Узагальнена стрілецька стрічка


22

Простий гольф для початку тижня! Вам надано три масиви: базовий масив B , масив значень V та масив індексів I . Ви повинні створити інший масив, куди Vвводяться значення в Bіндексах, визначених I. Ось приклад:

Base:    [5, 1, 4, 1, 3]
Values:  [0, 0, 7]
Indices: [5, 0, 3]

Індекси вказують на наступні позиції в базовому масиві:

[ 5, 1, 4, 1, 3 ]
 ^        ^    ^
 0        3    5

Отже, вставляючи відповідні елементи з масиву значень, результат повинен бути:

[0, 5, 1, 4, 7, 1, 3, 0]

Правила

Ви можете написати програму або функцію, взявши вхід через STDIN (або найближчу альтернативу), аргументи командного рядка або аргументи функції та вивести результат через STDOUT (або найближчу альтернативу), значення повернення функції або змінивши масив, заданий як Bпараметр .

Якщо ваше подання є функцією Iі Vможе бути змінено будь-яким способом, а також Bякщо воно не використовується для виводу.

Ви можете зробити наступні припущення щодо введення даних:

  • Усі елементи масиву бази та значень будуть невід’ємними цілими числами.
  • Масив значень матиме щонайменше ще один елемент, ніж базовий масив.
  • Масив значень та масив індексів матимуть однакову кількість елементів.
  • Масив індексів не міститиме повторних індексів, і всі індекси будуть у діапазоні.
  • Масиви бази та значень можуть містити повторювані елементи.
  • Будь-який або всі масиви можуть бути порожніми.
  • Ви не повинні вважати, що індекси даються в певному порядку.
  • Ви можете отримувати введення та виробляти вихід у будь-якому зручному, однозначному форматі рядка чи списку. Ви також можете отримати три масиви в іншому порядку.
  • Ви можете вибрати між індексацією на основі 0 та 1.

Це кодовий гольф, тому найкоротша відповідь (у байтах) виграє.

Випробування

Наведено у форматі B V I => Resultіндексації на основі 0. Якщо ви використовуєте індексацію на основі 1, збільште елементи третього масиву на 1.

[] [] [] => []
[] [1] [0] => [1]
[1,2] [] [] => [1,2]
[1,2] [3] [0] => [3,1,2]
[1,2] [3] [1] => [1,3,2]
[1,2] [3] [2] => [1,2,3]
[0,0,0] [1,1,1,1] [0,1,2,3] => [1,0,1,0,1,0,1]
[5,1,4,1,3] [0,0,7] [5,0,3] => [0,5,1,4,7,1,3,0]
[1,2,3,4] [4,3,2,1] [4,0,3,1] => [3,1,1,2,3,2,4,4]

Повідомте мене, якщо ви натрапите на інші цікаві кейси, і я додам їх.

Таблиця лідерів

Ось фрагмент стека для створення як звичайного табло, так і огляду переможців за мовою.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

# Language Name, N bytes

де Nрозмір вашого подання. Якщо ви покращите свій рахунок, ви можете зберегти старі бали у заголовку, прокресливши їх. Наприклад:

# Ruby, <s>104</s> <s>101</s> 96 bytes


4
Як ви ставитеся NULLдо порожнього масиву для мов, де порожній масив NULL?
Олексій А.

@AlexA. Якщо це загальне / уявлення порожнього масиву в зазначеному мовою (ах), я добре з цим.
Мартін Ендер

3
Просто гольф ? Це найскладніше, що я робив у CJam за весь тиждень. : P
Денніс

Відповіді:


13

Піт, 14 байт

s.icFPQmedSCtQ

Демонстрація.

Ця програма сприймає вхідні дані як 3-х списків списків у порядку База, Індекси, Значення.

Пояснення на прикладі [5, 1, 4, 1, 3], [5, 0, 3], [0, 0, 7]:

  1. Візьміть вхід: неявно, Q - вхід.

  2. Складіть індекс, пари значень: CtQ=[(5, 0), (0, 0), (3, 7)]

  3. Сортуйте пари у порядку збільшення показника: SCtQ=[(0, 0), (3, 7), (5, 0)]

  4. Візьміть значення кожної пари: medSCtQ=[0, 7, 0]

  5. Розбийте базовий список за місцем розташування показників: cFPQ=[[], [5, 1, 4], [1, 3], []]

  6. Перемежуйте 3 і 4: .icFPQmedSCtQ=[[], 0, [5, 1, 4], 7, [1, 3], 0, []]

  7. Об’єднайте в один список: s.icFPQmedSCtQ=[0, 5, 1, 4, 7, 1, 3, 0]


