Latar Belakang

Pemrogram hari ini sepertinya tidak bisa menjaga buffer mereka tetap lurus! Sumber kesalahan yang umum adalah mencoba menggunakan indeks array yang terlalu besar untuk buffer. Tugas Anda adalah mengimplementasikan buffer di mana indeks besar dikurangi menjadi ukuran yang bisa ditangani oleh buffer. Karena saya memutuskan dengan tepat apa yang terbaik untuk semua orang, Anda akan mengimplementasikan buffer ini ke spesifikasi saya yang tepat.

Ikhtisar

Anda memiliki penyangga khusus penyisipan yang tumbuh dalam ukuran ketika elemen ditambahkan ke dalamnya. Buffer diindeks nol, dan modulo juga diindeks ukurannya saat ini. Aturan khusus untuk tantangan ini adalah ini:

• Untuk memasukkan item pada indeks i berarti menghitung j , j = i % buffer.length()dan memasukkan item baru setelah item ke - j dalam daftar.

Satu-satunya kasus khusus adalah jika buffer kosong, karena modulo nol aritmatika tidak berfungsi. Jadi, jika buffer saat ini kosong, item baru akan menjadi indeks 0 .

Jika buffer hanya memiliki satu item, maka Anda selalu memasukkan setelah item ke - 0 . Ini hanya satu contoh dari kasus umum.

Jika buffer berisi 6 item: [4, 9, 14, 8, 5, 2]dan Anda diminta untuk memasukkan item baru 10di indeks 15 , Anda menemukan itu 15 % 6 == 3, dan kemudian memasukkan yang baru 10setelah 8pada indeks 3 yang memberikan buffer yang dihasilkan dari [4, 9, 14, 8, 10, 5, 2]

Masalah

Tulis fungsi atau program yang memasukkan daftar bilangan bulat positif yang terurut, dan indeks bilangan bulat positif untuk memasukkannya.

Mulai dengan buffer kosong, dan tambahkan bilangan bulat yang ditentukan ke buffer di indeks yang sesuai.

Keluarkan daftar bilangan bulat yang diurutkan dalam buffer setelah semua penyisipan yang ditentukan telah dibuat.

Ini adalah tantangan kode-golf, sehingga kode terpendek menang.

Panduan input

Anda dapat mengambil daftar input sesuai keinginan Anda. Contoh:

• Daftar pasangan: [ [1,1], [2,4], [3,9], [4,16], [5,25]...]
• Daftar item dan daftar indeks: [1, 2, 3, 4, 5...], [1, 4, 9, 16, 25]
• Diratakan: [1, 1, 2, 4, 3, 9, 4, 16, 5, 25 ...]
• dll.

Anda dapat menganggap input selalu mengandung setidaknya satu item dan indeks yang sesuai.

Uji kasus

Kotak kuadrat dari atas:

[(1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49), (8, 64)] -> [1, 2, 8, 7, 6, 5, 4, 3]

Saya membuat ini secara acak:

[(11, 9), (13, 14)] -> [11, 13]
[(1, 18), (11, 7), (3, 35), (16, 22)] -> [1, 11, 16, 3]
[(3, 16), (16, 37), (0, 28), (18, 24)] -> [3, 18, 0, 16]
[(7, 26), (8, 20), (11, 39), (1, 23), (17, 27)] -> [7, 8, 11, 1, 17]
[(15, 35), (17, 7), (16, 15), (1, 13), (2, 6), (11, 34)] -> [15, 17, 1, 2, 16, 11]
[(2, 13), (1, 20), (16, 25), (8, 21), (5, 2), (16, 37), (3, 0)] -> [2, 3, 8, 1, 16, 5, 16]
[(6, 20), (15, 15), (12, 26), (10, 27), (17, 13), (7, 18), (4, 16)] -> [6, 10, 17, 12, 7, 4, 15]
[(18, 9), (5, 34), (15, 4), (12, 29), (2, 5), (7, 0), (7, 10), (16, 38)] -> [18, 7, 15, 2, 16, 5, 7, 12]
[(0, 12), (12, 0), (4, 16), (15, 12), (6, 28), (8, 10), (11, 24), (0, 25)] -> [0, 11, 8, 6, 15, 0, 4, 12]
[(6, 12), (14, 13), (10, 33), (11, 35), (1, 3), (0, 28), (15, 27), (8, 10), (1, 2)] -> [6, 14, 10, 1, 11, 8, 15, 0, 1]
[(2, 29), (19, 30), (18, 17), (13, 3), (0, 21), (19, 19), (11, 13), (12, 31), (3, 25)] -> [2, 13, 3, 11, 0, 12, 19, 18, 19]

