Metnin çapraz satırlarını çizme


46

Bir sözcük listesi girişi göz önüne alındığında, sözcükleri çapraz olarak düzenlenmiş harfleriyle çıkın:

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f

(Yukarıdaki girdi için çıktı olmalıdır programming puzzles and code golf.)

Kesin olmak gerekirse, her kelime ilk sütunda ve önceki kelimenin üç satırında başlar ve art arda gelen her harf bir sütunu sağa, bir satır aşağıya taşır.

Giriş, tam olarak bir boşlukla ayrılmış tek bir sözcük dizisi veya sözcüklerin bir listesi / dizisi olarak sağlanabilir. Sözcükler yalnızca küçük harflerden oluşacak a-zve her zaman en az bir karakter uzunluğunda olacak.

Çıktı, tek bir dize, satır dizisi veya karakter dizisi dizisi olabilir. Bir izleyen ya da izleyen boşlukta, izleyen yeni bir satır dışında izin verilmez.

Diğer test durumları:

a bcd efgh i j

a


b
 c
  d
e
 f
  g
i  h


j

x

x

verylongword short

v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d

Bu olduğundan, bayttaki en kısa kod kazanır!


Bunun için 5 dakika içinde bir Python programı hazırlayabileceğimi hissediyorum, ancak her zaman başarısız görünüyor ...; _;
HyperNeutrino 14:16

Vay, görünüşte Turtlèd için tasarlanmış birçok zorluk var gibi görünüyor
Yok

Terminal kaçış kodlarına izin verilir mi? :)
Chromium

Yanıtlar:


17

Vim, 85, 76, 66 , 52 keystrokes / bytes

Bu zorluğa ilk baktığımda, "Bu vim için mükemmel!" Ve sonra denediğimde her şey ters gitti. İşte, dağınık hacky şanının hepsinde:

:se ve=all|s/ /\r\r\r/g
qqGo<esc>?\<.\S
lDjP@qq@qG?.
jdG

(Çoğunlukla) geriye uyumlu V tercümanı sayesinde çevrimiçi deneyin .

Açıklama:

İlk başta bu güzel basit 37 bayt sürümü yapabileceğimi düşündüm:

:se ve=all
qq:g/\S\S/norm ^lDjP
@qq@q

Ne yazık ki, o kadar basit değil. Hadi satır satır alalım:

:se ve=all

Bu, 'sanal düzenleme' adı verilen bir özelliği etkinleştirir. İmlecin henüz mevcut olmayan sütunlara gitmesini sağlar. Bu cevap temelde onsuz mümkün olmazdı.

Şimdi kelimeleri farklı satırlara ayırmamız gerekiyor. Böylece her boşluğu 3 yeni satırla değiştireceğiz. Bu bir ex komutu olduğu için, son ex komutumuzla eşzamanlı olarak :se ve=all, ikisini bir çubukla ayırarak çalıştırabiliriz .

|s/ /\r\r\r/g

Şimdi tampon şuna benziyor:

Programming


Puzzles


and


code-golf

İşte eğlence başlıyor. Geleneksel özyinelemeli makroyu: ile kurarız qqve sonra şunu çağırırız:

G               " Move to the last line
 o<esc>         " Append an extra newline

?               " Search backwards for
 \<.            " Any character at the beginning of a word
    \S          " Followed by a non-space character
l               " Move one character to the right
 D              " Delete eveything until the end of this line
  j             " Move down one line
   P            " Paste what we just deleted

Sonra özyinelemeli makro ile bitiririz @qq@q. Bu noktada, köşegenlerin hepsine sahibiz, sadece biraz temizlik yapmamız gerekiyor.

G                   " Move to the last line
 ?.                 " Search backwards for any character
j                   " Move down one line
 dG                 " Delete until the end of the buffer

Vay, JavaScript (şu anda) Vim'den daha kısa. Bugünlerde oldukça nadir görülen bir durum ...
ETHproductions

