En este desafío, debes simular una rana saltando de un lado a otro en nenúfares. El estanque es infinitamente grande, tiene una línea de un número infinito de nenúfares, y la rana puede saltar tantos nenúfares como quiera.

A esta rana le gusta saltar de un lado a otro: después de saltar hacia adelante, siempre salta hacia atrás y viceversa.

Se te pasa una lista de enteros, que representa sus saltos. Necesitas dar salida al resultado de sus saltos.

Por ejemplo, digamos que te aprobaron [2,3,6,8,2]:

Nuestra rana comienza saltando 2 nenúfares hacia adelante:

_2

Luego 3 hojas de lirio de vuelta:

3__2

Luego 6 hojas de lirio hacia adelante:

3__2__6

8 de vuelta:

8_3__2__6

Luego, finalmente, 2 nenúfares hacia adelante (observe cómo el 2 sobrescribe al 3):

8_2__2__6

Para ser más explícito: su entrada es una matriz de números S, necesita salir S[K]en la posición S[K] - S[K-1] + S[K-2] - S[K-3]....

• Si se van a imprimir varios números en una ubicación determinada, imprima solo el que tenga el índice más alto.
• Debe usar _si una ubicación en particular está vacía
• Si un número tiene varios dígitos, no ocupa múltiples ubicaciones. (En otras palabras, una ubicación puede constar de varios caracteres)
• Puede suponer que su lista no está vacía y que todos los enteros son mayores que 0.

Casos de prueba:

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

Este es un código de golf , ¡así que responda en la menor cantidad de caracteres posible!

MATL , 35 34 bytes

¡Gracias a @Emigna por guardar 1 byte!

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

Pruébalo en línea! O verificar todos los casos de prueba .

Cómo funciona

¡Golf tu código, no tus explicaciones!

Lo siguiente usa la entrada [2,3,6,8,2]como ejemplo. Para ver resultados intermedios en el código real, puede insertar un %(símbolo de comentario) para detener el programa en ese punto y ver el contenido de la pila. Por ejemplo, esto muestra la pila después de la declaración Ys(suma acumulativa).

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 bytes

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++]?:_;

toma datos de los argumentos de la línea de comandos; correr con -nr.

Descompostura

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

Javascript (ES6), 99 107 bytes

Editar: Debido a que el OP aclaró que el único límite debería ser la memoria disponible, esto se actualizó para asignar exactamente el espacio requerido en lugar de depender de un rango máximo codificado.

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)

Cómo funciona

Esta función funciona en dos pases:

• Durante el primer pase:

  • El 'puntero de rana' pse inicializa en 0.
  • La xvariable se establece en una cadena vacía, de modo que todos los intentos de modificarla simplemente se ignoran.
  • Calculamos my Mcuáles son, respectivamente, los valores mínimos y máximos alcanzados por p.
  • Al final de este pase: hacemos una llamada recursiva a f().

• Durante el segundo pase:

  • pse inicializa a -m.
  • xse establece en una matriz de tamaño M-m, llena de _caracteres.
  • Insertamos los números en las posiciones correctas en x.
  • Al final de este pase: devolvemos una versión conjunta de x, que es el resultado final.

Casos de prueba

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 bytes

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='')}

Pruébalo en línea!

La línea 1 encuentra todas las posiciones donde saltar. Primero, todos los saltos xse multiplican por 1 o −1 y luego se transforman en posiciones finales usando la suma acumulativa. El vector c(-1,1)se recicla si es necesario, sin embargo, cuando xes de longitud 1, xse recicla en su lugar. Por lo tanto, solo se consideran sumas seq(x^0)(equivalentes a seq_along(x)). (Se genera una advertencia cuando la longitud de xno es múltiplo de 2 pero no afecta el resultado)

La línea 2 aumenta las posiciones de salto para que todos sean al menos 1.

Las líneas 3 y 4 crean el resultado y lo imprimen.

−1 byte de Giuseppe

Javascript (ES6), 109 bytes

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>

Comentado:

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``

Perl 6 , 68 67 bytes

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

Pruébalo en línea!

Cómo funciona

Primero determina las ubicaciones de salto acumulativas:

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

Luego los convierte en índices de matriz basados ​​en 0 restando el número mínimo (pero como máximo 1) de todos los números:

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

Luego crea una matriz con los números de entrada asignados a esos índices:

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

Finalmente concatena la matriz a una cadena, con el guión bajo en lugar de elementos indefinidos:

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

Jalea ,  28  24 bytes

-2 (y permitiendo aún más -2) gracias a FrownyFrog (use la funcionalidad [post-desafío] de la aplicación de prefijo rápido, Ƥ)

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

Pruébalo en línea! Programa completo, para un conjunto de pruebas con la misma funcionalidad, haga clic aquí .

¿Cómo?

ṚƤḅ-µ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

Notas:

La concatenación final de una nueva línea ;⁷es para casos en los que no _aparece en la salida, en cuyo caso la impresión implícita mostrará una representación de la lista, por ejemplo [3, 1, 2, 4], en lugar de algo como el ejemplo _3125,. Para que no haya una nueva línea final, se puede reemplazar ;⁷con ;““para agregar una lista de listas de caracteres [[''],['']](no se ”requiere cierre, ya que es el último carácter de un programa).

La función de falsedad, Ṭ, proporciona una lista con 1s en los índices en su entrada, para un solo número natural, n que es n-1 0 s seguido de un 1permiso que permite colocar los números de entrada a su distancia correcta desde la izquierda por multiplicación . Se Ṛrequiere la reversión para que las visitas posteriores a las ranas se sobrescriban en lugar de las anteriores cuando se realiza la reducción con o o/,.

APL (Dyalog Unicode) , 45 30 bytes ^SBCS

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

Pruébalo en línea!

-\⍵escanear el argumento con alternancia -y+

(⊢ - 1 ⌊ ⌊/)de eso ( ⊢) reste 1 o el mínimo ( ⌊/), el que sea menor ( ⌊)

i← asignar a i

⌈/ 1+ aumentar y tomar el máximo

⍴∘'_' producir tantos guiones bajos

⍵@iponer los números del argumento ( ⍵) en las posicionesi

∊⍕¨ formatear cada uno y aplanar

Ruby , 85 bytes

->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]}*''}

Pruébalo en línea!

Registra las posiciones después de cada salto, convierte la matriz resultante en hash para eliminar duplicados (preservando el último valor en cada posición duplicada) y luego pega los valores con la cantidad requerida de guiones bajos.

Python 2 , 113 110 bytes

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])

Pruébalo en línea!