Dada una cadena como entrada, imprima una nueva cadena con cada letra empujada hacia la derecha por su índice alfabético respectivo.

Todos sabemos que A es lenta y Z es una letra rápida. Esto significa que Z se desplaza hacia la derecha 25 espacios, A no se desplaza en absoluto y B se desplaza 1 espacio.

Su programa solo tiene que manejar letras mayúsculas de AZ y no otros caracteres, espacios en blanco ni signos de puntuación.

Tenga en cuenta que si 2 o más letras caen en el mismo espacio después del cambio, se utilizará el último carácter. (Ejemplo: BA->  A)

Ejemplos

"AZ" -> "A                         Z"

"ABC" -> "A B C"

"ACE" -> "A  C  E"

"CBA" -> "  A"

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

Reglas

• Este es el código de golf , por lo que gana el código más corto en cualquier idioma.

• Las lagunas estándar están prohibidas.

• La entrada debe recibirse como una cadena.

• Puede imprimir el resultado stdouto devolver una cadena.
• A solo se permite con espacios en blanco y / o salto de línea.
• También puede usar letras minúsculas como entrada o salida, pero solo use cualquier caso.

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

Pruébalo en línea!

MATL , 11 bytes

''jtfy65-+(

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

La indexación de MATL está basada en 1. Este truco de golf se usa aquí. Este otro no se puede usar porque necesitamos una cadena vacía, no una matriz numérica vacía.

Considere la entrada 'ACE'como un ejemplo. El contenido de la pila se muestra de abajo hacia arriba.

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

Ahorró una tonelada de bytes portando un enfoque de valor ASCII como todos los demás. Triste no lo pensé antes :(

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

Pruébalo en línea!

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

Pruébalo en línea!

genera una lista ode espacios demasiado larga , luego itera s, reemplaza los valores ocon el valor correcto y actualiza Fla posición del carácter más a la derecha. Luego imprime los primeros Felementos osin separadores entre ellos.

05AB1E , 20 16 bytes

-4 bytes gracias a Emigna

ð₄×svyAuykN+ǝ}ðÜ

Pruébalo en línea!

JavaScript (ES6), 81 bytes

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

Algo se basa en la respuesta incompleta de Rick Hitchcock, pero terminó siendo bastante diferente.

Coloca los caracteres en su índice respectivo de una matriz vacía, luego usa la distribución de matriz ( [...a]) para convertir los elementos que faltan undefined, permitiendo mapreemplazar los elementos vacíos con un espacio.

Casos de prueba

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

Código de 41 bytes + 1 para -p. Las \x1bs en el código son caracteres de escape literales.

Se basa en secuencias de escape ANSI para posicionar el cursor y, por lo tanto, no funciona en 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 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('',' ');}

Pruébalo en línea!

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

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

Pruébalo en línea!

Solo para @lynn

brainfuck , 127 bytes

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

Pruébalo en línea!

Explicación

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

Protón , 78 bytes

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

Pruébalo en línea!

69 bytes portando la solución de Lynn: x=>{t=[]i=65for k:x{t+=[' ']*26t[ord(k)-i]=k;i--}"".join(t).rstrip()}

Jalea , 20 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Japt , 23 bytes

;iB ç
Ng £=hX10nY+XnG
U

¡Pruébelo en línea!

Primer intento, puede ser mejorable ...

Wolfram Language (Mathematica) , 76 bytes

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

Toma una lista de caracteres como entrada. Esto genera algunos mensajes de error que son seguros de ignorar.

Incluí Printy Charactercomando en el pie de página del enlace TIO para facilitar su uso. (el Charactercomando simplemente convierte una cadena en una lista de caracteres)

Pruébalo en línea!

J, 37 31 bytes

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

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

-6 bytes gracias a FrownyFrog

explicación

Todo es un gancho:

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

El lado derecho calcula los nuevos índices para todas las letras.

El lado izquierdo usa el gerundio de enmendar }primero en crear una cadena del número necesario de espacios: (' '#~(1+>./)@]). Y luego colocar cada letra de la cadena original en su índice apropiado dentro de la cadena de todo el espacio.

Pruébalo en línea!

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

Pruébalo en línea!

Haskell, 88 bytes

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

Pruébalo en línea!

qes la lista de los índices finales de las letras de la cadena de entrada (con un desplazamiento de 65). Recorra todos los índices (comenzando en 65) y encuentre todas las letras para ello, anteponiendo un espacio. Toma el último.

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

Guardado 7 bytes gracias a Ayb4tu .

Se cambió el tipo de retorno de stringa char[]para guardar 26 bytes.

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

Pruébalo en línea!

C # .NET, 89 bytes 87 bytes

-2 bytes gracias 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;}

Pruébalo en línea!

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

Si el espacio en blanco inicial permaneciera, simplemente llamaría en trimEnd()lugar de trim().

No minificado:

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

Tal vez Kotlin no sea el mejor lenguaje para el golf de código, pero me gustó el desafío y quería familiarizarme más con la biblioteca estándar de Kotlin.

q / kdb +, 37 bytes

Solución:

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

Ejemplos:

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"

Explicación:

Creo que esta es la misma idea que la solución J, calcule los índices correctos para la matriz de entrada y luego asígnelos a una cadena vacía de longitud correcta:

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

Expandido

  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

Pruébalo en línea!

Carbón , 16 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｐ                   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

Prefijo anónimo lambda que toma la cadena de entrada como argumento y devuelve la cadena de salida. Asume ⎕IO( I ndex O rigin) 0, que es por defecto en muchos sistemas.

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

Pruébalo en línea!

{... } lambda anónimo; ⍵representa el argumento

 ≢⍵ cuenta del argumento

 ⍳ que muchos dedos (0 ... LengthOfArgument-1)

 (... )+ más:

  ⎕A⍳⍵ los índices de la discusión en mayúscula Un alfabeto

 i← Strore in i(para i ndices)

 ⌈/ máximo (reducción)

 1+ Agrega uno

 ''↑⍨ tomar tantos caracteres de la cadena vacía, rellenando con espacios según sea necesario

 ⊢ rendimiento que (sirve para separar ide '')

 ⍵@i enmendar eso con las letras de argumento en los iíndices

SOGL V0.12 , 10 bytes

ā,{ZFWē+1ž

Pruébalo aquí!

Explicación:

ā           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

_{Tachado 44 sigue siendo 44 :(}

Bloody Pyth principiante.

Guardado 6 bytes gracias a @Mr. Xcoder

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

Pruébalo en línea!

¿Cómo?

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

Lote, 418 331 bytes

Funciona solo con letras mayúsculas y tomará algunos segundos para cadenas más largas.

Aprendí nuevos trucos aquí, el personaje a la conversión de valor ASCII %=exitcodeAscii%. Además, if definedy el acceso "matriz" mediante call. Además, el golf en casi 100 bytes fue un buen entrenamiento de golf por código de lote.

Tenga en cuenta el espacio final en 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}

Pruébalo en línea!

Ensamblaje IBM PC DOS 8088 ,34 33 bytes

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

Sin golf (sin montar):

    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

Este es un ejecutable completo de PC DOS que toma la cadena de entrada de la línea de comando e imprime la nueva versión "más rápida" en la pantalla. Requiere un mínimo de DOS 1.0 ... espero que al menos tenga eso.

Salida

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

Pruébalo en línea

Tuve que arreglar un error que no mostraba 'A' ...