La velocidad de las letras


43

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

El espacio en blanco al final está bien?
Okx

@ Ok Sí, tenga en cuenta mi comentario anterior.
Ian H.

1
¿Qué pasa con muchos espacios finales?
Okx

1
@ Ok Prohibido, uno es todo lo que obtienes.
Ian H.

Supongo que podemos usar letras minúsculas, ¿verdad?
Sr. Xcoder

Respuestas:



11

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'

55
(: nice builtin
Erik the Outgolfer

@EriktheOutgolfer Creo que es similar a 05AB1E ǝ? Ah, pero eso no parece vectorizarse en la segunda / tercera entrada
Luis Mendo

1
Exactamente por qué es único: p y también cómo MATL se llena automáticamente con 0sy se muestra 0como espacio.
Erik the Outgolfer

1
@LuisMendo Buena respuesta. Por curiosidad, y esta pregunta es probablemente aplicable a la mayoría de los langs basados ​​en pila, cuando escribe en MATL, ¿necesita hacer un seguimiento de la pila (por ejemplo, en una línea sobre el código, o un trozo de papel, etc.) a medida que escribe? redactar código? ¿O se ha vuelto lo suficientemente natural para ti que no lo haces?
Jonás

1
Je: aprendí algo nuevo hoy; Puede indexar en la misma posición dos veces sin ningún problema en MATL (AB). Ya comencé a escribir una respuesta complicada basada en un ciclo porque supuse que de lo contrario daría un error.
Sanchises

7

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.


6

05AB1E , 20 16 bytes

-4 bytes gracias a Emigna

ð₄×svyAuykN+ǝ}ðÜ

Pruébalo en línea!


1
Creo que puedes acortar al ð₄×svyAuykN+ǝ}ðÜmenos. Además, ¿hay una garantía de que la cadena de entrada desplazada no sea mayor de 1000 caracteres? Si no, g₂+ð×debería funcionar.
Emigna

6

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


¡Muy agradable! Estaba a punto de publicar una solución de 88 bytes, pero la suya es mucho mejor.
Rick Hitchcock

5

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

1
Aquí hay uno que funciona en TIO pero viene en un byte más (41 bytes de código + 2 para -F): ¡ Pruébelo en línea!
Xcali

1
@Xcali Deberías publicar eso para que pueda votarlo :)
Lynn el

1
@Xcali De acuerdo con Lynn también más publicaciones son geniales. ¡También me gusta la competencia de idiomas!
Dom Hastings



4

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

3

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





2

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!


LetterNumberCuál es una función para encontrar la posición de una letra en el alfabeto? Santa mierda, eso es ridículo.
numbermaniac

2

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!


(i.@#+65-~a.&i.)-> (i.@#+65-~3&u:)-> (i.@#-65-3&u:)-> (#\-66-3&u:)
FrownyFrog

También puedes quitar los paréntesis.
FrownyFrog

@FrownyFrog tyvm. Me había olvidado de esos dos trucos de golf.
Jonás

Puede guardar 3 bytes con(]' '#~1+>./)
millas

@miles. Agradable. Necesito hacer que los ganchos diádicos sean parte de mi caja de herramientas regular, noté que también los usaste en esa revisión de esta mañana.
Jonás


2

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.


1
Otra solución Haskell de 88 bytes, ver aquí y aquí .
nimi

2

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!


Puede guardar 7 bytes cambiando t[i+((int)n[i]-65)]a t[i+n[i]-65].
Ayb4btu

@ Ayb4btu Gracias olvidó que las char -> intconversiones son implícitas.
Ian H.

2

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!


Bienvenido al sitio! :)
DJMcMayhem

¡Gracias! Espero que esté bien publicar respuestas múltiples en el mismo idioma
Emiliano

Puede omitir las llaves en su forbucle de -2 bytes.
Ian H.

2

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.


1

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

1

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!


1

Carbón , 16 bytes

P FS«M⌕αι→ιM⌕αι←

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

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

1

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


1

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

1

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

38 Bytes:K*d+lz26Vlz K=XK-C@zN-65N@zN;.WqeHdPZK . WqeKd K=PK;Kse reemplaza por .W(while funcional) y sus argumentos, por supuesto, y FNrZlzse puede reemplazar VrZlz, pero rZ...significa U..., y Use genera automáticamente por V. Así se FNrZlzconvierteVlz
Mr. Xcoder

1

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%


1

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

0

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


A quien haya votado: probablemente haya hecho un clic incorrecto en el botón arriba. Corrija o envíeme un mensaje sobre por qué el voto negativo ... Tnx
steenbergh
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.