Lấy cảm hứng từ một meme tôi đã thấy trước đó ngày hôm nay.

Mô tả thử thách

Hãy xem xét một lưới bảng chữ cái vô hạn:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
...

Lấy một từ ( CODEGOLFtrong ví dụ này) và biến nó thành một chuỗi sau, thay thế các chữ cái không được sử dụng bằng một khoảng trắng và loại bỏ các chữ cái ở cuối lưới vô hạn hoàn toàn:

  C           O           
   DE G       O           
           L              
     F

Ví dụ

STACKEXCHANGE

                  ST      
A C       K               
    E                  X  
  C    H                  
A            N            
      G                   
    E

ZYXWVUTSRQPONMLKJIHGFEDCBA

                         Z
                        Y 
                       X  
                      W   
                     V    
                    U     
                   T      
                  S       
                 R        
                Q         
               P          
              O           
             N            
            M             
           L              
          K               
         J                
        I                 
       H                  
      G                   
     F                    
    E                     
   D                      
  C                       
 B                        
A

F

     F

ANTIDISESTABLISHMENTARIANISM

A            N     T      
        I                 
   D    I         S       
    E             ST      
AB         L              
        I         S       
       H    M             
    E        N     T      
A                R        
        I                 
A            N            
        I         S       
            M

Ghi chú

• Traites whitespaces được cho phép.
• Bạn không cần phải điền vào bất kỳ dòng cuối cùng có khoảng trắng. Ví dụ: nếu đầu vào là ABC, bạn có thể xuất ra ABCmà không có 23 dấu cách.
• Bạn có thể cho rằng đầu vào sẽ khớp với [A-Z]+regex.
• Ngoài ra, bạn có thể sử dụng bảng chữ cái chữ thường, trong đó trường hợp đầu ra sẽ khớp [a-z]+.
• Bạn phải sử dụng một dòng mới ( \n, \r\nhoặc tương đương) để dòng riêng biệt, đó là một danh sách các chuỗi được không phải là một định dạng đầu ra thích hợp.
• Đây là một thử thách chơi gôn , vì vậy hãy viết mã của bạn càng ngắn càng tốt!

Husk , 15 byte

TṪS`?' €…"AZ"ġ>

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

Giải trình

TṪS`?' €…"AZ"ġ>  Implicit input, e.g. "HELLO"
             ġ>  Split into strictly increasing substrings: x = ["H","EL","LO"]
        …"AZ"    The uppercase alphabet (technically, the string "AZ" rangified).
 Ṫ               Outer product of the alphabet and x
  S`?' €         using this function:
                   Arguments: character, say c = 'L', and string, say s = "EL".
       €           1-based index of c in s, or 0 if not found: 2
  S`?'             If this is truthy, then c, else a space: 'L'
                 This gives, for each letter c of the alphabet,
                 a string of the same length as x,
                 containing c for those substrings that contain c,
                 and a space for others.
T                Transpose, implicitly print separated by newlines.

Java 10, 161 159 152 byte

s->{var x="";int p=0;for(var c:s)x+=p<(p=c)?c:";"+c;for(var y:x.split(";"))System.out.println("ABCDEFGHIJKLMNOPQRSTUVWXYZ".replaceAll("[^"+y+"]"," "));}

-2 byte nhờ @Nevay .
-7 byte in trực tiếp thay vì trả về Chuỗi và chuyển đổi sang Java 10.

Giải thích: "

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

s->{                      // Method with String parameter and no return-type
  var x="";               //  Temp-String
  int p=0;                //  Previous character (as integer), starting at 0
  for(var c:s)            //  Loop (1) over the characters of the input
    x+=p<(p=c)?           //   If the current character is later in the alphabet
                          //   (replace previous `p` with current `c` afterwards)
        c                 //    Append the current character to Temp-String `x`
       :                  //   Else:
        ";"+c;            //    Append a delimiter ";" + this character to Temp-String `x`
  for(var y:x.split(";")) //  Loop (2) over the String-parts
    System.out.println(   //   Print, with trailing new-line:
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                          //    Take the alphabet,
        .replaceAll("[^"+y+"]"," "));}
                          //    and replace all letters not in the String-part with a space

Phần đầu tiên của phương thức chia từ đầu vào thành các phần bằng dấu phân cách.
Ví dụ: CODEGOLF→ CO;DEGO;L;Fhoặc BALLOON→ B;AL;LO;O;N.

Phần thứ hai lặp lại các phần này và sử dụng biểu thức chính quy [^...]để thay thế mọi thứ không khớp với một khoảng trắng.
Ví dụ, .replaceAll("[^CO]"," ")để lại C, và O, và thay thế mọi thứ khác bằng một khoảng trắng.

