Inspiré par un meme que j'ai vu plus tôt aujourd'hui.

Description du challenge

Considérons une grille infinie alphabet:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
...

Prenez un mot ( CODEGOLFdans cet exemple) et faites-en une sous-séquence de la grille, en remplaçant les lettres inutilisées par un espace et en supprimant les lettres à la fin de la grille infinie:

  C           O           
   DE G       O           
           L              
     F

Exemples

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

Remarques

• Les espaces de fuite sont autorisés.
• Vous n'avez pas besoin de remplir la dernière ligne avec des espaces. Par exemple, si l'entrée est ABC, vous pouvez générer uniquement ABCsans 23 espaces de fin.
• Vous pouvez supposer que l'entrée correspondra à [A-Z]+regex.
• Vous pouvez également utiliser un alphabet minuscule, auquel cas la sortie correspondra [a-z]+.
• Vous devez utiliser une nouvelle ligne ( \n, \r\nou équivalent) à des lignes séparées, qui est une liste de chaînes n'est pas un format de sortie approprié.
• Ceci est un défi de code-golf , alors faites votre code le plus court possible!

Coque , 15 octets

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

Essayez-le en ligne!

Explication

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 octets

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 octets grâce à @Nevay .
-7 octets imprimant directement au lieu de renvoyer une chaîne et de convertir en Java 10.

Explication: "

Essayez ici.

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

La première partie de la méthode divise le mot d'entrée en plusieurs parties avec un délimiteur.
Par exemple: CODEGOLF→ CO;DEGO;L;Fou BALLOON→ B;AL;LO;O;N.

La deuxième partie boucle sur ces parties et utilise l'expression régulière [^...]pour remplacer tout ce qui ne correspond pas à un espace.
Par exemple, .replaceAll("[^CO]"," ")quitte le C, et O, et remplace tout le reste par un espace.

C (gcc) , 69 octets

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

Essayez-le en ligne!

Perl 5 , 44 octets

Code 40 octets + 4 pour -lF.

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

Essayez-le en ligne!

Python 2 , 92 octets

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

Essayez-le en ligne!

JavaScript (ES6), 79

Modifier En tant que leader nouvelle ligne est acceptée, je peux économiser 2 octets

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

Pour 1 octet de plus, je peux accepter les entrées minuscules ou majuscules:

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

Moins joué au golf

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
}  

Tester

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 octets

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

Utilise des lettres minuscules.

Essayez-le sur MATL Online!

Explication

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

-2 octets grâce à @Shaggy

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

Entrée en majuscule seulement.

Essayez-le en ligne!

Explication

;

Basculer vers des variables alternatives, où Best l'alphabet majuscule.

ò¨

Fractionner la chaîne d'entrée entre des caractères lorsque le premier est supérieur ou égal à ( ¨) le second.

£

Mappez chaque partition par la fonction, où Xest la partition actuelle.

B®

Mappez chaque caractère de l'alphabet majuscule sur le suivant, avec Zla lettre actuelle.

kX

Supprime toutes les lettres de la partition actuelle de la lettre actuelle. Si la lettre en cours est contenue dans la partition en cours, il en résulte une chaîne vide.

?S:Z

Si cela est vrai (pas une chaîne vide), retournez un espace ( S), sinon, retournez la lettre courante.

·

Joignez le résultat de la ligne précédente avec des nouvelles lignes et imprimez le résultat.

Pyth, 18 octets

#pbVGp?JqhzNNd=>zJ

Essayez ici.

Nouvelle ligne principale dans la sortie, alphabet minuscule.

Gelée , 19 octets

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

Essayez-le en ligne!

C (gcc), 91 63 octets

-28 grâce à ASCII uniquement

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

Essayez-le en ligne!

Précédent:

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

Oui, il y a une solution plus courte, mais j'ai remarqué après avoir écrit celle-ci ... Essayez-la en ligne!

Mathematica, 101 octets

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

Splitl’entrée dans des séquences de lettres strictement croissantes, en comparant des lettres adjacentes avec Order. Si Order[x,y] == 1, alors xprécède ydans l'alphabet et peut donc apparaître sur la même ligne.

Pour chaque séquence de lettres, créez un motif pour faire correspondre les chaînes Exceptde ces lettres; #|##est un raccourci pour Alternatives. Remplacez les lettres Alphabetqui correspondent au motif par des espaces.

Illustration des étapes intermédiaires:

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

Essayez-le en ligne!

-1 octet grâce à une redéfinition finale de l’ nintégré.

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

Explication (avec une version légèrement différente):

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

Retina , 80 octets

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

Essayez-le en ligne!

