Xây dựng một thang từ


30

Đưa ra một danh sách ít nhất hai từ (chỉ gồm các chữ cái viết thường), xây dựng và hiển thị một thang ASCII của các từ bằng cách xen kẽ hướng viết trước sang phải, sau đó sang trái, tương đối theo hướng ban đầu từ trái sang phải .

Khi bạn viết xong một từ, thay đổi hướng và chỉ sau đó bắt đầu viết từ tiếp theo.

Nếu ngôn ngữ của bạn không hỗ trợ danh sách các từ hoặc thuận tiện hơn cho bạn, bạn có thể lấy đầu vào dưới dạng một chuỗi từ, cách nhau bởi một khoảng trắng.

Khoảng trắng hàng đầu và dấu vết được cho phép.

["hello", "world"] hoặc là "hello world"

hello
    w
    o
    r
    l 
    d

Ở đây chúng ta bắt đầu bằng cách viết hellovà khi chúng ta đến từ tiếp theo (hoặc trong trường hợp đầu vào là một chuỗi - tìm thấy khoảng trắng), chúng ta thay đổi hướng tương đối sang phải và tiếp tục viếtworld

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

["another", "test", "string"] or "another test string" ->   

another
      t
      e
      s
      tstring


["programming", "puzzles", "and", "code", "golf"] or "programming puzzles and code golf" ->

programming
          p
          u
          z
          z
          l
          e
          sand
             c
             o
             d
             egolf

["a", "single", "a"] or "a single a" ->

a
s
i
n
g
l
ea

Tiêu chí đánh giá

Mã ngắn nhất tính bằng byte trong mọi ngôn ngữ sẽ thắng. Đừng nản lòng với các ngôn ngữ chơi gôn!

Hộp cát



1
@Arnauld Có, tôi sẽ thêm nó vào mô tả.
Galen Ivanov

Câu trả lời:


12

Than , 9 byte

F⮌A«↑⮌ι‖↗

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải thích: Hoạt động bằng cách vẽ văn bản ngược, hoán đổi khung vẽ sau mỗi từ. 10 byte cho đầu vào chuỗi:

F⮌S≡ι ‖↗←ι

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải thích: Vẽ văn bản ngược, hoán đổi khung vẽ cho không gian.



6

05AB1E , 19 16 byte

€θ¨õšøíJD€gs24SΛ

-3 byte nhờ @Emigna .

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

Giải thích chung:

Cũng giống như @Emigna 05AB1E câu trả lời 's (hãy chắc chắn để upvote ông btw !!), tôi sử dụng các BUILTIN CanvasΛ .

Tuy nhiên, các tùy chọn tôi sử dụng khác nhau (đó là lý do tại sao câu trả lời của tôi dài hơn ..):

  • b(các chuỗi cần in): Tôi giữ nguyên chuỗi đầu tiên trong danh sách và thêm ký tự theo dõi vào mỗi chuỗi tiếp theo trong danh sách. Ví dụ ["abc","def","ghi","jklmno"]sẽ trở thành ["abc","cdef","fghi","ijklmno"].
  • a(kích thước của các dòng): Điều này sẽ bằng với các chuỗi này, vì vậy [3,4,4,7]với ví dụ trên.
  • c(hướng để in) : [2,4], sẽ ánh xạ tới[→,↓,→,↓,→,↓,...]

Vì vậy, ví dụ trên sẽ từng bước thực hiện như sau:

  1. Vẽ abctheo hướng 2/ .
  2. Vẽ cdeftheo hướng 4/ (trong đó ký tự đầu tiên trùng với ký tự cuối cùng, đó là lý do tại sao chúng tôi phải sửa đổi danh sách như thế này)
  3. Vẽ fghitheo hướng 2/ một lần nữa (cũng có sự chồng chéo của các ký tự dấu / dẫn đầu)
  4. Vẽ ijklmnotheo hướng 4/ một lần nữa (cũng với sự chồng chéo)
  5. Xuất kết quả của Canvas đã vẽ ngay lập tức sang STDOUT

Mã giải thích:

€θ                # Only leave the last characters in the (implicit) input-list
  ¨               # Remove the last one
   õš             # And prepend an empty string "" instead
     ø            # Create pairs with the (implicit) input-list
      í           # Reverse each pair
       J          # And then join each pair together to single strings
        Dg       # Get the length of each string (without popping by duplicating first)
           s      # Swap so the lengths are before the strings
            24S   # Push [2,4]
               Λ  # Use the Canvas builtin (which outputs immediately implicitly)

