Dans ce défi, vous devez simuler une grenouille sautant d'avant en arrière sur des nénuphars. L'étang est infiniment grand, a une ligne d'un nombre infini de nénuphars, et la grenouille peut sauter sur autant de nénuphars qu'il le souhaite.

Cette grenouille aime sauter d'avant en arrière: après avoir sauté en avant, il saute toujours en arrière , et vice versa.

Vous passez une liste d'entiers, qui représente ses sauts. Vous devez sortir le résultat de ses sauts.

Par exemple, disons que vous avez réussi [2,3,6,8,2]:

Notre grenouille commence par sauter 2 nénuphars en avant:

_2

Puis 3 nénuphars en arrière:

3__2

Puis 6 nénuphars en avant:

3__2__6

8 dos:

8_3__2__6

Puis enfin, 2 nénuphars en avant (remarquez comment les 2 écrasent les 3):

8_2__2__6

Pour être plus explicite: votre entrée est un tableau de nombres S, vous devez sortir S[K]à la position S[K] - S[K-1] + S[K-2] - S[K-3]....

• Si plusieurs numéros doivent être imprimés à un certain emplacement, n'imprimez que celui dont l'indice est le plus élevé.
• Vous devez utiliser _si un emplacement particulier est vide
• Si un numéro comporte plusieurs chiffres, il n'occupe pas plusieurs emplacements. (En d'autres termes, un emplacement peut être composé de plusieurs caractères)
• Vous pouvez supposer que votre liste n'est pas vide et que tous les entiers sont supérieurs à 0.

Cas de test:

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

Ceci est un code-golf , alors répondez-y en aussi peu de caractères que possible!

MATL , 35 34 octets

Merci à @Emigna pour avoir économisé 1 octet!

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

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Comment ça marche

Jouez votre code, pas vos explications!

Ce qui suit utilise l'entrée [2,3,6,8,2]comme exemple. Pour voir les résultats intermédiaires dans le code réel, vous souhaiterez peut-être insérer un %(symbole de commentaire) pour arrêter le programme à ce stade et voir le contenu de la pile. Par exemple, cela montre la pile après l'instruction Ys(somme cumulée).

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 octets

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

prend l'entrée des arguments de la ligne de commande; courir avec -nr.

panne

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 octets

Edit: Parce que l'OP a précisé que la seule limite devrait être la mémoire disponible, cela a été mis à jour pour allouer exactement l'espace requis au lieu de compter sur une plage maximale codée en dur.

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)

Comment ça marche

Cette fonction fonctionne en deux passes:

• Lors du premier passage:

  • Le «pointeur de grenouille» pest initialisé à 0.
  • La xvariable est définie sur une chaîne vide, de sorte que toutes les tentatives de modification sont simplement ignorées.
  • Nous calculons met Mqui sont respectivement les valeurs minimum et maximum atteintes par p.
  • A la fin de ce pass: nous faisons un appel récursif à f().

• Lors du deuxième passage:

  • pest initialisé à -m.
  • xest défini sur un tableau de taille M-m, rempli de _caractères.
  • Nous insérons les chiffres aux positions correctes dans x.
  • A la fin de ce pass: on retourne une version jointe de x, qui est le résultat final.

Cas de test

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 octets

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

Essayez-le en ligne!

La ligne 1 trouve toutes les positions où sauter. Tout d'abord, tous les sauts xsont multipliés par 1 ou -1, puis transformés en positions finales en utilisant la somme cumulative. Le vecteur c(-1,1)est recyclé si nécessaire, cependant, lorsqu'il xest de longueur 1, il xest recyclé à la place. Par conséquent, seules les sommes seq(x^0)(équivalentes à seq_along(x)) sont prises en compte. (Un avertissement est généré lorsque la longueur de xn'est pas un multiple de 2 mais qu'elle n'affecte pas le résultat)

La ligne 2 augmente les positions de saut afin que tous soient au moins 1.

Les lignes 3 et 4 créent la sortie et l'impriment.

−1 octet de Giuseppe

Javascript (ES6), 109 octets

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>

Commenté:

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 octets

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

Essayez-le en ligne!

Comment ça marche

Il détermine d'abord les emplacements de saut cumulatifs:

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

Ensuite, il les transforme en indices de tableau basés sur 0 en soustrayant le nombre minimum (mais au plus 1) de tous les nombres:

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

Ensuite, il crée un tableau avec les numéros d'entrée attribués à ces indices:

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

Enfin, il concatène le tableau en une chaîne, avec le soulignement à la place des éléments non définis:

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

Gelée ,  28  24 octets

-2 (et en permettant un autre -2) grâce à FrownyFrog (utilisez rapidement la fonctionnalité [post-challenge] de l'application de préfixe, Ƥ)

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

Essayez-le en ligne! Programme complet, pour une suite de tests utilisant les mêmes fonctionnalités, cliquez ici .

Comment?

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

Remarques:

La concaténation finale d'une nouvelle ligne, ;⁷est pour les cas où aucun _n'apparaît dans la sortie, auquel cas l'impression implicite afficherait une représentation de la liste, par exemple [3, 1, 2, 4], plutôt que quelque chose comme l'exemple _3125,. Pour aucun retour à la ligne, on pourrait remplacer ;⁷par ;““pour ajouter une liste de listes de caractères [[''],['']](pas de fermeture ”requise car c'est le dernier caractère d'un programme).

La fonction de contrefaçon, Ṭ, donne une liste avec 1s aux index dans son entrée, pour un seul nombre naturel, n qui est n-1 0 s suivi de a 1permettant aux nombres d'entrée d'être placés à leur distance correcte de la gauche par multiplication . L'inversion,, Ṛest nécessaire pour écraser les visites de grenouilles ultérieures plutôt que les précédentes lorsque la réduction avec ou o/, est effectuée.

APL (Dyalog Unicode) , 45 30 octets ^SBCS

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

Essayez-le en ligne!

-\⍵scanner l'argument avec alternance -et+

(⊢ - 1 ⌊ ⌊/)de ( ⊢) soustraire 1 ou le minimum ( ⌊/), le plus petit des deux ( ⌊)

i← affecter à i

⌈/ 1+ incrémenter et prendre le maximum

⍴∘'_' produire autant de soulignements

⍵@imettre les nombres de l'argument ( ⍵) aux positionsi

∊⍕¨ formater chacun et aplatir

Rubis , 85 octets

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

Essayez-le en ligne!

Enregistre les positions après chaque saut, convertit le tableau résultant en hachage pour supprimer les doublons (en conservant la dernière valeur à chaque position dupliquée), puis colle les valeurs avec la quantité requise de soulignements.

Python 2 , 113 110 octets

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

Essayez-le en ligne!