오늘 일찍 본 밈에서 영감을 얻었 습니다.

도전 설명

무한 알파벳 그리드를 고려하십시오.

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
...

단어 ( CODEGOLF이 예제에서)를 사용하여 그리드의 하위 시퀀스로 만들고 사용하지 않는 문자를 공백으로 바꾸고 무한 그리드의 끝에서 문자를 모두 제거하십시오.

  C           O           
   DE G       O           
           L              
     F

예

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

노트

• 후행 공백이 허용됩니다.
• 마지막 줄을 공백 으로 채울 필요는 없습니다 . 예를 들어, 입력이 인 경우 뒤에 공백없이 23 ABC개만 출력 할 수 ABC있습니다.
• 입력이 [A-Z]+정규식 과 일치한다고 가정 할 수 있습니다 .
• 또는 소문자 알파벳을 사용할 수 있으며이 경우 출력이 일치 [a-z]+합니다.
• 줄 바꿈 ( \n,\r\n 라인을 분리 또는 그에 상당), 그 문자열 목록은 적절한 출력 형식되지이다.
• 이것은 코드 골프 문제이므로 가능한 한 코드를 짧게 만드십시오!

껍질 , 15 바이트

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

온라인으로 사용해보십시오!

설명

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.

자바 (10), 161 (159) 152 바이트

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+"]"," "));}

@Nevay 덕분에 -2 바이트 .
String을 리턴하고 Java 10으로 변환하는 대신 직접 -7 바이트 인쇄

설명 : "

여기에서 시도하십시오.

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

이 방법의 첫 번째 부분은 입력 단어를 구분 기호가있는 부분으로 나눕니다.
예를 들면 다음과 같습니다. CODEGOLF→ CO;DEGO;L;F또는 BALLOON→ B;AL;LO;O;N.

두 번째 부분은 이러한 부분을 반복하고 정규 표현식 [^...]을 사용하여 공백과 일치하지 않는 모든 것을 바꿉니다 .
예를 들어 .replaceAll("[^CO]"," ")잎 C, 그리고 O, 그리고 공간을 다른 모든 대체합니다.

C (gcc) , 69 바이트

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

온라인으로 사용해보십시오!

펄 5 , 44 바이트

40 바이트 코드 + 4 -lF.

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

온라인으로 사용해보십시오!

파이썬 2 , 92 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 79

편집 선행 줄 바꿈이 허용되므로 2 바이트를 절약 할 수 있습니다

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

1 바이트 이상 소문자 또는 대문자 입력을 허용 할 수 있습니다.

s=>eval("for(o='',v=i=0;c=s[i];v%=27)o+=v++?parseInt(c,36)-8-v?' ':s[i++]:`\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
}  

테스트

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 바이트

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

소문자를 사용합니다.

MATL Online 에서 사용해보십시오 !

설명

''     % 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

apt , 18 16 바이트

@Shaggy 덕분에 -2 바이트

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

대문자 만 입력하십시오.

온라인으로 사용해보십시오!

설명

;

B대문자 알파벳 인 대체 변수로 전환 하십시오.

ò¨

첫 번째 문자가 두 번째 문자보다 크거나 같은 문자 사이에서 입력 문자열을 분할하십시오 ¨.

£

X현재 파티션이있는 기능으로 각 파티션을 맵핑 하십시오.

B®

대문자로 된 각 문자를 Z현재 문자로 다음에 매핑 하십시오.

kX

현재 문자에서 현재 파티션의 모든 문자를 제거하십시오. 현재 문자가 현재 파티션에 포함되어 있으면 빈 문자열이됩니다.

?S:Z

빈 문자열이 아닌 경우, 공백 ( S)을 반환하고, 그렇지 않으면 현재 문자를 반환하십시오.

·

이전 줄의 결과를 줄 바꿈과 결합하고 결과를 인쇄하십시오.

Pyth, 18 바이트

#pbVGp?JqhzNNd=>zJ

여기에서 시도하십시오.

출력에서 선행 줄 바꿈, 소문자 알파벳

젤리 , 19 바이트

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

온라인으로 사용해보십시오!

C (gcc), 91 63 바이트

ASCII 전용 -28 덕분에

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

온라인으로 사용해보십시오!

이전:

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

예, 더 짧은 해결책이 있지만 이것을 작성한 후에는 알아 차 렸습니다 ... 온라인으로 사용해보십시오!

Mathematica, 101 바이트

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

Split인접한 문자를와 비교하여 엄격하게 증가하는 문자 시퀀스로의 입력 Order. 만약 Order[x,y] == 1다음,x 선행y 같은 줄에 나타날 수 따라서 알파벳과.

각 문자 순서에 Except대해 해당 문자의 문자열과 일치하는 패턴을 작성하십시오 . #|##의 속기입니다 Alternatives. Alphabet패턴과 일치하는 문자 를 공백으로 바꿉니다 .

중간 단계 그림 :

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

골프 스크립트, 22 21 바이트

온라인으로 사용해보십시오!

n내장 의 신중한 최종 재정의 덕분에 -1 바이트 .

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

설명 (약간 다른 버전) :

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

레티 나 , 80 바이트

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

온라인으로 사용해보십시오!

