In dieser Herausforderung musst du einen Frosch simulieren, der auf Seerosenblättern vor und zurück springt. Der Teich ist unendlich groß, hat eine Reihe mit unendlich vielen Seerosenblättern und der Frosch kann über so viele Seerosenblätter springen, wie er möchte.

Dieser Frosch springt gern hin und her: Nach einem Sprung nach vorne springt er immer rückwärts und umgekehrt.

Ihnen wird eine Liste von ganzen Zahlen übergeben, die seine Sprünge darstellt. Sie müssen das Ergebnis seiner Sprünge ausgeben.

Angenommen, Sie sind bestanden [2,3,6,8,2]:

Unser Frosch springt zunächst zwei Seerosenblätter nach vorne:

_2

Dann 3 Seerosenblätter zurück:

3__2

Dann 6 Seerosenblätter vorwärts:

3__2__6

8 zurück:

8_3__2__6

Dann schliesslich 2 Seerosenblöcke nach vorne (beachten Sie, wie die 2 die 3 überschreibt):

8_2__2__6

Genauer gesagt: Ihre Eingabe ist ein Array von Zahlen S, die Sie S[K]an der Position ausgeben müssen S[K] - S[K-1] + S[K-2] - S[K-3]....

• Wenn mehrere Nummern an einem bestimmten Ort gedruckt werden sollen, drucken Sie nur die mit dem höchsten Index.
• Sie sind zu verwenden, _wenn ein bestimmter Ort leer ist
• Wenn eine Nummer aus mehreren Ziffern besteht, werden nicht mehrere Stellen belegt. (Mit anderen Worten, ein Ort kann aus mehreren Zeichen bestehen.)
• Sie können davon ausgehen, dass Ihre Liste nicht leer ist und alle Ganzzahlen größer als 0 sind.

Testfälle:

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

Dies ist ein Code-Golf , also beantworte es mit so wenig Zeichen wie möglich!

MATL , 35 34 Bytes

Vielen Dank an @Emigna für das Speichern von 1 Byte!

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

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Wie es funktioniert

Spielen Sie Ihren Code, nicht Ihre Erklärungen!

Im Folgenden wird die Eingabe [2,3,6,8,2]als Beispiel verwendet. Um Zwischenergebnisse im tatsächlichen Code anzuzeigen, können Sie ein %(Kommentarsymbol) einfügen , um das Programm an dieser Stelle anzuhalten und den Stapelinhalt anzuzeigen. Dies zeigt zum Beispiel den Stapel nach Anweisung Ys(kumulative Summe).

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

Nimmt Eingaben von Befehlszeilenargumenten entgegen. renn mit -nr.

Nervenzusammenbruch

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

Bearbeiten: Da das OP klarstellte, dass das einzige Limit der verfügbare Speicher sein sollte, wurde dieses Update aktualisiert, um genau den erforderlichen Speicherplatz zuzuweisen, anstatt sich auf einen fest codierten Maximalbereich zu verlassen.

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)

Wie es funktioniert

Diese Funktion arbeitet in zwei Durchgängen:

• Während des ersten Durchgangs:

  • Der 'Froschzeiger' pwird auf initialisiert 0.
  • Die xVariable ist auf eine leere Zeichenfolge festgelegt, sodass alle Änderungsversuche einfach ignoriert werden.
  • Wir berechnen mund Mwelche sind die minimalen und maximalen Werte, die von erreicht werden p.
  • Am Ende dieses Durchgangs: Wir rufen rekursiv auf f().

• Während des zweiten Durchgangs:

  • pwird initialisiert zu -m.
  • xist auf ein Array mit einer Größe festgelegt M-m, die mit _Zeichen gefüllt ist .
  • Wir fügen die Zahlen an den richtigen Stellen in ein x.
  • Am Ende dieses Durchlaufs: Wir geben eine verbundene Version von zurück x, die das Endergebnis ist.

Testfälle

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

Probieren Sie es online!

