Inspiriert von einem Mem, das ich heute früher gesehen habe.

Herausforderungsbeschreibung

Betrachten Sie ein unendliches Alphabetraster:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
...

Nehmen Sie ein Wort ( CODEGOLFin diesem Beispiel) und machen Sie es zu einer Untersequenz des Rasters. Ersetzen Sie nicht verwendete Buchstaben durch ein Leerzeichen und entfernen Sie die Buchstaben am Ende des unendlichen Rasters insgesamt:

  C           O           
   DE G       O           
           L              
     F

Beispiele

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

Anmerkungen

• Nachgestellte Leerzeichen sind zulässig.
• Sie müssen die letzte Zeile nicht mit Leerzeichen auffüllen. Wenn die Eingabe beispielsweise lautet ABC, können Sie nur ABCohne 23 nachgestellte Leerzeichen ausgeben .
• Sie können davon ausgehen, dass die Eingabe mit [A-Z]+Regex übereinstimmt .
• Alternativ können Sie auch Kleinbuchstaben verwenden. In diesem Fall stimmt die Ausgabe überein [a-z]+.
• Sie müssen eine neue Zeile verwenden ( \n, \r\noder gleichwertig) Linien zu trennen, dh eine Liste von Strings ist nicht eine richtige Ausgabeformat.
• Dies ist eine Code-Golf- Herausforderung, also mach deinen Code so kurz wie möglich!

Schale , 15 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

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 Bytes dank @Nevay .
-7 Byte direkt drucken, anstatt einen String zurückzugeben und auf Java 10 zu konvertieren.

Erläuterung: "

Probieren Sie es hier aus.

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

Der erste Teil der Methode teilt das Eingabewort in Teile mit einem Trennzeichen.
Zum Beispiel: CODEGOLF→ CO;DEGO;L;Foder BALLOON→ B;AL;LO;O;N.

Der zweite Teil durchläuft diese Teile und ersetzt mit der Regex [^...]alles, was nicht mit einem Leerzeichen übereinstimmt.
Zum Beispiel .replaceAll("[^CO]"," ")verlässt das Cund Ound ersetzt alles andere durch ein Leerzeichen.

C (gcc) , 69 Bytes

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

Probieren Sie es online!

Perl 5 , 44 Bytes

40 Byte Code + 4 für -lF.

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

Probieren Sie es online!

Python 2 , 92 Bytes

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

Probieren Sie es online!

JavaScript (ES6), 79

Bearbeiten Da ein führender Zeilenumbruch akzeptiert wird, kann ich 2 Bytes einsparen

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

Für 1 Byte mehr kann ich Eingaben in Klein- oder Großbuchstaben akzeptieren:

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

Weniger golfen

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
}  

Prüfung

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 Bytes

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

Verwendet Kleinbuchstaben.

Probieren Sie es bei MATL Online!

Erläuterung

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

-2 Bytes dank @Shaggy

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

Nur Eingabe in Großbuchstaben.

Probieren Sie es online!

Erläuterung

;

Wechseln Sie zu alternativen Variablen, wobei Bdas Großbuchstaben ist.

ò¨

Teilen Sie die Eingabezeichenfolge auf Zeichen auf, bei denen das erste größer oder gleich ( ¨) dem zweiten ist.

£

Ordnen Sie jede Partition der Funktion zu. Dabei Xhandelt es sich um die aktuelle Partition.

B®

Ordnen Sie jedes Zeichen im Großbuchstaben dem folgenden zu, wobei Zes sich um den aktuellen Buchstaben handelt.

kX

Entfernen Sie alle Buchstaben in der aktuellen Partition aus dem aktuellen Buchstaben. Wenn der aktuelle Buchstabe in der aktuellen Partition enthalten ist, führt dies zu einer leeren Zeichenfolge.

?S:Z

Wenn dies der Fall ist (keine leere Zeichenfolge), geben Sie ein Leerzeichen ( S) zurück, andernfalls den aktuellen Buchstaben.

