Diberikan masukan dari daftar kata-kata, output kata-kata dengan surat-surat mereka diatur secara diagonal:

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

(Di atas harus menjadi output untuk input programming puzzles and code golf.)

Tepatnya, setiap kata dimulai pada kolom pertama dan tiga baris di bawah kata sebelumnya, dan setiap huruf berturut-turut memindahkan satu kolom ke kanan dan satu baris ke bawah.

Input dapat diberikan sebagai string kata tunggal, dipisahkan dengan tepat satu spasi, atau daftar / array kata. Kata-kata hanya akan terdiri dari huruf kecil a-z,, dan akan selalu setidaknya satu karakter.

Outputnya bisa berupa string tunggal, array baris, atau array array karakter. Memimpin atau mengikuti spasi tidak diizinkan, kecuali untuk satu baris baru.

Kasus uji lebih lanjut:

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

Karena ini adalah kode-golf , kode terpendek dalam byte akan menang!

Vim, 85, 76, 66 , 52 penekanan tombol / byte

Ketika saya pertama kali melihat tantangan ini, saya berpikir, "Ini sempurna untuk vim!" Dan ketika saya mencobanya semuanya menjadi salah. Ini dia, dalam semua itu kemuliaan berantakan berantakan:

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

Cobalah online, berkat penerjemah V yang kompatibel (sebagian besar).

Penjelasan:

Pada awalnya saya pikir saya bisa melakukan versi 37 byte yang sangat sederhana ini:

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

Sayangnya, itu tidak sesederhana itu. Mari kita bawa baris demi baris:

:se ve=all

Ini memungkinkan fitur yang disebut 'pengeditan virtual'. Ini memungkinkan kursor untuk pindah ke kolom yang belum ada. Jawaban ini pada dasarnya tidak mungkin tanpanya.

Sekarang kita perlu memisahkan kata-kata ke baris yang berbeda. Jadi kami akan mengganti setiap ruang dengan 3 baris baru. Karena ini adalah perintah ex, kita dapat menjalankannya secara bersamaan dengan perintah ex terakhir kita :se ve=alldengan memisahkan keduanya dengan sebuah bar.

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

Sekarang buffer terlihat seperti ini:

Programming


Puzzles


and


code-golf

Di sinilah kesenangan dimulai. Kami menyiapkan makro rekursif tradisional dengan:, qqdan kemudian menyebutnya:

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

Lalu kami menyelesaikan makro rekursif dengan @qq@q. Pada titik ini, kita memiliki semua diagonal, kita hanya perlu melakukan sedikit pembersihan.

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

Turtlèd , 28 26 byte

Ya ampun, saya tampaknya mengalahkan bahasa yang dirancang khusus untuk bermain golf. ini hari yang menyenangkan.

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

Cobalah online!

Penjelasan

(tulis berarti menulis ke sel di grid, char menunjuk berarti char di input pointer menunjuk ke)

!                         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

perhatikan spasi tambahan.

Input juga membutuhkan ruang tambahan. mengingat python dapat mengambil daftar, ini sangat mirip dengan mengambil daftar di Turtlèd

MATL , 28 byte

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

Input adalah array sel string, dengan koma sebagai pemisah opsional:

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

atau

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

Cobalah online! Atau verifikasi semua kasus uji: 1 , 2 , 3 , 4 .

Penjelasan

Pertimbangkan input berikut sebagai contoh:

{'aaaa' 'bb' 'ccc'}

Anda dapat melihat hasil sebagian (menumpuk konten) menyisipkan simbol komentar %di setiap titik dalam kode. Misalnya, melihat konten tumpukan setelah fungsi keempat ( &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', '', '', '', ''}

JavaScript (ES6), 118 109 84 byte

Mengambil input sebagai array kata. Mengembalikan array array karakter.

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

Versi alternatif, 109 byte

Mengembalikan string.

let f =

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

console.log(f(["programming", "puzzles", "and", "code", "golf"]))

Common Lisp, 673 668 597 byte

Solusi yang mengerikan, saya tahu. Saya mungkin akan mengedit ini lagi setelah tidur.

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

Pemakaian:

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

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

Ini memotong setiap kata dalam daftar yang disediakan dan menambahkan karakter yang sesuai ke baris saat ini. Padding yang sesuai disediakan oleh saya di bawah penggunaan format.

Catatan: Saya baru mengenal Common Lisp, tetapi saya cukup tahu untuk menyadari bahwa ini dapat menggunakan banyak peningkatan.

C #, 336 Bytes:

Golf:

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;}

Tidak Disatukan:

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;
}

Pengujian:

  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

Python 2, 146 byte

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

Catatan: lekukan untuk dua baris terakhir adalah <space>dan <tab>, yang menyimpan satu byte karena saya tidak perlu menggandakan indentasi.

Input harus dimasukkan sebagai array string seperti: ["hello", "world"]atau ['hello', 'world']. Output adalah array array karakter.