Implementasi referensi Python3

def f(inputs):
    # `inputs` is a list of pairs
    buff = []
    for item, index in inputs:
        if len(buff) == 0:
            buff.insert(0, item)
        else:
            insert_after = index % len(buff)
            buff.insert(insert_after+1, item)
    return buff

MATL , 24 22 byte

"N?@2)yn\Q:&)@1)wv}@1)

Input adalah matriks (dengan ;pemisah baris) yang berisi nilai-nilai di baris pertama dan indeks di baris kedua.

Output adalah array kolom, ditampilkan sebagai angka yang dipisahkan oleh baris baru.

Cobalah online! Atau verifikasi semua kasus uji , dengan setiap hasil ditampilkan pada satu baris.

Penjelasan

"          % Input matrix (implicit). For each column 
  N        %   Number of elements in the stack
  ?        %   If nonzero (true for all iterations but the first)
    @2)    %     Push second element of current column: new index
    yn     %     Duplicate current buffer; push its number of elements
    \      %     Modulo
    Q      %     Add 1
    :&)    %     Split buffer at that point. This gives two pieces, one
           %     of which may be empty
    @1)    %     Push first element of current column: new value
    wv     %     Swap; concatenate all stack. This places the new value
           %     between the two pieces of the buffer
  }        %   Else (this is executed only in the first iteration)
    @1)    %     Push first element of current column: new value
           %   End (implicit)
           % End (implicit)
           % Display (implicit)

Perl, 37 byte

35 byte kode + 2 byte untuk -lpflag.