Блін. З якого часу у нас є метод перемежування? Просто хотів дописувати ssC,cFPQamedSCtQ].
Якубе

5
@Jakube isaac підступно скоїв це 6 днів тому.
orlp

@Jakube Оскільки github.com/isaacg1/pyth/commit/…
isaacg

3
@Jakube, оскільки Pyth може вирости для вирішення будь-якої проблеми. Ось проблема з мовами для гольфу. Езотеричні мови існують заради езотеричних мов; як вони розроблені * згодом.
сентяо

@sentiao Щоб бути справедливим, мова хоста (Python) вже деякий час переплітається під іншою назвою .
Мего

16

Пітон 2, 54

lambda B,*X:map(B.insert,*zip(*sorted(zip(*X))[::-1]))

Вводиться як " B,I,V. Модифікує вхід Bпри дзвінку (дякую Мартіну Бюттнеру, що нагадав, що це можливо).

Використання map для виклику B.insertкожної пари індекс / елемент. Щоб уникнути питання про зміщення індексів списку при вставці елементів, сортуйте пари в порядку зменшення індексу по потворному zip / sort / unzip. Якби не питання про зміщення, ми могли б просто зробити map(B.insert,*X).

Старий метод (65):

B,V,I=input()
for i,v in sorted(zip(I,V))[::-1]:B[i:i]=v,
print B

5

Хаскелл, 62 байти

import Data.List
f b v i=map snd$sort$zip[0.5,1.5..]b++zip i v

Приклад використання: f [5,1,4,1,3] [0,0,7] [5,0,3]->[0,5,1,4,7,1,3,0] .

Як це працює: доповнити базовий список індексами "півтора", починаючи з 0.5(наприклад,[(0.5,5),(1.5,1),(2.5,4),(3.5,1),(4.5,3)] ), і з'єднайте його з парами індекс-значення. Сортуйте та відкиньте індекс.

Зауваження : не знаю, чи я тут обманюю. З математичної точки зору це добре, але програміст може стверджувати, що список індексів [5,0,3]- це не список Integersзапитів, а запит Fractionals(якщо бути точним, тип є поліморфним, але повинен належати до Fractionalкласу, наприклад, Floatабо Double).


5

Рубі, 60 59 53 байти

->a,b,c{c.zip(b).sort.reverse.map{|i,v|a.insert i,v}}

І нелюбова версія

def riffle(array, values, indices)
    indices.zip(values).sort.reverse.each do |index, value|
        array.insert(index, value)
    end
end

2
Ви можете скоротити це, що робить його неназваний функцію замість: ->a,b,c{...}. Також шанси на те, insertщо не потрібні дужки.
Мартін Ендер

@ MartinBüttner Я знав про неназвану функцію з лямбдаю, але не відчував, що це відповідає духу виклику (який зазвичай вимагає названої функції). Дякую, що помітили парен.
Ділан Фрезе

Якщо виклик спеціально не вимагає названої функції, неназвані функції завжди прийнятні . І я не просив названої функції (я ніколи не роблю;)).
Мартін Ендер

5

CJam, 34 23 18 байт

{.\2/\ee+{0=}$1f=}

Моє перше подання CJam Поради вітаються, я впевнений, що в гольфі багато.

16 байт збережено за допомогою @ MartinBüttner та @Dennis.

Функція, що очікує введення в стеку в порядку B V I (I - найвищий).

Приклад використання:

[5 1 4 1 3] [0 0 7] [5 0 3] {.\2/\ee+{0=}$1f=}~

Спосіб:

  • з’єднати iелемент th з масивомi+0.5
  • пара вставних значень із позиціями вставки
  • об'єднайте отримані два масиви
  • сортувати масив на основі елементів позиції
  • зберігати ціннісні елементи

Цей підхід з плаваючою комою дуже розумний і (на жаль) кращий, ніж мій. Ви можете опуститися до 19 байт з q~.5fm.\2/\ee+$1f=pта до 18 байт, скориставшись анонімною функцією:{.5fm.\2/\ee+$1f=}
Денніс