Zeile 1 findet alle Positionen, an denen gesprungen werden soll. Zunächst werden alle Einsprünge xmit 1 oder –1 multipliziert und dann mit kumulativer Summierung zu Endpositionen transformiert. Der Vektor c(-1,1)wird bei Bedarf recycelt, wenn er jedoch die xLänge 1 hat, xwird er stattdessen recycelt. Daher werden nur seq(x^0)(äquivalente seq_along(x)) Beträge berücksichtigt. (Eine Warnung wird generiert, wenn die Länge von xnicht ein Vielfaches von 2 ist, aber das Ergebnis nicht beeinflusst.)

Zeile 2 erhöht die Sprungpositionen, sodass alle mindestens 1 sind.

In den Zeilen 3 und 4 wird die Ausgabe erstellt und gedruckt.

−1 Byte von Giuseppe

Javascript (ES6), 109 Byte

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>

Kommentiert:

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//"_"}

Probieren Sie es online!

Wie es funktioniert

Zunächst werden die kumulativen Sprungstellen ermittelt:

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

Dann werden sie in 0-basierte Array-Indizes umgewandelt, indem die minimale Zahl (aber höchstens 1) von allen Zahlen subtrahiert wird:

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

Dann erstellt es ein Array mit den Eingangsnummern, die diesen Indizes zugewiesen sind:

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

Schließlich wird das Array zu einer Zeichenfolge verkettet, wobei der Unterstrich anstelle von undefinierten Elementen verwendet wird:

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

Jelly ,  28  24 Bytes

-2 (und weitere -2 zulassen) dank FrownyFrog (benutze schnell die [post-challenge] -Funktion der Präfix-Anwendung Ƥ)

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

Probieren Sie es online! Das vollständige Programm für eine Testsuite mit derselben Funktionalität finden Sie hier .

Wie?

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

Anmerkungen:

Die letzte Verkettung einer neuen Zeile ;⁷ist für Fälle vorgesehen _, in denen in der Ausgabe kein Eintrag vorhanden ist. In diesem Fall zeigt der implizite Ausdruck eine Darstellung der Liste an, z. B. [3, 1, 2, 4]anstelle des Beispiels _3125. Für keine nachlauf Newline ersetzen könnte ;⁷mit ;““einer Liste von Zeichenlisten anhängen, [[''],['']](nein schließen ”erforderlich , da es das letzte Zeichen eines Programms ist).

Die Unwahrheitsfunktion Ṭ gibt eine Liste mit 1s an den Indexen in ihrer Eingabe für eine einzelne natürliche Zahl an, n mit n-1 0 s, gefolgt von einem 1Ermöglichen, dass die eingegebenen Zahlen durch Multiplikation in ihrem korrekten Abstand von links platziert werden . Die Umkehr Ṛist, erforderlich haben späte Frosch-Besuche überschreiben , anstatt früher diejenigen , wenn die Reduktion mit oder o/, durchgeführt wird.

APL (Dyalog Unicode) , 45 30 Byte ^SBCS

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

Probieren Sie es online!

-\⍵scannen Sie das Argument abwechselnd mit -und+

(⊢ - 1 ⌊ ⌊/)von diesem ( ⊢) subtrahiere 1 oder das Minimum ( ⌊/), je nachdem, welches kleiner ist ( ⌊)

i← zuweisen i

⌈/ 1+ inkrementieren und das Maximum nehmen

⍴∘'_' produzieren so viele Unterstriche

⍵@iSetzen Sie die Zahlen aus dem Argument ( ⍵) an die Positioneni

∊⍕¨ jeweils formatieren und abflachen

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

Probieren Sie es online!

Zeichnet die Positionen nach jedem Sprung auf, konvertiert das resultierende Array in einen Hash, um Duplikate zu entfernen (wobei der letzte Wert an jeder duplizierten Position beibehalten wird), und klebt dann die Werte mit der erforderlichen Anzahl von Unterstrichen.

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

Probieren Sie es online!