·

Verbinden Sie das Ergebnis der vorherigen Zeile mit Zeilenumbrüchen und drucken Sie das Ergebnis aus.

Pyth, 18 Bytes

#pbVGp?JqhzNNd=>zJ

Probieren Sie es hier aus.

Führender Zeilenumbruch in der Ausgabe, Kleinbuchstaben.

Jelly , 19 Bytes

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

Probieren Sie es online!

C (gcc) 91 63 Bytes

-28 dank nur ASCII

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

Probieren Sie es online!

Bisherige:

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

Ja, es gibt eine kürzere Lösung, aber ich habe festgestellt, nachdem ich diese geschrieben habe ... Probieren Sie es online aus!

Mathematica, 101 Bytes

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

Splitdie Eingabe in streng ansteigende Buchstabenfolgen durch Vergleich benachbarter Buchstaben mit Order. Wenn Order[x,y] == 1, dann xsteht yim Alphabet und kann somit in der gleichen Zeile stehen.

Erstellen Sie für jede Buchstabenfolge ein Muster, das den Zeichenfolgen Exceptfür diese Buchstaben entspricht. #|##ist eine Abkürzung für Alternatives. Ersetzen Sie Buchstaben von, die Alphabetdem Muster entsprechen, durch Leerzeichen.

Illustration der Zwischenschritte:

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

Golfscript, 22 21 Bytes

Probieren Sie es online!

-1 Byte dank sorgfältiger abschließender Neudefinition des Einbaus n.

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

Erklärung (mit einer etwas anderen Version):

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

Netzhaut , 80 Bytes

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

Probieren Sie es online!

Es gibt immer genau eine führende Zeile. Der Code stellt dem Wort etwas klobig das Alphabet voran, zusammen mit einer Markierung (Semikolon). Anschließend wird die Markierung auf den ersten Buchstaben des Wortes verschoben, während alle anderen Buchstaben in Leerzeichen umgewandelt werden. Es wird auch der erste Buchstabe des Wortes entfernt. Dies wird solange wiederholt, bis der erste Buchstabe des Wortes nicht mehr hinter dem Marker steht. Anschließend werden diese Markierung und der Rest des Alphabets gelöscht und durch eine neue Zeile und das Alphabet erneut durch eine Markierung ersetzt. Dies wird so oft wiederholt, bis das eingegebene Wort leer ist. Anschließend werden das letzte Alphabet und die letzte Markierung entfernt, sodass die gewünschte Ausgabe erhalten bleibt.

05AB1E , 18 Bytes

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

Probieren Sie es online!

05AB1E ć(Extrakt 1) hinterlässt nach dem Extrahieren des letzten Elements einen leeren String / eine leere Liste auf dem Stack. Diese Lösung wäre 1-2 Bytes kürzer, wenn es das nicht gäbe.

ć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

Retina , 130 126 Bytes

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

Probieren Sie es online! Bearbeiten: 4 Bytes mit dem Alphabet-Generator von @ MartinEnder gespeichert. Erläuterung:

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

Füge das Alphabet an.

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

Richten Sie so viele Buchstaben wie möglich an ihrer Position im Alphabet aus.

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

