Bu mücadelede, zambak yastıklarında ileri geri zıplayan bir kurbağaya benzetmeniz gerekir. Su birikintisi sonsuz derecede büyüktür, sonsuz sayıda zambak yastığı vardır ve kurbağa istediği kadar zambak yastığı geçebilir.

Bu kurbağa ileri geri atlamayı sever: ileri atladıktan sonra, her zaman geriye doğru zıplar ve tam tersi.

Onun atlayışını temsil eden bir tamsayılar listesine girdiniz. Onun atlayışlarının sonucunu çıkarmanız gerekiyor.

Örneğin, geçtiğinizi söyleyin [2,3,6,8,2]:

Kurbağamız, 2 zambak yastığı atlayarak başlar:

_2

Sonra 3 zambak geri yastık:

3__2

Ardından 6 zambak öne doğru:

3__2__6

8 geri:

8_3__2__6

Sonra nihayet, 2 zambak öne doğru uzanır (2'nin üzerine nasıl yazıldığına dikkat edin):

8_2__2__6

Daha açık olmak gerekirse: Girişiniz bir sayı dizisidir , pozisyonda Sçıkış yapmanız gerekir .S[K]S[K] - S[K-1] + S[K-2] - S[K-3]...

• Belirli bir yere birden çok numara yazdırılacaksa, yalnızca en yüksek dizine sahip olanı yazdırın.
• Sen kullanımına olan _belirli bir konum boşsa
• Bir sayının birden fazla basamağı varsa, birden fazla konum almaz. (Başka bir deyişle, bir konum birden çok karakterden oluşabilir)
• Listenizin boş olmadığını ve tüm tam sayıların 0'dan büyük olduğunu varsayabilirsiniz.

Test durumları:

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

Bu bir kod golf , bu yüzden mümkün olduğunca az karakter olarak cevap!

MATL , 35 34 bayt

1 byte tasarruf için @Emigna teşekkürler !

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

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

Nasıl çalışır

Kodunuzu yazın, açıklamalarınızı değil!

Aşağıdaki [2,3,6,8,2]örnek olarak girişi kullanır . Ara sonuçları gerçek kodda %görmek için, programı o noktada durdurmak ve yığın içeriğini görmek için bir (yorum sembolü) eklemek isteyebilirsiniz . Örneğin, bu deyimden sonra yığını gösterir Ys(kümülatif toplam).

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 bayt

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

komut satırı argümanlarından girdi alır; ile koş -nr.

Yıkmak

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 bayt

Düzenleme: OP tek sınırın mevcut bellek olması gerektiğini açıkladığından, kodlanmış bir maksimum aralığa güvenmek yerine tam olarak gereken alanı tahsis etmek için güncellenmiştir.

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)

Nasıl çalışır

Bu işlev iki geçişte çalışır:

• İlk geçişte:

  • 'Kurbağa işaretçisi' polarak başlatıldı 0.
  • xDeğişken boş bir dizeye ayarlanmış olduğundan, onu değiştirmek için tüm girişimler sadece göz ardı edilir söyledi.
  • Biz hesaplıyoruz mve Msırasıyla en düşük ve en yüksek değerlerin ulaştığını p.
  • Bu geçişten sonra: özyinelemeli bir çağrı yaparız f().

• İkinci geçiş sırasında:

  • piçin başlatıldı -m.
  • xkarakterlerle M-mdolu bir boyut dizisine ayarlanır _.
  • Sayıları doğru pozisyonlara yerleştiriyoruz x.
  • Bu pasonun sonunda: xNihai sonuç olan ortak versiyonunu geri veriyoruz .

Test durumları

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 bayt

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

Çevrimiçi deneyin!

Çizgi 1, atlanacak tüm konumları bulur. İlk olarak, tüm sıçramalar x1 veya −1 ile çarpılır ve daha sonra kümülatif toplamı kullanarak son pozisyonlara dönüştürülür. c(-1,1)Gerekirse vektör geri dönüştürülür, ancak xuzunluk 1 xolduğunda bunun yerine geri dönüştürülür. Bu nedenle sadece seq(x^0)(eşdeğer seq_along(x)) toplamlar dikkate alınır. (Uzunluğu x2 katı olmadığında bir uyarı verilir, ancak sonucu etkilemez)

Satır 2, atlama pozisyonlarını, en az 1 olacak şekilde arttırır.

3. ve 4. satırlar çıktıyı oluşturur ve yazdırır.

From1 bayt: Giuseppe

Javascript (ES6), 109 bayt

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>

Yorumlananlar:

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 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

İlk önce kümülatif atlama konumlarını belirler:

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

Sonra en az sayıyı (ancak en fazla 1) tüm sayılardan çıkararak bunları 0 tabanlı dizi dizinlerine dönüştürür:

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

Daha sonra bu endekslere atanmış giriş numaralarıyla bir dizi oluşturur:

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

Sonunda diziyi bir dizeyle birleştirir, alt çizgi tanımsız öğeler yerine:

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

Jöle ,  28  24 bayt

-2 (hızlı [tehdit sonrasında] ile önek uygulama işlevselliğini FrownyFrog sayesinde (ve diğer -2 sağlayan) Ƥ)

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

Çevrimiçi deneyin! Tam program, aynı işlevselliği kullanan bir test paketi için burayı tıklayın .

Nasıl?

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

Notlar:

Bir yeni satırın son birleştirmesi çıktıda görünmediği ;⁷durumlar içindir _, bu durumda örtülü baskı, örneğin [3, 1, 2, 4], örneğin bir şey yerine listenin bir gösterimini görüntüler _3125. İzleyen hiçbir yeni satır için, karakter listelerinin bir listesini eklemek için bir kişi ;⁷ile değiştirilemez (bir programın son karakteri olduğu için yakınına gerek yoktur ).;““[[''],['']]”

Yalan fonksiyonu, T, bir listesini verir 1, tek bir doğal sayı için, 's girdi dizinler s, n, yani n-1 0 s, ardından 1sağlayan giriş numaraları çoğalması ile soldan sağa doğru mesafede yerleştirilmesini . Ters, Ṛsahip olması gereken sonradan kurbağa ziyaretler yerine üzerine önceki azaltma ya, ne zaman olanları o/, gerçekleştirilir.

APL (Dyalog Unicode) , 45 30 bayt ^SBCS

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

Çevrimiçi deneyin!

-\⍵argümanı değişimli -ve+

(⊢ - 1 ⌊ ⌊/)ondan ( ⊢) 1'i veya minimumunu ( ⌊/), hangisi daha küçükse ( ⌊) çıkarın

i← atamak i

⌈/ 1+ artırma ve maksimuma çıkarma

⍴∘'_' bu kadar çok alt çizgi oluşturmak

⍵@iargümandaki ( ⍵) sayıları pozisyonlara koymaki

∊⍕¨ her birini biçimlendirin ve düzleştirin

Ruby , 85 bayt

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

Çevrimiçi deneyin!

Her atlamadan sonra pozisyonları kaydeder, elde edilen diziyi kopyaları çıkarmak için (her bir kopyalanan pozisyondaki son değeri koruyarak) karma değerine dönüştürür ve ardından değerleri istenen alt çizgi miktarına yapıştırır.

Python 2 , 113 110 bayt

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

Çevrimiçi deneyin!