배경

요즘 프로그래머는 버퍼를 똑바로 유지할 수 없습니다! 일반적인 오류 원인은 버퍼에 비해 너무 큰 배열 인덱스를 사용하려는 것입니다. 당신의 임무는 큰 인덱스가 버퍼가 처리 할 수있는 크기로 축소되는 버퍼를 구현하는 것입니다. 모든 사람에게 가장 적합한 것을 정확하게 결정하기 때문에이 버퍼를 정확한 사양으로 구현합니다.

개요

요소가 추가되면 크기가 커지는 삽입 전용 버퍼가 있습니다. 버퍼는 인덱스가 0이고 모듈로 의 현재 크기 도 인덱스됩니다 . 이 도전에 대한 특별한 규칙은 다음과 같습니다.

• 인덱스에 항목을 삽입하려면 내가 계산하는 것을 의미 J를 , j = i % buffer.length()그리고 이후에 새로운 항목을 삽입 j 번째 목록에서 항목을 선택합니다.

유일한 특수한 경우는 산술 모듈로 0이 작동하지 않으므로 버퍼가 비어있는 경우입니다. 따라서 버퍼가 현재 비어있는 경우 새 항목은 인덱스 0이 됩니다.

버퍼에 하나의 항목 만있는 경우 항상 0 번째 항목 뒤에 삽입합니다 . 이것은 일반적인 경우의 한 예일뿐입니다.

버퍼가 6 항목이 포함 된 경우 : [4, 9, 14, 8, 5, 2]당신이 새로운 항목을 삽입하라고하는 10인덱스 15 , 당신은 그것을 발견 15 % 6 == 3한 다음 새를 삽입 10애프터 8인덱스 3 의 결과 버퍼를 제공합니다 [4, 9, 14, 8, 10, 5, 2]

문제

순서가 지정된 양의 정수 목록과 그것들을 삽입 할 양의 정수 색인을 취하는 함수 또는 프로그램을 작성하십시오.

빈 버퍼로 시작하여 지정된 정수를 해당 인덱스의 버퍼에 추가하십시오.

지정된 모든 삽입이 완료된 후 버퍼에있는 정렬 된 정수 목록을 출력합니다.

이것은 코드 골프 도전이므로 가장 짧은 코드가 승리합니다.

입력 지침

입력 목록을 가져갈 수도 있지만 적합하다고 생각됩니다. 예 :

• 쌍 목록 : [ [1,1], [2,4], [3,9], [4,16], [5,25]...]
• 품목 목록 및 색인 목록 : [1, 2, 3, 4, 5...], [1, 4, 9, 16, 25]
• 단조롭게 하는: [1, 1, 2, 4, 3, 9, 4, 16, 5, 25 ...]
• 기타

입력에 항상 하나 이상의 항목과 해당 색인이 포함되어 있다고 가정 할 수 있습니다.

테스트 사례

위의 사각형 케이스 :

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

나는 이것을 무작위로 생성했다.

[(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]

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 바이트

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

입력은 ;첫 번째 행의 값과 두 번째 행의 값을 포함 하는 행렬 ( 행 구분 기호 포함)입니다.

출력은 열 배열이며, 줄 바꿈으로 구분 된 숫자로 표시됩니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오. 각 결과는 한 줄에 표시됩니다.

설명

"          % 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)

펄, 37 바이트

35 바이트의 코드 + -lp플래그의 경우 2 바이트

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

온라인으로 사용해보십시오!

구현은 매우 간단 하며 인덱스 splice에 배열 @F을 삽입합니다 1+<>%(@F||1)( @F||1배열이 비어있는 경우 를 처리합니다).

제 (겉으로는) 타의 추종을 불허하는 중괄호에 대한 그냥 몇 마디 }{(나는 그것에 대해 설명을했고, 나는 그것이 펄을 모르는 사람들을위한 아주 이상한 생각하기 때문에), 그것은 펄 golfings에서 매우 일반적 트릭 :
-p플래그는 코드를 둘러싸고 (거의) while(<>){ CODE } continue { print }으로 ( continue각 반복 후에 실행됩니다). 따라서 일치하지 않는 }{ 코드를 사용하여 코드를로 변경했습니다 while(<>) { CODE}{ } continue { print }. 따라서 내 코드 바로 뒤에 빈 블록을 만들지 만 (문제는 아닙니다) 모든 continue후 while(즉, 모든 입력을 읽은 후) 한 번만 실행됩니다 .

ES6 (자바 스크립트) 58,57,53, 50 바이트

골프

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

인덱스 값 쌍의 배열을 입력으로받습니다.

EDITS

• &&-1 바이트 값을 반환하는 데 사용
• |0-2 바이트 (연결은 분명히 NaN을 잘 처리 할 수 ​​있음)가 제거 되었습니다.
• 제작 b=[]번째 "인수"로 (지도) , -2 바이트 (들으 @ETHproductions를!)
• b.length를 map () 인덱스 (i), -3 바이트 (Thx @Patrick Roberts!)로 대체했습니다.

테스트

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 ]

하스켈 , 70 69 바이트

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

온라인으로 사용해보십시오! 사용법 : foldl(!)[] [(1,5),(2,4),(3,7)]. @nimi 덕분에 1 바이트를 절약했습니다!

설명:

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

모듈러스를 계산하지 않은 솔루션 : (90 바이트)

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

온라인으로 사용해보십시오!

파이썬 2 , 64 62 58 56 바이트

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

2 바이트를 골라 낸 @xnor에게 감사드립니다!

온라인으로 사용해보십시오!

파이썬 2 , 62 60 바이트

입력을 쌍의 목록으로 취하고 결과를 인쇄합니다. 편집 : Dennis가 Outgolfed

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

온라인으로 사용해보십시오!

이것은 매우 간단합니다. 입력을 반복하여 항목을 올바른 위치에 삽입 한 다음 결과를 인쇄하십시오. 삽입 할 인덱스 결정은로 수행됩니다 1+y%(len(b)or 1). 이것은 or 1빈 목록의 가장 중요한 경우를 처리하는 모듈 식 인덱싱을 수행하는 표준 방법 입니다.

자바 스크립트 (ES6), 60 바이트

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

테스트 스 니펫

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 바이트

이 답변은 list의 정의를 구부리고 일반적으로 목록 조작에 사용하는 언어는 아니지만 [count]/{regex}최근에 V에 추가 한 언어를 사용하고 싶었 습니다. 입력은 다음 [index] [num] [index] [num] ...과 같습니다 [num] [num] [num].

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

온라인으로 사용해보십시오!

2 개의 숨겨진 캐릭터를위한 Hexdump :

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

설명

코드는 dG@"모든 \d+ \d+쌍의 형식 을 지정하여 목록 1 2 3 4 5 6이

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

그런 다음 dG@"모든 것을 다음과 같이 V 코드로 실행합니다.

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 바이트

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

명령 행 인수에서 평탄화 된 입력을받습니다. 로 실행하십시오 -nr.

자바 7 125 124 바이트

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;}

플랫 값 목록과 색인이 사용됩니다. 제곱 테스트 사례의 경우 입력은new int[] {1, 2, 3, 4, 5, 6, 7, 8, 1, 4, 9, 16, 25, 36, 49, 64}

온라인으로 사용해보십시오!

수학, 62 바이트

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

첫 번째 인수가있는 순수한 함수 #는 쌍 목록이 될 것으로 예상됩니다. 빈 목록부터 시작 하여 다음 기능으로 입력 목록 을 {}남겼 Fold습니다 #.

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

펄 6 , 51 바이트

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

평평한 입력을받습니다.

클로저, 87 바이트

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