Beginnen Sie eine neue Zeile vor dem ersten Buchstaben, der nicht ausgerichtet werden konnte.

}`¶.*$

Löschen Sie das Alphabet, aber wiederholen Sie alles, bis keine falsch ausgerichteten Buchstaben mehr vorhanden sind.

q / kdb + , 48 45 Bytes

Lösung:

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

Probieren Sie es online!

Hinweis: Die Verknüpfung ist mit einem K (oK) -Port dieser Lösung verbunden, da für q / kdb + kein TIO vorhanden ist.

Beispiele:

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

Erläuterung:

Q wird von rechts nach links interpretiert. Die Lösung ist in zwei Teile geteilt. Teilen Sie zuerst die Zeichenfolge auf, wobei das nächste Zeichen kleiner oder gleich dem aktuellen ist:

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

Nehmen Sie dann eine Zeichenfolge mit 26 Leerzeichen und wenden Sie die Eingabe an den Indexen an, an denen die Eingabe im Alphabet angezeigt wird, und drucken Sie auf stdout.

"__________________________" -> __________________ST______

Nervenzusammenbruch:

-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

Anmerkungen:

• -3 Bytes durch Ersetzen von prev durch die K4-Version

Powershell, 70 63 Bytes

-7 Bytes danke @Veskah

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

Probieren Sie es online!

Erläuterung:

Für jedes Zeichen im splatted Argument:

• Ausgabezeichenfolge $xund $xLöschwert ( rvist ein Alias ​​für Remove-Variable ), wenn ein Code des aktuellen Zeichens kleiner oder gleichwertig ( -le) mit einem Code des vorherigen Zeichens ist.
• Fügen Sie Leerzeichen und das aktuelle Zeichen hinzu $xund speichern Sie es $x. Außerdem wird ein vorheriger Zeichenwert aktualisiert.

Letzte Ausgabe $x.

Jelly , 24 21 Bytes

3 Bytes dank Erik dem Outgolfer.

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

Probieren Sie es online!

SOGL V0.12 , 22 Bytes

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

Probieren Sie es hier aus!

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

Akzeptiert Groß- oder Kleinschreibung. Die Ausgabe entspricht dem Fall der Eingabe.

Tests

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 Bytes

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

Dank Laikoni 1 Byte gespart !

Probieren Sie es online aus.

Haskell Umarmungen Optimierungen

1. Mit dem Hugs-Interpreter kann ich ein weiteres Byte speichern, indem ich Folgendes (!cycle$['A'..'Z']++"\n")anstelle von: tue (!cycle(['A'..'Z']++"\n")), aber ersteres gefällt GHC nicht . (Dies ist jetzt veraltet. Laikoni hat diese Zeile bereits so umgeschrieben, dass 1 Byte gespart wurde.)

2. Anscheinend erfordert Hugs auch keine runden Klammern um den Listenmustervergleicher, sodass ich zwei weitere Bytes einsparen könnte, die von: q@(w:y)!(x:z)bis gehen q@(w:y)!x:z.

Python 3 , 87-85 Bytes

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

Probieren Sie es online!

J , 39 Bytes

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

Probieren Sie es online!

Kohle , 15 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

 θ              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⍳⊢

Probieren Sie es online!

K (NGN / k) , 29 28 Bytes

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

Probieren Sie es online!

{ } Funktion mit Argument x

>':x Ist es für jedes Zeichen größer als das vorherige?

~ negieren

& wo (bei welchen indizes) haben wir wahr

( )_xSchneiden Sie xan diesen Indizes, und geben Sie eine Liste von Zeichenfolgen zurück

{ }' für jede dieser Saiten

`c$65+!26

das englische Alphabet

x?Finden Sie den Index des ersten Vorkommens jedes Buchstabens in x, verwenden Sie 0N(einen speziellen "Null" -Wert), wenn er nicht gefunden wird

x@Index xdamit; Indizieren mit 0NRückgaben " ", sodass wir eine Zeichenfolge der Länge 26 erhalten, in der sich die Buchstaben von xan ihren alphabetischen Positionen befinden und alles andere Leerzeichen sind

R , 129 117 Bytes

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

Probieren Sie es online!

Erklärung (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.

R , 95 Bytes

Durchlaufen Sie das Großbuchstaben einfach wiederholt, während Sie einen Zähler um 1 vorrücken, wenn Sie den Buchstaben an der Zählerposition des Wortes finden und den Buchstaben ausdrucken, andernfalls ein Leerzeichen.

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

Probieren Sie es online!

GolfScript , 37 Bytes

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

Probieren Sie es online!

Ich habe ein Golfscript unter einem anderen Namen geschrieben, aber es hatte eine falsche Ausgabe.