C (gcc) , 69 byte

i;f(char*s){for(i=64;*s;putchar(*s^i?32:*s++))i+=i^90?1:puts("")-26;}

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

Perl 5 , 44 byte

Mã 40 byte + 4 cho -lF.

print map/$F[0]/?shift@F:$",A..Z while@F

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

Python 2 , 92 byte

f=lambda x,y=65:x and(y<=ord(x[0])and" "*(ord(x[0])-y)+x[0]+f(x[1:],-~ord(x[0]))or"\n"+f(x))

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

JavaScript (ES6), 79

Chỉnh sửa Khi một dòng mới hàng đầu được chấp nhận, tôi có thể lưu 2 byte

s=>eval("for(o='',v=i=0;c=s.charCodeAt(i);v%=27)o+=v++?c-63-v?' ':s[i++]:`\n`")

Để có thêm 1 byte, tôi có thể chấp nhận đầu vào chữ thường hoặc chữ hoa:

s=>eval("for(o='',v=i=0;c=s[i];v%=27)o+=v++?parseInt(c,36)-8-v?' ':s[i++]:`\n`")

Ít chơi gôn

s=>{
  var i,o,c,v
  for(o = '', v = 1, i = 0; c = s.charCodeAt(i); v %= 27)
    o += v++ ? c-63-v ? ' ' : s[i++] : '\n'
  return o
}  

Kiểm tra

f=s=>eval("for(o='',v=i=0;c=s.charCodeAt(i);v%=27)o+=v++?c-63-v?' ':s[i++]:`\n`")

function update() {
  var i=I.value
  i=i.replace(/[^A-Z]/gi,'').toUpperCase()
  O.textContent=f(i)
}

update()

<input id=I value='BALLOON' oninput='update()' >
<pre id=O></pre>

MATL , 24 23 byte