@ETHproductions Artık değil. :)
DJMcMayhem

6

Turtlèd , 28 26 bayt

Ah, özellikle golf oynamak için tasarlanmış bir dili atıyor gibiyim. bu harika bir gün.

!_4[*.[ rd+.]ul[ ul]r;_+]_

Çevrimiçi deneyin!

açıklama

(yazma, ızgaradaki hücreye yazma anlamına gelir, sivri char, karakterin girdiği karakterin girdiği karaktere işaret eder)

!                         Take string input into variable
 _                        Normally conditional, with >1 input (there will be), write ' '
  4                       set register to 4
   [*                   ] until the current cell is *
     .                    Write pointed char, initially first char
      [     ]             Until space is written on cell
        rd+.              move right, down, string pointer++, write pointed char
             ul[ ul]      Move back up to the top of the word
                    r;    Move right, down 4 (because this is register value)
                      _+  write * if end of input, else ' ', increment string pointer
                        _ will always write ' ', since it will always point at start char

takip eden boşluğu not edin.

Giriş aynı zamanda sonda alanı gerektirir. python'u bir liste alabilir gibi görmek, bu çok Turtlèd'de liste almak gibi bir şey.


5

MATL , 28 bayt

c!t&n:q3_*ts_b+5M4$XdZ!cZ{Zv

Giriş, isteğe bağlı ayırıcılar olarak virgül içeren bir hücre dizesi dizisidir:

{'programming' 'puzzles' 'and' 'code' 'golf'}

veya

{'programming', 'puzzles', 'and', 'code', 'golf'}

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın: 1 , 2 , 3 , 4 .

açıklama

Örnek olarak aşağıdaki girişi düşünün:

{'aaaa' 'bb' 'ccc'}

Yorum sembolünü %kodun herhangi bir yerine yerleştiren kısmi sonuçları (yığın içeriği) görüntüleyebilirsiniz . Örneğin , dördüncü işlevden ( ) sonra yığın içeriğini görüntüleyin&n .

c        % Input cell array of strings implicitly. Convert to 2D char array,
         % right-padding with spaces
         % STACK: ['aaaa'; 'bb  '; 'ccc']
!        % Transpose
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  ']
t        % Duplicate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '],
                  ['abc'
                   'abc'
                   'a c'
                   'a  '],
&n       % Number of rows and of columns
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, 3
:q       % Range, subtract 1
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 1 2]
3_*      % Multiply by -3
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6]
ts_      % Duplicate, sum, negate
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], 4, [0 -3 -6], 9
b        % Bubble up in stack
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 9, 4
+        % Add
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13
5M       % Push second input of last function again
         % STACK: ['abc'
                   'abc'
                   'a c'
                   'a  '], [0 -3 -6], 13, 4
4$Xd     % Buld numerical sparse matrix from the above four arguments. The
         % columns of the first input argument will be the diagonals of the
         % result, with indices given bu the second input (negative is below
         % main diagonal). The matrix size is the third and fourth arguments
         % STACK: [97  0  0  0
                    0 97  0  0
                    0  0 97  0
                   98  0  0 97
                    0 98  0  0
                    0  0 32  0
                   99  0  0 32
                    0 99  0  0
                    0  0 99  0
                    0  0  0 32
                    0  0  0  0
                    0  0  0  0
                    0  0  0  0]
Z!c      % Convert from sparse to full, and then to char. Character 0 is
         % displayed as space
         % STACK: ['a   '
                   ' a  '
                   '  a '
                   'b  a'
                   ' b  '
                   '    '
                   'c   '
                   ' c  '
                   '  c '
                   '    '
                   '    '
                   '    '
                   '    ']
