Vẽ các đường chéo của văn bản


46

Đưa ra một đầu vào của một danh sách các từ, xuất ra các từ với các chữ cái của chúng được sắp xếp theo đường chéo:

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

(Ở trên phải là đầu ra cho đầu vào programming puzzles and code golf.)

Nói chính xác, mỗi từ bắt đầu trên cột đầu tiên và ba hàng bên dưới từ trước đó và mỗi chữ cái liên tiếp sẽ di chuyển một cột sang phải và một hàng xuống.

Đầu vào có thể được cung cấp dưới dạng một chuỗi từ, được phân tách bằng chính xác một khoảng trắng hoặc danh sách / mảng từ. Các từ sẽ chỉ bao gồm các chữ cái viết thường a-zvà sẽ luôn có ít nhất một ký tự.

Đầu ra có thể là một chuỗi đơn, một mảng các dòng hoặc một mảng các ký tự. Không được phép dẫn đầu hoặc theo dõi khoảng trắng, ngoại trừ một dòng mới duy nhất.

Các trường hợp thử nghiệm khác:

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

Vì đây là , mã ngắn nhất tính bằng byte sẽ giành chiến thắng!


Tôi cảm thấy mình có thể tạo một chương trình Python cho việc này trong 5 phút, nhưng dường như nó luôn bị lỗi ...; _;
HyperNeutrino

Ồ, có vẻ như có rất nhiều thử thách dường như được thiết kế cho Turtlèd
Lemon

Mã thoát thiết bị đầu cuối có được phép không? :)
Chromium

Câu trả lời:


17

Vim, 85, 76, 66 , 52 tổ hợp phím / byte

Khi tôi lần đầu tiên nhìn vào thử thách này, tôi đã nghĩ "Điều này thật hoàn hảo cho vim!" Và sau đó khi tôi thử nó, mọi thứ đã đi sai. Đây là, trong tất cả các vinh quang hacky lộn xộn của nó:

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

Dùng thử trực tuyến, nhờ trình thông dịch V tương thích ngược (chủ yếu).

Giải trình:

Lúc đầu, tôi nghĩ rằng tôi có thể làm phiên bản 37 byte đơn giản tuyệt đẹp này:

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

Thật không may, nó không đơn giản. Hãy đưa nó theo từng dòng:

:se ve=all

Điều này cho phép một tính năng gọi là 'chỉnh sửa ảo'. Nó cho phép con trỏ di chuyển đến các cột chưa tồn tại. Câu trả lời này về cơ bản là không thể nếu không có nó.

Bây giờ chúng ta cần tách các từ thành các dòng khác nhau. Vì vậy, chúng tôi sẽ thay thế mỗi không gian bằng 3 dòng mới. Vì đây là lệnh ex, chúng ta có thể chạy đồng thời với lệnh ex cuối cùng :se ve=allbằng cách tách hai lệnh bằng một thanh.

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

Bây giờ bộ đệm trông như thế này:

Programming


Puzzles


and


code-golf

Đây là nơi niềm vui bắt đầu. Chúng tôi thiết lập macro đệ quy truyền thống với : qq, và sau đó gọi đây là:

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

Sau đó, chúng tôi kết thúc macro đệ quy với @qq@q. Tại thời điểm này, chúng ta có tất cả các đường chéo, chúng ta chỉ cần làm sạch một chút.

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

Ồ, JavaScript (hiện tại) ngắn hơn Vim. Điều đó khá hiếm khi xảy ra trong những ngày này ...
ETHproductions

@ETHproductions Không còn nữa. :)
DJMcMayhem

6

Turtlèd , 28 26 byte

Ôi trời, tôi dường như đang đánh bại một ngôn ngữ được thiết kế dành riêng cho việc chơi golf. đây là một ngày tuyệt vời

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

Hãy thử trực tuyến!

Giải trình

(viết có nghĩa là ghi vào ô trên lưới, char nhọn có nghĩa là char trong đầu vào con trỏ chuỗi trỏ tới)

!                         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

lưu ý không gian dấu.

Đầu vào cũng cần không gian kéo. xem như trăn có thể lấy một danh sách, điều này rất giống với việc lấy một danh sách trong Turtlèd


5

MATL , 28 byte

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

Đầu vào là một mảng ô của chuỗi, với dấu phẩy là dấu phân cách tùy chọn:

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

hoặc là

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

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp kiểm tra: 1 , 2 , 3 , 4 .

Giải trình

Hãy xem xét các đầu vào sau đây làm ví dụ:

{'aaaa' 'bb' 'ccc'}