Ця ж ідея без хитрості з плаваючою комою: {.\2/\ee+{0=}$1f=}(ще 18 байт)
Денніс

@Dennis Дякую, я не зміг знайти get array elementоператора 1f=. Я залишаю це як повноцінну програму.
randomra

Твій дзвінок. Ви не проти запитати, чому ви проти розміщення функції?
Денніс

@Dennis Я щойно запустив CJam і не знав, як використовувати функції. Тепер я зрозумів це, тому я змінив відповідь на це.
випадкова

5

К, 22 21 байт

{,//+(y@<z;(z@<z)_ x)}

Визначимо функцію 3 аргументу {…}з неявних змінних x, yі zпредставляє початковий список, список значень і список індексів, відповідно. Оператор "cut" ( _) використовується для розділення стартового списку на відсортований список заданих індексів ( (z@<z)). Ми переплітаємо значення (після сортування їх відповідно) з розділеними фрагментами вихідного масиву, формуючи список ( (a;b)), беручи його транспонирование ( +) і вирівнювання результату (,// ).

Приклад використання:

  f:{,//+(y@<z;(z@<z)_ x)}
{,//+(y@<z;(z@<z)_ x)}

  f[1 2 3 4;4 3 2 1;4 0 3 1]
3 1 1 2 3 2 4 4

  f[5 1 4 1 3;0 0 7;5 0 3]
0 5 1 4 7 1 3 0

Пробіли навколо підкреслення необхідні, оскільки K дозволяє підкреслити в ідентифікаторах. K5 усуває цю потенційну неоднозначність. Якщо ми могли б розраховувати, що індекси, що надходять у порядку зростання, і підкреслення не є дійсними ідентифікаторами, ми могли б скористатися набагато приємнішою 13-байтною програмою:

{,//+(y;z_x)}

(зітхає)

редагувати:

{,//+(y@<z;(z@<z)_ x)} / before
{,//+(y@<z;z[<z]_ x)}  / after

Порушує симетрію, але ми можемо зберегти байт, скориставшись дужкою-індексуванням ( […]) замість @оператора індексації інфіксу . Зазвичай це робить програми довшими, але в цьому випадку нам потрібні були паролі для сортування, zперш ніж виконувати скорочення.


4

Піт, 17 байт

ssC,cFPQamedSCtQ]

@isaacg вже обіграв моє рішення. Але оскільки я закінчила свою документацію, я все одно опублікую її.

Це вимагає введення у форматі B, I, V. Ви можете спробувати тут: Демонстрація або Тестовий набір

Пояснення:

Я використовую приклад B = [5,1,4,1,3], I = [5,0,3], V = [0,0,7]з ОП.

                    implicit: Q = input()
      PQ            all elements but last of Q   => [[5,1,4,1,3], [5,0,3]]
    cF              split B it the indices in I  => [[], [5,1,4], [1,3], []]

              tQ    all elements but first of Q  => [[5,0,3], [0,0,7]]
             C      zip                          => [(5,0), (0,0), (3,7)]
            S       sort                         => [(0,0), (3,7), (5,0)]
         med        extract the end of each pair => [0,7,0]
        a       ]   append an empty list         => [0,7,0,[]]

   ,                create a pair => ([[], [5,1,4], [1,3], []], [0,7,0,[]])
  C                 zip           => [([],0), ([5,1,4],7), ([1,3],0), ([],[])]
 s                  sum           => ([],0,[5,1,4],7,[1,3],0,[],[])
s                   sum           => [0,5,1,4,7,1,3,0]

4

JavaScript (ES6), 75

Функція з 3 параметрами масиву, що повертає масив. Дивно, що ця функція змінює свій iпараметр (як це дозволено ОП)

Тестуйте запуск фрагмента, Firefox лише як завжди.

f=(b,v,i,j=0)=>b.concat(v).map(p=>(p=i.indexOf(j))<0?b[j++]:(i[p]=-1,v[p]))

// TEST
out=x=>O.innerHTML+=x+'\n'

test=[
{ b:[], v:[], i:[], k:[] },
{ b:[], v:[1], i:[0], k:[1] },
{ b:[1,2], v:[], i:[], k:[1,2] },
{ b:[1,2], v:[3], i:[0], k:[3,1,2] },
{ b:[1,2], v:[3], i:[1], k:[1,3,2] },
{ b:[1,2], v:[3], i:[2], k:[1,2,3] },
{ b:[0,0,0], v:[1,1,1,1], i:[0,1,2,3], k:[1,0,1,0,1,0,1] },
{ b:[5,1,4,1,3], v:[0,0,7], i:[5,0,3], k:[0,5,1,4,7,1,3,0] },
{ b:[1,2,3,4], v:[4,3,2,1], i:[4,0,3,1], k:[3,1,1,2,3,2,4,4] }
];

test.forEach(x=>{
  r = f(x.b,x.v,x.i.slice(0)) // pass a copy of i, as the function will alter it
  ok = ''+r==''+x.k
  s='Test ' + (ok?'OK':'FAIL')
  +'\n B ['+x.b
  +']\n V ['+x.v
  +']\n I ['+x.i
  +']\n Result ['+r
  +']\n Check  ['+x.k
  +']\n'
  out(s)
  
})
<pre id=O></pre>


З цікавості, що з кодом робить його специфічним для Firefox? Це тому, що це ES6?
Олексій А.

@ AlexA.it тому, що це ES6, так. Особливо fat arrow functionце не реалізовано навіть у версії для розробників Chrome (AFAIK)
edc65

Дійсно, не підтримує навіть Chrome Canary збірка.
DocMax

4

Математика, 52 51 байт

Last/@(Tr@#2->#&~MapIndexed~#⋃Thread[#3+.5->#2])&

Приклад:

In[1]:= f = Last/@(Tr@#2->#&~MapIndexed~#⋃Thread[#3+.5->#2])&;

In[2]:= f[{5, 1, 4, 1, 3}, {0, 0, 7}, {5, 0, 3}]

Out[2]= {0, 5, 1, 4, 7, 1, 3, 0}

Пояснення:

Використовуючи приклад вище.

  • Tr@#2->#&~MapIndexed~# => {1 -> 5, 2 -> 1, 3 -> 4, 4 -> 1, 5 -> 3}
  • Thread[#3+.5->#2] => {5.5 -> 0, 0.5 -> 0, 3.5 -> 7}
  • Потім візьміть (відсортований) об'єднання цих двох списків. (=> {0.5 -> 0, 1 -> 5, 2 -> 1, 3 -> 4, 3.5 -> 7, 4 -> 1, 5 -> 3, 5.5 -> 0})
  • А потім візьміть останній елемент кожної пари. (=> {0, 5, 1, 4, 7, 1, 3, 0})


3

R, 75 байт

function(b,v,i){n=b;j=0;for(g in v)n=append(n,g,i[j<-j+1]+sum(i<i[j])-1);n}

Це створює неназвану функцію. Щоб зателефонувати, дайте ім’я, наприкладf=function... . Зауважте, що масиви повинні бути 1-індексованими, оскільки саме так R котиться.

Недоліки + пояснення:

f <- function(b, v, i) {
    # Initialize the output vector to b
    n <- b

    # Initialize an index over the indices
    j <- 0

    # Loop over the values to insert
    for(g in v) {
        # Get the index of the next given insertion index
        j <- j + 1

        # Insert g into n.
        # The position at which to insert the value is determined by
        # adding the number of indices less than the current one and
        # subtracting 1. The subtraction is because we're using the
        # `after` argument in the `append` function.

        n <- append(n, g, i[j] + sum(i < i[j]) - 1)
    }

    # Return n
    n
}

Приклади:

> f(c(), c(), c())
[1] NULL

> f(c(0, 0, 0), c(1, 1, 1, 1), c(1, 2, 3, 4))
[1] 1 0 1 0 1 0 1

> f(c(5, 1, 4, 1, 3), c(0, 0, 7), c(6, 1, 4))
[1] 0 5 1 4 7 1 3 0

Пропозиції вітаються як завжди!


2

CJam, 19 байт

l~_,)N*q~.{t}~.\N-p

Це повна програма, яка зчитує масиви B , I і V (по одному на рядок, у такому порядку) зі STDIN.

Спробуйте його в Інтернеті в інтерпретаторі CJam .

Як це працює

l~    e# Evaluate the first line of input.
_,)   e# Compute the array length and add 1.
N*    e# Push a string of that many linefeeds.
q~    e# Evaluate the remaining input.
.{t}~ e# Vectorized array set: for each index in the array from line 2, replace the
      e# LF at that index by the corresponding element of the array from line 3.
.\    e# Interleave the two arrays on the stack.
N-    e# Remove the linefeeds.
p     e# Print.

CJam, 20 байт

{Qa+@@.{a2$2$=+t}e_}

Це анонімна функція, яка спливає B , V і I (зверху вниз) зі стека і залишає один масив на стеку взамін.

Спробуйте його в Інтернеті в інтерпретаторі CJam .

Як це працює

Qa+      e# Append [[]] to B.
@@       e# Rotate V and I on top of B.
.{       e# For each v in V and the corresponding i in I:
   a     e#     Push [v].
   2$2$= e#     Retrieve b := B[i].
   +     e#     Append to push [v b].
         e#     The stack now consists of: B i [v b]
   t     e#     Set B[i] := [v b].
}        e#
e_       e# Flatten B.

1

Рубін, 48 байт

Я думаю, що це відповідає правилам, але будь ласка, перевірте.

->b,v,i{l=-1;i.map{|j|b[j]=[v[l+=1],b[j]]};b*?:}

Безіменна функція, що приймає три масиви як вхідні. Виводить рядок, який можна однозначно проаналізувати в масив чисел із виразом rubyx.split(/:+/).map(&:to_i) .

Тестові приклади на ideone .

Я міг би зберегти ще 3 байти, але вихідний формат [1,2,[nil,5]]розтягує правила трохи mych imo, хоча це однозначно.


Я думаю, що поточний формат добре. Вкладені масиви з переплетеними nilзначеннями трохи розтягуються. Але в будь-якому випадку це не виграє конкурс, тому я не дуже переживаю з цього приводу.
Мартін Ендер

1

R, 60

Як неназвана функція, яка приймає b, v і i

function(b,v,i){e=c(NA,rbind(b,NA));e[i*2+1]=v;e[!is.na(e)]}

Розширює b з NA Заповнює прогалини, де це потрібно, v Повертає вектор без NA

> f=function(b,v,i){e=c(NA,rbind(b,NA));e[i*2+1]=v;e[!is.na(e)]}
> f(c(), c(), c())
logical(0)
> f(c(0, 0, 0), c(1, 1, 1, 1), c(0, 1, 2, 3))
[1] 1 0 1 0 1 0 1
> f(c(5, 1, 4, 1, 3), c(0, 0, 7), c(5, 0, 3))
[1] 0 5 1 4 7 1 3 0

1

Ява, 253, 226, 219, 209

не зовсім переможець, але добре.

Якщо припустити, що B, V і я не є нульовими. v (мале v) - довжина масивів Значення / Індекси. R - повернутий масив. r - довжина повернутого масиву. x, y, i i - всі тимчасові вставки.

int[]f(int[]B,int[]V,int[]I){int v=V.length,r=B.length+v,x,y,i;int[]R=java.utils.Arrays.copyOf(B,r);for(x=0;x<v;x++){i=I[x];for(y=0;y<x;y++)if(I[x]>I[y])i++;for(y=r-2;y>=i;y--)R[y+1]=R[y];R[i]=V[x];}return R;}

розширено:

int[]f( int[] B, int[] V, int[] I ) {
    int v = V.length, //length of Values
        r = B.length + v, //length of the result
        x, y, i; //temps
        int[] R = java.utils.Arrays.copyOf( B, r );       
        for( x = 0; x < v; x++ ) {
        i = I[x];
        for( y = 0; y < x; y++ )
            if( I[x] > I[y] )
                i++;
        for( y = r - 2; y >= i; y-- )
            R[y+1] = R[y];
        R[i] = V[x];
    }
    return R;
}

1

APL, 22 байти

{(∊⌽2↑⍵)[⍋(2⊃⍵),⍳≢⊃⍵]}

У ⎕IO ← 0, щоб відповідати тестовим випадкам.

Це стандартний алгоритм: вектор індексу першого аргументу додається до заданих індексів (3-й аргумент). обчислює перестановку, яка б сортувала індекси у порядку зростання. Оскільки алгоритм сортування APL стабільний за визначенням, обчислена перестановка ставить елемент катенації другого та першого аргументу в потрібне місце.

Наприклад :

    {(∊⌽2↑⍵)[⍋(2⊃⍵),⍳≢⊃⍵]}(5 1 4 1 3)(0 0 7)(5 0 3)
0 5 1 4 7 1 3 0
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.