Dopasuj słowo do siatki alfabetu

55

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 , dlatego ustaw swój kod tak krótko, jak to możliwe!
shooqie
źródło
Czy dozwolone są nowe linie?
Erik the Outgolfer
@EriktheOutgolfer Pewnie, o ile nie psuje struktury siatki.
shooqie,
Czy byłoby dobrze, gdyby błąd nie powodujący błędu krytycznego zatrzymał program?
Zacharý
@ Zacharý Chociaż widzę, jak to może zaoszczędzić niektóre bajty, myślę, że jest brzydki i wytwarza niepożądane, zbędne dane wyjściowe. Więc nie. EDYCJA: Chyba że możesz sprawić, że twój program nie zakończy się fatalnie poprzez kod wyjścia lub coś, co nie wydrukuje śladu stosu wyjątków lub coś podobnego do stderr.
shooqie,
7
Sugerowany przypadek testowy: BALLOON(dwa sąsiednie znaki, które są takie same).
Kevin Cruijssen

Odpowiedzi:

10

Ł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.
Zgarb
źródło
7

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: CODEGOLFCO;DEGO;L;Flub BALLOONB;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ą.

Kevin Cruijssen
źródło
1
Nie byłoby B;AL;LO;O;N?
NieDzejkob
1
-2 bajtów: for(char c:s)x+=p<(p=c)?c:";"+c;.
Nevay
4

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!

Dom Hastings
źródło
Link, który opublikowałeś, dotyczy wersji 46 bajtów.
@ThePirateBay Thanks !! Wiedziałem, że czegoś nie zaktualizowałem!
Dom Hastings,
4

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>

edc65
źródło
Możesz zamienić na \ndosłowny znak nowej linii w backtickach dla -1 bajtów.
Justin Mariner
@JustinMariner nie, nie mogę, nie w podwójnym cytacie w eval
edc65
No tak, szkoda. Mój błąd.
Justin Mariner,
4

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
Luis Mendo
źródło
4

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.

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.

Justin Mariner
źródło
10 bajtów r"[^{Z}]"Swydaje się nieco niedorzeczne, ale nie mogę też znaleźć lepszego sposobu ...
ETHproductions
17 bajtów
Shaggy
16 bajtów
Shaggy,
@Shaggy Dobre myślenie z kX!
Justin Mariner
Właściwie myślę, że możesz zmienić, kX ?S:Zaby oX ªSzapisać dwa bajty
ETHprodukcje
3

Pyth, 18 bajtów

#pbVGp?JqhzNNd=>zJ

Wypróbuj tutaj.

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

Erik the Outgolfer
źródło
3

Galaretka , 19 bajtów

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

Wypróbuj online!

Erik the Outgolfer
źródło
OI<1®;-> >2\0;aby zaoszczędzić jeden bajt (faktycznie zrobiłem też >2\0;œṗµØAf€ȯ€⁶µ€Ydla 18, które osobiście uważam za łatwiejsze do przeanalizowania)
Jonathan Allan
@JonathanAllan Myślę, że to by się nie udało BALLOONlub coś.
Erik the Outgolfer,
Masz rację, tak - wymagałoby to kolejnego bajtu z czymś takim <2\1;¬; No cóż.
Jonathan Allan
@JonathanAllan W każdym razie zrealizuję twój pomysł w mojej odpowiedzi ... gotowe.
Erik the Outgolfer,
3

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!

MD XF
źródło
82 bajty , 80, jeśli dozwolone jest wprowadzanie nowej linii
tylko ASCII
73
Tylko ASCII,
63
Tylko ASCII
3

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"," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "}}
hftf
źródło
2

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
Josiah Winslow
źródło
2

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.

FryAmTheEggman
źródło
2

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
szkocki
źródło
W rzeczywistości ð,oznacza „wydrukuj spację i nowy wiersz”.
Erik the Outgolfer,
Masz rację. Naprawiono wyświetlanie kodu nowej linii.
scottinet
2

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.

Neil
źródło
Wydaje się, że drukuje tylko jedną linię, nie wyrównując liter w kolejnych liniach.
Justin Mariner,
@JustinMariner Mój zły, zrobiłem literówkę w ostatnim golfie i nie sprawdziłem go poprawnie.
Neil
2

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
streetster
źródło
2

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.

mazzy
źródło
1
63 Bajty za pomocą rozpryskiwania . Próbowałem użyć, |% *htaby zapisać niektóre bajty, ale wygląda na to, że nawet się zepsuł.
Veskah
1

Galareta , 24 21 bajtów

3 bajty dzięki Erikowi Outgolferowi.

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

Wypróbuj online!

Leaky Nun
źródło
8
Wierzę, że to się nie powiedzie dla wejścia „BALLOON” - powtarzające się znaki są w tym samym wierszu.
Justin Mariner,
1

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

Justin Mariner
źródło
1

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.

Cristian Lupascu
źródło
Możesz zapisać bajt za pomocą a=['A'..'Z']++'\n':a;(!a). Interesujące jest to, że Uściski wydają się mieć nieco luźniejsze zasady.
Laikoni
@Laikoni Patrzę na Haskella od miesięcy i nie przestaje mnie to zadziwiać. Uwielbiam a=...:asztuczkę. Dzięki!
Cristian Lupascu,
Nie wiem, czy zdajesz sobie z tego sprawę, ale myślę, że warto o tym wspomnieć. Powodem, dla którego Uściski są inne, jest to, że operator zdefiniowany przez użytkownika ma niższy priorytet niż w ghc.
Wheat Wizard
@WheatWizard Nie byłem świadomy. Ma to sens, biorąc pod uwagę błąd, który dostałem w GHC.
Cristian Lupascu,
1

Węgiel drzewny , 15 bajtów

Fθ«J⌕αι⁺ⅉ‹⌕αιⅈι

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

 θ              Input string
F «             Loop over characters
     α     α    Uppercase letters predefined variable
      ι     ι   Current character
    ⌕     ⌕     Find index
             ⅈ  Current X co-ordinate
         ‹      Compare
        ⅉ       Current Y co-ordinate
       ⁺        Sum
   J            Jump to aboslute position
              ι Print current character
Neil
źródło
1

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

ngn
źródło
1

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.
Giuseppe
źródło
1

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!

J.Doe
źródło