En az iki kelimelik bir liste göz önüne alındığında (sadece küçük harflerden yapılır), önce sola, sağdan sola, ilk soldan sağa, sonra da sola, sağdan sola doğru yazarak kelimelerin ASCII merdivenini oluşturun ve gösterin .

Bir kelimeyi yazmayı tamamladığınızda, yönü değiştirin ve sadece bir sonraki kelimeyi yazmaya başlayın.

Diliniz sözcük listelerini desteklemiyorsa veya sizin için daha uygunsa, girişi tek bir boşlukla ayrılmış bir sözcük dizisi olarak alabilirsiniz.

Lider ve takip eden boşluklara izin verilir.

["hello", "world"] veya "hello world"

hello
    w
    o
    r
    l 
    d

Burada yazmaya başlıyoruz hellove bir sonraki kelimeye geldiğimizde (ya da bir dize olarak girdi durumunda - bir boşluk bulunursa), göreceli yönü sağa doğru değiştirip yazmaya devam ediyoruz.world

Test durumları:

["another", "test", "string"] or "another test string" ->   

another
      t
      e
      s
      tstring


["programming", "puzzles", "and", "code", "golf"] or "programming puzzles and code golf" ->

programming
          p
          u
          z
          z
          l
          e
          sand
             c
             o
             d
             egolf

["a", "single", "a"] or "a single a" ->

a
s
i
n
g
l
ea

Şarap kriterleri

Her dilde bayt cinsinden en kısa kod kazanır. Golf dilleri tarafından cesareti kırılmasın!

Kum havuzu

Mangal kömürü , 9 bayt

Ｆ⮌Ａ«↑⮌ι‖↗

Çevrimiçi deneyin!Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama: Metni geriye doğru çekerek, her kelimeden sonra tuvali transpoze ederek çalışır. Dize girişi için 10 bayt:

Ｆ⮌Ｓ≡ι ‖↗←ι

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama: Metni geriye doğru çekerek tuvali boşluklar için harcar.

C (gcc) , 94 78 74 bayt

-4 Johan du Toit tarafından

o,f;g(int*s){for(o=f=0;*s;s++)*s<33?f=!f:printf("\n%*c"+!f,f*(o+=!f),*s);}

Çevrimiçi deneyin!

Her seferinde bir karakter (girişin) karakterini basar. Boşlukla ayrılmış bir kelime dizisi alır.

05AB1E , 19 16 bayt

€θ¨õšøíJD€gs24SΛ

-3 bayt sayesinde @Emigna .

Çevrimiçi deneyin.

Genel açıklama:

Tıpkı @Emigna'nın 05AB1E cevabı gibi (onu btw'yi oyladığınızdan emin olun !!), Canvas yerleşik kullanıyorumΛ .

Ancak kullandığım seçenekler farklı (bu nedenle cevabım daha uzun ..):

• b(yazdırılacak dizeler): Listedeki ilk dizgiyi değiştirmeden bırakarım ve takip eden karakterleri listedeki her dizgiye eklerim. Mesela ["abc","def","ghi","jklmno"]olur ["abc","cdef","fghi","ijklmno"].
• a(satırların boyutları): Bu, [3,4,4,7]yukarıdaki örnekte olduğu gibi , bu dizgilere eşit olacaktır .
• c(yönde yazdırmak için): [2,4], hangi harita ediyorum[→,↓,→,↓,→,↓,...]

Bu yüzden yukarıdaki örnek adım adım şunları yapacaktır:

1. / abcYönünde çizin .2→
2. / cdefYönünde çizin (ilk karakterin son karakterle çakıştığı, bu nedenle listeyi böyle değiştirmek zorunda kaldık)4↓
3. fghiYön 2/ →tekrar çizin (ayrıca üst üste gelen / ana karakterlerin üst üste geldiği karakterlerle)
4. ijklmnoYönünde çizin4 /↓ tekrar (örtüşme ile birlikte)
5. Çizilen Tuvalin sonucunu derhal STDOUT'a gönder

Kod açıklaması:

€θ                # Only leave the last characters in the (implicit) input-list
  ¨               # Remove the last one
   õš             # And prepend an empty string "" instead
     ø            # Create pairs with the (implicit) input-list
      í           # Reverse each pair
       J          # And then join each pair together to single strings
        D€g       # Get the length of each string (without popping by duplicating first)
           s      # Swap so the lengths are before the strings
            24S   # Push [2,4]
               Λ  # Use the Canvas builtin (which outputs immediately implicitly)

