Po wprowadzeniu listy słów wypisz słowa z literami ułożonymi po przekątnej:

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

(Powyższe powinno być wyjściem dla danych wejściowych programming puzzles and code golf.)

Mówiąc ściślej, każde słowo zaczyna się w pierwszej kolumnie i trzy rzędy poniżej poprzedniego słowa, a każda kolejna litera przesuwa jedną kolumnę w prawo i jeden wiersz w dół.

Dane wejściowe mogą być dostarczane jako pojedynczy ciąg słów oddzielony dokładnie jedną spacją lub lista / tablica słów. Słowa będą się składać tylko z małych liter a-zi zawsze będą miały co najmniej jeden znak.

Wynik może być pojedynczym łańcuchem, tablicą linii lub tablicą tablic znaków. Wiodące lub końcowe białe znaki nie są dozwolone, z wyjątkiem pojedynczej nowej linii.

Dalsze przypadki testowe:

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

Ponieważ jest to code-golf , wygra najkrótszy kod w bajtach!

Vim, 85, 76, 66 , 52 naciśnięcia klawiszy / bajty

Kiedy po raz pierwszy spojrzałem na to wyzwanie, pomyślałem: „To idealne rozwiązanie dla vima!” A potem, kiedy spróbowałem, wszystko poszło nie tak. Oto wszystko, w całej tej niechlujnej, hackerskiej chwale:

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

Wypróbuj online, dzięki (głównie) kompatybilnemu wstecznie interpreterowi V.

Wyjaśnienie:

Na początku myślałem, że mogę zrobić tę pięknie prostą 37-bajtową wersję:

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

Niestety nie jest to takie proste. Weźmy to linia po linii:

:se ve=all

Umożliwia to funkcję zwaną „edycją wirtualną”. Pozwala kursorowi przejść do kolumn, które jeszcze nie istnieją. Bez niej odpowiedź byłaby w zasadzie niemożliwa.

Teraz musimy rozdzielić słowa na różne linie. Dlatego zastąpimy każde miejsce 3 nowymi liniami. Ponieważ jest to polecenie ex, możemy je uruchomić jednocześnie z naszym ostatnim poleceniem ex :se ve=all, oddzielając je dwoma paskiem.

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

Teraz bufor wygląda następująco:

Programming


Puzzles


and


code-golf

Tutaj zaczyna się zabawa. Skonfigurowaliśmy tradycyjne makro rekurencyjne za pomocą:, qqa następnie nazywamy to:

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

Następnie kończymy makro rekurencyjne za pomocą @qq@q. W tym momencie mamy wszystkie przekątne, musimy tylko trochę posprzątać.

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 bajtów

Och, wydaje mi się, że biję język specjalnie zaprojektowany do gry w golfa. to jest wspaniały dzień.

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

Wypróbuj online!

Wyjaśnienie

(zapis oznacza zapis do komórki na siatce, spiczasty znak oznacza znak na wejściu, na który wskazuje wskaźnik łańcucha)

!                         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

zwróć uwagę na spację końcową.

Dane wejściowe również wymagają spacji końcowych. widząc, jak Python może pobrać listę, jest to bardzo podobne do pobierania listy w Turtlèd

MATL , 28 bajtów

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

Dane wejściowe to tablica komórek z ciągami znaków, z przecinkami jako opcjonalnymi separatorami:

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

lub

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

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe: 1 , 2 , 3 , 4 .

Wyjaśnienie

Rozważ następujące dane wejściowe jako przykład:

{'aaaa' 'bb' 'ccc'}

