Giriş aşağıdaki karakterlerden oluşacaktır:

• ^: Bir tane yukarı git
• v: Aşağı inin
• ▲ veya k : İkie kadar git
• ▼veya j: İki aşağı in

Örneğin, aşağıdaki giriş:

^^▲^v▼▲^^v

aşağıdaki çıktıyı üretecektir:

        ^
   ^   ^ v
  ▲ v ▲

 ^   ▼
^

İmleci gibi hareket ettiren çıkış dizileri \e[B izin verilmez. Çıktıyı boşlukları ve yeni satırları kullanarak üretmelisiniz.

İşte birkaç test vakası.

▲v^v^v^v^v^v^v^v▲

                ▲
▲ ^ ^ ^ ^ ^ ^ ^ 
 v v v v v v v v

^^^^^^^▲▲▲▼▼▼vvvvvv

         ▲

        ▲ ▼

       ▲   ▼

      ^     ▼
     ^       v
    ^         v
   ^           v
  ^             v
 ^               v
^                 v

v^^vv^^vvv^v^v^^^vvvv^^v^^vv

  ^   ^         ^
 ^ v ^ v       ^ v       ^
v   v   v ^ ^ ^   v   ^ ^ v
         v v v     v ^ v   v
                    v

Pyth, 27 bayt

jCm.<.[*5lzd\ =+Ztx"v ^k"dz

Çevrimiçi deneyin: Gösteri veya Test Paketi

Kullandığım kve jyerine ▲ve ▼. Önde gelen ve takip eden boş çizgiler var. Görüntüyü bulmak için biraz aramanız gerekiyor. İşte tüm önde gelen ve sondaki boş satırları kaldıran 34 baytlık bir sürümü.

j.sCm.<.[*5lzd\ =+Ztx"v ^k"dz]*lzd

Çevrimiçi deneyin: Gösteri veya Test Paketi

Açıklama:

jCm.<.[*5lzd\ =+Ztx"v ^k"dz  implicit: Z = 0
  m                       z  map each char d from input string z to:
                  x"v ^k"d     find d in the string "v ^k", -1 if not found
                 t             -1, that gives -2 for j, -1 for v, 1 for ^ and 2 for k
              =+Z              add this number to Z
     .[*5lzd\                  append spaces on the left and on the right of d, 
                               creating a 5*len(input_string) long string
   .<           Z              rotate this string to the left by Z chars
jC                           transpose and print on lines

Okunamayan , 2199 2145 2134 2104 2087 2084 bayt

Destekler hem k/ jhem de ▲/ '▼ sözdizimini destekler.

İyi Okunamayan geleneğinde, burada kesme işareti ve çift tırnak arasındaki farkı gizlemek için orantılı fontta biçimlendirilmiş programdır:

' '' '' ''' "" "" "" "" ' '' ' ' '''' ' ' '''' "' '' "' '' ''" ' '' '' ''' "" ' ''' "" ' ''' "" " ' '''" "" "" " ' '' '' '''" "" "" "" " ' '' ' ' '''' " ' '' '' '' ' ' '' '' '' '''' '''" "" "" "" "" " ' '' '''" "" " ' '' ''' '' ''' "" "" ' '' '' ''' "" ' ''' "" ' ''' "" ' '' ' ' '''' ''' "" "" "" ' ''' "" ' ''' "" ' '' "' '' '' '' '' "' '' '' ' ' '' '' '''' ' ' ''''"'" " ' '' ' ' '' '' '' '''' '' '' '''" " ' '''" " ' '''" "" ' '' ''' "" """" ' '''" " ' '''" " ' '''" "" ' '' '' '' '' "' '' '' '' ' ' '''' ' ' ''''" ' ''' "" " ' '' '' '' '''" "" "" "" ' ''' "" ' ''' "" ' ''' "" " ' '''" "' "" " ' '' '' '''" "" ' '' '' '' '' "' '' '' ''" ' '' ' ' '''' '' '' '''"" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" ' '' '' '' '' ' ' '''' '' '' ''' "" " ' '' '' '' '' ' ' '''' ' ' '''' '' "" "" ' '' ' ' '' ' ' '''' ' ' '' ' ' '''' '''' '' '' '' '''' '' '' ''' ''' "" ' ''' "" ' ''' "" " ' '' ' ' '''' ' ' '' ' ' '' '' '''' '''' '' '' "" "" ' '' '' '' "' '' "' '' '' '' '' ' ' ''''" ' '' '' ''"' '' "' '' ''" "" "" ' ''' "" ' ''' "" ' '' '' '' "' '' "' '' ' ' ''''"' '' ' ' ''''"" ' '' '' '' '' ' ' '' '' '' ' ' '''' ' ' '''' ' ' '''' '''' ' ' '''' '''" "" ' '' '' ' ' '' '' '''' ' ' '''' ' ' '''' ''' "" "" "" "" ' '' '' '' "'" " ' '''" " ' '''" "" ' '' ''' "" "" ' '' '' '' '' "' '' '' '' ' ' ''''"' ''' "" " ' '' '' '''" " ' '''" " ' '' ' ' '''' '' '' '''" " ' '''" " ' '' " ' '' ' ' '' '' '''' ' ' '''' '''" "' '' '' '' ' ' ''''" ' '' "' '' '' '' ' ''' "" " ' '' '' '' '''" "" "" "" ' ''' "" " ' '' '' ' ' '' '' '''' '''"" "" "" "" ' '' '' '' "' '' ' ' '' '''' '' ' ' '' '' '''' ' ' '''' "' ''" ' '' '' '' ''' "" "" "" " ' '''" " ' '''" "" ' '' '' '' '' "' '' '' '' "'" " ' '''" "" ' '' '' ''' "" ' ''' "" " ' '' '' '' '''" "" "" "" ' ''' ""' '' "' '' ' ' '' '' '''' ' ' '' ' ' '''' '' '' '''' "' '' ' ' '' '' ''''" ' '' '' '' ' ' '' '' '' '''' ''' "" ' '' '' '' ' ' '''' ''' "" "" " ' '' '' "" "" ' '' '' ''' "" ' ''' "" ' '' ' ' '''' '' '' ''' "" ' ''' "" ' ''"' '' ''' "" "" "" ' ''' "" " ' '' '' '' '''" "" "" "" ' ''' "" " ' '' '' '' ' ''' "" ' '' ' ' '''' '' '' ''' "" ' ''' "" " ' '' '' ' ' '' '' '' '''' '' "" " ' '''" "" ' ''' "" "" "" " ' '''" "" ' '' ''' "" "" "" ' '' " ' '''"" "" "" " ' '' '' '' '''" "" ' '' '' ' ' '' '' '' '''' '' '' '' "' '' ''" "' '' ' ' '' '' '' '''' '' '' ''" ' '' '' '' "' '' ' ' '' '' '''' '' '' '' ' '' ' ' '''' '' '' ''' "" "" "" "' ''"' '' '' ' ' '''' " ' '' '' '''"" ' ''' "" " ' '' '' '' '''" "" "" "" ' ''' "" ' '' ' ' '' '''' '' "' ''" " ' '' '' '''" "' '' ' ' '''' ' ' '''' ' ' '''' '' ''" ' '' ' ' '''' "' '' ' ''' "" " ' '' '' ' ' '' '' '' '''' '' '' '' ' ' '' '' '' '''' '' '' ''" ' '' '' '' '''" "" "" " ' '' '' '' '''" "" ' '' '' '' ''' "" "" "" "" '" "" "" "" ' '' '' '' ''' "" "'"' '' '' '' '' ' ' '' '' '''' ' ' '' '' '''' "" ' ''' "" ' '' '' '' ' ' '' ' ' '' '' '' '''' '' '' '''' "' '' '' ''"' '' ' ' '''' ' ' '''' ' ' '''' ' ' '''' ' ' '''' ' ' '''' ' ' ''''"' '' ' ''' "" ' ''' "" ' ''' "" ' ''' "" "" "" " ' '''" "" ' '' '' '' "' '' ''" "" ' '' ' ' '' '' '''' '' '' '' "' '' ' ' '''' "' '' '' ''" ' ''"' "' ''"" "" " ' '''" ""

Bu inanılmaz bir mücadeleydi. Gönderdiğiniz için teşekkür ederiz!

açıklama

Okunamayan'ın yapabileceklerinin neler yapabileceğini hissetmek için Brainfuck'un her iki yönde de sonsuz bir bantla olduğunu hayal edin, ancak bir seferde bir hücreyi hareket ettiren bir bellek işaretçisi yerine, bir işaretçiyi düzenleyerek herhangi bir bellek hücresine erişebilirsiniz. Modulo dahil olmak üzere diğer aritmetik işlemlerin elle yapılması gerektiğine rağmen, bu çözüm oldukça kullanışlı.

İşte programın yönetmen yorumu ile sahte kod olarak:

// Initialize memory pointer. Why 5 will be explained at the very end!
ptr = 5

// FIRST PASS:
// Read all characters from stdin, store them in memory, and also keep track of the
// current line number at each character.

// We need the +1 here so that EOF, which is -1, ends the loop. We increment ptr by 2
// because we use two memory cells for each input character: one contains the actual
// character (which we store here); the other will contain the line number at which the
// character occurs (updated at the end of this loop body).
while ch = (*(ptr += 2) = read) + 1:

    // At this point, ch will be one more than the actual value.
    // However, the most code-economical way for the following loop is to
    // decrement inside the while condition. This way we get one fewer
    // iteration than the value of ch. Thus, the +1 comes in handy.

    // We are now going to calculate modulo 4 and 5. Why? Because
    // the mod 4 and 5 values of the desired input characters are:
    //
    //  ch  %5  %4
    //  ^   1
    //  v   2
    //  k   3
    //  j   4
    //  ▲   0   2
    //  ▼   0   0
    //
    // As you can see, %5 allows us to differentiate all of them except ▲/▼,
    // so we use %4 to differentiate between those two.

    mod4 = 0      // read Update 2 to find out why mod5 = 0 is missing
    while --ch:
        mod5 = mod5 ? mod5 + 1 : -4
        mod4 = mod4 ? mod4 + 1 : -3

    // At the end of this loop, the value of mod5 is ch % 5, except that it
    // uses negative numbers: -4 instead of 1, -3 instead of 2, etc. up to 0.
    // Similarly, mod4 is ch % 4 with negative numbers.

    // How many lines do we need to go up or down?
    // We deliberately store a value 1 higher here, which serves two purposes.
    // One, as already stated, while loops are shorter in code if the decrement
    // happens inside the while condition. Secondly, the number 1 ('""") is
    // much shorter than 0 ('""""""""'""").
    up = (mod5 ? mod5+1 ? mod5+3 ? 1 : 3 : 2 : mod4 ? 3 : 1)
    dn = (mod5 ? mod5+2 ? mod5+4 ? 1 : 3 : 2 : mod4 ? 1 : 3)

    // As an aside, here’s the reason I made the modulos negative. The -1 instruction
    // is much longer than the +1 instruction. In the above while loop, we only have
    // two negative numbers (-3 and -4). If they were positive, then the conditions in
    // the above ternaries, such as mod5+3, would have to be mod5-3 etc. instead. There
    // are many more of those, so the code would be longer.

    // Update the line numbers. The variables updated here are:
    // curLine = current line number (initially 0)
    // minLine = smallest linenum so far, relative to curLine (always non-positive)
    // maxLine = highest linenum so far, relative to curLine (always non-negative)
    // This way, we will know the vertical extent of our foray at the end.

    while --up:
        curLine--
        minLine ? minLine++ : no-op
        maxLine++

    while --dn:
        curLine++
        minLine--
        maxLine ? maxLine-- : no-op

    // Store the current line number in memory, but +1 (for a later while loop)
    *(ptr + 1) = curLine + 1

// At the end of this, minLine and maxLine are still relative to curLine.
// The real minimum line number is curLine + minLine.
// The real maximum line number is curLine + maxLine.
// The total number of lines to output is maxLine - minLine.

// Calculate the number of lines (into maxLine) and the real minimum
// line number (into curLine) in a single loop. Note that maxLine is
// now off by 1 because it started at 0 and thus the very line in which
// everything began was never counted.
while (++minLine) - 1:
  curLine--
  maxLine++

// Make all the row numbers in memory positive by adding curLine to all of them.
while (++curLine) - 1:
  ptr2 = ptr + 1
  while (ptr2 -= 2) - 2:    // Why -2? Read until end!
    *ptr2++

// Finally, output line by line. At each line, we go through the memory, output the
// characters whose the line number is 0, and decrement that line number. This way,
// characters “come into view” in each line by passing across the line number 0.
while (--maxLine) + 2:    // +2 because maxLine is off by 1
  ptr3 = 5
  while (ptr -= 2) - 5:
    print (*((ptr3 += 2) + 1) = *(ptr3 + 1) - 1) ? 32 : *ptr3   // 32 = space
  ptr = ptr3 + 2
  print 10  // newline

Program mantığı için çok fazla. Şimdi bunu Okunamayan'a çevirmemiz ve birkaç ilginç golf oyunu kullanmamız gerekiyor .

Değişkenler her zaman Sayısal olarak Okunamayan öğesinden çıkarılır (örn . a = 1Gibi bir şey olur *(1) = 1). Bazı sayısal değişmezler diğerlerinden daha uzundur; en kısa olanı 1, ardından 2'dir, vb. Ne kadar uzun negatif sayı olduğunu göstermek için, -1 ile 7 arasındaki sayılar:

-1  '""""""""'""""""""'"""  22
 0  '""""""""'"""           13
 1  '"""                     4
 2  '""'"""                  7
 3  '""'""'"""              10
 4  '""'""'""'"""           13
 5  '""'""'""'""'"""        16
 6  '""'""'""'""'""'"""     19
 7  '""'""'""'""'""'""'"""  22

Açıkça, # 1 değişkenini kodda en sık meydana gelen olana tahsis etmek istiyoruz . İlk süre döngüsünde, bu kesinlikle mod5, bu 10 kez geliyor. Ancak mod5, ilk while döngüsünden sonra artık ihtiyacımız yok, bu yüzden aynı bellek konumunu daha sonra kullandığımız diğer değişkenlere yeniden tahsis edebiliriz. Bunlar ptr2ve ptr3. Şimdi değişken toplamda 21 kez referans alınmıştır. (Oluşum sayısını kendiniz saymaya çalışıyorsanız a++, değeri almak için iki kez, değeri bir kez almak ve bir kez ayarlamak için bir kez saymayı unutmayın .)

Yeniden kullanabileceğimiz tek bir değişken var; Modulo değerlerini hesapladıktan sonra, chartık gerekli değildir. upve dnaynı sayıda kez gelince, her ikisi de iyidir. Diyelim birleştirme chile up.

Bu toplam 8 benzersiz değişken bırakır. 0 ile 7 arasındaki değişkenleri tahsis edebilir ve 8'de hafıza bloğunu başlatabiliriz (karakterleri ve satır numaralarını içeren) 8. 7, length1 kodunda aynı uzunlukta olduğundan, −1 - 6 değişkenlerini de kullanabiliriz ve hafıza bloğunu 7'de başlatabiliriz. Bu şekilde, hafıza bloğunun başlangıç ​​konumuna her referans kodda biraz daha kısadır! Bu bize aşağıdaki görevlerle devam eder:

-1    dn
 0                      ← ptr or minLine?
 1    mod5, ptr2, ptr3
 2    curLine
 3    maxLine
 4                      ← ptr or minLine?
 5    ch, up
 6    mod4
 7... [data block]

Şimdi bu en baştaki başlatmayı açıklıyor: 5 çünkü 7 (hafıza bloğunun başlangıcı) eksi 2 (ilk sırada koşulu zorunlu artış). Aynısı son döngüdeki 5'in diğer iki oluşumu için de geçerlidir.

Unutmayın ki, 0 ve 4'ten beri kodun uzunluğu aynı ptrve minLineher iki şekilde de tahsis edilebiliyor. ... Ya da yapabilirler?

Dönerken ikinci sondaki gizemli 2 ne olacak? Bu 6 olmamalı mı? Sadece veri bloğundaki sayıları azaltmak istiyoruz, değil mi? 6'ya ulaştığımızda, veri bloğunun dışındayız ve durmalıyız! Arabellek taşması hatası hatası arızası güvenlik açığı olur!

Durmazsak ne olacağını bir düşün. Değişkenler 6 ve 4'ü azaltırız mod4. Değişken 6'dır . Bu sadece ilk defa döngüde kullanılır ve artık burada ihtiyaç duyulmaz, bu yüzden zarar vermez. Peki ya değişken 4? Ne düşünüyorsun, değişken 4 olmalı mı ptryoksa olmalı minLinemı? Bu doğru, minLineartık bu noktada da kullanılmıyor! Böylece, değişken # 4, minLinegüvenle azaltabilir ve zarar vermeyebiliriz!

GÜNCELLEME 1! Fark ile 2145 bayt 2199 golfed dnolabilir ayrıca ile birleştirilecektir mod5rağmen mod5hala için değerin hesaplanmasında kullanılır dn! Yeni değişken ataması şimdi:

 0    ptr
 1    mod5, dn, ptr2, ptr3
 2    curLine
 3    maxLine
 4    minLine
 5    ch, up
 6    mod4
 7... [data block]

GÜNCELLEME 2! 2145'ten 2134 bayta kadar olan, mod5şu anda dnbir süre döngüsünde 0 olarak sayılan ile aynı değişkende olduğundan, mod5artık açıkça 0 olarak başlatılması gerekmediğinin farkına varmak suretiyle golf oynadı .

GÜNCELLEME 3! İki şeyi gerçekleştirerek 2134'ten 2104 bayta kadar golf oynadı. “Negatif modülo” fikri için değer o olmasına rağmen ilk mod5, aynı mantık için geçerli değildir mod4karşı biz asla testi nedeniyle mod4+2vb Dolayısıyla değişen mod4 ? mod4+1 : -3için mod4 ? mod4-1 : 32110 bayt götürüyor. İkincisi, mod4her zaman 0 veya 2 olduğundan, mod40 yerine 2 olarak başlatabilir ve iki üçlemi ( mod4 ? 3 : 1yerine mod4 ? 1 : 3) tersine çevirebiliriz .

GÜNCELLEME 4! Modulo değerlerini hesaplayan süre döngüsünün her zaman en az bir kez çalıştığını ve böyle bir durumda Okunamayan'ın son ifadenin değerini başka bir ifadede yeniden kullanmanıza izin verdiğini fark ederek 2104'ten 2087 bayta kadar golf tutulur. Böylece, while --ch: [...]; up = (mod5 ? mod5+1 ? [...]biz şimdi yerine up = ((while --ch: [...]) ? mod5+1 ? [...](ve bunun içindeki döngü içinde, mod4ilk olarak hesaplıyoruz , bu yüzden bu mod5son ifadedir).

GÜNCELLEME 5! 2087'den 2084 bayta kadar olan ve sabitleri 32ve 10(boşluk ve yeni satırları) yazmak yerine 10 sayısını (şimdi kullanılmayan) değişken # 2'de (hadi arayalım ten) saklayabileceğimi fark ederek . Bunun yerine ptr3 = 5yazarız ten = (ptr3 = 5) + 5, sonra 32olur ten+22ve print 10olur print ten.

CJam, 37 bayt

r_,2*:L3*S*f{\_iImd8-g\8>)*L+:L\t}zN*

Bu , OP tarafından izin verilen istenen çıktıdan önce ve sonra boş satırları yazdırır .

CJam tercümanında çevrimiçi olarak deneyin .

Nasıl çalışır

r_     e# Read a token from STDIN and push a copy.
,2*:L  e# Compute its length, double it and save it in L.
3*S*   e# Push a string of 6L spaces.
f{     e# For each character C in the input, push C and the string of spaces; then
  \    e#   Swap C with the string of spaces.
  _i   e#   Push a copy of C and cast it to integer.
  Imd  e#   Push quotient and remainder of its division by 18.
  8-g  e#   Push the sign((C%18) - 8). Gives -1 for ^ and ▲, 1 for v and ▼.
  \    e#   Swap the result with the quotient.
  8>)  e#   Push ((C/18) > 1) + 1. Gives 2 for ▲ and ▼, 1 for ^ and v.
  *    e#   Multiply both results. This pushes the correct step value.
  L+:L e#   Add the product to L, updating L.
  \t   e#   Replace the space at index L with C.
}      e# We've built the columns of the output.
z      e# Zip; transpose rows with columns.
N*     e# Join the rows, separating by linefeeds.

Python 2, 102

s=input()
j=3*len(s)
exec"w='';i=j=j-1\nfor c in s:i-='kv_^j'.find(c)-2;w+=i and' 'or c\nprint w;"*2*j

Satır satır yazdırır.

Girişteki karakterler arasında dolaşır ve geçerli yüksekliği izler. Yükseklik, +2, +1, -1, -2hesaplandığı şekliyle biri tarafından güncellenir 'kv_^j'.find(c)-2. Muhtemelen daha kısa bir mod zinciri var

Geçerli yükseklik, satır numarasına (negatif olabilir) eşit olduğunda, geçerli karakteri satıra ekler, aksi takdirde boşluk ekleriz. Sonra çizgiyi yazdırıyoruz. Aslında, yüksekliği geçerli satır numarasında başlatmak ve değer çarptığında karakter ekleyerek yükseklik değişikliklerini çıkarmak daha kısadır 0.

Satır sayıları, yukarı iki veya aşağı iki dizisinin içinde kalacağı yeterince geniş bir aralığı kapsar. Aslında, çok fazla miktarda var. Girdi uzunluğu üzerinde bir üst sınır olsaydı, yazmak daha kısa olurdu, örneğin j=999.

Şaşırtıcı bir şekilde, i and' 'or cnormalden daha kısaydı[' ',c][i==0] . Not inegatif olabilir, hangi bazı olağan hileler dışarı keser.

MATLAB, 116

function o=u(a)
x=0;y=1;o='';for c=a b=find(c=='j^ vk')-3;y=y+b;if y<1 o=[zeros(1-y,x);o];y=1;end
x=x+1;o(y,x)=c;end

Bu bir başlangıç. jvek ben matematiksel olarak gelen eşlemek için bir yol bulamıyorum gibi baş belası yapmak j^vkiçin [-2 -1 1 2]ve MATLAB Unicode tanımama ile (MATLAB. Git Şekilde 26 bir değere sahip aşağı görünüşte yukarı hem de!) Vardır Haritalamayı yaparken çok sayıda bayt harcandı.

@Xnors çözümünden ilham alınarak kod for döngüsü içindeki kontrol karakterini eşleyerek kod 14 karakter daha azaltılabilir.

Girdi dizgisinin deseni başladığı dizinin altına geri gönderirse (belki dizge uzunluğunda bir sınır varsa, o biti basitleştirebilirim) hesaba katmak için harcanan çok sayıda bayt vardır.

Ve okunabilir biçimde:

function o=u(a)
%We start in the top left corner.
x=0; %Although the x coordinate is 1 less than it should be as we add one before storing the character
y=1;
o=''; %Start with a blank array
for c=a
    %Map the current character to [-2 -1 1 2] for 'j^vk' respectively.
    b=find(c=='j^ vk')-3;
    y=y+b; %Offset y by our character
    if y<1 %If it goes out of range of the array
        o=[zeros(1-y,x); o]; %Add enough extra lines to the array. This is a bit of a hack as 0 prints as a space in MATLAB.
        y=1; %Reset the y index as we have now rearranged the array
    end
    x=x+1; %Move to the next x coordinate (this is why we start at x=0
    o(y,x)=c; %Store the control character in the x'th position at the correct height.
end

JavaScript (ES6), 140

Aşağıdaki pasajı EcmaScript 6 uyumlu bir tarayıcıda çalıştırmayı test edin (Firefox'ta test edilmiştir).

f=s=>[...s].map(c=>{for(t=r[y+=c>'▲'?2:c>'v'?-2:c>'^'?1:-1]||x;y<0;y++)r=[,...r];r[y]=t+x.slice(t.length)+c,x+=' '},y=0,r=[x=''])&&r.join`
`

// Less golfed

f=s=>(
  y=0,
  x='',
  r=[],
  [...s].forEach( c =>
    {
      y += c > '▲' ? 2 : c > 'v' ? -2 : c > '^' ? 1 : -1;
      t = r[y] || x;
      while (y < 0)
      {
        y++;
        r = [,...r]
      }  
      r[y] = t + x.slice(t.length) + c;
      x += ' '
    }
  ),
  r.join`\n`
)  


//Test

;[
  '^^▲^v▼▲^^v'
, '▲v^v^v^v^v^v^v^v▲'
, '^^^^^^^▲▲▲▼▼▼vvvvvv'
, 'v^^vv^^vvv^v^v^^^vvvv^^v^^vv'  
].forEach(t=>document.write(`${t}<pre>${f(t)}</pre>`))

pre { border:1px solid #777 }

GS2, 34 bayt

Bu, çıkış sınırlarını doğru olarak hesaplar, böylece fazla boşluk üretilmez. İşte onaltılı çözümüm

5e 20 76 6a 05 3e 26 ea 30 e0 6d 40 28 26 cf d3
31 e9 d0 4d 42 5e e2 b1 40 2e e8 29 cf d3 5c e9
9a 54

Küçük bir açıklama var. Yığında ascii kodları dizisi olarak kullanıcı girişi var. Program nedeniyle hazır bir dizgede başlar 05. İşte başlıyoruz.

  5e 20 76 6a      # ascii for "^ vj"
  05               # finish string literal and push to stack
  3e               # index - find index in array or -1 if not found
  26               # decrement
ea                 # map array using block of 3 instructions (indented)

  30               # add 
e0                 # create a block of 1 instruction
6d                 # scan (create running total array of array using block)
40                 # duplicate top of stack
28                 # get minimum of array
26                 # decrement
cf                 # pop from stack into register D (this is the "highest" the path goes)

  d3               # push onto stack from register D
  31               # subtract
e9                 # map array using block of 2 instructions

d0                 # push onto stack from register A (unitialized, so it contains stdin)

  4d               # itemize - make singleton array (also is single char string)
  42               # swap top two elements in stack
  5e               # rjust - right justify string
e2                 # make block from 3 instructions
b1                 # zipwith - evaluate block using parallel inputs from two arrays
40                 # duplicate top of stack

  2e               # get length of array/string
e8                 # map array using block of 1 instruction
29                 # get maximum of array
cf                 # pop from stack into register D (this is the "lowest" the path goes)

  d3               # push from register D onto stack
  5c               # ljust - left justify string
e9                 # map array using block of two instructions
9a                 # transpose array of arrays
54                 # show-lines - add a newline to end of each element in array

GS2, 24 bayt

Ayrıca çıktı boyutunu hesaplamakla ilgilenmeyen ve fazladan boşluk bırakan 24 baytlık bir çözümüm var. Boşlukları minimumda tutulacak olanı tercih ederim.

5e 20 76 6a 05 3e 26 ea 30 e0 6d d0 08 4d 42 d1
30 5e d1 5c 09 b1 9a 54

Crayon , 13 bayt (yarışmaz)

O"^ vj"\CynIq

Çevrimiçi deneyin! Gerçek okları kullanır çünkü neden olmasın.

Rekabet etmiyor çünkü Crayon bu mücadeleden çok daha yeni.

Nasıl çalışır

Crayon, ASCII sanatının zorluklarına katil olmak üzere tasarlanmış, istifleme tabanlı bir dildir. 2 boyutlu bir çıktı olan "kanvas" ve bu kanvas etrafında hareket eden bir imleç "mum boya" temelinde inşa edilmiştir. Çıktıya gönderilen herhangi bir şey tuval üzerine mum boya pozisyonunda ve mum boya yüzü bakacak şekilde çizilir. Varsayılan olarak, pastel boya Doğu'ya (sağa) işaret eder.

O"^ v▼"\CynIq   Implicit: input string is on top of the stack
O               For each char I in the input string:
 "^ v▼"          Push this string.
       \         Swap the top two items (so I is on top).
        C        Take the index of I in the string.
                 This returns 3 for ▼, 2 for v, 0 for ^, and -1 for ▲.
         y       Move the crayon by this number of spaces on the Y-axis (south).
          n      Move the crayon one position north.
                 The crayon has now been translated 2 positions south for ▼,
                 1 south for v, 1 north for ^, and 2 north for ▲.
           Iq    Draw I at the crayon. This automatically moves the crayon forward
                 by the length of I, which is 1 in this case.

pb - 136 bayt

^w[B!0]{>}v[3*X]<[X]<b[1]^[Y]^>w[B!0]{t[B]<vw[B=0]{v}>w[T=107]{^^b[T]t[0]}w[T=94]{^b[T]t[0]}w[T=118]{vb[T]t[0]}w[T!0]{vvb[T]t[0]}^[Y]^>}

Kullanır kve jyerine ▲ve ▼.

Birkaç not:

• Escape sequences that move the cursor such as \e[B are not allowed. You must produce the output using spaces and newlines.Bu kurala uyuyorum! pb, karakterleri çıkarmak için "fırça" kavramını kullanır. Fırça "tuval" etrafında hareket eder ve hemen altına bir karakter yazdırabilir. Ancak, asıl uygulama karakteri boşluk ve yeni satır kullanarak yazdırır.
• Kararını görene kadar pb ile eğlenceli olacağını düşünmeme rağmen bu zorlukla uğraşmayacağım You are allowed trailing spaces and/or empty lines. Bunun birkaç nedeni var:
  • pb olamaz olmayan sonunda boşluk. Her zaman dikdörtgen çıktı üretir, gerektiğinde boşluklarla doldurulur.
  • Bu program çok fazla boş satır üretir. Çıkış yapmaya başladığı zaman çıktının ne kadar uzun olacağını bilmiyor, bu yüzden başladığı bir uzunluk girişi niçin Y=3n+1. -1Aşağı gidiyor çünkü 3ngelen Y=-1ve başlayan Y=2n-1tüm bir giriş için başarısız k.

Bu programı YouTube'da çalışırken izleyebilirsiniz! Bu sürüm, sadece aşağı gidiyor ki biraz değiştirildi n-1. Bu giriş için çalışır, ancak diğerleri için başarısız olur. Ancak, çok daha iyi yakalar.

Yorumlarla:

^w[B!0]{>}             # Go to the end of the input
v[3*X]                 # Go down 3 times the current X value
<[X]<                  # Go to X=-1 (off screen, won't be printed)
b[1]                   # Leave a non-zero value to find later
^[Y]^>                 # Back to the beginning of the input
w[B!0]{                # For every byte of input:
    t[B]                 # Copy it to T
    <vw[B=0]{v}>         # Go 1 to the right of the character to the left
                         # (either the last one printed or the value at X=-1)
                         # Move the correct amount for each character and print it:
    w[T=107]{^^b[T]t[0]} # k
    w[T=94]{^b[T]t[0]}   # ^
    w[T=118]{vb[T]t[0]}  # v
    w[T!0]{vvb[T]t[0]}   # j (Every other possibility sets T to 0, so if T is not 0
                         #    it must be j. T!0 is shorter than T=106)
    ^[Y]^>               # To the next byte of input to restart the loop
}

Seylan, 447 bayt

import ceylon.language{o=null,v=variable,s=shared}s void y(){v L c;v L f;v L l;v Integer i=0;class L(v L?p,v L?n){s v String t="";s L u=>p else(f=p=L(o,this));s L d=>n else(l=n=L(this,o));s void a(Character c)=>t=t+" ".repeat(i-t.size)+c.string;}f=l=c=L(o,o);for(x in process.readLine()else""){switch(x)case('^'){c=c.u;}case('v'){c=c.d;}case('▲'|'k'){c=c.u.u;}case('▼'|'j'){c=c.d.d;}else{}c.a(x);i++;}print(f.t);while(f!=l){f=f.d;print(f.t);}}

Veya "okunabilirlik" için satır sonları ile: import ceylon.language{o=null,v=variable,s=shared}s void y(){v L c;v L f;v L l;v Integer i=0;class L(v L?p,v L?n){s v String t="";s L u=>p else(f=p=L(o,this));s L d=>n else(l=n=L(this,o));s void a(Character c)=>t=t+" ".repeat(i-t.size)+c.string;}f=l=c=L(o,o);for(x in process.readLine()else""){switch(x)case('^'){c=c.u;}case('v'){c=c.d;}case('▲'|'k'){c=c.u.u;}case('▼'|'j'){c=c.d.d;}else{}c.a(x);i++;}print(f.t);while(f!=l){f=f.d;print(f.t);}}

Bu hem ▲ / ▼ hem de j / k girişi ile çalışır (Sadece bir tanesini desteklemek zorunda olsaydık, program 8 bayt daha kısa olurdu). Son çıkış çizgisi başlangıç ​​pozisyonu üzerindeyken boştur (yani ilk giriş a ▲veya ^daha sonra bir daha asla bulamadık). Belirtilen karakterlerden biri olmayan giriş, satır değiştirilmeden, olduğu gibi basılır:

v^^vv^^vvv^v^v^^^Hellovvvv^^v^^vv

→

  ^   ^         ^Hello
 ^ v ^ v       ^      v       ^
v   v   v ^ ^ ^        v   ^ ^ v
         v v v          v ^ v   v
                         v

Burada biçimlendirilmiş bir sürüm (753 bayt):

shared void y() {
    variable L c;
    variable L f;
    variable L l;
    variable Integer i = 0;
    class L(variable L? p, variable L? n) {
        shared variable String t = "";
        shared L u => p else (f = p = L(null, this));
        shared L d => n else (l = n = L(this, null));
        shared void a(Character c) => t = t + " ".repeat(i - t.size) + c.string;
    }
    f = l = c = L(null, null);
    for (x in process.readLine() else "") {
        switch (x)
        case ('^') { c = c.u; }
        case ('v') { c = c.d; }
        case ('▲' | 'k') { c = c.u.u; }
        case ('▼' | 'j') { c = c.d.d; }
        else {}
        c.a(x);
        i++;
    }
    print(f.t);
    while (f != l) {
        f = f.d;
        print(f.t);
    }
}

Bu neredeyse düz ileri "nesne yönelimli" bir programdır ... (yerel) sınıf L(satır arabelleği), bir metin satırı (in t) ve sonraki ( n) ve önceki ( p) (nullable) işaretçileri saklar. hat. (Null değil) öznitelikleri u(yukarı) ve d(aşağı), gerektiğinde bunları (kendi kendine ters işaretçi ile) başlatır ve bu durumda, genel olarak ilk ve son çizgiyi ( fve ldeğişkenlerde) izler .

a(Ekleme) yöntemi en sonunda gereken bazı boşluklar da dahil olmak üzere, bu hat bir karakteri ekler.

cGeçerli satır. readLineGeçerli dizgeyi güncelleyen ve sonra append yöntemini çağıran bir switch ifadesi kullanarak giriş dizesini ( giriş bir satırda olması gerektiği gibi) ayrıştırırız .

Ayrıştırma işlemi bittikten sonra, her birini yazdırdıktan sonra, ilkinden sonuncuya doğru satırları yineleriz. (Bu, yok ederf işaretçiyi daha sonra gerekirse, bunun için ayrı bir değişken kullanmalıydık.)

Bazı golf oynamak için kullanılan hileler:

• Diğer dillerde anahtar kelimeler olabilecek bazı şeyler aslında yalnızca ceylon.languagepaketteki tanımlayıcılardır ve takma ad içe aktarımı ile yeniden adlandırılabilirler - bunu açıklamalarda shared(5 × kullanılmış) ve variable(6 × kullanılmış) hem de nesne için kullandık. null(4 kez kullanılmış):

  import ceylon.language{o=null,v=variable,s=shared}
  

  (Trivia: Ceylon IDE'deki Biçimlendirici, bazı yerleşik dil ek açıklamalarını aralarında biçimlendirir variableve sharedbunları ek açıklama bildiriminde ayrı bir sıraya yerleştirilen özel ek açıklamalara zıt olarak eklenmiş bildirimle aynı satıra yerleştirir. golf programın biçimlendirilmiş versiyonunu okunaksız hale getiriyor, bu yüzden bu versiyon için takma ad ithalatını değiştirdim.)

  this, void, case, elseGerçek anahtar kelimeler ve bu şekilde yeniden adlandırılamaz ve Integer, Stringve Characterböylece ithal ederek elde edilecek bir şey yok, sadece birer kez görünür.

• Aslında, ayrı bir ScreenBuffer sınıfım da vardı (bu, bağlı arabelleklerin listesini, geçerli dizini vb. Takip etti), ancak bunun yalnızca bir nesnesi olduğu için, en iyi duruma getirildi.

• Bu Screenbuffer sınıfı da vardı upve downayrıştırıcı 'dan çağrılan yöntemleri, (adil ve yaptığımız currentLine = currentLine.upsırasıyla currentLine = currentLine.down). Bunu doğrudan parserin anahtarında yapmanın daha kısa olduğunu gösterdi. Ayrıca currentLine = currentLine.up.up(sonra oldu c = c.u.u) yerine yazmaya izin verdi currentLine = currentLine.up;currentLine = currentLine.up.

• Başlangıçta, şu anki indeksi argüman olarak append metoduna (ve hatta döngüden ayrıştırıcıya) geçirdik - onu içeren fonksiyonda bir değişkene sahip olmak daha kısa.

• Başlangıçta printAll yöntemim geçerli işaretçiyi kullandı ve önce geçerli satır boş kalana kadar yukarı, sonra her satırı yazdırırken aşağı kaydırdı. Satırların üstünden atlamak için ▲ ve ▼ kullanırken bu durum kırıldı, bu yüzden bu atlanan satırlara açıkça bir şeyler eklemek zorunda kaldık. İlk / son satırın takip edilmesinin daha kolay olduğu görülmüştür (Ceylon'da iki döngü ifade kullanılmasını zorunlu kılmıştır, çünkü Ceylon'da döngü yapılmaz).

• Başlangıçta böyle bir şey vardı:

    String? input = process.readLine();
    if(exists input) {
       for(x in input) {
           ...
       }
    }
  

  process.readLinenullokunabilen bir satır yoksa (giriş kapatıldığından) döner ve Ceylon derleyicisi erişmeden önce bunu kontrol etmemi ister input. Bu durumda olduğu gibi hiçbir şey yapmak istemiyorum, eşit elsedeğilse, ilk argümanını döndüren işleci ve aksi halde ikinci argümanını, değişkeni ve if-ifadesini kaydederek kullanabilirim. (Bu da bize test için varsayılan bir giriş kodlamak için izin verecek: for (x in process.readLine() else "^^▲^v▼▲^^v") {)

JavaScript (ES6), 228 bayt

E=(r,p=(' '[M='repeat'](Z=r.length)+',')[M](Z*4),i=Z*2,k=0)=>Z>k?E(r,(p.split(',').map((o,q)=>q==i?o.slice(0,k)+r[k]+o.slice(k++):o)).join`,`,i+(H={'^':-1,k:-2,j:2,v:1})[r[k]],k):p.split(',').join`
`.replace(/\s+\n$|^\s+\n/g,'')

Peki, burada verilen tüm test durumlarını geçen (oldukça uzun) özyinelemeli bir çözüm. Güzel bir meydan okumaydı. Bu kullanır kve jyerine ▼ve ▲.

Test Parçacığı

Teslim kendisi yalnızca işleyebilir rağmen k,j, şu pasajı, hem işleyebilir k,jve ▼,▲.

E=(r,p=(' '[M='repeat'](Z=r.length)+',')[M](Z*4),i=Z*2,k=0)=>Z>k?E(r,(p.split(',').map((o,q)=>q==i?o.slice(0,k)+r[k]+o.slice(k++):o)).join`,`,i+(H={'^':-1,k:-2,j:2,v:1})[r[k]],k):p.split(',').join`
`.replace(/\s+\n$|^\s+\n/g,'')

Input: <input type="text" oninput=o.textContent=E(this.value.replace(/▲/g,'k').replace(/▼/g,'j'))></input>
<pre id='o'></pre>