Dato l'inserimento di un elenco di parole, genera le parole con le loro lettere disposte in diagonale:

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

(Quanto sopra dovrebbe essere l'output per l'input programming puzzles and code golf.)

Per essere precisi, ogni parola inizia sulla prima colonna e tre righe sotto la parola precedente e ogni lettera successiva sposta una colonna a destra e una riga in basso.

L'input può essere fornito come una singola stringa di parole, separate da esattamente uno spazio o un elenco / matrice di parole. Le parole saranno composte solo da lettere minuscole a-ze saranno sempre lunghe almeno un carattere.

L'output può essere una singola stringa, una matrice di linee o una matrice di matrici di caratteri. Gli spazi bianchi iniziali o finali non sono consentiti, ad eccezione di una nuova riga finale finale.

Ulteriori casi di test:

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

Dato che si tratta di code-golf , vincerà il codice più breve in byte!

Tasti, 85, 76, 66 , 52 tasti / byte

Quando ho visto per la prima volta questa sfida, ho pensato "Questo è perfetto per VIM!" E poi quando l'ho provato tutto è andato storto. Eccola, in tutta la sua gloria disordinata e confusa:

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

Provalo online, grazie all'interprete V (principalmente) retrocompatibile.

Spiegazione:

All'inizio ho pensato di poter fare questa versione meravigliosamente semplice di 37 byte:

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

Sfortunatamente, non è così semplice. Prendiamolo riga per riga:

:se ve=all

Ciò abilita una funzione chiamata "modifica virtuale". Permette al cursore di spostarsi su colonne che non esistono ancora. Questa risposta sarebbe praticamente impossibile senza di essa.

Ora dobbiamo separare le parole su righe diverse. Quindi sostituiremo ogni spazio con 3 nuove righe. Dato che si tratta di un comando ex, possiamo eseguirlo contemporaneamente al nostro ultimo comando ex :se ve=allseparando i due con una barra.

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

Ora il buffer è simile al seguente:

Programming


Puzzles


and


code-golf

Ecco dove inizia il divertimento. Abbiamo impostato la macro ricorsiva tradizionale con:, qqquindi chiamiamo questo:

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

Quindi finiamo la macro ricorsiva con @qq@q. A questo punto, abbiamo tutte le diagonali, dobbiamo solo fare un po 'di pulizia.

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

Oh mio Dio, sembra che stia battendo un linguaggio appositamente progettato per il golf. questo è un grande giorno

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

Provalo online!

Spiegazione

(scrivere significa scrivere nella cella della griglia, char appuntito significa char in input a cui punta il puntatore stringa)

!                         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

nota spazio finale.

Anche l'input ha bisogno di spazio finale. visto che Python può prendere una lista, è molto simile a prendere una lista in Turtlèd

MATL , 28 byte

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

L'input è un array di celle di stringhe, con virgole come separatori opzionali:

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

o

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

Provalo online! Oppure verifica tutti i casi di test: 1 , 2 , 3 , 4 .

Spiegazione

Considera il seguente input come esempio:

{'aaaa' 'bb' 'ccc'}

È possibile visualizzare i risultati parziali (contenuto dello stack) inserendo il simbolo di commento %in qualsiasi punto del codice. Ad esempio, visualizzare il contenuto dello stack dopo la quarta funzione ( &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

Accetta input come una matrice di parole. Restituisce una matrice di matrici di caratteri.

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

Versione alternativa, 109 byte

Restituisce una stringa.

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

Lisp comune, 673 668 597 byte

Soluzione terribile, lo so. Probabilmente lo modificherò più dopo un po 'di sonno.

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

Uso:

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

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

Questo scorre su ogni parola nell'elenco fornito e aggiunge i caratteri appropriati alla riga corrente. Un'adeguata imbottitura è fornita dal mio utilizzo scadente di format.

Nota: sono nuovo di Common Lisp, ma so abbastanza per rendermi conto che questo potrebbe comportare molti miglioramenti.

C #, 336 byte:

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:

  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

Nota: i rientri delle ultime due righe sono <space>e <tab>, il che consente di risparmiare un byte poiché non è necessario eseguire il doppio rientro.

L'input deve essere inserito come una matrice di stringhe in questo modo: ["hello", "world"]oppure ['hello', 'world']. L'output è una matrice di matrici di caratteri.

Probabilmente c'è un modo migliore per farlo ...

EDIT Grazie a Doorknob per aver segnalato una parentesi quadra chiusa mancante. L'ho inserito prima *k...nella terza riga.

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}},#!={""}&]&