항상 하나의 주요 개행 문자가 있습니다. 이 코드는 알파벳과 함께 단어 앞에 마커 (세미콜론)를 붙입니다. 그런 다음 마커를 단어의 첫 번째 글자까지 이동하고 다른 모든 글자는 공백으로 바꿉니다. 또한 단어의 첫 글자를 제거합니다. 단어의 첫 글자가 더 이상 마커 뒤에 있지 않을 때까지 이것을 반복합니다. 그런 다음 해당 마커와 나머지 알파벳을 지우고 새 줄로 바꾸고 알파벳을 다시 마커로 바꿉니다. 입력 단어가 비어있을 때까지 계속 반복 한 다음 마지막 알파벳과 마커를 정리하여 원하는 출력을 유지합니다.

05AB1E , 18 바이트

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

온라인으로 사용해보십시오!

ć마지막 요소가 추출 된 후 스택에 빈 문자열 / 목록을 남겨두고 05AB1E (추출물 1)에 문제가 발생했습니다 . 그렇지 않은 경우이 솔루션은 1-2 바이트 더 짧아집니다.

ć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

망막 , 130 126 바이트

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

온라인으로 사용해보십시오! 편집 : @MartinEnder의 알파벳 생성기를 사용하여 4 바이트를 저장했습니다. 설명:

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

알파벳을 추가하십시오.

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

알파벳의 위치와 가능한 한 많은 글자를 정렬하십시오.

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

정렬 할 수없는 첫 글자 앞에 새 줄을 시작하십시오.

}`¶.*$

알파벳을 삭제 한 다음 잘못 정렬 된 문자가 없을 때까지 모든 작업을 다시 수행하십시오.

q / kdb + , 48 45 바이트

해결책:

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

온라인으로 사용해보십시오!

참고 : q / kdb +에 대한 TIO가 없으므로이 솔루션 의 K (oK) 포트에 연결됩니다.

예 :

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

설명:

Q는 오른쪽에서 왼쪽으로 해석됩니다. 솔루션은 두 부분으로 나뉩니다. 먼저 다음 문자가 현재보다 작거나 같은 문자열을 분할하십시오.

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

그런 다음 26 개의 공백을 취하고 입력이 알파벳으로 나타나는 색인에 입력을 적용하고 stdout으로 인쇄하십시오.

"__________________________" -> __________________ST______

고장:

-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

노트:

• prev를 K4 버전으로 대체하여 -3 바이트

Powershell, 70 63 바이트

-7 바이트 덕분에 @Veskah

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

온라인으로 사용해보십시오!

설명:

산산조각이 난 인수의 각 문자에 대해 :

• 현재 문자 코드가 이전 문자 코드 보다 작거나 같은 경우 출력 문자열 $x및 일반 $x값 ( Remove-Variable의rv 별명 임)입니다.-le
• 에 공백과 현재 문자를 추가하여 $x에 저장하십시오 $x. 또한 이전 문자 값을 새로 고칩니다.

마지막 출력 $x.

젤리 , 24 21 바이트

Outgolfer 에릭 덕분에 3 바이트.

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

온라인으로 사용해보십시오!

SOGL V0.12 , 22 바이트

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

여기 사용해보십시오!

JavaScript (ES6), 87 바이트

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

대문자 또는 소문자 입력을 허용합니다. 출력은 입력의 경우와 일치합니다.

테스트

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>

하스켈, 81 74 73 바이트

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

Laikoni 덕분에 1 바이트 절약 !

온라인으로 사용해보십시오.

하스켈 포옹 최적화

1. Hugs 인터프리터를 사용하면 (!cycle$['A'..'Z']++"\n")다음 대신 다음을 수행하여 하나 이상의 바이트를 절약 할 수 (!cycle(['A'..'Z']++"\n"))있지만 GHC는 전자를 좋아하지 않습니다 . (이제 더 이상 사용되지 않습니다. Laikoni는 이미 1 바이트를 절약 한 방식으로 해당 행을 다시 작성했습니다.)

2. 분명히, 포옹도 목록 패턴 매처 괄호를 필요로하지 않는다, 그래서에서가 두 개 더 바이트를 절약 할 수있다 : q@(w:y)!(x:z)에 q@(w:y)!x:z.

파이썬 3 , 87 85 바이트

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

온라인으로 사용해보십시오!

J , 39 바이트

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

온라인으로 사용해보십시오!

숯 , 15 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

 θ              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 바이트

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

온라인으로 사용해보십시오!

K (ngn / k) , 29 28 바이트

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

온라인으로 사용해보십시오!

{ } 인수 기능 x

>':x 각 문자마다 이전 문자보다 큽니까?

~ 부정하다

& 우리는 어디에서 (지수) 우리는 진실합니까?

( )_xx색인을 잘라 내고 문자열 목록을 반환

{ }' 각 문자열마다

`c$65+!26

영어 알파벳

x?에서 각 문자의 첫 항목 색인을 찾고, 찾을 수없는 x경우 0N(특수 "널"값)을 사용하십시오.

x@그것으로 색인 x; 0Nreturns로 인덱싱 " "하므로 문자 x가 알파벳 위치에 있고 그 밖의 모든 것이 공백 인 길이 -26 문자열을 얻습니다.

R , 129117 바이트

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,,"")}

온라인으로 사용해보십시오!

설명 (ungolfed) :

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.

아르 자형 , 95 바이트

단어의 카운터 위치에서 문자를 발견하고 문자를 인쇄하면 공백을 제외하고 카운터를 1 씩 진행하면서 대문자 알파벳을 반복해서 실행하십시오.

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

온라인으로 사용해보십시오!

GolfScript , 37 바이트

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

온라인으로 사용해보십시오!

다른 이름으로 Golfscript를 사용했지만 출력이 잘못되었습니다.