Data una stringa come input, stampa una nuova stringa con ogni lettera spinta a destra dal rispettivo indice alfabetico.

Sappiamo tutti che A è un lento e Z è una lettera veloce. Ciò significa che Z viene spostato a destra di 25 spazi, A non viene spostato affatto e B viene spostato di 1 spazio.

Il tuo programma deve gestire solo lettere maiuscole dalla A alla Z, e nessun altro carattere, nessuno spazio bianco, nessuna punteggiatura.

Nota che se 2 o più lettere cadono nello stesso spazio dopo lo spostamento, verrà utilizzato l'ultimo carattere. (Esempio: BA->  A)

Esempi

"AZ" -> "A                         Z"

"ABC" -> "A B C"

"ACE" -> "A  C  E"

"CBA" -> "  A"

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

Regole

• Questo è code-golf , quindi vince il codice più breve in qualsiasi lingua byte.

• Sono vietate le scappatoie standard.

• L'input deve essere ricevuto come una stringa.

• È possibile stampare il risultato stdouto restituire una stringa.
• È consentito un singolo spazio finale e / o newline finale.
• Puoi anche usare lettere minuscole come input o output, ma usa solo entrambi i casi.

Python 2 , 81 byte

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

Provalo online!

MATL , 11 byte

''jtfy65-+(

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

L'indicizzazione MATL è basata su 1. Questo trucco da golf è usato qui. Quest'altro non può essere utilizzato perché è necessaria una stringa vuota, non una matrice numerica vuota.

Considera l'input 'ACE'come esempio. I contenuti dello stack sono mostrati dal basso verso l'alto.

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

Ho salvato una tonnellata di byte portando un approccio a valori ASCII come tutti gli altri. Triste non ci avevo pensato prima :(

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

Provalo online!

risposta originale, 129 byte:

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

Provalo online!

genera un elenco odi spazi troppo lungo , quindi scorre s, sostituendo i valori ocon il valore corretto e aggiornando Fla posizione del carattere più a destra. Quindi stampa i primi Felementi di osenza separatori tra di loro.

05AB1E , 20 16 byte

-4 byte grazie a Emigna

ð₄×svyAuykN+ǝ}ðÜ

Provalo online!

JavaScript (ES6), 81 byte

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

Si basa in qualche modo sulla risposta incompleta di Rick Hitchcock, ma è risultato piuttosto diverso.

Posiziona i caratteri nel rispettivo indice di un array vuoto, quindi utilizza array spread ( [...a]) per trasformare gli elementi mancanti in undefined, consentendo mapdi sostituire gli elementi vuoti con uno spazio.

Casi test

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 byte

41 byte codice + 1 per -p. Le \x1bs nel codice sono letteralmente caratteri di escape.

Si basa su sequenze di escape ANSI per posizionare il cursore e quindi non funziona su TIO.

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

uso

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 173 170 byte

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('',' ');}

Provalo online!

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

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

Provalo online!

Solo per @lynn

Brainfuck , 127 byte

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

Provalo online!

Spiegazione

