이 도전에서는 릴리 패드에서 앞뒤로 점프하는 개구리를 시뮬레이션해야합니다. 연못은 무한히 크며 무한한 수의 릴리 패드가 있으며 개구리는 그가 원하는만큼 릴리 패드를 뛰어 넘을 수 있습니다.

이 개구리는 앞뒤로 점프하는 것을 좋아합니다. 앞으로 점프 한 후에는 항상 뒤로 점프 하며 그 반대도 마찬가지입니다.

그의 점프를 나타내는 정수 목록이 전달됩니다. 그의 점프 결과를 출력해야합니다.

예를 들어, 다음과 같이 전달되었다고 가정하십시오 [2,3,6,8,2].

우리의 개구리는 두 개의 릴리 패드를 앞으로 점프하여 시작합니다.

_2

다음 3 릴리 패드 다시 :

3__2

다음 6 릴리 패드 앞으로 :

3__2__6

8 등 :

8_3__2__6

마지막으로 2 개의 릴리 패드가 앞으로 나옵니다 (2가 3을 덮어 쓰는 방법에 주목하십시오).

8_2__2__6

더 명확하게 말하면 : 입력은 숫자의 배열이므로 position에서 S출력해야합니다 .S[K]S[K] - S[K-1] + S[K-2] - S[K-3]...

• 특정 위치에 여러 번호를 인쇄하려면 색인이 가장 높은 번호 만 인쇄하십시오.
• _특정 위치가 비어있는 경우 사용해야 합니다
• 숫자에 숫자가 여러 개인 경우 여러 위치를 차지하지 않습니다. 즉, 위치는 여러 문자로 구성 될 수 있습니다.
• 목록이 비어 있지 않고 모든 정수가 0보다 크다고 가정 할 수 있습니다.

테스트 사례 :

5                   ____5
2,2                 2_2
4,3,2,1             3124
5,3,2,1             _3125
2,3,6,8,2           8_2__2__6
10,3,12,4,1,12,16   ___12__3__10____41__1216
100,4,7,2,2         _______________________________________________________________________________________________4___1002_2

이것은 code-golf 이므로 가능한 적은 문자로 대답하십시오!

MATL , 35 34 바이트

1 바이트를 절약 해 준 @Emigna 에게 감사합니다 !