splice@F,1+<>%(@F||1),0,$_}{$_="@F"

Cobalah online!

Implementasinya cukup lurus ke depan, splicememasukkan array @Fpada indeks 1+<>%(@F||1)(catatan yang @F||1menangani kasus array kosong).

Hanya beberapa kata tentang kawat gigi (tampaknya) yang tak tertandingi }{(karena saya punya komentar tentang itu, dan saya pikir itu sangat aneh untuk orang-orang yang tidak tahu Perl), dan itu adalah trik yang cukup umum di golfing Perl:
-pbendera mengelilingi kode dengan (kurang lebih) while(<>){ CODE } continue { print }, ( continuedijalankan setelah setiap iterasi). Jadi dengan orang-orang yang tak tertandingi }{ , saya mengubah kode saya untuk while(<>) { CODE}{ } continue { print }. Jadi itu menciptakan blok kosong tepat setelah kode saya (tapi itu tidak masalah), dan continuedijalankan hanya sekali, setelah while(mis. Ketika semua input telah dibaca).

ES6 (Javascript), 58,57,53, 50 byte

Golf

a=>a.map((e,i)=>b.splice(1+e[1]%i,0,e[0]),b=[])&&b

Mengambil array pasangan nilai indeks, sebagai input.

EDIT

• Gunakan &&untuk mengembalikan nilai, -1 byte
• Dihapus |0(karena sambungan tampaknya dapat menangani NaN dengan baik), -2 byte
• Buat b=[]"argumen" kedua untuk memetakan () , -2 byte (Thx @ETHproductions!)
• Digantikan b.length dengan map () index (i), -3 bytes (Thx @Patrick Roberts!)

Uji

F=a=>a.map((e,i)=>b.splice(1+e[1]%i,0,e[0]),b=[])&&b

F([[11, 9], [13, 14]])
[ 11, 13 ]

F([[2, 29], [19, 30], [18, 17], [13, 3], [0, 21], [19, 19], [11, 13], [12, 31], [3, 25]])
[ 2, 13, 3, 11, 0, 12, 19, 18, 19 ]

Haskell , 70 69 byte

b!(x,i)|b==[]=[x]|j<-1+i`mod`length b=take j b++x:drop j b
foldl(!)[]

Cobalah online! Penggunaan: foldl(!)[] [(1,5),(2,4),(3,7)]. Disimpan satu byte berkat @nimi!

Penjelasan:

b!(x,i)                         -- b!(x,i) inserts x into list b at position i+1
 | b==[] = [x]                  -- if b is empty return the list with element x
 | j <- 1 + i `mod` length b    -- otherwise compute the overflow-save insertion index j
     = take j b ++ x : drop j b -- and return the first j elements of b + x + the rest of b
foldl(!)[]                      -- given a list [(1,2),(3,5),...], insert each element with function ! into the initially empty buffer

Solusi tanpa menghitung modulus: (90 byte)

f h t(x,-1)=h++x:t
f h[]p=f[]h p
f h(c:t)(x,i)=f(h++[c])t(x,i-1)
g((x,_):r)=foldl(f[])[x]r

Cobalah online!

Python 2 , 64 62 58 56 byte

x=[]
for n,i in input():x[i%(len(x)or 1)+1:0]=n,
print x

Terima kasih kepada @xnor karena bermain golf 2 byte!

Cobalah online!

Python 2 , 62 60 byte

Mengambil input sebagai daftar pasangan, mencetak hasilnya. Sunting: Dikalahkan oleh Dennis

b=[]
for x,y in input():b.insert(1+y%(len(b)or 1),x)
print b

Cobalah online!

Ini cukup sederhana - loop melalui input, memasukkan item ke tempat yang benar, dan kemudian cetak hasilnya. Memutuskan indeks mana yang akan dimasukkan 1+y%(len(b)or 1). Ini adalah cara standar untuk melakukan pengindeksan modular, dengan or 1menangani kasus tepi daftar kosong.

JavaScript (ES6), 60 byte

f=([[q,r],...a],z=[])=>z.splice(r%z.length+1,0,q)+a?f(a,z):z

Cuplikan tes

f=([[q,r],...a],z=[])=>z.splice(r%z.length+1,0,q)+a?f(a,z):z

I.textContent = I.textContent.replace(/(.+) -> (.+)/g, (_,a,b) => _ + " (" + (f(eval(a.replace(/\(/g, "[").replace(/\)/g, "]"))) + "" == eval(b) + "") + ")")

<pre id=I>[(11, 9), (13, 14)] -> [11, 13]
[(1, 18), (11, 7), (3, 35), (16, 22)] -> [1, 11, 16, 3]
[(3, 16), (16, 37), (0, 28), (18, 24)] -> [3, 18, 0, 16]
[(7, 26), (8, 20), (11, 39), (1, 23), (17, 27)] -> [7, 8, 11, 1, 17]
[(15, 35), (17, 7), (16, 15), (1, 13), (2, 6), (11, 34)] -> [15, 17, 1, 2, 16, 11]
[(2, 13), (1, 20), (16, 25), (8, 21), (5, 2), (16, 37), (3, 0)] -> [2, 3, 8, 1, 16, 5, 16]
[(6, 20), (15, 15), (12, 26), (10, 27), (17, 13), (7, 18), (4, 16)] -> [6, 10, 17, 12, 7, 4, 15]
[(18, 9), (5, 34), (15, 4), (12, 29), (2, 5), (7, 0), (7, 10), (16, 38)] -> [18, 7, 15, 2, 16, 5, 7, 12]
[(0, 12), (12, 0), (4, 16), (15, 12), (6, 28), (8, 10), (11, 24), (0, 25)] -> [0, 11, 8, 6, 15, 0, 4, 12]
[(6, 12), (14, 13), (10, 33), (11, 35), (1, 3), (0, 28), (15, 27), (8, 10), (1, 2)] -> [6, 14, 10, 1, 11, 8, 15, 0, 1]
[(2, 29), (19, 30), (18, 17), (13, 3), (0, 21), (19, 19), (11, 13), (12, 31), (3, 25)] -> [2, 13, 3, 11, 0, 12, 19, 18, 19]</pre>

V , 38 40 35 byte

Jawaban ini membengkokkan definisi daftar, dan biasanya bukan bahasa yang akan Anda gunakan untuk manipulasi daftar, tetapi saya ingin menggunakan [count]/{regex}yang baru-baru ini saya tambahkan ke V. Masukan diambil seperti [index] [num] [index] [num] ...dan dikembalikan seperti [num] [num] [num].

Í ¨ä«© ½/¯ÜdÜ+òhea ±^
Hdd2xdG@"
X

Cobalah online!

Hexdump untuk 2 karakter tersembunyi:

00000000: cd20 a8e4 aba9 20bd 2faf dc64 dc2b f268  . .... ./..d.+.h
00000010: 6561 20b1 161b 5e0a 4864 6432 7864 4740  ea ...^.Hdd2xdG@
00000020: 220a 58                                  ".X

Penjelasan

Kode hingga dG@"memformat semua \d+ \d+pasangan sehingga daftar 1 2 3 4 5 6 akan berakhir seperti

a 2^[^3/\d\+
hea 4^[^5/\d\+
hea 6^[^

dan kemudian dG@"jalankan semua itu sebagai kode V seperti berikut:

a 2^[                 | insert " 2" and return to command mode
     ^                | LOOP: go to the first number
      3/\d\+          | find the 3rd number (0 indexed)
h                     | move one character left
 e                    | go to the end of the next word
  a 4^[               | append " 4" and return to command mode
       ^5/\d\+        | basically the same as LOOP on, just with different numbers

PHP, 72 92 byte

for($b=[];++$i<$argc;)array_splice($b,$b?$argv[$i]%count($b)+1:0,0,$argv[++$i]);print_r($b);

mengambil input yang diratakan dari argumen baris perintah. Jalankan dengan -nr.

Java 7, 125 124 byte

import java.util.*;List z(int[]a){List r=new Stack();for(int i=0,q=a.length/2;i<q;)r.add(i<1?0:a[i+q]%i+1,a[i++]);return r;}

Menerima daftar nilai rata yang diikuti oleh indeks. Untuk kasus uji kuadrat, inputnya adalahnew int[] {1, 2, 3, 4, 5, 6, 7, 8, 1, 4, 9, 16, 25, 36, 49, 64}

Cobalah online!

Mathematica, 62 byte

Fold[Insert[#,#2[[1]],Mod[Last@#2,Tr[1^#]]+2/.0/0->-1]&,{},#]&

Fungsi murni dengan argumen pertama #diharapkan menjadi daftar pasangan. Dimulai dengan daftar kosong {}, meninggalkan Folddaftar input #dengan fungsi berikut:

Insert[                                            Insert
       #,                                          into the first argument
         #2[[1]],                                  the first element of the second argument
                 Mod[                              at the position given by the modulus of
                     Last@#2,                      the second element of the second argument
                             Tr[1^#]               with respect to the length of the first argument
                                    ]+2            plus 2 (plus 1 to account for 1-indexing, plus 1 because we are inserting after that position)
                                       /.          then replace
                                         0/0       Indeterminate
                                            ->     with
                                              -1   negative 1
                                                ]& End of function

Perl 6 , 51 byte

{my @a;.map:{splice @a,(@a??$^b%@a+1!!0),0,$^a};@a}

Mengambil input yang rata.

Clojure, 87 byte

#(reduce(fn[r[v i]](let[[b e](split-at(+(mod i(max(count r)1))1)r)](concat b[v]e)))[]%)