,[                    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 byte

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

Provalo online!

69 byte eseguendo il porting della soluzione di Lynn: x=>{t=[]i=65for k:x{t+=[' ']*26t[ord(k)-i]=k;i--}"".join(t).rstrip()}

Gelatina , 20 byte

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

Provalo online!

Haskell , 90 88 byte

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

Provalo online!

Japt , 23 byte

;iB ç
Ng £=hX10nY+XnG
U

Provalo online!

Primo tentativo, potrebbe essere migliorabile ...

Wolfram Language (Mathematica) , 76 byte

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

Accetta un elenco di caratteri come input. Questo genera alcuni messaggi di errore che è possibile ignorare.

Ho incluso Printe Charactercomando nel piè di pagina del collegamento TIO per facilità d'uso. (il Charactercomando converte semplicemente una stringa in un elenco di caratteri)

Provalo online!

J, 37 31 byte

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

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

-6 byte grazie a FrownyFrog

spiegazione

L'intera cosa è un gancio:

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

Il lato destro calcola i nuovi indici per tutte le lettere.

Il lato sinistro utilizza la forma di gerundio Modificare }primo a creare una stringa del numero necessario di spazi: (' '#~(1+>./)@]). E quindi posizionare ogni lettera della stringa originale nel suo indice appropriato all'interno della stringa di tutti gli spazi.

Provalo online!

Haskell , 88 byte

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

Provalo online!

Haskell, 88 byte

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

Provalo online!

qè l'elenco degli indici finali delle lettere della stringa di input (con un offset di 65). Scorri tutti gli indici (a partire da 65) e trova tutte le lettere per esso, anteponendo uno spazio. Prendi l'ultimo.

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

Salvato 7 byte grazie a Ayb4tu .

Modificato il tipo restituito da stringa char[]per salvare 26 byte.

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;}

Provalo online!

C #. NET, 89 byte 87 byte

-2 byte grazie a 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;}

Provalo online!

Kotlin, 207 byte 189 byte 187 byte 177 byte

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

Se il vuoto iniziale dovesse rimanere, chiamerei trimEnd()invece di trim().

Unminified:

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

Forse Kotlin non è la lingua migliore per giocare a golf, ma mi è piaciuta la sfida e volevo familiarizzare con la biblioteca standard di Kotlin.

q / kdb +, 37 byte

Soluzione:

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

Esempi:

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"

Spiegazione:

Penso che questa sia la stessa idea della soluzione J, calcolare gli indici corretti per l'array di input e quindi assegnarli a una stringa vuota della lunghezza corretta:

@[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 byte

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

allargato

  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

Provalo online!

Carbone , 16 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｐ                   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 byte

Lambda prefisso anonimo che accetta la stringa di input come argomento e restituisce la stringa di output. Assume ⎕IO( I NDICE O rigine) 0, che è di default su molti sistemi.

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

Provalo online!

{... } lambda anonimo; ⍵rappresenta l'argomento

 ≢⍵ conteggio dell'argomento

 ⍳ di molti ɩ nteger (0… LengthOfArgument-1)

 (... )+ più:

  ⎕A⍳⍵ gli indici dell'argomento in maiuscolo A lphabet

 i← strore in i(per i ndices)

 ⌈/ massimo (riduzione)

 1+ Aggiungi uno

 ''↑⍨ prendi così tanti caratteri dalla stringa vuota, riempiendoli di spazi se necessario

 ⊢ resa che (serve per separarsi ida '')

 ⍵@i modificare tale argomento con le lettere agli indicii

SOGL V0.12 , 10 byte

ā,{ZFWē+1ž

Provalo qui!

Spiegazione:

ā           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 byte

_{Scolpito 44 è ancora 44 :(}

Principiante di Bloody Pyth.

6 byte salvati grazie a @Mr. Xcoder.

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

Provalo online!

Come?

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

Lotto, 418 331 byte

Funziona solo con lettere maiuscole e impiegherà alcuni secondi per stringhe più lunghe.

Ho imparato nuovi trucchi qui, usando la conversione del carattere in valore ASCII %=exitcodeAscii%. Inoltre, if definede "array" accedono usando call. Inoltre, giocare a golf di quasi 100 byte è stato un buon allenamento di golf con codice batch.

Nota lo spazio finale 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%

Rubino , 68 byte

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

Provalo online!

IBM PC DOS 8088 Assembly ,34 33 byte

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

Ungolfed (non assemblato):

    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

Questo è un eseguibile completo per PC DOS che prende la stringa di input dalla riga di comando e stampa la nuova versione "più veloce" sullo schermo. Richiede un minimo di DOS 1.0 ... speriamo che tu abbia almeno quello.

Produzione

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 byte

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;}

Provalo online

Ho dovuto correggere un bug che non avrebbe prodotto 'A' ...