Il y a toujours exactement une nouvelle ligne principale. Le code préfixe légèrement le mot avec l'alphabet et un marqueur (point-virgule). Il déplace ensuite le marqueur jusqu'à la première lettre du mot, tout en modifiant toutes les autres lettres, il passe aux espaces. Il supprime également la première lettre du mot. Il répète ceci jusqu'à ce que la première lettre du mot ne soit plus après le marqueur. Ensuite, il efface ce marqueur et le reste de l'alphabet et le remplace par une nouvelle ligne et l'alphabet par un marqueur à nouveau. Il répète cette opération jusqu'à ce que le mot saisi soit vide, puis nettoie le dernier alphabet et le dernier marqueur, en laissant la sortie souhaitée.

05AB1E , 18 octets

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

Essayez-le en ligne!

Problème rencontré avec 05AB1E ć(extrait 1) en laissant une chaîne / liste vide sur la pile après l'extraction du dernier élément. Si ce n’était pas le cas, cette solution serait plus courte de 1 à 2 octets.

ć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 octets

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

Essayez-le en ligne! Edit: 4 octets enregistrés à l’aide du générateur d’alphabet de @ MartinEnder. Explication:

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

Ajouter l'alphabet.

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

Alignez autant de lettres que possible avec leur position dans l'alphabet.

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

Commencez une nouvelle ligne avant la première lettre qui n'a pas pu être alignée.

}`¶.*$

Supprimez l'alphabet, puis recommencez jusqu'à ce qu'il n'y ait plus de lettres mal alignées.

q / kdb + , 48 45 octets

Solution:

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

Essayez-le en ligne!

Remarque: Link est relié à un port K (oK) de cette solution car il n'y a pas de TIO pour q / kdb +.

Exemples:

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

Explication:

Q est interprété de droite à gauche. La solution est divisée en deux parties. Commencez par diviser la chaîne lorsque le caractère suivant est inférieur ou égal à la valeur actuelle:

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

Prenez ensuite une chaîne de 26 espaces vierges et appliquez-la aux index où l'entrée apparaît dans l'alphabet, puis imprimez sur la sortie standard.

"__________________________" -> __________________ST______

Panne:

-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

Remarques:

• -3 octets en remplaçant prev par la version K4

Powershell, 70 à 63 octets

-7 octets merci @Veskah

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

Essayez-le en ligne!

Explication:

Pour chaque caractère de l'argument splatté:

• Chaîne de sortie $xet $xvaleur vide ( rvalias pour Remove-Variable ), si le code du caractère en cours est inférieur ou équivalent ( -le) à un code du caractère précédent.
• Ajoutez des espaces et le caractère actuel à $x, stockez-le dans $x. En outre, il rafraîchit une valeur de caractère précédente.

Sortie en dernier $x.

Gelée , 24 21 octets

3 octets grâce à Erik the Outgolfer.

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

Essayez-le en ligne!

SOGL V0.12 , 22 octets

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

Essayez-le ici!

JavaScript (ES6), 87 octets

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

Accepte les majuscules ou les minuscules. La sortie correspond à la casse de l'entrée.

Des 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 octets

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

Sauvé 1 octet grâce à Laikoni !

Essayez-le en ligne.

Optimisations de Haskell Hugs

1. L'interpréteur Hugs me permet de sauvegarder un octet de plus en faisant (!cycle$['A'..'Z']++"\n")plutôt (!cycle(['A'..'Z']++"\n"))que :, mais GHC n'aime pas le précédent . (Ceci est maintenant obsolète; Laikoni a déjà réécrit cette ligne de manière à économiser 1 octet.)

2. Apparemment, Hugs n’exige pas non plus de parenthèses autour de la liste des motifs de liste, ce qui me permet de sauvegarder deux octets supplémentaires allant de: q@(w:y)!(x:z)à q@(w:y)!x:z.

Python 3 , 87 85 octets

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

Essayez-le en ligne!

J , 39 octets

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

Essayez-le en ligne!

Charbon de bois , 15 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

 θ              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 octets

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

Essayez-le en ligne!

K (ngn / k) , 29 28 octets

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

Essayez-le en ligne!

{ } fonction avec argument x

>':x pour chaque personnage, est-il supérieur au précédent?

~ nier

& où (à quels indices) avons-nous vrai

( )_xcouper xà ces index, retourne une liste de chaînes

{ }' pour chacune de ces chaînes

`c$65+!26

L'alphabet anglais

x?trouver l'index de la première occurrence de chaque lettre en x, utilisez 0N(une valeur "nulle" spéciale) si non trouvé

x@index xavec ça; indexation avec des 0Nretours " ", nous obtenons donc une chaîne de longueur 26 dans laquelle les lettres xsont à leur position alphabétique et tout le reste est constitué d'espaces

R , 129 117 octets

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

Essayez-le en ligne!

Explication (non golfée):

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 octets

Parcourez simplement l'alphabet majuscule de manière répétée en faisant avancer d'un compteur de 1 si vous rencontrez la lettre dans la position de compteur du mot et en imprimant la lettre, sinon un espace.

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

Essayez-le en ligne!

GolfScript , 37 octets

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

Essayez-le en ligne!

J'ai fait un Golfscript sous un nom différent, mais la sortie était incorrecte.