Możesz zobaczyć wyniki częściowe (zawartość stosu) wstawiając symbol komentarza %w dowolnym punkcie kodu. Na przykład wyświetl zawartość stosu po czwartej funkcji ( &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 bajtów

Pobiera dane wejściowe jako tablicę słów. Zwraca tablicę tablic znaków.

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

Alternatywna wersja, 109 bajtów

Zwraca ciąg.

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 bajtów

Okropne rozwiązanie, wiem. Prawdopodobnie zedytuję to później po pewnym czasie snu.

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

Stosowanie:

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

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

Powoduje to zapętlanie każdego słowa na podanej liście i dodaje odpowiednie znaki do bieżącego wiersza. Odpowiednie wypełnienie zapewnia moje niestosowne użycie format.

Uwaga: Jestem nowy w Common Lisp, ale wiem wystarczająco dużo, aby zdać sobie sprawę, że przydałoby się to wiele ulepszeń.

C #, 336 bajtów:

Gra w golfa:

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

Nie golfowany:

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

Testowanie:

  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 bajtów

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

Uwaga: wcięcia dla dwóch ostatnich wierszy to <space>i <tab>, co oszczędza jeden bajt, ponieważ nie muszę podwójnego wcięcia.

Dane wejściowe należy wprowadzić jako tablicę ciągów takich jak: ["hello", "world"]lub ['hello', 'world']. Dane wyjściowe to tablica tablic znaków.

Prawdopodobnie jest na to lepszy sposób ...

EDYCJA Dzięki Klamce za wskazanie brakującego nawiasu kwadratowego. Umieściłem go przed *k...trzecim wierszem.

Mathematica, 146 bajtów

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

Jestem rozczarowany tym bajtem, ale no cóż.

Definiuje anonimową funkcję, która pobiera listę słów (np. {"this","that","these"}) I zwraca dwuwymiarową tablicę znaków. Aby wyświetlić w formie siatki, dodaj //Gridna końcu.

Konwertuje ciągi znaków na tablicę, dodaje dodatkowe linie, transponuje tablicę, poprzedza niezbędne zmiany, a następnie transponuje ponownie.

Przykładowy wynik (sformatowany jako siatka):

Galaretka , 24 bajty

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

Wypróbuj online!

W jaki sposób?

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 bajty

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

Nieco długi, ale po stronie dodatniej, zwraca ciąg bez końcowych białych spacji w każdej linii i bez końcowych białych spacji lub zwraca na końcu; ograniczenia, których niektóre inne wpisy nie przestrzegają.

Lista słów jest przekazywana do funkcji; niektóre „puste” miejsca są dodawane do tej listy, a następnie algorytm odwzorowuje wiersz, parę kolumn na słowoNumer, znakNumer na rozwiniętej liście. (Jest to odwrotność zwykłej strategii obserwowanej w innych rozwiązaniach).

Jeśli zezwolimy na końcowe białe znaki na wszystkich liniach oprócz ostatniej, możemy zrobić trochę lepiej (163 bajty):

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 bajtów

Rozwiązanie:

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

Przykłady:

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

Objaśnienie (bez golfa):

Podstawową zasadą jest utworzenie wiązki ciągów o równej długości z ciągu wejściowego, odwrócenie (obrócenie), a następnie dodanie odpowiedniej białej spacji, aby uzyskać coś, co wygląda następująco:

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

który jest ponownie odwracany i drukowany na standardowe wyjście.

Oto podział koncepcji linia po linii:

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

Uwagi:

Kilka sposobów na zmniejszenie niektórych (11) łatwych bajtów, jeśli naprawdę chcemy:

• Można zapisać 2 bajty, upuszczając f: i pozostawiając jako funkcję anonimową
• Można zapisać 3 bajty, upuszczając -1i; i powrocie listę ciągów zamiast drukować do stdout
• Można by zapisać 6 bajtów, gdybyśmy przekazali listę ciągów zamiast ciągu oddzielonego spacjami

Edycje:

• -11 bajtów, użyj, rtrimaby znaleźć maksymalną długość do padu, usunięto potrzebę przechowywaniaC zmiennej
• -15 bajtów, wyłączając max count eachfunkcję lambda, aktóra jest tworzona raz i używana dwa razy
• -4 bajty, przejście razedo funkcji lambda, aby zapisaćraze each
• -4 bajty, uprościła podstawową funkcję lambda, która dodaje białe znaki
• -2 bajty, użyj (+)jako skrót dlaflip

Węgiel drzewny , 16 9 bajtów

ＷＳ«Ｐ↘ιＭ³↓

Moja pierwsza odpowiedź na węgiel drzewny. Dzięki @DLosc za sugestie Ｐi Ｍzamiast używania ＳiＪ (Jump), aby wrócić do początku linii (i trzy w dół).

Wypróbuj online (pełny) lub Wypróbuj online (czysty) .

Wyjaśnienie:

Pętla, gdy jest jeszcze następny ciąg wejściowy:

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

Wydrukuj ten ciąg bez przesuwania kursora w prawo-dół:

Multiprint(:DownRight, i);
Ｐ↘ι

Następnie przejdź o trzy pozycje w dół do następnej iteracji:

Move(3, :Down);
Ｍ³↓

Japt -Rx, 17 16 13 bajtów

Pobiera dane wejściowe jako tablicę słów. Jeśli końcowe białe znaki w każdej linii byłyby dozwolone, można usunąć 4 ostatnie znaki, aby powiązać je z roztworem węgla drzewnego.

yÈmú3)iYçÃmx1

Wypróbuj lub uruchom wszystkie przypadki testowe

Wyjaśnienie

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 bajtów

Rozwiązanie:

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

Przykłady:

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"

Wyjaśnienie:

Ciągi prawego pada, aby były tej samej długości, transponuj, łącz, za pomocą " "lewego pada, aby wygenerować przekątne, a następnie prawego pada, aby skorygować długości i transponować z powrotem. Pobiera listę ciągów i zwraca listę ciągów. Prawdopodobnie gra w golfa, ale wciąż jest krótszy niż moje rozwiązanie 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 bajtów

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

Wypróbuj online!

Argument wejściowy to lista słów. Dane wyjściowe to tablica znaków.

PHP , 100 bajtów

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

Wypróbuj online!