Bạn có thể xem kết quả một phần (nội dung ngăn xếp) chèn ký hiệu nhận xét %tại bất kỳ điểm nào trong mã. Ví dụ, xem nội dung ngăn xếp sau hàm thứ tư ( &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 byte

Đưa đầu vào như một mảng các từ. Trả về một mảng các ký tự.

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

Phiên bản thay thế, 109 byte

Trả về một chuỗi.


2

Lisp thường gặp, 673 668 597 byte

Giải pháp khủng khiếp, tôi biết. Có lẽ tôi sẽ chỉnh sửa nó nhiều hơn sau một số giấc ngủ.

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

Sử dụng:

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

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

Vòng lặp này trên mỗi từ trong danh sách được cung cấp và thêm các ký tự phù hợp vào dòng hiện tại. Đệm phù hợp được cung cấp bởi cách sử dụng phụ của tôi format.

Lưu ý: Tôi chưa quen với Lisp thông thường, nhưng tôi biết đủ để nhận ra rằng điều này có thể sử dụng rất nhiều cải tiến.


2
> :( "ppcg ... ok"!?
Lemon phá hủy

2

C #, 336 byte:

Chơi gôn

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

Ung dung:

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

Kiểm tra:

  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

Điều này xuất hiện để tạo khoảng trắng ở cuối dòng, không được phép của đặc tả thách thức. Ngoài ra, yêu cầu các chuỗi khoảng trắng để phân tách các từ trong mảng đầu vào không phải là định dạng đầu vào được phép.
Doorknob

@Doorknob Rất tiếc, xin lỗi ... Đã sửa, chỉ tốn của tôi 2 byte :)
Pete Arden

1
Biên dịch thành a Func<string[], string>và thực hiện nhiều thay đổi khác cho 297 byte 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;};tuy nhiên bạn cần thêm 18 byte chousing System.Linq;
TheLethalCoder

@TheLethalCoder Cảm ơn, nhưng tôi không thực sự muốn lấy toàn bộ giải pháp của bạn :)
Pete Arden

Nó không phải của tôi, tôi chỉ đánh gôn một số thứ, ví dụ như di chuyển ijđến phần khai báo int ở trên cùng và di chuyển một số thứ ++để chúng được sử dụng trong lần sử dụng cuối cùng của biến
TheLethalCoder

2

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

Lưu ý: các vết lõm cho hai dòng cuối cùng <space><tab>, giúp lưu một byte vì tôi không cần phải thụt lề kép.

Đầu vào được nhập dưới dạng một chuỗi các chuỗi như vậy: ["hello", "world"]hoặc ['hello', 'world']. Đầu ra là một mảng các mảng ký tự.

Có lẽ có một cách tốt hơn để làm điều này ...

EDIT Cảm ơn Doorknob đã chỉ ra một khung vuông gần bị thiếu. Tôi đặt nó trước *k...dòng thứ ba.


Có lỗi cú pháp trong mã của bạn trên dòng thứ ba; Có hai dấu ngoặc mở nhưng chỉ có một dấu ngoặc đóng. Tuy nhiên, tôi sửa nó (bằng cách thêm một khung đóng thêm hoặc loại bỏ khung mở thêm), chương trình sẽ báo lỗi khi chạy.
Doorknob

Điều này bây giờ xuất hiện để khoảng trắng đầu ra ở cuối dòng và ở cuối đầu ra, không được phép bởi đặc tả thách thức.
Doorknob


@LeakyNun Cảm ơn. Bạn chỉ cần đi qua và chơi golf tất cả các câu trả lời của tôi? : P
HyperNeutrino

1

Toán học, 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}},#!={""}&]&

Tôi thất vọng bởi bytecount này, nhưng oh tốt.

Xác định một hàm ẩn danh nhận danh sách các từ (ví dụ {"this","that","these"}) và trả về một mảng các ký tự hai chiều. Để xem ở dạng lưới, thêm một //Gridở cuối.

Chuyển đổi các chuỗi thành một mảng, thêm các dòng bổ sung, hoán chuyển mảng, chuẩn bị các dịch chuyển cần thiết, sau đó chuyển đổi lại.

Kết quả ví dụ (được định dạng dưới dạng lưới): Kết quả ví dụ


1

Thạch , 24 byte

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

Hãy thử trực tuyến!

Làm sao?

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

Hơi dài một chút, nhưng về mặt tích cực, nó trả về một chuỗi không có khoảng trắng ở cuối mỗi dòng và không có khoảng trắng ở cuối hoặc trả về ở cuối; những hạn chế mà một số mục khác không tuân theo.

Một danh sách các từ được truyền vào hàm; một số 'khoảng trống' được quảng cáo vào danh sách này và sau đó thuật toán ánh xạ một hàng, cặp cột thành một wordNumber, characterNumber trong danh sách mở rộng. (Đây là một chút nghịch đảo của chiến lược thông thường được thấy trong các giải pháp khác).

