Geben Sie eine Zeichenfolge als Eingabe ein und drucken Sie eine neue Zeichenfolge, wobei jeder Buchstabe durch den jeweiligen Alphabetindex nach rechts verschoben wird.

Wir alle wissen, dass A ein langsamer und Z ein schneller Buchstabe ist. Dies bedeutet, dass Z um 25 Felder nach rechts verschoben wird, A überhaupt nicht und B um 1 Feld verschoben wird.

Ihr Programm muss nur Großbuchstaben von AZ und keine anderen Zeichen, keine Leerzeichen und keine Interpunktion verarbeiten.

Beachten Sie, dass das neueste Zeichen verwendet wird, wenn zwei oder mehr Buchstaben nach dem Verschieben auf die gleiche Stelle fallen. (Beispiel: BA->  A)

Beispiele

"AZ" -> "A                         Z"

"ABC" -> "A B C"

"ACE" -> "A  C  E"

"CBA" -> "  A"

"HELLOWORLD" -> "     E H    DLL   OLO   R  W"

Regeln

• Das ist Code-Golf , also gewinnt der kürzeste Code in einem Sprachbyte.

• Standardlücken sind verboten.

• Die Eingabe muss als Zeichenfolge empfangen werden.

• Sie können das Ergebnis ausdrucken stdoutoder eine Zeichenfolge zurückgeben.
• Ein einzelnes abschließendes Leerzeichen und / oder eine neue Zeile ist zulässig.
• Sie können auch Kleinbuchstaben als Eingabe oder Ausgabe verwenden, jedoch nur Groß- und Kleinschreibung.

Python 2 , 81 Bytes

t=[]
i=65
for c in input():t+=[' ']*26;t[ord(c)-i]=c;i-=1
print`t`[2::5].rstrip()

Probieren Sie es online!

MATL , 11 Bytes