1
Phiên bản 2/3/4 của bạn có thể tiết kiệm 3 byte với €θ¨õšsøJ.
Emigna

@Emigna Cảm ơn! Bây giờ tôi thấy nó trông rất đơn giản .. Và ở đây tôi đã có ba người thay thế 19 người thay thế ..
Kevin Cruijssen

Một số lựa chọn thay thế €θ¨õšsøJõIvy«¤}), õUεXì¤U}ε¯Jθ줈}(hai yêu cầu cuối cùng --no-lazy). Thật không may, đó là tất cả cùng một chiều dài. Điều này sẽ dễ dàng hơn nhiều nếu một trong các biến được mặc định là ""...
Grimmy

@Grimy " Điều này sẽ dễ dàng hơn nhiều nếu một trong các biến được mặc định là ""... " Bạn đang tìm kiếm õ, hoặc ý bạn là nếu X/ Y/ ®sẽ là ""? Btw, 13 byter tốt đẹp trong bình luận câu trả lời của Emigna. Hoàn toàn khác so với cả tôi và tbh của anh ấy, với các hướng [→,↙,↓,↗]mà bạn đã sử dụng.
Kevin Cruijssen

õkhông phải là một biến. Vâng, tôi có nghĩa là một biến mặc định "". Tôi thực sự làm õUkhi bắt đầu một trong các đoạn mã, vì vậy nếu X (hoặc bất kỳ biến nào khác) được mặc định "", nó sẽ lưu hai byte một cách tầm thường. Cảm ơn! Vâng, là một chút mới, nhưng tôi có ý tưởng xen kẽ các bài viết thực sự với chiều dài 2 hình nộm viết từ câu trả lời của Emigna.
Grimmy

6

05AB1E , 14 13 byte

Đã lưu 1 byte nhờ Grimy

€ðÀD€g>sŽ9÷SΛ

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

Giải trình

                 # example input ["Hello", "World"]
€ðÀ              # push a space after each word
                 # STACK: ["Hello"," ","World"," "]
   D             # duplicate
    €g>          # get the length of each word in the copy and add 1
                 # these are the lengths to draw
                 # STACK: ["Hello"," ","World"," "], [6, 2, 6, 2]
       s         # swap the list of word to the top of the stack
        Ž9÷S     # push [2, 5, 4, 1]
                 # this is the list of directions to draw
                 # 1=northeast, 2=east, 4=south, 5=southwest
            Λ    # paint on canvas

1
Oh dang, cách tiếp cận tốt đẹp! Tôi sẽ đăng các phiên bản 19 byte của mình ngay lập tức, nhưng rất hay với Bifurcate và chỉ vẽ hai chữ cái.
Kevin Cruijssen

1
Btw, bạn biết có một tích hợp cho xen kẽ, phải không? €Y¦có thể 2.ý(không phải là nó sẽ lưu bất kỳ byte nào ở đây). Và đây là lần đầu tiên tôi thấy hành vi mới so với bản đồ thông thường là hữu ích.
Kevin Cruijssen

@KevinCruijssen: Tôi đã thấy sử dụng trước đây nhưng tôi chưa bao giờ sử dụng bản thân mình vì vậy tôi đã không nghĩ về nó. là bản đồ thường xuyên đối với tôi và tôi thường sử dụng nó, bản đồ khác là bản đồ "mới";)
Emigna


2
Xấu của tôi, tôi không nhận thấy khó khăn chẵn / lẻ! Đây là số 13 thực sự nên hoạt động: € ðÀD € g> sŽ9 SΛ
Grimmy

5

Canvas , 17 12 11 10 byte

