Avec l'entrée d'une liste de mots, affichez les mots avec leurs lettres disposées en 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

(Ce qui précède devrait être la sortie pour l'entrée programming puzzles and code golf.)

Pour être précis, chaque mot commence sur la première colonne et trois lignes en dessous du mot précédent, et chaque lettre successive déplace une colonne vers la droite et une ligne vers le bas.

L'entrée peut être fournie sous forme d'une chaîne de mots unique, séparée par un seul espace, ou d'une liste / tableau de mots. Les mots ne seront composés que de lettres minuscules a-zet comporteront toujours au moins un caractère.

La sortie peut être une chaîne unique, un tableau de lignes ou un tableau de caractères. Les espaces de début ou de fin ne sont pas autorisés, à l'exception d'un seul nouveau trait de fin.

Autres cas de 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

Puisqu'il s'agit de code-golf , le code le plus court en octets va gagner!

Vim, 85, 76, 66 , 52 frappes / octets

Quand j'ai regardé ce défi pour la première fois, j'ai pensé "C'est parfait pour vim!" Et puis quand j'ai essayé, tout s'est mal passé. Le voici, dans toute sa gloire de hacky en désordre:

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

Essayez-le en ligne, grâce à l’interpréteur V (principalement) compatible.

Explication:

Au début, je pensais pouvoir faire cette version magnifiquement simple de 37 octets:

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

Malheureusement, ce n'est pas si simple. Prenons cela ligne par ligne:

:se ve=all

Cela active une fonctionnalité appelée «édition virtuelle». Cela permet au curseur de se déplacer vers des colonnes qui n'existent pas encore. Cette réponse serait fondamentalement impossible sans elle.

Nous devons maintenant séparer les mots sur des lignes différentes. Nous allons donc remplacer chaque espace par 3 nouvelles lignes. Puisqu'il s'agit d'une commande ex, nous pouvons l'exécuter simultanément avec notre dernière commande ex :se ve=allen séparant les deux avec une barre.

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

Maintenant, le tampon ressemble à ceci:

Programming


Puzzles


and


code-golf

Voici où commence le plaisir. Nous mettons en place la macro récursive traditionnelle avec:, qqpuis appelons ceci:

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

Ensuite, nous finissons la macro récursive avec @qq@q. À ce stade, nous avons toutes les diagonales, nous avons juste besoin de faire un peu de nettoyage.

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

Tortue , 28 26 octets

Oh mon Dieu, je parais battre un langage spécialement conçu pour le golf. c'est un grand jour.

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

Essayez-le en ligne!

Explication

(écrire signifie écrire dans la cellule de la grille, le caractère pointé signifie que le caractère entré dans le pointeur de la chaîne)

!                         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

notez l'espace de fin.

L'entrée nécessite également un espace de fin. vu que python peut prendre une liste, cela ressemble beaucoup à prendre une liste dans Turtlèd

MATL , 28 octets

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

Input est un tableau de cellules de chaînes, avec des virgules comme séparateurs facultatifs:

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

ou

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

Essayez-le en ligne! Ou vérifiez tous les cas de test: 1 , 2 , 3 , 4 .

Explication

Considérez l'entrée suivante comme exemple:

{'aaaa' 'bb' 'ccc'}

Vous pouvez afficher les résultats partiels (contenu de la pile) en insérant le symbole de commentaire %à n’importe quel point du code. Par exemple, affichez le contenu de la pile après la quatrième fonction ( &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 octets

Prend les entrées sous forme de tableau de mots. Retourne un tableau de tableaux de caractères.

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

Version alternative, 109 octets

Retourne une chaîne.

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 octets

Terrible solution, je sais. Je vais probablement éditer cela plus après un peu de sommeil.

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

Usage:

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

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

Cela boucle sur chaque mot de la liste fournie et ajoute les caractères appropriés à la ligne en cours. Un rembourrage approprié est fourni par mon utilisation sous la moyenne de format.

Remarque: je suis nouveau dans Common Lisp, mais j'en sais assez pour comprendre que cela pourrait nécessiter beaucoup d'amélioration.

C #, 336 octets:

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

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

Essai:

  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 octets

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

Remarque: les indentations des deux dernières lignes sont <space>et <tab>, ce qui enregistre un octet puisque je n'ai pas besoin de faire un double retrait.

L'entrée doit être entrée comme un tableau de chaînes comme suit: ["hello", "world"]ou ['hello', 'world']. La sortie est un tableau de tableaux de caractères.

Il y a probablement une meilleure façon de faire ça ...

EDIT Merci à Doorknob pour avoir signalé un crochet manquant. Je l'ai placé avant *k...la troisième ligne.

Mathematica, 146 octets

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

Je suis déçu par ce décompte, mais bon.

Définit une fonction anonyme qui prend une liste de mots (par exemple {"this","that","these"}) et renvoie un tableau de caractères à deux dimensions. Pour afficher sous forme de grille, ajoutez un //Gridà la fin.

Convertit les chaînes en tableau, ajoute des lignes supplémentaires, transpose le tableau, ajoute les décalages nécessaires, puis transpose à nouveau.

Exemple de résultat (formaté en grille):

Gelée , 24 octets

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

Essayez-le en ligne!

Comment?

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 octets

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 peu long, mais du côté positif, il retourne une chaîne sans espace blanc final sur chaque ligne, ni espace blanc final, ni retour à la fin; contraintes auxquelles certaines autres entrées n'obéissent pas.

Une liste de mots est passée à la fonction; certains "espaces" sont ajoutés à cette liste, puis l'algorithme mappe une ligne, une paire de colonnes sur un motNuméro, un caractèreNumier dans la liste développée. (Ceci est un peu l'inverse de la stratégie habituelle vue dans d'autres solutions).

Si nous autorisons les espaces en fin de ligne sur toutes les lignes sauf la dernière, nous pouvons faire un peu mieux (163 octets):

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 octets

Solution:

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

Exemples:

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

Explication (non golfée):

L'essentiel est de créer un groupe de chaînes de longueur égale à partir de la chaîne d'entrée, de les retourner (de les faire pivoter), puis d'ajouter les espaces blancs appropriés pour obtenir un résultat ressemblant à ceci:

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

qui est retourné à nouveau et imprimé sur la sortie standard.

Voici une ventilation du concept ligne par ligne:

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

Remarques:

Quelques façons de supprimer quelques (11) octets faciles si nous voulions vraiment :

• Pourrait économiser 2 octets en laissant tomber le f:et en laissant une fonction anonyme
• Pourrait économiser 3 octets en supprimant les -1et ;et en renvoyant une liste de chaînes plutôt qu'en imprimant sur la sortie standard.
• Pourrait économiser 6 octets si nous passions dans une liste de chaînes plutôt que dans une chaîne séparée par des espaces

Modifications:

• -11 octets, utilisé rtrimpour trouver la longueur maximale du pad, suppression de la nécessité de stocker la Cvariable
• -15 octets, désactivant la max count eachpour une fonction lambda aqui est créée une fois et utilisée deux fois
• -4 octets, en déplaçant la razedans la fonction lambda pour enregistrer unraze each
• -4 octets, simplifie la fonction principale lambda qui ajoute les espaces
• -2 octets, utiliser (+)comme raccourci pourflip

Charbon de bois , 16 à 9 octets

ＷＳ«Ｐ↘ιＭ³↓

Ma première réponse au fusain. Merci à @DLosc pour avoir suggéré Ｐet Ｍau lieu d'utiliser Ｓet Ｊ(Jump) pour revenir au début de la ligne (et trois vers le bas).

Essayez-le en ligne (verbeux) ou Essayez-le en ligne (pur) .

Explication:

Boucle pendant qu'il y a encore une chaîne d'entrée suivante:

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

Imprimez cette chaîne sans déplacer le curseur dans le bas à droite:

Multiprint(:DownRight, i);
Ｐ↘ι

Et puis déplacez trois positions vers le bas pour la prochaine itération:

Move(3, :Down);
Ｍ³↓

Japt -Rx, 17 16 13 octets

Prend les entrées sous forme de tableau de mots. Si les espaces en fin de ligne étaient autorisés sur chaque ligne, les 4 derniers caractères pourraient être supprimés pour être liés à la solution de charbon de bois.

yÈmú3)iYçÃmx1

Essayez-le ou lancez tous les cas de test

Explication

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 octets

Solution:

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

Exemples:

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"

Explication:

Les chaînes du pad droit ont donc la même longueur, transposent, se joignent avec " ", le pad gauche génère des diagonales, puis le pavé droit pour corriger les longueurs et transposer en arrière. Prend une liste de chaînes et renvoie une liste de chaînes. Probablement golfable mais toujours plus court que ma solution 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 octets

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

Essayez-le en ligne!

L'argument d'entrée est une liste de mots. La sortie est un tableau de caractères.

PHP , 100 octets

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

Essayez-le en ligne!