''jtfy65-+(

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Die MATL-Indizierung basiert auf 1. Dieser Golftrick wird hier verwendet. Dieser andere kann nicht verwendet werden, da wir eine leere Zeichenfolge und kein leeres numerisches Array benötigen.

Betrachten Sie die Eingabe 'ACE'als Beispiel. Der Stapelinhalt wird von unten nach oben angezeigt.

''     % Push empty string
       %   Stack: ''
j      % Input string
       %   Stack: '', 'ACE'
t      % Duplicate
       %   Stack: '', 'ACE', 'ACE'
f      % Indices of nonzero entries. Gives [1 2 ... n] where n is input length
       %   Stack: '', 'ACE', [1 2 3]
y      % Duplicate from below
       %   Stack: '', 'ACE', [1 2 3], 'ACE'
65     % Push 65
       %   Stack: '', 'ACE', [1 2 3], 'ACE', 65
-      % Subtract, element-wise. Characters are converted to codepoints
       %   Stack: '', 'ACE', [1 2 3], [0 2 4]
+      % Add, element-wise
       %   Stack: '', 'ACE', [1 4 7]
(      % Fill string '' with values 'ACE' at positions [1 4 7]. The original
       % empty string is extended. Non-existing values are filled with char 0,
       % which is displayed as space. Implicitly display
       %   Stack: 'A  C  E'

R , 140 133 129 74 Bytes

Es wurden eine Menge Bytes gespeichert, die wie alle anderen einen ASCII-Werteansatz portierten. Traurig, dass ich vorher nicht daran gedacht habe :(

function(s){F[X-65+1:sum(X|1)]=X=utf8ToInt(s)
F[is.na(F)]=32
intToUtf8(F)}

Probieren Sie es online!

ursprüngliche Antwort, 129 Bytes:

function(s){o=rep(' ',(n=nchar(s))+25)
for(i in 1:n){k=substr(s,i,i)
o[x<-i+match(k,LETTERS)-1]=k
F=max(F,x)}
cat(o[1:F],sep='')}

Probieren Sie es online!

generiert eine zu lange Liste ovon Leerzeichen, durchläuft sie dann s, ersetzt die Werte odurch den richtigen Wert und aktualisiert Fdie Position des am weitesten rechts stehenden Zeichens. Druckt dann die ersten FElemente oohne Trennzeichen aus.

05AB1E , 20 16 Bytes

-4 Bytes dank Emigna

ð₄×svyAuykN+ǝ}ðÜ

Probieren Sie es online!

JavaScript (ES6), 81 Byte

s=>[...s].map((c,i)=>a[i+parseInt(c,36)-10]=c,a=[])&&[...a].map(c=>c||" ").join``

Etwas baut auf Rick Hitchcocks unvollständiger Antwort auf , endete jedoch etwas anders.

Platziert die Zeichen in den entsprechenden Index eines leeren Arrays und [...a]verwandelt die fehlenden Elemente mithilfe von array spread ( ) in undefined, sodass mapleere Elemente durch ein Leerzeichen ersetzt werden können.

Testfälle

let f=
s=>[...s].map((c,i)=>a[i+parseInt(c,36)-10]=c,a=[])&&[...a].map(c=>c||" ").join``

;["AZ", "ABC", "ACE", "CBA", "HELLOWORLD"]
.forEach(t=>console.log(`"${t}"`, "=>", `"${f(t)}"`))

Perl 5, 42 Bytes

41 Byte Code + 1 für -p. Die \x1bs im Code sind wörtliche Escapezeichen.

Verlässt sich auf ANSI-Escape-Sequenzen, um den Cursor zu positionieren, und funktioniert daher nicht bei TIO.

s/./($-=-65+ord$&)?"\x1b[$-C$&\x1b[--$-D":$&/ge

Verwendungszweck

perl -pe 's/./($-=-65+ord$&)?"\x1b[$-C$&\x1b[--$-D":$&/ge' <<< 'HELLOWORLD'
     E H    DLL   OLO   R  W

Java (OpenJDK 8) , 207 191 189 183 178 174 173 170 Bytes

s->{char i=0,l,c[]=new char[s.chars().map(j->j+s.lastIndexOf(j)).max().getAsInt()-64];for(;i<s.length();c[i+l-66]=l)l=s.charAt(i++);return"".valueOf(c).replace('',' ');}

Probieren Sie es online!

Perl 5 , 41 + ( -F) = 43 Bytes

map$r[$i++-65+ord]=$_,@F;print$_||$"for@r

Probieren Sie es online!

Nur für @lynn

Brainfuck , 127 Bytes

,[[-<+<+>>]----[----<<->>]<<-[[>]>++++>[-<[-]<+>>]<[-<++++++++>]<[<]>-]>[>]<[-]+[<]>-[[>]<+[<]>-]>.[-]>[>]<[[->>+<<]<]>,]>>[.>]

Probieren Sie es online!

Erläuterung

,[                    Take input and start main loop
  [-<+<+>>]             Make two copies of input byte
  ----[----<<->>]<<-    Subtract 64 from one of them to get position in alphabet

                        There are two zero cells between the input and the
                        remaining output cells; we wish to move these zeroes
                        to indicate where the letter is to be moved

  [                     A number of times equal to the position in the alphabet:
    [>]                   Go to current position in output string
    >++++>                Create 4 (as part of creating a space if needed)
    [-<[-]<+>>]           Move output byte back two cells; zero the previous 4 if output existed
    <[-<++++++++>]        Otherwise move a space (32) into that position
    <[<]>-                Move back to counter and decrement
  ]
  >[>]<[-]              Delete last moved byte to make room for input byte
  +[<]>-                Initialize slot at 1 so it is always nonzero in this loop
  [[>]<+[<]>-]          Move input byte into slot
  >.[-]                 Output next output byte and clear
  >[>]<                 Move to space vacated in preparation to remove gap
                        (Moves to end instead if input was A; this causes no problems)
  [[->>+<<]<]           Move values two cells right until zero reached
  >,                    Get into position and take another byte of input
]
>>[.>]                Output characters beyond end of input

Proton , 78 Bytes

x=>{t=[' ']*26*(q=len(x))for i:0..q{t[i+ord(k=x[i])-65]=k}"".join(t).rstrip()}

Probieren Sie es online!

69 Bytes durch Portierung von Lynns Lösung: x=>{t=[]i=65for k:x{t+=[' ']*26t[ord(k)-i]=k;i--}"".join(t).rstrip()}

Gelee , 20 Bytes

ØAiЀ+JṬ€a"⁸Zḟ€0Ṫ€o⁶

Probieren Sie es online!

Haskell , 90 88 Bytes

d=drop 1
[a]#s|s<"A"=a:d s|0<1=s
b#s=(s++" ")!!0:d b#d s
f(c:t)=['A'..c]#(' ':f t)
f s=s

Probieren Sie es online!

Japt , 23 Bytes

;iB ç
Ng £=hX10nY+XnG
U

Online testen!

Erster Versuch, vielleicht verbesserungsfähig ...

Wolfram Language (Mathematica) , 76 Byte

SparseArray[Reverse@MapIndexed[#&@@#2+LetterNumber@#-1->#&,#]]<>""/. 0->" "&

Nimmt eine Liste von Zeichen als Eingabe. Dadurch werden einige Fehlermeldungen generiert, die ignoriert werden können.

Ich habe Printund CharacterBefehl in der Fußzeile des TIO-Links für die Benutzerfreundlichkeit. ( CharacterBefehl konvertiert einfach einen String in eine Liste von Zeichen)

Probieren Sie es online!

J, 37 31 Bytes

[`]`(' '#~(1+>./)@])}(i.@#+65-~a.&i.)

[`]`(' '#~(1+>./)@])}#\-66-3&u:

-6 Bytes dank FrownyFrog

Erläuterung

Das Ganze ist ein Haken:

[`]`(' '#~(1+>./)@])}  #\-66-3&u:

Die rechte Seite berechnet die neuen Indizes für alle Buchstaben.

Die linke Seite verwendet die gerund Form ändert }zunächst eine Reihe von der notwendigen Anzahl von Räumen zu erzeugen: (' '#~(1+>./)@]). Und dann, um jeden Buchstaben der ursprünglichen Zeichenfolge in den entsprechenden Index innerhalb der All-Space-Zeichenfolge einzufügen.

Probieren Sie es online!

Haskell , 88 Bytes

foldr(\c->(((['B'..c]>>" ")++[c])#).(' ':))[]
(x:r)#(y:t)|y>' '=y:r#t|1<3=x:r#t
r#t=r++t

Probieren Sie es online!

Haskell, 88 Bytes

f s|q<-zipWith((+).fromEnum)s[0..]=[last$' ':[c|(c,i)<-zip s q,i==p]|p<-[65..maximum q]]

Probieren Sie es online!

qist die Liste der letzten Indizes der Buchstaben der Eingabezeichenfolge (mit einem Offset von 65). Durchlaufen Sie alle Indizes (beginnend bei 65) und suchen Sie alle Buchstaben, wobei Sie ein Leerzeichen voranstellen. Nimm den letzten.

C # (.NET Core) , 117 110 84 Bytes

7 Bytes gespart dank Ayb4tu .

Der Rückgabetyp wurde von stringauf geändert char[], um 26 Byte zu sparen.

n=>{int i=0,l=n.Length;var t=new char[l+26];for(;i<l;)t[i+n[i]-65]=n[i++];return t;}

Probieren Sie es online!

C # .NET, 89 Bytes 87 Bytes

-2 Bytes dank Lan H.

f=>{var s=new char[f.Length+26];for(int i=0;i<f.Length;i++)s[f[i]+i-65]=f[i];return s;}

Probieren Sie es online!

Kotlin, 207 Bytes 189 Bytes 187 Bytes 177 Bytes

fun main(){val i=(readLine()+" ".repeat(26)).toCharArray();for(x in(i.size-1) downTo 0){if(i[x]!=' '){i[x+i[x].toInt()-65]=i[x];i[x]=' '}};print(i.joinToString("").trim())}

Wenn das führende Leerzeichen bleiben soll, würde ich einfach anrufen trimEnd()anstatt trim().

Nicht abgeschlossen:

fun main() {
    val m = (readLine() + " ".repeat(26)).toCharArray()
    for (x in (m.size - 1) downTo 0) {
        if(m[x] != ' ') {
            m[x + m[x].toInt() - 65] = m[x]
            m[x] = ' '
        }
    }

    print(m.joinToString("").trim())
}

Vielleicht ist Kotlin nicht die beste Sprache für Code-Golf, aber ich mochte die Herausforderung und wollte mich mit Kotlins Standardbibliothek vertraut machen.

q / kdb + 37 Bytes

Lösung:

@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:

Beispiele:

q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"AZ"
"A                         Z"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"ABC"
"A B C"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"ACE"
"A  C  E"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"CBA"
"  A"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"HELLOWORLD"
"     E H    DLL   OLO   R  W"

Erläuterung:

Ich denke, dies ist die gleiche Idee wie die J-Lösung, berechnen Sie die richtigen Indizes für das Eingabearray und weisen Sie sie dann einer leeren Zeichenfolge mit der richtigen Länge zu:

@[max[1+m]#" ";m:til[count x]+.Q.A?x;:;]x: / ungolfed solution
                                        x: / save input as x
@[            ;                     ; ;]   / apply[variable;indices;function;parameters]
                                     :     / assignment
                              .Q.A?x       / location of x in uppercase alphabet
                             +             / added to
                     count x               / length of input
                 til[       ]              / range, 0..n
               m:                          / save as m
  max[   ]                                 / maximum of list
      1+m                                  / m + 1
          #" "                             / take " ", creates empty character list

Jq 1,5 , 91 Bytes

reduce(explode|[.,keys]|transpose[]|.[1]+=.[0]-65)as[$c,$p]([];.[$p]=$c)|map(.//32)|implode

Erweitert

  reduce(  explode         # convert string to array of ordinals
         | [.,keys]        # [ [v0,v1,...], [0,1,2,...] ]
         | transpose[]     # [ [v0,0], [v1,1], [v2,2]...]
         | .[1]+=.[0]-65   # adjust position of each value
  ) as[$c,$p] (
    []
  ; .[$p]=$c               # store each value at its position
  )
| map(.//32)               # map null values to spaces
| implode                  # convert back to string

Probieren Sie es online!

Kohle , 16 Bytes

Ｐ ＦＳ«Ｍ⌕αι→ιＭ⌕αι←

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

Ｐ                   Output a space to force the indent
   Ｓ                Input string
  Ｆ «               Loop over each letter
       α            Uppercase letters predefined variable
      ⌕ ι           Find index of current letter
     Ｍ   →          Move that many characters right
          ι         Implicitly print the current letter
           Ｍ⌕αι←    Move the same number of characters left

APL (Dyalog) , 26 Bytes

Anonymes Präfix Lambda, das die Eingabezeichenfolge als Argument verwendet und die Ausgabezeichenfolge zurückgibt. Angenommen ⎕IO( I ndex O rigin) 0, was auf vielen Systemen Standard ist.

{⍵@i⊢''↑⍨1+⌈/i←(⎕A⍳⍵)+⍳≢⍵}

Probieren Sie es online!

{… } Anonymes Lambda; ⍵repräsentiert das Argument

 ≢⍵ Zusammenfassung des Arguments

 ⍳ als viele Zahlen (0… LengthOfArgument-1)

 (… )+ Plus:

  ⎕A⍳⍵ die Indizes des Arguments in Großbuchstaben A lphabet

 i← einlagern i(für i ndices)

 ⌈/ Maximum (Reduzierung)

 1+ füge eins hinzu

 ''↑⍨ Nehmen Sie so viele Zeichen aus der leeren Zeichenfolge und füllen Sie sie nach Bedarf mit Leerzeichen auf

 ⊢ ergeben, dass (dient zur Trennung ivon '')

 ⍵@i ändern Sie dies mit den Argumentationsbuchstaben an den iIndizes

SOGL V0.12 , 10 Bytes

ā,{ZFWē+1ž

Probieren Sie es hier aus!

Erläuterung:

ā           push an empty array
 ,{         for each char in the input
   ZFW        get its index in the uppercase alphabet
      ē+      add to that the 0-indexed counter
        1ž    at [pop; 1] insert in the array the current character

Pyth , 44 38 Bytes

_{Durchgestrichen 44 ist immer noch 44 :(}

Bloody Pyth Anfänger.

6 Bytes gespart dank @Mr. Xcoder.

K*d+lz26Vlz K=XK-C@zN-65N@zN;.WqeHdPZK

Probieren Sie es online!

Wie?

K*d+lz26Vlz K=XK-C@zN-65N@zN;.WqeHdPZK          Full program

K*d+lz26                                        Assign a string consisting of 
                                                  (26 + input.length) whitespaces to K
        Vlz                                     For-loop from 0 to input.length
                -C@zN-65N                       Calculate the index for the current letter
                         @zN                    The current letter
            K=XK                                Insert the current letter into K at
                                                  position i
                            ;                   End statement
                             .WqeHdPZK          While the last character of H is not a 
                                                  whitespace, pop the last character off K

Batch, 418 331 Bytes

Funktioniert nur mit Großbuchstaben und dauert einige Sekunden für längere Zeichenfolgen.

Neue Tricks erlernt man hier, die Zeichen in ASCII-Werte umzuwandeln %=exitcodeAscii%. Auch if definedund "Array" Zugriff mit call. Das Golfen mit fast 100 Bytes war auch ein gutes Batchcode-Golftraining.

Beachten Sie das nachfolgende Leerzeichen in set z=set.

@echo off
setlocal EnableDelayedExpansion
set z=set 
%z%a=%1
:a
%z%v=64
:b
%z%/Av+=1
cmd/Cexit %v%
if %=exitcodeAscii% neq %a:~0,1% goto b
%z%/Ao=v+c
%z%a%o%=%a:~0,1%
if %o%. geq %m%. %z%m=%o%
%z%/Ac+=1
%z%a=%a:~1%
if %a%. neq . goto a
for /l %%n in (65,1,%m%)do (
if defined a%%n (call %z%r=%%r%%%%a%%n%%
)else %z%r=!r! )
echo %r%

Ruby , 68 Bytes

->s{r,w="",-66;s.bytes{|b|r[(b+w+=1).times{|a|r[a]||=" "}]=b.chr};r}

Probieren Sie es online!

IBM PC DOS 8088 Assembly ,34 33 Bytes

b403 cd10 be80 00ad 8bc8 32ed ac8b de02 d880 ebc4 8ad3 b402 cd10 b40e cd10 e2ec c3

Ungolfed (nicht zusammengebaut):

    MOV  AH, 03H        ; get current cursor position row into DH
    INT  10H
    MOV  SI, 80H        ; point SI to PSP
    LODSW               ; fetch length into AL, increment SI to 82H
    MOV  CX, AX         ; move to CX
    XOR  CH, CH         ; clear CH
OUTPUT:
    LODSB               ; load DS:SI into AL
    MOV  BX, SI         ; input string offset into BX (so doesn't overwrite DH)
    ADD  BL, AL         ; add ASCII value of char
    SUB  BL, 'A'+83H    ; convert to numeric val (A=0, Z=25)
    MOV  DL, BL         ; DL is column number
    MOV  AH, 02H        ; BIOS set cursor position function    
    INT  10H            ; move to column
    MOV  AH, 0EH        ; BIOS display char function in AL
    INT  10H            ; write to screen
    LOOP OUTPUT
    RET                 ; return to DOS

Dies ist eine vollständige ausführbare PC-DOS-Datei, die die Eingabezeichenfolge von der Befehlszeile übernimmt und die neue "schnellere" Version auf dem Bildschirm ausgibt. Benötigt mindestens DOS 1.0 ... hoffentlich haben Sie mindestens das.

Ausgabe

A>SPEED.COM ABC
A B C
A>SPEED.COM AZ
A                         Z
A>SPEED.COM CBA
  A
A>SPEED.COM HELLOWORLD
     E H    DLL   OLO   R  W

PHP, 127 123 Bytes

function b($i){for($q=0;$q<strlen($i);$q++){$n[ord($i[$q])-65]=$i[$q];}while($x++<26){$m.=$n[$x-1]?$n[$x-1]:" ";}return$m;}

Probieren Sie es online aus

Musste einen Fehler beheben, der nicht 'A' ausgeben würde ...