ø⁸⇵{⟳K└×∔⤢

Hãy thử nó ở đây!

Giải trình:

ø⁸⇵{⟳K└×∔⤢  full program taking array as input (loaded with ⁸)

ø         push an empty canvas               ["test", "str"], ""
 ⁸⇵{      for each input word, in reverse:   "str", "test" (showing 2nd iter)
    ⟳       rotate the word vertically       "str", "t¶e¶s¶t"
     K      pop off the last letter          "str", "t¶e¶s", "t"
      └     swap the two items below top     "t¶e¶s", "str", "t"
       ×    prepend                          "t¶e¶s", "tstr"
        ∔   vertically append                "t¶e¶s¶tstr"
         ⤢  transpose the canvas             "test
                                                 s
                                                 t
                                                 r"

5

JavaScript (ES8),  91 79  77 byte

Đưa đầu vào như một mảng các từ.

a=>a.map((s,i)=>i&1?[...s].join(p):s+=p+=''.padEnd(s.length-!i),p=`
`).join``

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

Đã bình luận

a =>                 // a[] = input array
  a.map((s, i) =>    // for each word s at position i in a[]:
    i & 1 ?          //   if this is a vertical word:
      [...s].join(p) //     split s and join it with p
    :                //   else:
      s +=           //     add to s:
        p +=         //       add to p:
          ''.padEnd( //         as many spaces
            s.length //         as there are letters in s
            - !i     //         minus 1 if this is the 1st word (because it's not connected
          ),         //         with the last letter of the previous vertical word)
    p = `\n`         //   start with p = linefeed
  ).join``           // end of map(); join everything

Sử dụng pđể theo dõi các kết thúc dòng rất thông minh +1
Downgoat


5

Brainfuck , 57 byte

->,[[.<+>,],[<<[-]++++++++++.--[-<++++>]>[-<+<.>>]>.<,],]

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

Lấy đầu vào là các chuỗi tách NUL. Lưu ý rằng điều này đang sử dụng EOF là 0 và sẽ ngừng hoạt động khi thang vượt quá 256 khoảng trắng.

Giải trình:

-           Initialise counter as -1
>,[         Start ladder
   [.<+>,]  Print the first word, adding the length of it to the counter
   ,[       Loop over each letter of the second word
      <<[-]++++++++++.    Print a newline
      --[-<++++>]         Create a space character
      >[-<+<.>>]          Print counter many spaces
      >.<,                Print the letter and move to the next letter
   ] 
   ,        Repeat until there are no more words
]

Tôi có thể yêu cầu giải pháp trong Brain-Flak không?
Galen Ivanov

Nỗ lực đầu tiên của tôi để hiểu BF. 2 câu hỏi: Từ đầu tiên được in như thế nào khi không có .char trong dòng 3 (của phiên bản đã nhận xét)? Tôi đã cố gắng chơi với đầu vào trên TIO. Trên Mac, tôi đã chuyển bàn phím sang nhập văn bản Unicode và thử tạo ranh giới từ mới bằng cách nhập option+0000nhưng nó không hoạt động. Bất cứ ý tưởng tại sao không?
Giô-na

1
@Jonah Ah bắt tốt, tôi vô tình gõ -thay vì .để giải thích. Để thêm byte NUL trong TIO, tôi khuyên bạn nên sử dụng bàn điều khiển và chạy lệnh như thế nào $('#input').value = $('#input').value.replace(/\s/g,"\0");. Tôi không biết tại sao cách của bạn không hiệu quả
Jo King

5

JavaScript, 62 byte

a=>' '+a.replace(/./g,c=>1-c?(a=!a,''):a?(p+=' ',c):p+c,p=`
`)

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

Cảm ơn Rick Hitchcock , đã lưu 2 byte.


JavaScript, 65 byte

a=>a.replace(/./g,c=>1-c?(t=!t,''):t?p+c:(p+=p?' ':`
`,c),t=p='')

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

a => a.replace (/./ g, c => (// cho mỗi ký tự c trong chuỗi a
    1 - c? // if (c là không gian)
      (t =! t, // update t: giá trị boolean mô tả chỉ mục từ
                       // Truthy: các từ được lập chỉ mục lẻ;
                       // falsy: các từ được lập chỉ mục
        ''): // không tạo gì cho không gian
    t? // if (là chỉ số lẻ) có nghĩa là dọc
      p + c: // thêm '\ n', một số khoảng trắng và một charater sigle
                       // khác
      (p + = p? '': '\ n', // chuẩn bị chuỗi trả trước cho các từ dọc
         c) // thêm một ký tự
),
  t = p = '' // khởi tạo
)

Tôi nghĩ bạn có thể tiết kiệm 2 byte bằng cách thay thế tbằng a, sau đó xóat=
Rick Hitchcock

5

Aheui (bí truyền) , 490 458 455 byte

삭뱃밸때샏배샐배새뱄밿때빠뱋빼쌘투@밧우
@두내백뱃빼선대내백뱃섣@여우샐처샐추
희차@@@뭏누번사@빼뭏오추뻐@@@배
By@@@새대백@@@우뻐색
Legen@@빼쵸누번@@빼
DUST@@@샌뽀터본섣숃멓
@@@@@@@오어아@먛요아@@샏매우
@@@@@아@@@@@@오@@@@@서어
@@@@@희차@@요

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

Chơi gôn một chút bằng cách sử dụng các ký tự có độ rộng đầy đủ (2 byte) thay vì tiếng Hàn (3 byte).

Giải trình

Aheui giống như esolang. Đây là mã có màu : Mã Aheui có màu ? 1 phần kiểm tra xem ký tự hiện tại có phải là khoảng trắng hay không.

? 2 phần kiểm tra xem các từ đã được viết từ phải sang trái hay từ trên xuống.

? 3 phần là điều kiện ngắt của vòng lặp loại không gian.

? 4 phần kiểm tra xem ký tự hiện tại có kết thúc dòng không (-1).

Phần màu đỏ là khởi tạo ngăn xếp. Aheui sử dụng ngăn xếp (từ Nothingđến : 28 ngăn xếp) để lưu trữ giá trị.

Phần màu cam lấy đầu vào ( ) và kiểm tra xem đó có phải là không gian không, bằng cách trừ đi 32(mã ascii của không gian).

Phần màu xanh lá cây thêm 1 vào ngăn xếp lưu trữ giá trị độ dài của không gian, nếu viết từ phải sang trái.

Phần màu tím là vòng lặp để in các không gian, nếu viết lên xuống.

Kiểm tra phần màu xám nếu ký tự hiện tại là -1, bằng cách thêm một vào ký tự hiện tại.

Phần màu xanh in ký tự hiện tại, và chuẩn bị cho nhân vật tiếp theo.


Bạn đã sử dụng những gì để tạo ra hình ảnh trong bài viết này?
bb94

@ bb94 cơ sở là AheuiChem , IDE Aheui trực tuyến (loại) được xây dựng đẹp của Hàn Quốc. Và tôi đã sử dụng Powerpoint để tô màu cho nó.
LegenDUST

4

Japt -P , 15 byte

ò mrÈ+R+YÕùT±Xl

Thử nó

ò mrÈ+R+YÕùT±Xl     :Implicit input of string array
ò                   :Partition into 2s
  m                 :Map each pair
   r                :  Reduce by
    È               :  Passing through the following function as X & Y
     +              :    Append to X
      R             :    Newline
       +            :    Append
        YÕ          :    Transpose Y
          ù         :    Left pad each line with spaces to length
           T±       :      T (initially 0) incremented by
             Xl     :      Length of X
                    :Implicitly join and output

4

bash, 119 ký tự

X=("\e7" "\n\e8")
w="$@"
l=${#w}
d=0
for((i=0;i<l;i++));do
c="${w:$i:1}"
[ -z $c ]&&d=$((1-d))||printf ${X[$d]}$c
done

Điều này sử dụng các chuỗi điều khiển ANSI để di chuyển con trỏ - ở đây tôi chỉ sử dụng lưu \e7và khôi phục \e8; nhưng khôi phục phải được thêm tiền tố \nđể cuộn đầu ra nếu nó đã ở dưới cùng của thiết bị đầu cuối. Đối với một số lý do nó không hoạt động nếu bạn không đã ở dưới cùng của nhà ga. * nhún vai *

Ký tự hiện tại $cđược phân lập dưới dạng một chuỗi con ký tự đơn từ chuỗi đầu vào $w, sử dụng forchỉ mục vòng lặp $ilàm chỉ mục vào chuỗi.

Thủ thuật thực sự duy nhất tôi đang sử dụng ở đây là [ -z $c ]sẽ trả về true, tức là chuỗi trống, khi nào $clà khoảng trắng , vì nó không được trích dẫn. Trong cách sử dụng bash chính xác, bạn sẽ trích dẫn chuỗi đang được kiểm tra -zđể tránh chính xác tình huống này. Điều này cho phép chúng ta lật cờ hướng $dgiữa 10, sau đó được sử dụng làm chỉ mục vào mảng chuỗi điều khiển ANSI, Xtrên giá trị không phải không gian tiếp theo của $c.

Tôi rất muốn thấy một cái gì đó sử dụng printf "%${x}s" $c.

Oh gosh hãy thêm một số khoảng trắng. Tôi không thể thấy mình đang ở đâu ...

X=("\e7" "\n\e8")
w="$@"
l=${#w}
d=0
for ((i=0;i<l;i++)); do
  c="${w:$i:1}"
  [ -z $c ] && d=$((1-d)) || printf ${X[$d]}$c
done

À nhân tiện, bạn không thể thử cái này trên trang web tio.run đó - giống như một vài trang khác, không có xử lý trình tự kiểm soát ANSI nên nó chỉ là barfs.
Giàu

4

Perl 6 , 65 byte

{$/=0;.map:{$/+=$++%2??!.comb.fmt("%$/s","
").print!!.say*.comb}}

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

Khối mã ẩn danh nhận danh sách các từ và in thẳng sang STDOUT.

Giải trình

{                           }  # Anonymous code block
 $/=0;                         # Initialise $/ to 0
 .map:{                    }   # Map the list of words to
       $/+=                    # Increment $/ by
           $++%2??             # For even indexes
                   .comb       # Each letter of the word
                   .fmt(           ) # Formatted as
                        "%$/s"       # Padded with $/-1 spaces
                              ,"\n"  # Joined by newlines
                   .print            # And printed without a newline
                  !   # Boolean not this to add 0 to $/
                !!            # For odd indexes
                  .say        # Print with a newline
                      *.comb  # And add the length of the word

Tôi tò mò cách thức hoạt động của Jo, tôi không biết Perl 6
Jonah

@Jonah Tôi đã thêm một lời giải thích
Jo King

Cảm ơn, giải pháp tốt đẹp.
Giô-na

3

Than , 19 byte

FLθ¿﹪鲫↓§θι↗»«§θι↙

Nhập dưới dạng danh sách các chuỗi

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:

Vòng lặp trong phạm vi [0, input-length):

For(Length(q))
FLθ

Nếu chỉ số là số lẻ:

If(Modulo(i,2)){...}
﹪鲫...»

In chuỗi tại chỉ mục itheo hướng đi xuống:

Print(:Down, AtIndex(q,i));
↓§θι

Và sau đó di chuyển con trỏ một lần về phía trên bên phải:

Move(:UpRight);
↗

Khác (chỉ số là chẵn):

Else{...}
«...

In chuỗi tại chỉ mục itheo đúng hướng thông thường:

Print(AtIndex(q,i));
§θι

Và sau đó di chuyển con trỏ một lần về phía dưới bên trái:

Move(:DownLeft);
↙



3

J , 47 45 43 byte

;[`(([:<@(+/)\#&>##$#:@1 2)@])`([' '"0/[)}]

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

Tôi tìm thấy một cách tiếp cận thú vị, khác biệt ...

Tôi bắt đầu loay hoay với các miếng đệm bên trái và khóa kéo với các gerund chu kỳ, v.v., nhưng sau đó tôi nhận ra rằng sẽ dễ dàng hơn khi chỉ tính toán từng vị trí của chữ cái (điều này rút gọn thành một tổng quét của mảng được chọn chính xác) và áp dụng sửa đổi }thành một khoảng trống vải trên đầu vào bị san bằng.

Giải pháp được xử lý gần như hoàn toàn bởi Amend }:

; [`(([: <@(+/)\ #&> # # $ #:@1 2)@])`([ ' '"0/ [)} ]
  • ; ( single verb that does all the work ) ] ngã ba tổng thể
  • ; phần bên trái phá vỡ đầu vào, nghĩa là đặt tất cả các chữ cái thành một chuỗi liền kề
  • ] phần bên phải là đầu vào
  • (stuff)}chúng tôi sử dụng hình thức sửa đổi gerund }, bao gồm ba phần v0`v1`v2.
    • v0cung cấp cho chúng tôi "giá trị mới", đó là giá trị (nghĩa là tất cả các ký tự của đầu vào dưới dạng một chuỗi), vì vậy chúng tôi sử dụng [.
    • v2cung cấp cho chúng tôi giá trị bắt đầu, mà chúng tôi đang chuyển đổi. chúng tôi chỉ đơn giản muốn có một khung trống của các không gian có kích thước cần thiết. ([ ' '"0/ [)cung cấp cho chúng tôi một kích thước (all chars)x(all chars).
    • Động từ ở giữa v1chọn vị trí nào chúng ta sẽ đặt các ký tự thay thế của mình. Đây là mấu chốt của logic ...
  • Bắt đầu từ vị trí 0 0ở phía trên bên trái, chúng tôi nhận thấy rằng mỗi ký tự mới là 1 ở bên phải của vị trí trước đó (nghĩa là prev + 0 1) hoặc một xuống (nghĩa là prev + 1 0). Thật vậy, chúng ta thực hiện "len của từ 1" lần trước, sau đó là "len của từ 2" ​​lần sau, và cứ thế xen kẽ. Vì vậy, chúng tôi sẽ tạo ra chuỗi chính xác của các chuyển động này, sau đó quét tổng hợp chúng và chúng tôi sẽ có các vị trí của chúng tôi, sau đó chúng tôi sẽ đóng hộp vì đó là cách Amend hoạt động. Những gì tiếp theo chỉ là cơ chế của ý tưởng này ...
  • ([: <@(+/)\ #&> # # $ 1 - e.@0 1)
    • Đầu tiên #:@1 2tạo ma trận không đổi 0 1;1 0.
    • # $sau đó mở rộng nó để nó có nhiều hàng như đầu vào. ví dụ: nếu đầu vào chứa 3 từ thì nó sẽ tạo ra 0 1;1 0;0 1.
    • #&> #phần bên trái là một mảng có độ dài của các từ đầu vào và #được sao chép, vì vậy nó sao chép 0 1"len của từ 1" lần, sau đó 1 0"len của từ 2 lần", v.v.
    • [: <@(+/)\ không tổng quét và hộp.

3

T-SQL, 185 byte

DECLARE @ varchar(max)='Thomas Clausen Codegolf Script'
,@b bit=0,@s INT=0SET @+=':'WHILE @ like'%_:%'SELECT
@b+=len(left(@,1))-1,@=stuff(@,1,1,'')+iif(left(@,@b)='','','
'+space(@s))+trim(left(@,1)),@s+=len(left(@,~@b))PRINT
stuff(@,1,1,'')

Dùng thử trực tuyến


1
Sử dụng rất thông minh các giá trị BIT, không gian dấu phân cách và xử lý chuỗi tròn. Câu trả lời tốt hơn nhiều so với của tôi!
Muqo

2

Võng mạc , 51 byte

1,2,`\w+
;$&
+(m`^(.(.*?)) ?;(.)
$1¶$.2* $3;
; |;$

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

Một cách tiếp cận khá đơn giản đánh dấu từng từ khác và sau đó áp dụng chuyển đổi trực tiếp.

Giải trình

1,2,`\w+
;$&

Chúng tôi đánh dấu mỗi từ khác bằng dấu chấm phẩy bằng cách khớp từng từ, nhưng chỉ áp dụng thay thế cho các kết quả khớp (được lập chỉ mục bằng 0) bắt đầu từ kết hợp 1 và sau đó 3, v.v.

+(m`^(.(.*?)) ?;(.)
$1¶$.2* $3;

+(mthiết lập một số thuộc tính cho các giai đoạn sau. Dấu cộng bắt đầu một vòng lặp "trong khi nhóm giai đoạn này thay đổi một cái gì đó" và dấu ngoặc mở biểu thị rằng dấu cộng nên áp dụng cho tất cả các giai đoạn sau cho đến khi có một dấu ngoặc gần phía trước một backtick (đó là tất cả các giai đoạn trong trường hợp này). Việc mchỉ cho regex coi ^là cũng khớp từ đầu dòng thay vì chỉ bắt đầu chuỗi.

Regex thực tế là khá đơn giản. Chúng tôi chỉ cần khớp số lượng công cụ thích hợp trước dấu chấm phẩy đầu tiên và sau đó sử dụng *cú pháp thay thế của Retina để đặt đúng số lượng khoảng trắng.

; |;$

Giai đoạn này được áp dụng sau lần cuối cùng để loại bỏ dấu chấm phẩy và khoảng trắng ở cuối từ mà chúng ta đã thay đổi thành dọc.


2

Võng mạc 0.8.2 , 58 byte

(?<!^(\S* \S* )*\S*)
¶
¶? 

+`(..(.)*¶)((?<-2> )*\S)
$1 $3

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải pháp thay thế, cũng 58 byte:

( \S*) 
$1¶
+` (.)
¶$1 
 ¶

+`(..(.)*¶)((?<-2> )*\S)
$1 $3

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm.

Tôi cố tình không sử dụng Retina 1 ở đây, vì vậy tôi không được sử dụng các từ thay thế miễn phí; thay vào đó tôi có hai cách tiếp cận. Cách tiếp cận đầu tiên phân tách trên tất cả các chữ cái trong các từ thay thế bằng cách đếm các khoảng trắng trước, trong khi cách tiếp cận thứ hai thay thế các khoảng trắng thay thế bằng các dòng mới và sau đó sử dụng các khoảng trắng còn lại để giúp nó phân tách các từ thay thế thành các chữ cái. Mỗi cách tiếp cận sau đó phải nối chữ cái dọc cuối cùng với từ ngang tiếp theo, mặc dù mã khác nhau vì chúng phân chia các từ theo những cách khác nhau. Giai đoạn cuối cùng của cả hai cách tiếp cận sau đó đệm từng dòng cho đến khi ký tự không phải không gian đầu tiên của nó được căn chỉnh theo ký tự cuối cùng của dòng trước đó.

Lưu ý rằng tôi không cho rằng các từ chỉ là chữ cái vì tôi không phải làm vậy.


2

PowerShell , 101 89 83 byte

-12 byte nhờ mazzy .

$args|%{$l+=if(++$i%2){$_.length-1;$t+=$_}else{1;$_|% t*y|%{$t+='
'+' '*$l+$_}}};$t

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


tốt đẹp. bạn có thể: 1) xóa dòng đầu tiên, 2) sử dụng phép nối & $b @p(mỗi từ làm một đối số), 3) sử dụng dạng ngắn hơn cho new linehằng số. xem 3,4 dòng trong ví dụ này
mazzy

@mazzy, với sự lách luật tôi nhận được câu trả lời sai cho foo. thấy .
Andrei Odegov

oO! Việc ghép nối chia tách một từ thành một mảng char. Hấp dẫn. Cảm ơn!
mê mẩn

1
@mazzy, đó không phải lỗi của tôi :)
Andrei Odegov

Tôi nghĩ rằng chúng ta có thể sử dụng quy tắcGiven a list of at least two words...
mazzy



2

T-SQL, 289 byte

DECLARE @ VARCHAR(MAX)='a a',@I INT=1,@S INT=0,@B INT=0WHILE @I<=LEN(@)IF SUBSTRING(@,@I,1)=''IF @B=0SELECT @S-=1,@=STUFF(@,@I,1,'
'+SPACE(@S)),@I+=@S+3,@B=1 ELSE SELECT @=STUFF(@,@I,1,''),@S+=1,@B=\ELSE IF @B=0SELECT @I+=1,@S+=1 ELSE SELECT @=STUFF(@,@I,0,'
'+SPACE(@S)),@I+=@S+3PRINT @

Điều này chạy trên SQL Server 2016 và các phiên bản khác.

@ giữ danh sách giới hạn không gian. @I theo dõi vị trí chỉ mục trong chuỗi. @S theo dõi tổng số khoảng trắng để thụt lề từ bên trái. @B theo dõi trục nào chuỗi được căn chỉnh tại điểm @I.

Số byte bao gồm danh sách ví dụ tối thiểu. Kịch bản đi qua danh sách, từng ký tự và thay đổi chuỗi để nó sẽ hiển thị theo yêu cầu. Khi kết thúc chuỗi, chuỗi được IN.


Xin chào @Mugo Có vẻ như có một trục trặc trong tập lệnh của bạn khi sử dụng đầu vào dài hơn. Nếu bạn kiểm tra dữ liệu từ câu trả lời của tôi, bạn sẽ thấy có một sự bẻ cong ngoài ý muốn trong từ cuối cùng giữa p và t
t-clausen.dk

@ t-clausen.dk Rất tiếc, tôi đã không xử lý lần lặp cuối cùng đúng cách. Cảm ơn!
Muqo

xác nhận nó hoạt động ngay bây giờ
t-clausen.dk

1

JavaScript (Node.js) , 75 byte

a=>a.map(x=>i++&1?[,...x].join(`
`.padEnd(n)):(n+=x.length,x),n=i=0).join``

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

Giải thích và vô lương tâm

function f(a) {                   // Main function:
 return a.map(                    //  Map through all words:
  function(x) {
   if (i++ & 1)                   //   If i % 2 == 1 (i.e. vertical):
    return [,...x].join(          //    Since the first one needs to have its own linefeed 
                                  //    and indentation, add a dummy item to the start.
     "\n".padEnd(n)               //    Join the array with the padded line feeds.
    );
   else {                         //   If i % 2 == 0 (i.e. horizontal):
    n += x.length;                //    Add the length of this string to the variable that
                                  //    counts how long the padded line feeds should be.
    return x;                     //    Append the string at the end without line feeds.
   }
  },
  n = i = 0                       //   Initialize variables.
                                  //   n: the length of the padded line feeds 
                                  //      (including the line feed)
                                  //   i: keeps track of the direction
 ).join("")                       //  Join all stuffs and return.
}




1

Brain-Flak , 152 byte

<>([()])<>{<>({}<>{()<({}<>)><>}<>)<>{}{<>({}<((()()()()()){})>)({<({}[()]<((((()()()()){}){}){})>)>()}{})<>(({}<>({}))[({}[{}])])<>}{}}<>{}{({}<>)<>}<>

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

Tôi nghi ngờ điều này có thể ngắn hơn bằng cách kết hợp hai vòng lặp cho các từ lẻ và chẵn.


1
Cảm ơn vì điều này!
Galen Ivanov

1

J, 35 33 byte

3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y'

Đây là một động từ lấy đầu vào là một chuỗi với các từ được phân tách bằng dấu cách. Ví dụ: bạn có thể gọi nó như thế này:

3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y' 'programming puzzles and code golf'

Đầu ra là một ma trận gồm các chữ cái và dấu cách, mà trình thông dịch xuất ra với các dòng mới theo yêu cầu. Mỗi dòng sẽ được đệm bằng khoảng trắng để chúng có cùng độ dài.

Có một vấn đề nhỏ với mã: nó sẽ không hoạt động nếu đầu vào có hơn 98 từ. Nếu bạn muốn cho phép nhập liệu dài hơn, hãy thay thế _98mã trong bằng cách _998cho phép tối đa 998 từ, v.v.


Hãy để tôi giải thích làm thế nào điều này hoạt động thông qua một số ví dụ.

Giả sử chúng ta có một ma trận các chữ cái và khoảng trắng mà chúng ta tưởng tượng là một đầu ra một phần cho một số từ, bắt đầu bằng một từ nằm ngang.

   [m=: 3 3$'vwx  y  z'
vwx
  y
  z

Làm thế nào chúng ta có thể thêm một từ mới trước đó, theo chiều dọc? Không khó: chỉ cần chuyển từ mới thành ma trận một cột của các chữ cái với động từ ,., sau đó nối đầu ra vào ma trận cột đơn đó. (Động từ ,.này thuận tiện vì nó hoạt động như một chức năng nhận dạng nếu bạn áp dụng nó cho một ma trận, mà chúng ta sử dụng để chơi gôn.)

   (,.'cat') , m
c  
a  
t  
vwx
  y
  z

Bây giờ chúng ta không thể lặp lại cách này để chuẩn bị một từ như vậy, bởi vì sau đó chúng ta chỉ nhận được các từ dọc. Nhưng nếu chúng ta hoán chuyển ma trận đầu ra giữa mỗi bước, thì mọi từ khác sẽ nằm ngang.

   (,.'dog') , |: (,.'cat') , m
d     
o     
g     
catv  
   w  
   xyz

Vì vậy, nỗ lực đầu tiên của chúng tôi cho một giải pháp là đưa từng từ vào một ma trận cột đơn, sau đó gấp chúng lại bằng cách nối thêm và hoán vị giữa chúng.

   > (,|:)&.>/ ,.&.>;: 'car house dog children'
c            
a            
r            
housed       
     o       
     g       
     children

Nhưng có một vấn đề lớn với điều này. Điều này đặt chữ cái đầu tiên của từ tiếp theo trước khi xoay một góc vuông, nhưng đặc tả yêu cầu phải quay trước khi đặt chữ cái đầu tiên, vì vậy đầu ra phải là một cái gì đó như thế này:

c             
a             
rhouse        
     d        
     o        
     gchildren

Cách chúng ta đạt được điều này là đảo ngược toàn bộ chuỗi đầu vào, như trong

nerdlihc god esuoh rac

sau đó sử dụng quy trình trên để xây dựng zig-zag nhưng chỉ quay sau chữ cái đầu tiên của mỗi từ:

n     
e     
r     
d     
l     
i     
h     
c     
gode  
   s  
   u  
   o  
   h  
   rac

Sau đó lật đầu ra:

   [;.0> (,|:)&.>/ ,.&.>;:|. 'car house dog children'
car   
  h   
  o   
  u   
  s   
  edog
     c
     h
     i
     l
     d
     r
     e
     n

Nhưng bây giờ chúng tôi có một vấn đề khác. Nếu đầu vào có số lượng từ lẻ, thì đầu ra sẽ có từ đầu tiên theo chiều dọc, trong khi thông số kỹ thuật nói rằng từ đầu tiên phải nằm ngang. Để khắc phục điều này, giải pháp của tôi đệm danh sách các từ thành chính xác 98 từ, nối thêm các từ trống, vì điều đó không thay đổi đầu ra.

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.