32Oittn:oEq*Yst1hX<-Q(Vh' 0'95ZtXz

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

설명이 아닌 코드를 골프화하십시오!

다음은 입력 [2,3,6,8,2]을 예로 사용합니다. 실제 코드에서 중간 결과를 보려면 %(코멘트 기호)를 삽입하여 해당 시점에서 프로그램을 중지하고 스택 내용을 확인하십시오. 예를 들어, 이 명령문 이후 스택 나타낸다 Ys(누적 합계).

32       % Push 32 (ASCII for space)
O        % Push 0
i        % Input array
         % STACK: 32, 0, [2,3,6,8,2]
t        % Duplicate
         % STACK: 32, 0, [2,3,6,8,2], [2,3,6,8,2]
tn:      % Push [1 2 ... n] where n is length of input array
         % STACK: 32, 0, [2,3,6,8,2], [2,3,6,8,2], [1,2,3,4,5]
o        % Modulo 2
         % STACK: 32, 0, [2,3,6,8,2], [2,3,6,8,2], [1,0,1,0,1]
Eq       % Multiply by 2, subtract 1
         % STACK: 32, 0, [2,3,6,8,2], [2,3,6,8,2], [1,-1,1,-1,1]
*        % Multiply elementwise
         % STACK: 32, 0, [2,3,6,8,2], [2,-3,6,-8,2]
Ys       % Cumulative sum
         % STACK: 32, 0, [2,3,6,8,2], [2,-1,5,-3,1]
         % The top-most array is the positions where the entries of the second-top
         % array will be written. But postions cannot be less than 1; if that's
         % the case we need to correct so that the minimum is 1. If this happens,
         % it means that the frog has gone further left than where he started
t        % Duplicate
1hX<     % Append 1 and compute minimum. So if the original minimum is less than 1
         % this gives that minimum, and if it is more than 1 it gives 1
         % STACK: 32, 0, [2,3,6,8,2], [2,-1,5,-3,1], -3
-        % Subtract
         % STACK: 32, 0, [2,3,6,8,2], [5 2 8 0 2]
Q        % Add 1
         % STACK: 32, 0, [2,3,6,8,2], [6 3 9 1 3]
(        % Assign values (top array) to specified positions (second-top) into array
         % which contains a single 0 (third-top). Newer values overwrite earlier
         % values at the same position
         % STACK: 32, [8 0 2 0 0 2 0 0 6]
V        % Convert to string. This produces spaces between the numbers
         % STACK: 32, '8 0 2 0 0 2 0 0 6'
h        % Concatenate with initial 32 (space). This converts to char
         % STACK: ' 8 0 2 0 0 2 0 0 6'
         % Thanks to this initial space, all zeros that need to be replaced by '_'
         % are preceded by spaces. (In this example that initial space would not
         % be needed, but in other cases it will.) Other zeros, which are part of
         % a number like '10', must not be replaced
' 0'     % Push this string: source for string replacement
         % STACK: ' 8 0 2 0 0 2 0 0 6', ' 0 '
95       % Push 95 (ASCII for '_'): target for string replacement
         % STACK: ' 8 0 2 0 0 2 0 0 6', ' 0 ', 95
Zt       % String replacement
         % STACK: ' 8_2__2__6'
Xz       % Remove spaces. Implicit display
         % STACK: '8_2__2__6'

PHP, 100 (101) 99 104 바이트

for($p=-1;$d=$argv[++$k];+$i<$p?:$i=$p,$x>$p?:$x=$p)$r[$p+=$k&1?$d:-$d]=$d;for(;$i<=$x;)echo$r[$i++]?:_;

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

고장

for($p=-1;          // init position
    $d=$argv[++$k]; // loop $d through command line arguments
    +$i<$p?:$i=$p,          // 3. $i=minimum index
    $x>$p?:$x=$p            // 4. $x=maximum index
)
    $r[
        $p+=$k&1?$d:-$d     // 1. jump: up for odd indexes, down else
    ]=$d;                   // 2. set result at that position to $d
for(;$i<=$x;)           // loop $i to $x inclusive
    echo$r[$i++]?:_;        // print result at that index, underscore if empty

자바 스크립트 (ES6) 99 107 바이트

편집 : OP는 사용 가능한 메모리 만 제한해야한다고 명시했기 때문에 하드 코드 된 최대 범위에 의존하는 대신 필요한 공간을 정확하게 할당하도록 업데이트되었습니다.

f=(a,x='',p=M=0)=>a.map(n=>x[(p-=(i=-i)*n)<m?m=p:p>M?M=p:p]=n,i=m=1)&&x?x.join``:f(a,Array(M-m).fill`_`,-m)

작동 원리

이 기능은 두 단계로 작동합니다.

• 첫 번째 패스 중 :

  • '개구리 포인터' p는로 초기화됩니다 0.
  • x변수는 빈 문자열로 설정되어 있으므로이를 수정하기위한 모든 시도는 단순히 무시됩니다.
  • 우리는 계산 m하고 M각각 최소있는 최대 값은 도달 p.
  • 이 단계가 끝나면 :에 대한 재귀 호출을 수행합니다 f().

• 두 번째 패스 중 :

  • p로 초기화됩니다 -m.
  • x문자로 M-m채워진 size 배열로 설정됩니다 _.
  • 에 올바른 위치에 숫자를 삽입합니다 x.
  • 이 단계가 끝나면 : 결합 된 버전을 반환합니다 x. 이것이 최종 결과입니다.

테스트 사례

f=(a,x='',p=M=0)=>a.map(n=>x[(p-=(i=-i)*n)<m?m=p:p>M?M=p:p]=n,i=m=1)&&x?x.join``:f(a,Array(M-m).fill`_`,-m)

console.log(f([5]));                  // ____5
console.log(f([4,3,2,1]));            // 3124
console.log(f([5,3,2,1]));            // _3125
console.log(f([2,3,6,8,2]));          // 8_2__2__6
console.log(f([10,3,12,4,1,12,16]));  // ___12__3__10____41__1216
console.log(f([100,4,7,2,2]));        // _..._4___1002_2

R , 100 97 96 바이트

function(x){p=cumsum(x*c(1,-1))[seq(x^0)]
p=p+max(1-p,0)
v=rep('_',max(p));v[p]=x
cat(v,sep='')}

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

라인 1은 점프 할 모든 위치를 찾습니다. 먼저 모든 점프에 x1 또는 -1을 곱한 다음 누적 합산을 사용하여 최종 위치로 변환합니다. c(-1,1)필요한 경우 벡터 가 재활용되지만 x길이가 1 인 x경우 대신 재활용됩니다. 따라서 합계 seq(x^0)( seq_along(x)) 만 고려됩니다. (길이 x가 2의 배수가 아니지만 결과에 영향을 미치지 않으면 경고가 생성됨 )

라인 2는 점프 위치를 증가시켜 모두 1 이상이되도록합니다.

3 행과 4 행은 출력을 작성하고 인쇄합니다.

주세페 에서 -1 바이트

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

f=x=>x.map((y,i)=>o[j=(j-=i%2?y:-y)<0?o.unshift(...Array(-j))&0:j]=y,o=[],j=-1)&&[...o].map(y=>y||'_').join``

<!-- snippet demo: -->
<input list=l oninput=console.log(f(this.value.split(/,/)))>
<datalist id=l><option value=5><option value="4,3,2,1"><option value="5,3,2,1"><option value="2,3,6,8,2"><option value="10,3,12,4,1,12,16"><option value="100,4,7,2,2"></datalist>

댓글 :

f=x=>x.map((y,i)=>o[j=(j-=i%2?y:-y)<0?o.unshift(...Array(-j))&0:j]=y,o=[],j=-1)&&[...o].map(y=>y||'_').join``
                /* initialize output array [] and index j at -1: */  o=[],j=-1
     x.map((y,i)=> /* iterate over all items in input x (y=item, i=index) */  )
                      (j-=i%2?y:-y) /* update j +/-y based on if index i is odd */
                                   <0? /* if resulting j index is less than zero */
                                      o.unshift(...Array(-j)) /* prepend -j extra slots to the output array */
                                                             &0 /* and give result 0 */
                                                               :j /* else give result j */
                    j= /* assign result to j */
                  o[ /* assign y to output array at index j */   ]=y
   /* short-circuit && then spread output array to fill any missing entries */ &&[...o]
                                                      /* fill falsey slots with '_' */ .map(y=>y||'_')
                                                                         /* join with empty spaces */ .join``

펄 6 , 68 67 바이트

{(my @a)[[[\+] |(1,-1)xx*Z*$_].&{$_ X-min 1,|$_}]=$_;[~] @a X//"_"}

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

작동 원리

먼저 누적 점프 위치를 결정합니다.

[[\+] |(1,-1)xx*Z*$_]
                  $_  # Input array.          e.g.  2, 3, 6, 8, 2
      |(1,-1)xx*      # Infinite sequence:          1,-1, 1,-1, 1...
                Z*    # Zip-multiplied.       e.g.  2,-3, 6,-8, 2
 [\+]                 # Cumulative addition.  e.g.  2,-1, 5,-3,-1

그런 다음 모든 숫자에서 최소 수 (최대 1)를 빼서 0을 기준으로 배열 인덱스로 바꿉니다.

.&{$_ X-min 1,|$_}    #                       e.g.  5, 2, 8, 0, 2

그런 다음 해당 인덱스에 지정된 입력 번호로 배열을 만듭니다.

(my @a)[   ]=$_;      #                       e.g.  8, Nil, 2, Nil, Nil, 2 Nil, Nil, 6

마지막으로 정의되지 않은 요소 대신 밑줄을 사용하여 배열을 문자열로 연결합니다.

[~] @a X//"_"         #                       e.g.  8_2__2__6

젤리 ,  28  24 바이트

FrownyFrog 덕분에 -2 (그리고 또 다른 -2 허용 Ƥ)

ṚƤḅ-µCṀ»0+µṬ€×"³Ṛo/o”_;⁷

온라인으로 사용해보십시오! 동일한 기능을 사용하는 테스트 스위트의 전체 프로그램은 여기를 클릭 하십시오 .

방법?

ṚƤḅ-µCṀ»0+µṬ€×"³Ṛo/o”_;⁷ - Main link: list a       e.g. [ 5, 3, 2, 1]
 Ƥ                       - prefix application of:
Ṛ                        -  reverse                e.g. [[5],[3,5],[2,3,5],[1,2,3,5]]
   -                     - literal minus one
  ḅ                      - from base (vectorises)  e.g. [ 5, 2, 4, 3]=
    µ                    - start a new monadic chain - call that list c
                         - [code to shift so minimum is 1 or current minimum]
     C                   - complement (vectorises) e.g. [-4,-1,-3,-2]
      Ṁ                  - maximum                 e.g.     -1
       »0                - maximum of that & zero  e.g.      0
         +               - add to c (vectorises)   e.g. [ 5, 2, 4, 3]
          µ              - start a new monadic chain - call that list d
           Ṭ€            - untruth €ach            e.g. [[0,0,0,0,1],[0,1],[0,0,0,1],[0,0,1]]
               ³         - the program input (a)
             ×"          - zip with multiplication e.g. [[0,0,0,0,5],[0,3],[0,0,0,2],[0,0,1]]
                Ṛ        - reverse                      [[0,0,1],[0,0,0,2],[0,3],[0,0,0,0,5]]
                 o/      - reduce with or          e.g. [0,3,1,2,5]
                    ”_   - '_'
                   o     - or (replace 0 with '_') e.g. ['_',3,1,2,5]
                      ;⁷ - concatenate a newline   e.g. ['_',3,1,2,5, '\n']
                         - implicit print

노트:

개행의 최종 연결은 출력에 나타나지 ;⁷않는 경우를위한 것 _입니다.이 경우 암시 적 인쇄는 예 [3, 1, 2, 4]를 들어서와 같이 목록의 표시를 표시합니다 _3125. 대체 할 수없는 후행 줄 바꿈 하나의 경우 ;⁷에 ;““문자리스트의 목록을 추가하려면, [[''],['']](더 가까운 ”이 프로그램의 마지막 문자의로 필요 없음).

비 진실 함수 Ṭ는 1입력에서 인덱스에 s 가 포함 된 목록을 제공합니다 . 단일 자연수 n 은 n-1 0 s 1이며 입력 숫자는 왼쪽에서 올바른 거리에 곱셈으로 배치됩니다. . 반전 Ṛ은 또는로 축소를 수행 할 때 초기 개구리 방문보다 나중에 개구리 방문을 덮어 써야 합니다 o/.

APL (Dyalog Unicode) , 45 30 바이트 ^SBCS

{∊⍕¨⍵@i⍴∘'_'⌈/1+i←(⊢-1⌊⌊/)-\⍵}

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

-\⍵교대로 논쟁을 스캔 -하고+

(⊢ - 1 ⌊ ⌊/)그 ( ⊢) 에서 1을 빼거나 최소값 ( ⌊/) 중 작은 값 ( ⌊)

i← 할당하다 i

⌈/ 1+ 증분 최대

⍴∘'_' 많은 밑줄을 만들어

⍵@i인수 ( ⍵) 의 숫자를 위치에 넣습니다.i

∊⍕¨ 각각을 포맷하고 평평하게

루비 , 85 바이트

->a{i=1;j=c=0;a.map{|x|[c-=x*i=-i,x]}.to_h.sort.map{|x,y|[?_*[x+~j,0*j=x].max,y]}*''}

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

각 점프 후 위치를 기록하고 결과 배열을 해시로 변환하여 중복을 제거하고 (각 중복 된 위치에서 마지막 값을 유지) 필요한 양의 밑줄로 값을 붙입니다.

파이썬 2 , 113110 바이트

J=input()
i=sum(J)
l=['_']*2*i
v=i,
d=1
for j in J:i+=d*j;d=-d;l[i]=`j`;v+=i,
print''.join(l[min(v):max(v)+1])

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