Nếu chúng tôi cho phép dấu cách khoảng trắng trên tất cả các dòng ngoại trừ dòng cuối cùng, chúng tôi có thể làm tốt hơn một chút (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()

1

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

Giải pháp:

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

Ví dụ:

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

Giải thích (vô danh):

Ý chính cơ bản là tạo ra một chuỗi các chuỗi có độ dài bằng nhau từ chuỗi đầu vào, lật (xoay) chúng, sau đó thêm khoảng trắng thích hợp để có được một cái gì đó trông như thế này:

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

được lật lại và in ra thiết bị xuất chuẩn.

Dưới đây là phân tích từng dòng của khái niệm:

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

Ghi chú:

Một vài cách để loại bỏ một số (11) byte dễ dàng nếu chúng ta thực sự muốn:

  • Có thể lưu 2 byte bằng cách bỏ f:và để lại dưới dạng hàm ẩn danh
  • Có thể tiết kiệm 3 byte bằng cách thả các -1;và trả về một danh sách các chuỗi chứ không phải in tới stdout
  • Có thể lưu 6 byte nếu chúng ta chuyển vào danh sách các chuỗi thay vì chuỗi được phân tách bằng dấu cách

Chỉnh sửa:

  • -11 byte, sử dụng rtrimđể tìm độ dài tối đa để đệm, cần loại bỏ để lưu trữC biến
  • -15 byte, chuyển đổi max count eachchức năng lambda ađược tạo một lần và sử dụng hai lần
  • -4 byte, di chuyển razevào hàm lambda để lưu mộtraze each
  • -4 byte, đơn giản hóa hàm lambda lõi có thêm khoảng trắng
  • -2 byte, sử dụng (+)làm tốc ký choflip

1

Than , 16 9 byte

WS«P↘ιM³↓

Câu trả lời đầu tiên của tôi. Cảm ơn @DLosc đã gợi ý thay vì sử dụng (Nhảy) để quay lại điểm bắt đầu của dòng (và ba xuống).

Dùng thử trực tuyến (dài dòng) hoặc Thử trực tuyến (thuần túy) .

Giải trình:

Lặp lại trong khi vẫn còn một chuỗi đầu vào tiếp theo:

While(InputString()){ ... }
WS« ...

In chuỗi này mà không di chuyển con trỏ theo hướng xuống bên phải:

Multiprint(:DownRight, i);
P↘ι

Và sau đó di chuyển ba vị trí xuống cho lần lặp tiếp theo:

Move(3, :Down);
M³↓

Khi thử thách cần một đầu vào duy nhất bao gồm một mảng, Char than thất bại khi nó tách chuỗi đầu vào lấy từng từ đơn làm đầu vào riêng biệt. Nhưng trong Char than, θbiến đại diện cho đầu vào đầu tiên, vì vậy tôi chỉ gán đầu vào kiểm tra cho biến đó trong tiêu đề và sau đó viết phần còn lại của mã, để bạn có thể thoát khỏi αbiến và lặp qua các mục được chia của θ. Hãy thử trực tuyến! (Không cạnh tranh do không gian hàng đầu.)
Charlie

Ít nhất, không ai phàn nàn khi tôi sử dụng mánh khóe đó ở đây . :-)
Charlie

@CarlosAlejo Tôi thực sự bắt gặp câu trả lời của bạn khi tôi đang tìm cảm hứng cho câu trả lời Char than hiện có. :)
Kevin Cruijssen

IDK, phương thức tôi thường sử dụng chỉ là chuỗi + chuỗi trống ở cuối, nếu có là đa dòng thì hãy nhập dưới dạng mảng python
ASCII-only chỉ

@CarlosAlejo Đã được một thời gian, nhưng tôi đã sử dụng nhiều dòng bây giờ với một dòng trống để phá vỡ thời gian (và đánh golf 7 byte cùng một lúc). Tôi thấy nó đang được sử dụng trong một trong những câu trả lời của Neil và bây giờ tôi thấy chỉ có ASCII đề xuất điều tương tự (bằng cách nào đó đã bỏ lỡ nhận xét đó).
Kevin Cruijssen

1

Japt -Rx, 17 16 13 byte

Đưa đầu vào như một mảng các từ. Nếu khoảng trắng theo dõi trên mỗi dòng được cho phép thì 4 ký tự cuối cùng có thể được loại bỏ để liên kết với giải pháp Than.

yÈmú3)iYçÃmx1

Hãy thử nó hoặc chạy tất cả các trường hợp thử nghiệm


Giải trình

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 byte

Giải pháp:

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

Ví dụ:

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"

Giải trình:

Các chuỗi pad phải sao cho chúng có cùng độ dài, hoán vị, nối với " ", pad bên trái để tạo các đường chéo, sau đó là pad phải để điều chỉnh độ dài và chuyển trở lại. Lấy danh sách các chuỗi và trả về danh sách các chuỗi. Có thể chơi được nhưng vẫn ngắn hơn giải pháp q / kdb + của tôi.

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

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

Hãy thử trực tuyến!

Đối số đầu vào là một danh sách các từ. Đầu ra là một mảng các ký tự.


Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.