Zainspirowany memem, który widziałem dzisiaj dzisiaj.

Opis wyzwania

Rozważ nieskończoną siatkę alfabetu:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
...

Weź słowo ( CODEGOLFw tym przykładzie) i uczyń z niego podsekwencję siatki, zastępując nieużywane litery spacją i usuwając litery na końcu nieskończonej siatki:

  C           O           
   DE G       O           
           L              
     F

Przykłady

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

Notatki

• Końcowe białe znaki są dozwolone.
• Nie musisz wypełniać ostatniego wiersza spacjami. Na przykład, jeśli dane wejściowe są ABC, możesz wygenerować wynik ABCbez 23 końcowych spacji.
• Możesz założyć, że dane wejściowe będą pasować do [A-Z]+wyrażenia regularnego.
• Alternatywnie możesz użyć małych liter alfabetu, w którym to przypadku wynik będzie zgodny [a-z]+.
• Należy użyć znaku nowej linii ( \n, \r\nlub odpowiednik), aby oddzielić linie, czyli listą ciągów nie jest właściwy format.
• Jest to wyzwanie dla golfistów , dlatego ustaw swój kod tak krótko, jak to możliwe!

Łuska , 15 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajtów

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 bajty dzięki @Nevay .
-7 bajtowe drukowanie bezpośrednio zamiast zwracania ciągu i konwertowanie do Java 10.

Objaśnienie: „

Wypróbuj tutaj.

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

Pierwsza część metody dzieli słowo wejściowe na części z separatorem.
Na przykład: CODEGOLF→ CO;DEGO;L;Flub BALLOON→ B;AL;LO;O;N.

Druga część zapętla się nad tymi częściami i używa wyrażenia regularnego, [^...]aby zastąpić wszystko, co nie jest spacją.
Na przykład .replaceAll("[^CO]"," ")pozostawia C, i O, i zastępuje wszystko inne spacją.

C (gcc) , 69 bajtów

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

Wypróbuj online!

Perl 5 , 44 bajtów

40 bajtów kod + 4 dla -lF.

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

Wypróbuj online!

Python 2 , 92 bajty

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

Wypróbuj online!

JavaScript (ES6), 79

Edytuj Po zaakceptowaniu wiodącej nowej linii mogę zapisać 2 bajty

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

Dla 1 bajta więcej mogę przyjąć małe lub duże litery:

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

Mniej golfa

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
}  

Test

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 bajty

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

Używa małych liter.

Wypróbuj w MATL Online!

Wyjaśnienie

''     % 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 bajtów

-2 bajty dzięki @Shaggy

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

Tylko duże litery.

Wypróbuj online!

Wyjaśnienie

;

Przełącz na zmienne alternatywne, gdzie Bjest wielkie litery.

ò¨

Podziel wejściowy ciąg znaków na znaki, których pierwszy jest większy lub równy ( ¨) drugiemu.

£

Odwzoruj każdą partycję według funkcji, gdzie Xjest bieżąca partycja.

B®

Zamapuj każdy znak wielkimi literami na następujący, Zjako bieżącą literę.

kX

Usuń wszystkie litery z bieżącej partycji z bieżącej litery. Jeśli bieżąca litera jest zawarta w bieżącej partycji, wynikiem jest pusty ciąg.

?S:Z

Jeśli to prawda (nie pusty ciąg znaków), zwróć spację ( S), w przeciwnym razie zwróć bieżącą literę.

·

Połącz wynik poprzedniego wiersza z nowymi wierszami i wydrukuj wynik.

Pyth, 18 bajtów

#pbVGp?JqhzNNd=>zJ

Wypróbuj tutaj.

Wiodąca nowa linia w wydruku, małe litery alfabetu.

Galaretka , 19 bajtów

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

Wypróbuj online!

C (gcc), 91 63 bajtów

-28 dzięki tylko ASCII

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

Wypróbuj online!

Poprzedni:

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

Tak, istnieje krótsze rozwiązanie, ale zauważyłem po napisaniu tego ... Wypróbuj online!

Mathematica, 101 bajtów

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

Splitwkład w ściśle rosnące sekwencje liter, porównując sąsiednie litery z Order. Jeśli Order[x,y] == 1, to xpoprzedza yalfabet, a zatem może pojawić się w tym samym wierszu.

Dla każdej sekwencji liter utwórz wzór dopasowujący ciągi znaków Exceptdla tych liter; #|##jest skrótem od Alternatives. Zastąp litery Alphabetpasujące do wzoru spacjami.

Ilustracja pośrednich kroków:

"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 bajtów

Wypróbuj online!

-1 bajt dzięki starannemu ostatecznemu przedefiniowaniu nwbudowanego.

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

Objaśnienie (z nieco inną wersją):

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

Siatkówka , 80 bajtów

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

Wypróbuj online!

Zawsze jest dokładnie jedna wiodąca nowa linia. Kod nieco niezdarnie poprzedza słowo alfabetem wraz ze znacznikiem (średnikiem). Następnie przesuwa znacznik do pierwszej litery słowa, zmieniając wszystkie pozostałe litery, które przechodzi w spacje. Usuwa również pierwszą literę słowa. Powtarza to, dopóki pierwsza litera słowa nie jest już za znacznikiem. Następnie usuwa znacznik i resztę alfabetu i zastępuje go nową linią, a alfabet ponownie znacznikiem. Powtarza to, dopóki słowo wejściowe nie będzie puste, a następnie czyści ostatni alfabet i znacznik, pozostawiając pożądany wynik.