Z{       % Split into cell array, with each row in a cell
         % STACK: {'a   ', ' a  ', '  a ', 'b  a', ' b  ', '    ', 'c   ', ' c  ', '  c ', '   ', '   ', '   ', '   '}
Zv       % Deblank: remove trailing space from each string. Implicitly display,
         % each string on a different line. Empty strings do not generate
         % a newline
         % STACK: {'a   ', ' a', '  a', 'b  a', ' b', '', 'c', ' c', '  c', '', '', '', ''}

4

JavaScript (ES6), 118 109 84 bayt

Bir kelime dizisi olarak girdi alır. Karakter dizisini döndürür.

s=>s.map((w,y)=>[...w].map((c,x)=>(a[p=y*3+x]=a[p]||Array(x).fill(' '))[x]=c),a=[])&&a

Alternatif versiyon, 109 bayt

Bir dize döndürür.


2

Ortak Lisp, 673 668 597 bayt

Korkunç bir çözüm biliyorum. Muhtemelen biraz uyuduktan sonra bunu daha çok düzenleyeceğim.

(defun f(&rest z)(let((l)(a 0)(s)(o)(b)(c 0))(loop(setf b(length l))(setf l"")(loop for w in z for i from 0 do(if(>(+(length w)(* i 3))c)(setf c(+(length w)(* i 3))))(setf s(+(* i -3)a))(when(and(>= s 0)(< s(length w)))(setf o(format nil"~v@{~a~:*~}"s" "))(if(and(>=(- s 3)0)(not(equal i(-(length z)1))))(setf o(subseq o(- s 2))))(setf l(concatenate'string o(string(char w s))l)))(when(>= s(length w))(setf l(concatenate'string"   "l))))(if(<=(length l)b)(setf l(concatenate'string(format nil"~v@{~a~:*~}"(- b(length l)-1)" ")l)))(print(string-right-trim" "l))(if(>= b c)(return))(setf a(1+ a)))))

Kullanımı:

* (f "ppcg" "is" "pretty" "ok")

"p" 
" p" 
"  c" 
"i  g" 
" s" 
"" 
"p" 
" r" 
"  e" 
"o  t" 
" k  t" 
"     y" 
""
NIL

Bu, sağlanan listedeki her kelimenin üzerinden geçerek geçerli satıra uygun karakterler ekler. Alt dolgu kullanımım ile uygun dolgu malzemesi sağlanmaktadır format.

Not: Common Lisp'te yeniyim, ancak bunun çok fazla iyileştirme yapabileceğini anlamak için yeterince bilgim var.


2
> :( "ppcg ... tamam" !?
Limon

2

C #, 336 Bayt:

golfed:

string D(string[]s){int x=0,y=0,r=0,q=2*(s.Max().Length+s.Length)+1;var a=new char[q, q];for(int i=0;i<s.Length;i++){y=r;for(int j=0;j<s[i].Length;j++){a[y,x]=s[i][j];x+=1;y+=1;}x=0;r+=3;}var o="";for(x=0;x<q;x++){var t="";for(y=0;y<q;y++)t+=a[x,y];o+=t==string.Join("",Enumerable.Repeat('\0',q))?"":(t.TrimEnd('\0')+"\r\n");}return o;}

Ungolfed:

public string D(string[] s)
{
  int x = 0, y = 0, r = 0, q = 2 * (s.Max().Length + s.Length) + 1;
  var a = new char[q, q];
  for (int i = 0; i < s.Length; i++)
  {
    y = r;
    for (int j = 0; j < s[i].Length; j++)
    {
      a[y, x] = s[i][j];
      x += 1;
      y += 1;
    }
    x = 0;
    r +=3;
  }
  var o = "";
  for (x = 0; x < q; x++)
  {
    var t = "";
    for (y = 0; y < q; y++)
      t += a[x, y];
    o += t == string.Join("", Enumerable.Repeat('\0', q)) ? "" : (t.TrimEnd('\0') + "\r\n");
  }
  return o;
}

Test yapmak:

  var codeGolf = new DrawDiagonalLinesOfText();
  Console.WriteLine(codeGolf.E(new string[] { "programming", "puzzles", "and", "code", "golf" }));
  Console.WriteLine(codeGolf.E(new string[] { "a", "bcd", "efgh", "i", "j" }));
  Console.WriteLine(codeGolf.E(new string[] { "verylongword", "short" }));

p
 r
  o
p  g
 u  r
  z  a
a  z  m
 n  l  m
  d  e  i
c     s  n
 o        g
  d
g  e
 o
  l
   f


a
b
 c
  d
e
 f
  g
i  h
j


v
 e
  r
s  y
 h  l
  o  o
   r  n
    t  g
        w
         o
          r
           d

Bu, zorlu şartname tarafından izin verilmeyen, satırların sonunda izleyen boşluk bırakıyor gibi görünüyor. Ayrıca, giriş dizisindeki sözcükleri ayırmak için boşluk dizeleri istemek izin verilen bir giriş biçimi değildir.
Doorknob

@Doorknob Üzgünüz ... Sabit, sadece bana maliyeti 2 Byte :)
Pete Arden

1
Func<string[], string>297 bayt için bir derleme yapın ve çeşitli değişiklikler yapın; s=>{int i=0,x=0,y=0,r=0,l=s.Length,q=2*(s.Max().Length+l)+1,j;var a=new char[q,q];for(;i<l;i++){y=r;for(j=0;j<s[i].Length;)a[y++,x++]=s[i][j++];x=0;r+=3;}var o="";for(;x<q;x++){var t="";for(y=0;y<q;)t+=a[x,y++];o+=t==string.Join("",Enumerable.Repeat('\0',q))?"":(t.TrimEnd('\0')+"\n");}return o;};ancak bunun için 18 bayt eklemeniz gerekirusing System.Linq;
TheLethalCoder

@TheLethalCoder Teşekkürler, ama gerçekten tüm çözümünüzü almak istemiyorum :)
Pete Arden

Ben sadece Thwe hareketli yani uzak bazı şeyler golfed mayın onun senin değil ive jüstündeki int ilanına ve bazı hareketli ++onlar değişkenin son kullanım kullanılır böylece
TheLethalCoder

2

Python 2, 146 bayt

s=input()
k=max(map(len,s))
a=[k*[' ']for x in range(k+len(s)*3+3)]
for x in range(len(s)):
 for y in range(len(s[x])):a[x*3+y][y]=s[x][y]
print a

Not: Son iki satırın girintileri, <space>ve <tab>çift ​​girintiye gerek duymadığım için bir bayt kazandıran değerdir.

Giriş, şöyle bir dizi dizisi olarak girilmelidir: ["hello", "world"]veya ['hello', 'world']. Çıktı, bir karakter dizisidir.

Bunu yapmanın daha iyi bir yolu olabilir ...

EDIT Doorknob'a, eksik bir köşeli parantez işaretini gösterdiği için teşekkürler. *k...Üçüncü satıra daha önce yerleştirdim .


Üçüncü satırda kodunuzda bir sözdizimi hatası var; iki tane açık parantez var ama sadece bir tane kapalı parantez var. Ancak bunu düzeltirim (fazladan bir kapatma braketi ekleyerek veya fazladan açma braketini sökerek), program çalıştırıldığında hata veriyor.
Kapı tokmağı

Bu, satır sonlarında ve çıkışın sonunda, yarışma şartnamesinin izin vermeyeceği iz bırakan boşlukları gösterir.
Kapı tokmağı


@LeakyNun Teşekkürler. Sadece tüm cevaplarımı mı geçiyor ve golfe mi atıyorsun? : P
HyperNeutrino

1

Mathematica, 146 bayt

P=PadRight;T=Transpose;R=Riffle;Select[Rest@T@P@MapIndexed[""~Table~#2~Join~#1&,T@P@R[Characters/@#~R~{},{},3]]//.{0->"",{x__,""}->{x}},#!={""}&]&

Bu bayttan dolayı hayal kırıklığına uğradım, ama oh iyi.

Kelimelerin bir listesini (örneğin {"this","that","these"}) alan ve iki boyutlu bir karakter dizisi döndüren adsız bir işlevi tanımlar . Izgara biçiminde görüntülemek //Gridiçin sonuna bir ekleyin .

Dizeleri bir diziye dönüştürür, fazladan satır ekler, diziyi çevirir, gerekli vardiyaları hazırlar, sonra tekrar çevrilir.

Örnek sonuç (ızgara olarak biçimlendirilmiş): Örnek sonuç


1

Jöle , 24 bayt

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷

Çevrimiçi deneyin!

Nasıl?

z⁶j€⁾  µJ’⁶ẋ;"z⁶œr€⁶Yœr⁷ - Main link: a list of strings
z                        - transpose with filler...
 ⁶                       -     space character
  j€                     - join €ach with
    ⁾                    -     two spaces
       µ                 - monadic chain separation, call the result x
        J                - range(length(x)) [1,2,...,x]
         ’               - decrement (vectorises) [0,1,...x-1]
           ẋ             - repeat (vectorises)
          ⁶              - a space ['', ' ',...,'x spaces']
             "           - zip with
            ;            - concatenation (prefixes with the space strings)
              z          - transpose with filler...
               ⁶         -     space character
                œr€⁶     - trim spaces from the right of €ach
                    Y    - join with line feeds
                     œr⁷ - trim line feeds from the right
                         - implicit print

1

Python 2,182 bayt

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:
  i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i];k+=1
  if i==M-1:r=r.rstrip()+'\n'
 return r.strip()

Biraz uzun, ama pozitif tarafta, her satırda izleyen beyaz boşluk olmayan ve sonunda beyaz boşluk bırakmayan veya sonunda dönen bir dize döndürür; diğer bazı girişimlerin uymadığı kısıtlamalar.

İşleve bir sözcük listesi iletilir; bazı 'boşluklar' bu listeye eklenir ve algoritma bir satır, sütun çifti, bir genişletilmiş listede bir wordNumber, characterNumber ile eşlenir. (Bu, diğer çözümlerde görülen olağan stratejinin biraz tersidir).

Sonuncusu hariç tüm satırlarda boşluk bırakılmasına izin verirsek, biraz daha iyi yapabiliriz (163 bayt):

def f(s):
 M=max(map(len,s));p=' '*M;L=[p]+s+M*[p];r='';k=0
 while k/M<len(s)*3+M:i=k%M;w=k/M-i+1;r+=(L[(w/3+1)*(w%3==1)]+p)[i]+'\n'*(i==M-1);k+=1
 return r.strip()

1

q / kdb +, 130 109 94 90 86 84 bayt

Çözüm:

f:{-1(+)a rtrim(til(#)E){raze(x#" "),y,\:"  "}'E:(+)(a:{(max(#:)each x)$x})" "vs x;}

Örnekler:

q)f "programming puzzles and code golf"
p          
 r         
  o        
p  g       
 u  r      
  z  a     
a  z  m    
 n  l  m   
  d  e  i  
c     s  n 
 o        g
  d        
g  e       
 o         
  l        
   f 
q)f "a bcd efgh i j"
a   


b   
 c  
  d 
e   
 f  
  g 
i  h


j  
q)f (),"x"
x
q)f "verylongword short"
v           
 e          
  r         
s  y        
 h  l       
  o  o      
   r  n     
    t  g    
        w   
         o  
          r 
           d

Açıklama (asılsız):

Temel amaç, girdi dizgisinden eşit uzunlukta bir dizi dizisi oluşturmak, bunları çevirmek (döndürmek) ve şuna benzer bir şey elde etmek için uygun boşluklar eklemektir:

"p  p  a  c  g   "
" r  u  n  o  o  "
"  o  z  d  d  l "
"   g  z     e  f"
"    r  l        "
"     a  e       "
"      m  s      "
"       m        "
"        i       "
"         n      "
"          g     "

tekrar çevrilmiş ve stdout'a basılmıştır.

İşte konseptin satır satır dökümü:

A:"programming puzzles and code golf"; // original input
B:" " vs A;                            // split on " "
C:max count each B;                    // find length of the longest string
D:C$B;                                 // pad each string to this length
E:flip D;                              // flip (rotate) string
F:{raze(x#" "),y,\:"  "};              // appends each char with "  " and prepends an increasing number of " "
G:(til count E)F'E;                    // execute function F with each pair of 0..n and item in list E
H:max count each rtrim G;              // find longest string (ignoring right whitespace)
I:H$G;                                 // pad each of the strings to this length
J:flip I;                              // flip to get result
-1 J;                                  // print to stdout, swallow return value

Notlar:

Gerçekten istersek bazı (11) kolay baytları tıraş etmenin birkaç yolu :

  • f:Bırakarak ve anonim bir işlev olarak bırakarak 2 bayt tasarruf edilebilir
  • Bırakarak 3 bayt kurtarabilecek -1ve ;ve dizgi listesi dönen yerine Stdout'a baskı
  • Boşluktan ayrılmış bir dize yerine bir dize listesinden geçersek 6 bayt tasarruf edilebilir

Düzenlemeler:

  • -11 bayt, rtrimpede maksimum uzunluğu bulmak için kullanın, Cdeğişken depolamak için ihtiyaç kaldırıldı
  • -15 bayt, max count eachbir akez yaratılan ve iki kez kullanılan bir lambda fonksiyonunu devre dışı bırakarak
  • -4 bayt, razekaydetmek için lambda işlevine hareketraze each
  • -4 bayt, boşluk ekleyen çekirdek lambda işlevini basitleştirdi
  • -2, kullanım bayt (+)için kısaltma olarakflip

1

Kömür , 16 9 bayt

WS«P↘ιM³↓

İlk kömür cevabım. Sayesinde @DLosc öneri için ve kullanmak yerine ve çizgi başlangıcı (ve üç aşağı) dönmek (Atlama).

Çevrimiçi deneyin (ayrıntılı) veya Çevrimiçi deneyin (yalnızca saf) .

Açıklama:

Hala bir sonraki giriş dizgisi varken döngü:

While(InputString()){ ... }
WS« ...

İmleci aşağı yönde hareket ettirmeden bu dizgiyi yazdırın:

Multiprint(:DownRight, i);
P↘ι

Ardından bir sonraki yineleme için üç konumu aşağı kaydırın:

Move(3, :Down);
M³↓

Meydan okuma bir diziden oluşan tek bir girişe ihtiyaç duyduğunda, Kömür her bir sözcüğü ayrı bir giriş olarak alarak giriş dizesini böldüğü için başarısız olur. Fakat Charcoal'da θdeğişken ilk girişi temsil eder, bu yüzden sadece test girişini başlıktaki o değişkene atadım ve sonra kodun geri kalanını yazdım, böylece değişkenden kurtulup αbölünmüş öğelerin üzerinde yinelenebilirsiniz θ. Çevrimiçi deneyin! (Önde gelen alanlardan dolayı yarışmaz.)
Charlie,

Bu numarayı kullanıldığında En azından kimse şikayet buraya . :-)
Charlie

@CarlosAlejo Aslında Kömür cevabından ilham almak için aradığın cevabını gördüm. :)
Kevin Cruijssen

IDK, genellikle kullandığım yöntem sadece dizeler + sonunda boş bir dizgedir, eğer varsa çok satırlı varsa o zaman bir python dizisi olarak girin
ASCII-sadece

@CarlosAlejo Bir süre oldu, fakat şimdi sadece boş bir satırla süreyi kesmek için birden fazla satır kullandım (ve aynı anda 7 bayt golf oynadım). Neil'in cevaplarından birinde kullanıldığını gördüm ve şimdi ASCII'nin sadece aynı şeyi önerdiğini gördüm (bu yorumu bir şekilde kaçırdım).
Kevin Cruijssen

1

Japt -Rx, 17 16 13 bayt

Bir kelime dizisi olarak girdi alır. Her satırdaki sondaki boşluk boşluğuna izin verildiyse, o zaman son 4 karakter Kömür çözeltisine bağlamak için kaldırılabilir.

yÈmú3)iYçÃmx1

Deneyin veya tüm test durumlarını çalıştırın


açıklama

y                 :Transpose
 È                :Map each word at 0-based index Y
  m               :  Map each character
   ú3             :    Right pad with spaces to length 3
     )            :  End mapping
      i           :  Prepend
       Yç         :   Space repeated Y times
         Ã        :End mapping and transpose
          m       :Map
           x1     :  Trim right
                  :Implicitly join with newlines, trim and output

1

K4 , 58 bayt

Çözüm:

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:

Örnekler:

q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("programming";"puzzles";"and";"code";"golf")
"p          "
" r         "
"  o        "
"p  g       "
" u  r      "
"  z  a     "
"a  z  m    "
" n  l  m   "
"  d  e  i  "
"c     s  n "
" o        g"
"  d        "
"g  e       "
" o         "
"  l        "
"   f       "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:(,"a";"bcd";"efgh";,"i";,"j")
"a   "
"    "
"    "
"b   "
" c  "
"  d "
"e   "
" f  "
"  g "
"i  h"
"    "
"    "
"j   "
q)k)+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:("verylongword";"short")
"v           "
" e          "
"  r         "
"s  y        "
" h  l       "
"  o  o      "
"   r  n     "
"    t  g    "
"        w   "
"         o  "
"          r "
"           d"

Açıklama:

Sağ yastıklı dizgiler, aynı uzunlukta olmaları, transpozit, " "çaprazlama oluşturmak için sol yastığa, daha sonra uzunlukları düzeltmek ve geriye doğru transpoze etmek için sağ yastığa sahip olmaları içindir. Dizelerin listesini alır ve dizelerin listesini döndürür. Muhtemelen golf oynayabilir ama yine de q / kdb + çözümümden daha kısa.

+(|/{0+/|\|~^x}@'x)$x:(2-(!c)+3*#x)$"  "/:'$+(c:|/#:'x)$x:
                                                        x:      / save as variable x
                                                       $        / pad
                                             (        )         / do this together
                                                  #:'x          / count (#:) each (') x
                                                |/              / max
                                              c:                / save as variable c
                                            +                   / flip / transpose
                                           $                    / string ($)
                                    "  "/:'                     / join each with "  "
                                   $                            / pad
                      (           )                             / do this together
                                #x                              / count (#) x
                              3*                                / multiply by 3
                             +                                  / add to
                         (  )                                   / do this together
                          !c                                    / range 0..c
                       2-                                       / subtract from 2
                    x:                                          / save as x:
                   $                                            / pad
 (                )                                             / do all this together
    {         }@'x                                              / apply (@) lambda {} to each x
            ^x                                                  / null (^) x (" " is considered null)
           ~                                                    / not
          |                                                     / reverse
        |\                                                      / max (|) scan (\), maxs
     0+/                                                        / sum (+) over (/) starting with 0
  |/                                                            / max (|) over (/), max
+                                                               / transpose

0

Perl 6 , 73 bayt

{my@t;for .kv ->\i,\w{for w.comb.kv {@t[3*i+$^a][$^a]=$^b}};@t »||»" "}

Çevrimiçi deneyin!

Giriş argümanı bir sözcük listesidir. Çıktı bir karakter dizisi dizisidir.


Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.