Mungkin ada cara yang lebih baik untuk melakukan ini ...

EDIT Terima kasih kepada Doorknob karena menunjukkan braket kotak yang hilang. Saya menempatkannya *k...di baris ketiga.

Mathematica, 146 byte

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

Saya kecewa dengan bytecount ini, tapi oh well.

Menentukan fungsi anonim yang mengambil daftar kata (misalnya {"this","that","these"}) dan mengembalikan array karakter dua dimensi. Untuk melihat dalam bentuk kisi, tambahkan a //Griddi bagian akhir.

Mengonversi string ke array, menambahkan garis ekstra, mentransposisi array, menambahkan perubahan yang diperlukan, lalu mentranspos lagi.

Contoh hasil (diformat sebagai kisi):

Jelly , 24 byte

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

Cobalah online!

Bagaimana?

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

Python 2, 182 byte

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

Agak panjang, tetapi di sisi positif, ia mengembalikan string tanpa spasi putih di setiap baris, dan tidak ada spasi putih atau kembali di akhir; kendala yang tidak dipatuhi beberapa entri lainnya.

Daftar kata-kata diteruskan ke fungsi; beberapa 'kosong' ditambahkan ke daftar ini dan kemudian algoritma memetakan baris, pasangan kolom ke wordNumber, characterNumber dalam daftar yang diperluas. (Ini adalah sedikit kebalikan dari strategi yang biasa terlihat dalam solusi lain).

Jika kita membolehkan mengekor ruang putih di semua baris kecuali yang terakhir, kita dapat melakukan sedikit lebih baik (163 byte):

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

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

Larutan:

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

Contoh:

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

Penjelasan (ungolfed):

Inti dasarnya adalah membuat sekelompok string dengan panjang yang sama dari string input, membalik (rotate) mereka, kemudian menambahkan spasi yang sesuai untuk mendapatkan sesuatu yang terlihat seperti ini:

"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     "

yang dibalik lagi, dan dicetak ke stdout.

Berikut ini adalah rincian konsep ini:

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

Catatan:

Beberapa cara untuk mengurangi beberapa (11) byte mudah jika kita benar - benar ingin:

• Bisa menghemat 2 byte dengan menjatuhkan f:dan membiarkannya sebagai fungsi anonim
• Bisa menyelamatkan 3 byte dengan menjatuhkan -1dan ;dan kembali daftar string daripada mencetak ke stdout
• Bisa menghemat 6 byte jika kita meneruskan daftar string daripada string yang dipisahkan ruang

Suntingan:

• -11 byte, gunakan rtrimuntuk mencari panjang max ke pad, kebutuhan dihapus untuk menyimpan Cvariabel
• -15 byte, max count eachmematikan fungsi lambda ayang dibuat sekali dan digunakan dua kali
• -4 byte, memindahkan razeke fungsi lambda untuk menyimpan araze each
• -4 byte, menyederhanakan fungsi inti lambda yang menambahkan spasi putih
• -2 byte, gunakan (+)sebagai singkatan untukflip

Arang , 16 9 byte

ＷＳ«Ｐ↘ιＭ³↓

Jawaban pertama saya tentang Arang. Terima kasih kepada @DLosc untuk saran Ｐdan Ｍalih-alih menggunakan Ｓdan Ｊ(Langsung) untuk kembali ke awal baris (dan tiga ke bawah).

Cobalah online (verbose) atau Coba online (murni) .

Penjelasan:

Loop sementara masih ada input-string berikutnya:

While(InputString()){ ... }
ＷＳ« ...

Cetak string ini tanpa menggerakkan kursor ke arah kanan bawah:

Multiprint(:DownRight, i);
Ｐ↘ι

Dan kemudian pindahkan tiga posisi ke bawah untuk iterasi berikutnya:

Move(3, :Down);
Ｍ³↓

Japt -Rx, 17 16 13 byte

Mengambil input sebagai array kata. Jika membuntuti spasi putih pada setiap baris diizinkan maka 4 karakter terakhir dapat dihapus untuk mengikat dengan solusi Charcoal.

yÈmú3)iYçÃmx1

Cobalah atau jalankan semua test case

Penjelasan

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

K4 , 58 byte

Larutan:

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

Contoh:

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"

Penjelasan:

String pad kanan sehingga panjangnya sama, transpos, gabung dengan " ", pad kiri untuk menghasilkan diagonal, lalu pad kanan untuk mengoreksi panjang dan transpos kembali. Mengambil daftar string dan mengembalikan daftar string. Mungkin golf tetapi masih lebih pendek dari solusi q / kdb + saya.

+(|/{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

Perl 6 , 73 byte

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

Cobalah online!

Argumen input adalah daftar kata-kata. Outputnya adalah array dari array karakter.

PHP , 100 byte

<?foreach($_GET as$k=>$v)for($x=0;$y=$v[$x];$t[$x++]=$y)($t=&$s[$k*3+$x])?:$t=" ";echo join("
",$s);

Cobalah online!