05AB1E , 18 bajtów

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

Wypróbuj online!

Wystąpił problem z 05AB1E ć(ekstrakt 1) pozostawiającym pusty ciąg / listę na stosie po wyodrębnieniu ostatniego elementu. To rozwiązanie byłoby o 1-2 bajty krótsze, gdyby nie to.

ć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

Siatkówka , 130 126 bajtów

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

Wypróbuj online! Edycja: Zapisano 4 bajty za pomocą generatora alfabetów @ MartinEnder. Wyjaśnienie:

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

Dołącz alfabet.

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

Dopasuj jak najwięcej liter do ich pozycji w alfabecie.

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

Rozpocznij nowy wiersz przed pierwszą literą, której nie można wyrównać.

}`¶.*$

Usuń alfabet, ale następnie zrób wszystko od nowa, dopóki nie będzie żadnych niepoprawnych liter.

q / kdb + , 48 45 bajtów

Rozwiązanie:

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

Wypróbuj online!

Uwaga: Link jest do K (oK) portu tego rozwiązania, ponieważ nie ma TIO dla q / kdb +.

Przykłady:

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

Wyjaśnienie:

Q jest interpretowane od prawej do lewej. Rozwiązanie jest podzielone na dwie części. Najpierw podziel ciąg, w którym następny znak jest mniejszy lub równy bieżącemu:

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

Następnie weź ciąg 26 pustych pól i zastosuj dane wejściowe przy indeksach, w których dane wejściowe pojawiają się w alfabecie, i wypisz na standardowe wejście.

"__________________________" -> __________________ST______

Awaria:

-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

Uwagi:

• -3 bajty poprzez zastąpienie poprzedniej wersją K4

PowerShell, 70 63 bajtów

-7 bajtów dzięki @Veskah

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

Wypróbuj online!

Wyjaśnienie:

Dla każdego znaku w rozproszonym argumencie:

• Łańcuch wyjściowy $xi $xwartość rvzerowa ( to alias dla zmiennej usuwania ), jeśli kod bieżącego znaku jest mniejszy lub równoważny ( -le) kodowi poprzedniego znaku.
• Dodaj spacje i bieżący znak do $x, zapisz go $x. Odświeża również poprzednią wartość postaci.

Wyjście ostatnie $x.

Galareta , 24 21 bajtów

3 bajty dzięki Erikowi Outgolferowi.

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

Wypróbuj online!

SOGL V0.12 , 22 bajty

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

Wypróbuj tutaj!

JavaScript (ES6), 87 bajtów

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

Akceptuje wprowadzanie wielkich lub małych liter. Dane wyjściowe są zgodne z wielkością danych wejściowych.

Testy

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 bajty

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

Zaoszczędzono 1 bajt dzięki Laikoni !

Wypróbuj online.

Optymalizacje Haskell Hugs

1. Interpreter uścisków pozwala mi zaoszczędzić jeszcze jeden bajt, wykonując (!cycle$['A'..'Z']++"\n")zamiast :,(!cycle(['A'..'Z']++"\n")) ale GHC nie lubi tego pierwszego . (To jest teraz przestarzałe; Laikoni przepisał już tę linię w sposób, który oszczędził 1 bajt.)

2. Najwyraźniej uściski również nie wymagają nawiasów wokół dopasowywania wzorca listy, więc mogłem zapisać dwa kolejne bajty od: q@(w:y)!(x:z)do q@(w:y)!x:z.

Python 3 , 87 85 bajtów

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

Wypróbuj online!

J , 39 bajtów

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

Wypróbuj online!

Węgiel drzewny , 15 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

 θ              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 bajtów

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

Wypróbuj online!

K (ngn / k) , 29 28 bajtów

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

Wypróbuj online!

{ } funkcja z argumentem x

>':x dla każdego znaku, czy jest większy niż poprzedni znak?

~ negować

& gdzie (przy jakich indeksach) mamy prawdę

( )_xwycięte xprzy tych indeksach, zwróć listę ciągów

{ }' dla każdego z tych ciągów

`c$65+!26

angielski alfabet

x?znajdź indeks pierwszego wystąpienia każdej litery w x, użyj 0N(specjalnej wartości „null”), jeśli nie zostanie znaleziona

x@indeksuj xz tym; indeksowanie ze 0Nzwrotami " ", więc otrzymujemy ciąg o długości 26, w którym litery z xsą na swoich pozycjach alfabetycznych, a wszystko inne to spacje

R , 129 117 bajtów

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

Wypróbuj online!

Objaśnienie (bez golfa):

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 bajtów

Wystarczy kilka razy przewijać wielkie litery, przesuwając licznik o 1, jeśli napotkasz literę w pozycji przeciwnej słowa i wydrukujesz literę, w przeciwnym razie spację.

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

Wypróbuj online!

GolfScript , 37 bajtów

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

Wypróbuj online!

Zrobiłem Golfscript pod inną nazwą, ale miał niepoprawny wynik.