05AB1E , 14 13 bayt

Grimy sayesinde 1 bayt kaydedildi

€ðÀD€g>sŽ9÷SΛ

Çevrimiçi deneyin!

açıklama

                 # example input ["Hello", "World"]
€ðÀ              # push a space after each word
                 # STACK: ["Hello"," ","World"," "]
   D             # duplicate
    €g>          # get the length of each word in the copy and add 1
                 # these are the lengths to draw
                 # STACK: ["Hello"," ","World"," "], [6, 2, 6, 2]
       s         # swap the list of word to the top of the stack
        Ž9÷S     # push [2, 5, 4, 1]
                 # this is the list of directions to draw
                 # 1=northeast, 2=east, 4=south, 5=southwest
            Λ    # paint on canvas

Tuval , 17 12 11 10 bayt

ø⁸⇵｛⟳Ｋ└×∔⤢

Burada dene!

Açıklama:

ø⁸⇵{⟳K└×∔⤢  full program taking array as input (loaded with ⁸)

ø         push an empty canvas               ["test", "str"], ""
 ⁸⇵{      for each input word, in reverse:   "str", "test" (showing 2nd iter)
    ⟳       rotate the word vertically       "str", "t¶e¶s¶t"
     K      pop off the last letter          "str", "t¶e¶s", "t"
      └     swap the two items below top     "t¶e¶s", "str", "t"
       ×    prepend                          "t¶e¶s", "tstr"
        ∔   vertically append                "t¶e¶s¶tstr"
         ⤢  transpose the canvas             "test
                                                 s
                                                 t
                                                 r"

JavaScript (ES8),  91 79  77 bayt

Bir kelime dizisi olarak girdi alır.

a=>a.map((s,i)=>i&1?[...s].join(p):s+=p+=''.padEnd(s.length-!i),p=`
`).join``

Çevrimiçi deneyin!

Yorumlananlar

a =>                 // a[] = input array
  a.map((s, i) =>    // for each word s at position i in a[]:
    i & 1 ?          //   if this is a vertical word:
      [...s].join(p) //     split s and join it with p
    :                //   else:
      s +=           //     add to s:
        p +=         //       add to p:
          ''.padEnd( //         as many spaces
            s.length //         as there are letters in s
            - !i     //         minus 1 if this is the 1st word (because it's not connected
          ),         //         with the last letter of the previous vertical word)
    p = `\n`         //   start with p = linefeed
  ).join``           // end of map(); join everything

Python 2 , 82 bayt

b=p=0
r=''
for w in input():
 for c in w:r+='\n'.ljust(p)*b+c;p+=1-b
 b^=1
print r

Çevrimiçi deneyin!

brainfuck , 57 bayt

->,[[.<+>,],[<<[-]++++++++++.--[-<++++>]>[-<+<.>>]>.<,],]

Çevrimiçi deneyin!

NUL ayrılmış dizeler olarak girdi alır. Bunun EOF'yi 0 olarak kullandığını ve merdiven 256 alanı aştığında çalışmayı durduracağını unutmayın.

Açıklama:

-           Initialise counter as -1
>,[         Start ladder
   [.<+>,]  Print the first word, adding the length of it to the counter
   ,[       Loop over each letter of the second word
      <<[-]++++++++++.    Print a newline
      --[-<++++>]         Create a space character
      >[-<+<.>>]          Print counter many spaces
      >.<,                Print the letter and move to the next letter
   ] 
   ,        Repeat until there are no more words
]

JavaScript, 62 bayt

a=>' '+a.replace(/./g,c=>1-c?(a=!a,''):a?(p+=' ',c):p+c,p=`
`)

Çevrimiçi deneyin!

Teşekkürler Rick Hitchcock , 2 bayt kaydedildi.

JavaScript, 65 bayt

a=>a.replace(/./g,c=>1-c?(t=!t,''):t?p+c:(p+=p?' ':`
`,c),t=p='')

Çevrimiçi deneyin!

a => a.replace (/./ g, c => (// a karakterindeki c için
    1 - c? // eğer (c boşluk)
      (t =! t, // güncelleme t: boolean değer word index'i açıklar
                       // truthy: tek dizinlenmiş kelimeler;
                       // falsy: endekslenmiş kelimeler bile
        ''): // boşluk için hiçbir şey üretmeyin
    t? // eğer (tek indeks ise) bu dikey
      p + c: // '\ n', bazı boşluklar ve sigle karakterleri ekleyin
                       // Başka
      (p + = p? '': '\ n', // dikey kelimeler için prepend dizesini hazırlayın
         c) // tek bir karakter ekleyin
),
  t = p = '' // başlat
)

Aheui (esotope) , 490 458 455 bayt

삭뱃밸때샏배샐배새뱄밿때빠뱋빼쌘투＠밧우
＠두내백뱃빼선대내백뱃섣＠여우샐처샐추
희차＠＠＠뭏누번사＠빼뭏오추뻐＠＠＠배
Ｂｙ＠＠＠새대백＠＠＠우뻐색
Ｌｅｇｅｎ＠＠빼쵸누번＠＠빼
ＤＵＳＴ＠＠＠샌뽀터본섣숃멓
＠＠＠＠＠＠＠오어아＠먛요아＠＠샏매우
＠＠＠＠＠아＠＠＠＠＠＠오＠＠＠＠＠서어
＠＠＠＠＠희차＠＠요

Çevrimiçi deneyin!

Korece (3 bayt) yerine tam genişlikli karakterler (2 bayt) kullanarak hafifçe golf oynayın.

açıklama

Aheui befunge benzeri esolang. Burada renkli kod var:? 1 kısım geçerli karakterin boşluk olup olmadığını kontrol eder.

? 2 kısım, kelimelerin sağdan sola mı yoksa yukarıdan aşağıya mı yazıldığını kontrol eder.

3 3 kısım, boşluğu alan döngünün kırılma koşulu.

? 4 parça, geçerli karakterin satırın (-1) olup olmadığını kontrol eder.

Kırmızı kısım yığın başlatma. Aheui dan (yığınlarını kullanarak Nothingiçinㅎ değeri depolamak : 28 yığın arası) kullanır.

Turuncu kısım ( 뱋) girişini alır ve alanın 32ascii kodu ile çıkartarak boşluk olup olmadığını kontrol eder .

Yeşil kısım, sağdan sola yazıyorsa, alan uzunluğunun değerini depolayan yığına 1 ekler.

Mor kısım, yukarıdan aşağıya yazılıyorsa, yazdırma alanları için döngüdür.

Mevcut karaktere -1bir tane ekleyerek mevcut karakterin gri olup olmadığını kontrol edin .

Mavi kısım mevcut karakteri basar ve bir sonraki karaktere hazırlar.

Japt -P , 15 bayt

ò mrÈ+R+YÕùT±Xl

Dene

ò mrÈ+R+YÕùT±Xl     :Implicit input of string array
ò                   :Partition into 2s
  m                 :Map each pair
   r                :  Reduce by
    È               :  Passing through the following function as X & Y
     +              :    Append to X
      R             :    Newline
       +            :    Append
        YÕ          :    Transpose Y
          ù         :    Left pad each line with spaces to length
           T±       :      T (initially 0) incremented by
             Xl     :      Length of X
                    :Implicitly join and output

bash, 119 karakter

X=("\e7" "\n\e8")
w="$@"
l=${#w}
d=0
for((i=0;i<l;i++));do
c="${w:$i:1}"
[ -z $c ]&&d=$((1-d))||printf ${X[$d]}$c
done

Bu, imleci hareket ettirmek için ANSI kontrol dizilerini kullanır - burada sadece kaydet \e7ve geri yükle kullanıyorum \e8; ancak geri yükleme ile ön eklenmesi gerekir\n terminalin altındaysa, çıktının kaydırılması önceden yapılması gerekir. Eğer değilsen Nedense çalışmıyor zaten terminalin dibinde. * omuz silkme *

Geçerli karakter $c, giriş dizesinden tek karakterli bir alt dize olarak izole edilir $w.for döngü dizini dizini $iolarak .

Burada kullandığım tek gerçek numara [ -z $c ], geri dönecek olan true, yani dize boştu, boşluk olduğunda $c, çünkü alıntı yapılamaz. Doğru bash kullanımında, -ztam olarak bu durumdan kaçınmak için test edilmekte olan ipten alıntı yaparsınız . Bu, yön işaretini çevirmemize izin verir$d arasında 1ve 0, daha sonra, ANSI kontrol dizisi diziye bir dizin olarak kullanılan,X bir sonraki boşluk olmayan değerine $c.

Kullanan bir şey görmek isterim printf "%${x}s" $c .

Aman Tanrım, biraz boşluk ekleyelim. Nerede olduğumu göremiyorum ...

X=("\e7" "\n\e8")
w="$@"
l=${#w}
d=0
for ((i=0;i<l;i++)); do
  c="${w:$i:1}"
  [ -z $c ] && d=$((1-d)) || printf ${X[$d]}$c
done

Perl 6 , 65 bayt

{$/=0;.map:{$/+=$++%2??!.comb.fmt("%$/s","
").print!!.say*.comb}}

Çevrimiçi deneyin!

Kelimelerin listesini alan ve doğrudan STDOUT'a basan adsız kod bloğu.

açıklama

{                           }  # Anonymous code block
 $/=0;                         # Initialise $/ to 0
 .map:{                    }   # Map the list of words to
       $/+=                    # Increment $/ by
           $++%2??             # For even indexes
                   .comb       # Each letter of the word
                   .fmt(           ) # Formatted as
                        "%$/s"       # Padded with $/-1 spaces
                              ,"\n"  # Joined by newlines
                   .print            # And printed without a newline
                  !   # Boolean not this to add 0 to $/
                !!            # For odd indexes
                  .say        # Print with a newline
                      *.comb  # And add the length of the word

Kömür , 19 bayt

ＦＬθ¿﹪鲫↓§θι↗»«§θι↙

Dizelerin bir listesi olarak giriş yapın

Çevrimiçi olarak deneyin (ayrıntılı) veya çevrimiçi deneyin (saf)

Açıklama:

Aralıktaki döngü [0, input-length):

For(Length(q))
ＦＬθ

Dizin tekse:

If(Modulo(i,2)){...}
﹪鲫...»

Dizeyi dizinde iaşağı yönde yazdır :

Print(:Down, AtIndex(q,i));
↓§θι

Ardından imleci bir kez üst sağa doğru hareket ettirin:

Move(:UpRight);
↗

Başka (dizin çift):

Else{...}
«...

Dizeyi dizinde idüzenli olarak doğru yönde yazdırın :

Print(AtIndex(q,i));
§θι

Ve sonra imleci bir kez sola doğru hareket ettirin:

Move(:DownLeft);
↙

Python 2 , 89 88 bayt

s=i=-1
r=''
for w in input():r+=[('\n'+' '*s).join(' '+w),w][i];s-=i*len(w);i=~i
print r

Çevrimiçi deneyin!

C # (Visual C # Etkileşimli Derleyici) , 122 bayt

a=>{int i=0;var t="\n";foreach(var z in a)Write(i++%2<1?z+(t+="".PadRight(z.Length-(i<2?1:0))):string.Join(t,z.Skip(0)));}

Çevrimiçi deneyin!

J , ^{47 45} 43 bayt

;[`(([:<@(+/)\#&>##$#:@1 2)@])`([' '"0/[)}]

Çevrimiçi deneyin!

Eğlenceli, farklı bir yaklaşım buldum.

Döngüsel zarafetlerle sol pedlerle ve fermuarlarla uğraşmaya başladım, ancak daha sonra her bir mektubun pozisyonunu hesaplamanın daha kolay olacağını fark ettim (bu, doğru seçilmiş dizinin tarama toplamına kadar aşağı iner) ve değişiklik uygulayın. } boş Püskürtülen girdideki tuval.

Çözüm neredeyse tamamen Amend tarafından ele alındı }:

; [`(([: <@(+/)\ #&> # # $ #:@1 2)@])`([ ' '"0/ [)} ]

• ; ( single verb that does all the work ) ] genel çatal
• ; sol kısım girişi keser, yani tüm harfleri bitişik bir dizgeye yerleştirir.
• ] sağ kısım girişin kendisidir
• (stuff)}}üç bölümden oluşan , alend formunun gerund şeklini kullanıyoruz v0`v1`v2.
  • v0 bize puslu olan "yeni değerleri" verir (yani, girişin tüm karakterleri bir dize olarak), [ .
  • v2bize dönüştürdüğümüz başlangıç ​​değerini verir. biz sadece gerekli boyutlardaki boşlukların boş bir tuvalini istiyoruz. ([ ' '"0/ [)bize bir boyut verir(all chars)x(all chars) .
  • Ortadaki fiil, v1hangi karakterleri yerine koyacağımızı seçer. Bu, mantığın özüdür ...
• 0 0Sol üstteki pozisyondan başlayarak, her yeni karakterin önceki pozisyonun (1) sağında prev + 0 1ya da bir aşağı (yani prev + 1 0) olduğunu fark ediyoruz . Nitekim eski "1 kelimelik len" kez, sonra ikinci "2 len kelimelik" kez vb. Böylece sadece bu hareketlerin doğru sırasını yaratacağız, sonra toplamları tarayacağız ve konumumuza sahip olacağız, o zaman kutulayacağız çünkü Amend böyle çalışıyor. Takip eden şey bu fikrin mekaniği.
• ([: <@(+/)\ #&> # # $ 1 - e.@0 1)
  • İlk #:@1 2önce sabit matrisi yaratır 0 1;1 0.
  • # $daha sonra, girdi kadar çok satır içerecek şekilde genişletir. örneğin, giriş 3 kelime içeriyorsa, üretecektir 0 1;1 0;0 1.
  • #&> #Bunun sol kısmı, giriş kelimelerinin uzunluklarının bir dizisidir ve #kopyadır, bu nedenle 0 1"1 kelimesi len" kez kopyalar , sonra1 0 "2 kelimenin len kelimesi", vb.
  • [: <@(+/)\ tarama toplamı ve kutusunu yapar.

T-SQL, 185 bayt

DECLARE @ varchar(max)='Thomas Clausen Codegolf Script'
,@b bit=0,@s INT=0SET @+=':'WHILE @ like'%_:%'SELECT
@b+=len(left(@,1))-1,@=stuff(@,1,1,'')+iif(left(@,@b)='','','
'+space(@s))+trim(left(@,1)),@s+=len(left(@,~@b))PRINT
stuff(@,1,1,'')

Çevrimiçi deneyin

Retina , 51 bayt

1,2,`\w+
;$&
+(m`^(.(.*?)) ?;(.)
$1¶$.2* $3;
; |;$

Çevrimiçi deneyin!

Diğer her bir kelimeyi işaretleyen ve daha sonra dönüşümü doğrudan uygulayan oldukça basit bir yaklaşım.

açıklama

1,2,`\w+
;$&

Diğer her bir kelimeyi noktalı virgül ile işaretleyerek her bir kelimeyi eşleştirerek, ancak yalnızca yerine 1. ve daha sonra 3. sıradan başlayarak eşleşmelere (sıfır dizine eklenmiş) uygulayarak işaretleriz.

+(m`^(.(.*?)) ?;(.)
$1¶$.2* $3;

+(mAşağıdaki aşamalar için bazı özellikleri ayarlar. Artı, "bu aşamalar grubu bir şeyi değiştirirken" döngüsünü başlatır. bu durum). mSadece tedavi için regex'i söyler^ de yerine dize sadece başında hatlarının başından eşleşen olarak.

Gerçek regex oldukça basittir. İlk noktalı virgülden önce uygun miktarda maddeyle eşleşiyor ve ardından *doğru sayıda boşluğa koymak için Retina'nın yeni sözdizimini kullanıyoruz.

; |;$

Bu aşama sonuncusundan sonra dikey olarak değiştirdiğimiz kelimelerin sonundaki noktalı virgülleri ve boşlukları kaldırmak için uygulanır.

Retina 0.8.2 , 58 bayt

(?<!^(\S* \S* )*\S*)
¶
¶? 

+`(..(.)*¶)((?<-2> )*\S)
$1 $3

Çevrimiçi deneyin! Link, test durumlarını içerir. Alternatif çözüm, ayrıca 58 bayt:

( \S*) 
$1¶
+` (.)
¶$1 
 ¶

+`(..(.)*¶)((?<-2> )*\S)
$1 $3

Çevrimiçi deneyin! Link, test durumlarını içerir.

Burada kasıtlı olarak Retina 1 kullanmıyorum, bu nedenle alternatif kelimeleri ücretsiz olarak işlem göremiyorum; bunun yerine iki yaklaşımım var. İlk yaklaşım, önceki boşlukları sayarak alternatif sözcüklerdeki tüm harflere ayrılırken, ikinci yaklaşım alternatif boşlukları yeni satırlarla değiştirir ve sonra kalan boşlukları alternatif sözcükleri harflere ayırmasına yardımcı olmak için kullanır. Her yaklaşım daha sonra dikey harfleri bir sonraki yatay sözcükle birleştirmelidir, ancak kod farklıdır, çünkü sözcükleri farklı şekillerde bölüştürür. Her iki yaklaşımın son aşaması daha sonra her bir çizgiyi boşluksuz ilk karakteri önceki çizginin son karakteri ile aynı hizaya gelene kadar doldurur.

Unutmayın ki kelimeler sadece harflerdir, çünkü mecbur değilim.

PowerShell , 101 89 83 bayt

Mazzy sayesinde -12 bayt .

$args|%{$l+=if(++$i%2){$_.length-1;$t+=$_}else{1;$_|% t*y|%{$t+='
'+' '*$l+$_}}};$t

Çevrimiçi deneyin!

PowerShell , 74 65 bayt

-join($args|%{$_|% t*y|%{($p+=(' ','
')[!$p]*!$i)*$i;$_};$i=!$i})

Çevrimiçi deneyin!

R , 126 bayt

function(x,`>`=strrep)for(i in seq(x)){H=i%%2;cat(paste0('
'>!H,' '>F*!H,e<-'if'(H,x,strsplit(x,''))[[i]]))
F=F+nchar(e[1])-H}

Çevrimiçi deneyin!

• @Giuseppe sayesinde -3 bayt

T-SQL, 289 bayt

DECLARE @ VARCHAR(MAX)='a a',@I INT=1,@S INT=0,@B INT=0WHILE @I<=LEN(@)IF SUBSTRING(@,@I,1)=''IF @B=0SELECT @S-=1,@=STUFF(@,@I,1,'
'+SPACE(@S)),@I+=@S+3,@B=1 ELSE SELECT @=STUFF(@,@I,1,''),@S+=1,@B=\ELSE IF @B=0SELECT @I+=1,@S+=1 ELSE SELECT @=STUFF(@,@I,0,'
'+SPACE(@S)),@I+=@S+3PRINT @

Bu, SQL Server 2016 ve diğer sürümlerde çalışır.

@, alanla ayrılmış listeyi tutar. @I dizedeki dizin konumunu izler. @S, soldan girintili toplam alan sayısını izler. @ B, dizenin hangi eksende @I noktasında hizalandığını izler.

Bayt sayısı en az örnek listeyi içerir. Komut dosyası listede, karakter karakterinde ilerler ve dizeyi gereksinimlere göre gösterecek şekilde değiştirir. Dizenin sonuna gelindiğinde, dize YAZDIRILIR.

JavaScript (Node.js) , 75 bayt

a=>a.map(x=>i++&1?[,...x].join(`
`.padEnd(n)):(n+=x.length,x),n=i=0).join``

Çevrimiçi deneyin!

Açıklama ve asılsız

function f(a) {                   // Main function:
 return a.map(                    //  Map through all words:
  function(x) {
   if (i++ & 1)                   //   If i % 2 == 1 (i.e. vertical):
    return [,...x].join(          //    Since the first one needs to have its own linefeed 
                                  //    and indentation, add a dummy item to the start.
     "\n".padEnd(n)               //    Join the array with the padded line feeds.
    );
   else {                         //   If i % 2 == 0 (i.e. horizontal):
    n += x.length;                //    Add the length of this string to the variable that
                                  //    counts how long the padded line feeds should be.
    return x;                     //    Append the string at the end without line feeds.
   }
  },
  n = i = 0                       //   Initialize variables.
                                  //   n: the length of the padded line feeds 
                                  //      (including the line feed)
                                  //   i: keeps track of the direction
 ).join("")                       //  Join all stuffs and return.
}

Stax , 12 bayt

ìZΣFτëWº═φ‼R

Koş ve hata ayıkla

Jöle , 21 bayt

Ẉm2Ä’x2Ż⁶xⱮṛ;⁷ɗ;ⱮY¥ƭ"

Çevrimiçi deneyin!

Girdiyi dizelerin bir listesi olarak alan ve dolaylı olarak merdiveni kelimesine yerleştirmek için çıkarılan tam bir program.

C (gcc) , 93 87 bayt

Önerileriniz için gastropner'e teşekkürler.

Bu sürüm, NULL işaretçisi ile sonlandırılan bir dizi dizge alır.

c,d;f(s,t)char**s,*t;{for(c=d=0;t=*s++;d=!d)for(;*t;c+=!d)printf("\n%*c"+!d,d*c,*t++);}

Çevrimiçi deneyin!

Brain-Flak , 152 bayt

<>([()])<>{<>({}<>{()<({}<>)><>}<>)<>{}{<>({}<((()()()()()){})>)({<({}[()]<((((()()()()){}){}){})>)>()}{})<>(({}<>({}))[({}[{}])])<>}{}}<>{}{({}<>)<>}<>

Çevrimiçi deneyin!

İki döngüyü tek ve hatta kelimeler için birleştirerek bunun daha kısa olabileceğinden şüpheleniyorum.

J, 35 33 bayt

3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y'

Bu, girişi boşluklarla ayrılmış sözcüklerle tek bir dize olarak alan bir fiildir. Örneğin, şöyle diyebilirsin:

3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y' 'programming puzzles and code golf'

Çıktı, tercümanın gerektiği gibi yeni satırlarla çıktığı bir harf ve boşluk matrisidir. Her satır boşluklarla doldurulacak ve aynı uzunlukta olacaklardır.

Kodda küçük bir sorun var: girişin 98 kelimeden daha fazlası varsa işe yaramaz. Daha uzun bir girdiye izin vermek istiyorsanız, 998 kelimeye kadar izin vermek _98için koddaki kodu değiştirin _998.

Bunun nasıl çalıştığını bazı örnekler üzerinden açıklayayım.

Diyelim ki hayal ettiğimiz bir harf ve boşluk matrisimiz var, bazı kelimeler için kısmi bir çıktı, yatay bir kelimeyle başlayarak.

   [m=: 3 3$'vwx  y  z'
vwx
  y
  z

Bundan önce dikey olarak nasıl yeni bir kelime hazırlayabiliriz? Zor değil: yeni sözcüğü fiille tek sütunlu bir harf matrisine çevirin ,., ardından çıktıyı o tek sütunlu matrise ekleyin. (Fiil ,.uygundur, çünkü golf oynamak için kullandığımız bir matrise uygularsanız bir kimlik işlevi olarak işlev görür.)

   (,.'cat') , m
c  
a  
t  
vwx
  y
  z

Şimdi sadece bu şekilde bir kelime hazırlama yolunu yineleyemeyiz, çünkü o zaman sadece dikey kelimeler alırız. Fakat eğer çıktı matrisini her adımın arasına aktarırsak, diğer tüm kelimeler yatay olacaktır.

   (,.'dog') , |: (,.'cat') , m
d     
o     
g     
catv  
   w  
   xyz

Dolayısıyla çözüm için ilk girişimimiz, her bir kelimeyi tek sütunlu bir matrise koymak, sonra aralarına ekleyerek ve bunları dönüştürerek bunları katlamak.

   > (,|:)&.>/ ,.&.>;: 'car house dog children'
c            
a            
r            
housed       
     o       
     g       
     children

Fakat bununla ilgili büyük bir sorun var. Bu, bir dik açmadan önce bir sonraki kelimenin ilk harfini koyar, ancak şartname ilk harfi koymadan önce dönmeyi gerektirir, bu nedenle çıktı bunun yerine şöyle olmalıdır:

c             
a             
rhouse        
     d        
     o        
     gchildren

Bunu başarmamızın yolu, giriş dizgisinin tamamını olduğu gibi tersine çevirmektir.

nerdlihc god esuoh rac

daha sonra zig-zag'ı oluşturmak için yukarıdaki prosedürü kullanın, ancak sadece her kelimenin ilk harfinden sonra döndürün:

n     
e     
r     
d     
l     
i     
h     
c     
gode  
   s  
   u  
   o  
   h  
   rac

Ardından çıktıyı çevirin:

   [;.0> (,|:)&.>/ ,.&.>;:|. 'car house dog children'
car   
  h   
  o   
  u   
  s   
  edog
     c
     h
     i
     l
     d
     r
     e
     n

Ama şimdi başka bir sorunumuz var. Girdide tek sayıda kelime varsa, çıktının ilk kelimesi dikey olacaktır, oysa şartname ilk kelimenin yatay olması gerektiğini söyler. Bunu düzeltmek için benim çözümüm, boş bir kelime ekleyerek, çıktıyı değiştirmediğinden, kelimeler listesini tam olarak 98 kelimeye sıkıştırıyor.