''jt8+t1)wdh26X\Ys(26e!

Sử dụng chữ thường.

Hãy thử nó tại MATL Online!

Giải trình

''     % Push empty string
jt     % Push input string. Duplicate
8+     % Add 8 to each char (ASCII code). This transforms 'a' 105,
       % 'b' into 106, which modulo 26 correspond to 1, 2 etc
t1)    % Duplicate. Get first entry
wd     % Swap. COnsecutive differences.
h      % Concatenate horizontally
26X\   % 1-based modulo 26. This gives a result from 1 to 26
Ys     % Cumulative sum
(      % Write values (converted into chars) at specified positions
       % of the initially empty string
26e    % Reshape into a 26-row char matrix, padding with char 0
!      % Transpose. Implicitly display. Char 0 is shown as space

Japt , 18 16 byte

-2 byte nhờ @Shaggy

;ò¨ £B®kX ?S:Z
·

Chỉ nhập đầu vào.

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

Giải trình

;

Chuyển sang các biến thay thế, trong đó Blà bảng chữ cái viết hoa.

ò¨

Chia chuỗi đầu vào giữa các ký tự trong đó ký tự đầu tiên lớn hơn hoặc bằng ( ¨) thứ hai.

£

Ánh xạ mỗi phân vùng theo chức năng, đâu Xlà phân vùng hiện tại.

B®

Ánh xạ từng ký tự trong bảng chữ cái in hoa theo sau, với Zchữ cái hiện tại.

kX

Xóa tất cả các chữ cái trong phân vùng hiện tại khỏi chữ cái hiện tại. Nếu chữ cái hiện tại được chứa trong phân vùng hiện tại, điều này dẫn đến một chuỗi trống.

?S:Z

Nếu đó là sự thật (không phải là một chuỗi rỗng), hãy trả về một khoảng trắng ( S), nếu không thì trả về chữ cái hiện tại.

·

Tham gia kết quả của dòng trước với dòng mới và in kết quả.

Bình thường, 18 byte

#pbVGp?JqhzNNd=>zJ

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

Dòng mới hàng đầu trong đầu ra, bảng chữ cái chữ thường.

Thạch , 19 byte

<2\¬0;œṗfȯ⁶$¥€@€ØAY

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

C (gcc), 91 63 byte

-28 chỉ nhờ ASCII

_;f(char*s){for(_=64;*s;)putchar(++_>90?_=64,10:*s^_?32:*s++);}

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

Trước:

i,j;f(char*s){while(s[i]){for(j=65;j<91;j++)s[i]==j?putchar(s[i++]):printf(" ");puts("");}}

Vâng, có một giải pháp ngắn hơn, nhưng tôi nhận thấy sau khi tôi viết bài này ... Hãy thử trực tuyến!

Toán học, 101 byte

StringRiffle[
  Alphabet[]/.#->" "&/@
   (Except[#|##,_String]&@@@
     Split[Characters@#,#==1&@*Order]),"
",""]&

Splitđầu vào thành các chuỗi chữ cái tăng nghiêm ngặt, so sánh các chữ cái liền kề với Order. Nếu Order[x,y] == 1, xtrước đó ytrong bảng chữ cái và do đó có thể xuất hiện trên cùng một dòng.

Đối với mỗi chuỗi chữ cái, tạo một mẫu để khớp chuỗi Exceptcho các chữ cái đó; #|##là một tốc ký cho Alternatives. Thay thế các chữ cái Alphabetphù hợp với mẫu bằng dấu cách.

Minh họa các bước trung gian:

"codegolf";
Split[Characters@#,#==1&@*Order]  &@%
Except[#|##,_String]&@@@         #&@%
Alphabet[]/.#->" "&/@               %

{{"c", "o"}, {"d", "e", "g", "o"}, {"l"}, {"f"}}

{Except["c" | "c" | "o", _String], 
 Except["d" | "d" | "e" | "g" | "o", _String], 
 Except["l" | "l", _String],
 Except["f" | "f", _String]}

{{" "," ","c"," "," "," "," "," "," "," "," "," "," "," ","o"," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," ","d","e"," ","g"," "," "," "," "," "," "," ","o"," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," "," "," "," "," "," "," "," "," ","l"," "," "," "," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," "," "," ","f"," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "}}

Golf, 22 21 byte

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

-1 byte nhờ xác định lại cẩn thận cuối cùng của tích nhợp.

{.n>{}{'
'\}if:n}%:n;

Giải thích (với phiên bản hơi khác):

{.n>{}{"\n"\}if:n}%:n; # Full program
{                }%    # Go through every character in the string
 .n>         if        # If ASCII code is greater than previous...
                       # (n means newline by default, so 1st char guaranteed to fit)
    {}                 # Do nothing
      {"\n"\}          # Else, put newline before character
               :n      # Redefine n as the last used character
                   :n; # The stack contents are printed at end of execution
                       # Literally followed by the variable n, usually newline
                       # So because n is by now an ASCII code...
                       # ...redefine n as the new string, and empty the stack

Võng mạc , 80 byte

^
;¶
{`;.*
¶;ABCDEFGHIJKLMNOPQRSTUVWXYZ
¶¶
¶
)+`;(.*)(.)(.*¶)\2
$.1$* $2;$3
;.*

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

Luôn luôn có chính xác một dòng mới hàng đầu. Mã có phần vụng về chuẩn bị từ với bảng chữ cái cùng với một điểm đánh dấu (dấu chấm phẩy). Sau đó, nó di chuyển điểm đánh dấu lên chữ cái đầu tiên của từ, trong khi thay đổi tất cả các chữ cái khác mà nó chuyển vào khoảng trắng. Nó cũng loại bỏ chữ cái đầu tiên của từ này. Nó lặp lại điều này cho đến khi chữ cái đầu tiên của từ không nằm sau điểm đánh dấu nữa. Sau đó, nó xóa điểm đánh dấu đó và phần còn lại của bảng chữ cái, và thay thế nó bằng một dòng mới và bảng chữ cái một lần nữa. Nó tiếp tục lặp lại điều này cho đến khi từ đầu vào trống, sau đó nó xóa sạch bảng chữ cái và điểm đánh dấu cuối cùng, để lại đầu ra mong muốn.

05AB1E , 18 byte

ćIgµ¶?AvDyÊið?ë¼?ć

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

Gặp sự cố với 05AB1E ć(trích xuất 1) để lại một chuỗi / danh sách trống trên ngăn xếp sau khi phần tử cuối cùng được trích xuất. Giải pháp này sẽ ngắn hơn 1-2 byte nếu không có.

ćIgµ¶?AvDyÊið?ë¼?ć  Implicit input 
ć                   Extract the 1st char from the string
 Igµ                While counter != length of the string
    ¶?              Print a newline
      Av            For each letter of the lowercased alphabet
        DyÊ         Is the examined character different from the current letter?
           ið?      If true, then print a space

              ë¼?ć  Else increment the counter, print the letter and push
                    the next character of the string on the stack

Võng mạc , 130 126 byte

$
¶A
{-2=`
$'
}T`RL`_o`.$
+`(?<=(.)*)((.).*¶(?<-1>.)*(?(1)(?!)).+\3.*$)
 $2
(?<=(.)*)((.).*¶(?<-1>.)*(?<-1>\3.*$))
¶$2
}`¶.*$

Hãy thử trực tuyến! Chỉnh sửa: Đã lưu 4 byte bằng cách sử dụng trình tạo bảng chữ cái của @ MartinEnder. Giải trình:

$
¶A
{-2=`
$'
}T`RL`_o`.$

Nối bảng chữ cái.

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

Căn chỉnh càng nhiều chữ cái càng tốt với vị trí của chúng trong bảng chữ cái.

(?<=(.)*)((.).*¶(?<-1>.)*(?<-1>\3.*$))
¶$2

Bắt đầu một dòng mới trước chữ cái đầu tiên không thể căn chỉnh.

}`¶.*$

Xóa bảng chữ cái, nhưng sau đó làm lại mọi thứ cho đến khi không có chữ cái sai.

q / kdb + , 48 45 byte

Giải pháp:

-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:;

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

Lưu ý: Liên kết là một cổng K (oK) của giải pháp này vì không có TIO cho q / kdb +.

Ví dụ:

q)-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:"STACKEXCHANGE";
                  ST
A C       K
    E                  X
  C    H
A            N
      G
    E

q)-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:"BALLOON";
 B
A          L
           L  O
              O
             N

Giải trình:

Q được giải thích từ phải sang trái. Giải pháp được chia thành hai phần. Đầu tiên phân tách chuỗi trong đó ký tự tiếp theo nhỏ hơn hoặc bằng hiện tại:

"STACKEXCHANGE" -> "ST","ACK","EX","CH","AN","G","E"

Sau đó lấy một chuỗi 26 khoảng trống và áp dụng đầu vào cho nó tại các chỉ mục nơi đầu vào xuất hiện trong bảng chữ cái và in ra thiết bị xuất chuẩn.

"__________________________" -> __________________ST______

Phá vỡ:

-1{@[26#" ";.Q.A?x;:;x]}each(0,where (<=':)x) cut x:; / ungolfed solution
-1                                                  ; / print to stdout, swallow return value
                                                  x:  / store input as variable x
                                              cut     / cut slices x at these indices
                            (               )         / do this together
                                     (<=':)x          / is current char less-or-equal (<=) than each previous (':)?
                               where                  / indices where this is true
                             0,                       / prepended with 0
                        each                          / take each item and apply function to it
  {                    }                              / lambda function with x as implicit input
   @[      ;      ; ; ]                               / apply[variable;indices;function;arguments]
     26#" "                                           / 26 take " " is "      "...
            .Q.A?x                                    / lookup x in the uppercase alphabet, returns indice(s)
                   :                                  / assignment
                     x                                / the input to apply to these indices

Ghi chú:

• -3 byte bằng cách thay thế trước bằng phiên bản K4

Powershell, 70 63 byte

-7 byte cảm ơn @Veskah

$args|%{if($_-le$p){$x;rv x}
$x=("$x"|% *ht($_-65))+($p=$_)}
$x

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

Giải trình:

Đối với mỗi ký tự trong đối số được tách ra:

• Chuỗi đầu ra $xvà $xgiá trị rõ ràng ( rvlà bí danh cho Loại bỏ biến ), nếu một mã của ký tự hiện tại ít hơn hoặc tương đương ( -le) với mã của ký tự trước đó.
• Nối các khoảng trắng và ký tự hiện tại vào $x, lưu trữ nó vào $x. Ngoài ra nó làm mới một giá trị nhân vật trước đó.

Đầu ra cuối cùng $x.

Thạch , 24 21 byte

3 byte nhờ Erik the Outgolfer.

O64;I%26’⁶ẋЀ;"⁸Ẏs26Y

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

SOGL V0.12 , 22 byte

±E⁄Z*{@;eJι=?Xē}}¹∑z⁄n

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

JavaScript (ES6), 87 byte

f=([...s])=>s[0]?(g=i=>i>35?`
`+f(s):(i-parseInt(s[0],36)?" ":s.shift())+g(i+1))(10):""

Chấp nhận đầu vào chữ hoa hoặc chữ thường. Đầu ra khớp với trường hợp của đầu vào.

Xét nghiệm

f=([...s])=>s[0]?(g=i=>i>35?`
`+f(s):(i-parseInt(s[0],36)?" ":s.shift())+g(i+1))(10):""

;O.innerText=["CODEGOLF","STACKEXCHANGE","F","ZYXWVUTSRQPONMLKJIHGFEDCBA","ANTIDISESTABLISHMENTARIANISM"]
.map(f).join("=".repeat(26)+"\n")

<pre id=O>

Haskell, 81 74 73 byte

q@(w:y)!(x:z)|w==x=x:y!z|1<2=min ' 'x:q!z
x!_=x
a=['A'..'Z']++'\n':a
(!a)

Đã lưu 1 byte nhờ Laikoni !

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

Tối ưu hóa Haskell ôm

1. Trình thông dịch Hugs cho phép tôi lưu thêm một byte bằng cách thực hiện (!cycle$['A'..'Z']++"\n")thay vì : (!cycle(['A'..'Z']++"\n")), nhưng GHC không thích cái trước đó . (Điều này hiện đã lỗi thời; Laikoni đã viết lại dòng đó theo cách đã lưu 1 byte.)

2. Rõ ràng, Hugs cũng không yêu cầu dấu ngoặc đơn xung quanh trình so khớp mẫu danh sách, vì vậy tôi có thể lưu thêm hai byte đi từ: q@(w:y)!(x:z)đến q@(w:y)!x:z.

Python 3 , 87 85 byte

def f(s,l=65):c,*t=s;o=ord(c)-l;return o<0and'\n'+f(s)or' '*o+c+(t and f(t,o-~l)or'')

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

J , 39 byte

(_65+3 u:[)}&(26{.'')/.~0+/\@,2>:/\3&u:

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

Than , 15 byte

Ｆθ«Ｊ⌕αι⁺ⅉ‹⌕αιⅈι

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 trình:

 θ              Input string
Ｆ «             Loop over characters
     α     α    Uppercase letters predefined variable
      ι     ι   Current character
    ⌕     ⌕     Find index
             ⅈ  Current X co-ordinate
         ‹      Compare
        ⅉ       Current Y co-ordinate
       ⁺        Sum
   Ｊ            Jump to aboslute position
              ι Print current character

APL (Dyalog Classic) , 20 byte

⊃¨⎕a∘.∩⍨⊢⊂⍨1,2≥/⎕a⍳⊢

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

K (ngn / k) , 29 28 byte

{{x@x?`c$65+!26}'(&~>':x)_x}

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

{ } chức năng với đối số x

>':x Đối với mỗi char, nó có lớn hơn char trước không?

~ phủ định

& chúng ta có sự thật ở đâu (tại đó

( )_xcắt xtại các chỉ số đó, trả về một danh sách các chuỗi

{ }' cho mỗi chuỗi

`c$65+!26

Bảng chữ cái tiếng Anh

x?tìm chỉ mục của lần xuất hiện đầu tiên của mỗi chữ cái x, sử dụng 0N(giá trị "null" đặc biệt) nếu không tìm thấy

x@chỉ số xvới điều đó; lập chỉ mục với 0Ntrả về " ", vì vậy chúng tôi nhận được một chuỗi dài 26 trong đó các chữ cái xở vị trí theo thứ tự chữ cái của chúng và mọi thứ khác là khoảng trắng

R , 129 117 byte

function(s){z={}
y=diff(x<-utf8ToInt(s)-64)
z[diffinv(y+26*(y<0))+x[1]]=LETTERS[x]
z[is.na(z)]=" "
write(z,1,26,,"")}

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

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

function(s){
 z <- c()                  # initialize an empty vector
 x <- utf8ToInt(s)-64      # map to char code, map to range 1:26
 y <- diff(x)              # successive differences of x
 idx <- cumsum(c(          # indices into z: cumulative sum of:
    x[1],                  # first element of x
    ifelse(y<=0,y+26,y)))  # vectorized if: maps non-positive values to themselves + 26, positives to themselves
 z[idx] <- LETTERS[x]      # put letters at indices
 z[is.na(z)] <- " "        # replace NA with space
 write(z,"",26,,"")        # write z as a matrix to STDOUT ("") with 26 columns and empty separator.

R , 95 byte

Chỉ cần chạy qua bảng chữ cái in hoa nhiều lần trong khi tiến lên bộ đếm bằng 1 nếu bạn gặp chữ cái ở vị trí bộ đếm của từ và in ra chữ cái, một khoảng trắng.

function(s)while(F>""){for(l in LETTERS)cat("if"((F=substr(s,T,T))==l,{T=T+1;l}," "));cat("
")}

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

GolfScript , 37 byte

64:a;{.a>{}{'
'\64:a;}if.a-(' '*\:a}%

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

Tôi đã thực hiện một Golfscript dưới một tên khác, nhưng nó có đầu ra không chính xác.