Sono deluso da questo resoconto, ma vabbè.

Definisce una funzione anonima che accetta un elenco di parole (ad es. {"this","that","these"}) E restituisce una matrice bidimensionale di caratteri. Per visualizzare in forma di griglia, aggiungere //Grida alla fine.

Converte le stringhe in un array, aggiunge ulteriori righe, traspone l'array, antepone gli spostamenti necessari, quindi traspone di nuovo.

Risultato di esempio (formattato come griglia):

Gelatina , 24 byte

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

Provalo online!

Come?

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

Un po 'lungo, ma sul lato positivo, restituisce una stringa senza spazi bianchi finali su ogni riga e senza spazi bianchi finali o ritorni alla fine; vincoli a cui alcune altre voci non obbediscono.

Un elenco di parole viene passato nella funzione; alcuni "spazi vuoti" vengono aggiunti a questo elenco e quindi l'algoritmo mappa una riga, una coppia di colonne in un numero di parola, numero di carattere nell'elenco espanso. (Questo è un po 'l'inverso della solita strategia vista in altre soluzioni).

Se consentiamo lo spazio bianco finale su tutte le righe tranne l'ultima, possiamo fare un po 'meglio (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

Soluzione:

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

Esempi:

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

Spiegazione (non golfizzato):

L'essenza di base è creare un gruppo di stringhe di uguale lunghezza dalla stringa di input, capovolgerle (ruotarle), quindi aggiungere spazi bianchi appropriati per ottenere qualcosa del genere:

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

che viene nuovamente capovolto e stampato su stdout.

Ecco una ripartizione riga per riga del concetto:

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

Appunti:

Alcuni modi per eliminare alcuni (11) byte facili se volessimo davvero :

• Potrebbe salvare 2 byte rilasciando f:e lasciando come una funzione anonima
• Impossibile salvare 3 byte facendo cadere il -1ed ;e restituendo una lista di stringhe, piuttosto che la stampa su stdout
• Potrebbe salvare 6 byte se passassimo in un elenco di stringhe anziché in stringhe separate da spazio

modifiche:

• -11 byte, utilizzare rtrimper trovare la lunghezza massima per il pad, rimossa la necessità di memorizzare Cvariabili
• -15 byte, disattivando la funzione max count eachfor a lambda ache viene creata una volta e utilizzata due volte
• -4 byte, spostando razenella funzione lambda per salvare araze each
• -4 byte, semplificata la funzione lambda core che aggiunge lo spazio bianco
• -2 byte, usare (+)come scorciatoia perflip

Carbone , 16 9 byte

ＷＳ«Ｐ↘ιＭ³↓

La mia prima risposta al carbone. Grazie a @DLosc per i suggerimenti Ｐe Ｍinvece di usare Ｓe Ｊ(Salta) per tornare all'inizio della riga (e tre in basso).

Provalo online (dettagliato) o Provalo online (puro) .

Spiegazione:

Ripeti mentre c'è ancora una stringa di input successiva:

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

Stampa questa stringa senza spostare il cursore in una direzione verso il basso:

Multiprint(:DownRight, i);
Ｐ↘ι

Quindi sposta tre posizioni verso il basso per la successiva iterazione:

Move(3, :Down);
Ｍ³↓

Japt -Rx, 17 16 13 byte

Accetta input come una matrice di parole. Se fossero consentiti spazi vuoti finali su ciascuna riga, gli ultimi 4 caratteri potrebbero essere rimossi per legare con la soluzione di carbone.

yÈmú3)iYçÃmx1

Provalo o esegui tutti i casi di test

Spiegazione

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

Soluzione:

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

Esempi:

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"

Spiegazione:

Stringhe del pad destro in modo che abbiano la stessa lunghezza, trasposizione, unione con il " "pad sinistro per generare diagonali, quindi pad destro per correggere le lunghezze e trasporre indietro. Prende un elenco di stringhe e restituisce un elenco di stringhe. Probabilmente giocabile a golf ma ancora più breve della mia soluzione q / kdb +.

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

Provalo online!

L'argomento di input è un elenco di parole. L'output è un array di array di caratteri.

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

Provalo online!