Narysuj ukośne linie tekstu


46

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 , wygra najkrótszy kod w bajtach!


Czuję, że powinienem być w stanie stworzyć do tego program w języku Python w ciągu 5 minut, ale zawsze wydaje się, że zawodzi ...; _;
HyperNeutrino

Wow, wygląda na to, że istnieje wiele wyzwań, które najwyraźniej zostały zaprojektowane dla Turtlèd
Destructible Lemon

Czy dozwolone są kody ucieczki terminala? :)
Chromium

Odpowiedzi:


17

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

Wow, JavaScript jest (obecnie) krótszy niż Vim. To obecnie dość rzadkie zjawisko ...
ETHproductions

@ETHproductions Już nie. :)
DJMcMayhem

6

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


5

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', '', '', '', ''}

4

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.


2

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ń.


2
> :( "ppcg ... ok" !?
Destructible Lemon

2

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

Wydaje się, że generuje końcowe białe znaki na końcach linii, co nie jest dozwolone w specyfikacji wyzwania. Ponadto wymaganie ciągów spacji do oddzielenia słów w tablicy wejściowej nie jest dozwolonym formatem wejściowym.
Klamka

@Doorknob Ups, przepraszam ... Naprawiono, kosztowało mnie tylko 2 bajty :)
Pete Arden

1
Skompiluj do a Func<string[], string>i dokonaj różnych innych zmian dla 297 bajtów, 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;};jednak musisz dodać 18 bajtów dlausing System.Linq;
TheLethalCoder

@TheLethalCoder Dzięki, ale tak naprawdę nie chcę brać całego rozwiązania :)
Pete Arden

To nie jest moje, po prostu grałem w golfa z niektórymi rzeczami, tj. Przenosząc thwe ii jdo deklaracji int na górze i przenosząc niektóre z nich, ++więc są one używane przy ostatnim użyciu zmiennej
TheLethalCoder

2

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.


W trzecim wierszu kodu występuje błąd składniowy; są dwa otwarte nawiasy, ale tylko jeden zamknięty nawias. Jednak naprawiam to (dodając dodatkowy wspornik zamykający lub usuwając dodatkowy wspornik otwierający), program wyświetla błąd podczas uruchamiania.
Klamka

Teraz wydaje się, że wyświetla końcowe białe znaki na końcach linii i na końcu danych wyjściowych, co nie jest dozwolone w specyfikacji wyzwania.
Klamka


@LeakyNun Thanks. Po prostu przeszukujesz wszystkie moje odpowiedzi i grasz w golfa? : P
HyperNeutrino

1

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): Przykładowy wynik


1

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

1

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

1

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

1

Węgiel drzewny , 16 9 bajtów

WS«P↘ιM³↓

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()){ ... }
WS« ...

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

Multiprint(:DownRight, i);
P↘ι

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

Move(3, :Down);
M³↓

Gdy wyzwanie wymaga pojedynczego wejścia składającego się z tablicy, węgiel drzewny zawodzi, ponieważ dzieli ciąg wejściowy, biorąc każde słowo jako osobne wejście. Ale w Charcoal θzmienna reprezentuje pierwsze wejście, więc po prostu przypisuję wejście testowe do tej zmiennej w nagłówku, a następnie piszę resztę kodu, abyś mógł pozbyć się αzmiennej i iterować podzielone elementy θ. Wypróbuj online! (Nie konkuruje z powodu wiodących miejsc.)
Charlie

Przynajmniej nikt nie narzekał, kiedy użyłem tej sztuczki tutaj . :-)
Charlie

@CarlosAlejo Rzeczywiście natknąłem się na twoją odpowiedź, kiedy szukałem inspiracji do istniejących odpowiedzi na węgiel drzewny. :)
Kevin Cruijssen

IDK, metodą, której zwykle używam, są tylko łańcuchy + pusty łańcuch na końcu, jeśli jakieś są wielowierszowe, a następnie wprowadzane jako tablica python
tylko ASCII

@CarlosAlejo Minęło trochę czasu, ale użyłem teraz wielu linii z pustą linią, aby przerwać ten czas (i grałem w golfa 7 bajtów jednocześnie). Widziałem, że jest używany w jednej z odpowiedzi Neila , i teraz widzę, że ASCII zasugerowało to samo (jakoś pominął ten komentarz).
Kevin Cruijssen

1

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

1

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

0

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.


Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.