Inspirado por el Codewars Kata .

Su objetivo es tomar una cadena de entrada como esta:

"'Twas a dark and stormy night..."

y devuelve una cadena que contiene la posición de cada carácter en el alfabeto, separada por espacios e ignorando caracteres no alfabéticos, como este:

"20 23 1 19 1 4 1 18 11 1 14 4 19 20 15 18 13 25 14 9 7 8 20"

Para un desafío adicional, puede reemplazar cualquier carácter numérico en la cadena original con ellos mismos + 27. Por ejemplo, "25"sería "29, 32". Esto es completamente opcional.

Debe utilizar 1-indexación ( 'a'==1, 'b'==2, etc.)

Reglas adicionales:

• Debe devolver una cadena, no una matriz.

• El espacio en blanco al final está bien.

El ganador tiene el conteo de bytes más bajo.

¡Buena suerte!

05AB1E , (5?) 7 bytes

^{Los dos bytes más a la derecha tienen formato de salida}

áÇ32%ðý

Un puerto de mi respuesta Jelly , pero O5AB1E es más conciso para el filtrado del alfabeto.

Pruébalo en línea!

¿Cómo?

áÇ32%ðý - take input implicitly
á       - filter keep alphabetical characters
 Ç      - to ordinals
  32    - thirty-two
    %   - modulo (vectorises)
     ð  - push a space character
      ý - join

Java 8, 82 78 72 69 62 bytes

s->{for(int c:s)System.out.print(c>64&~-c%32<26?c%32+" ":"");}

-13 bytes gracias a @ OlivierGrégoire .

Pruébalo en línea.

Explicación:

s->                    // Method with character-array parameter and no return-type
  for(int c:s)         //  Loop over its characters as integers
    System.out.print(  //   Print:
     c>64&~-c%32<26?   //    If the current character is a letter:
      c%32+" "         //     Print the position in the alphabet with a trailing space
     :                 //    Else:
      "");}            //     Print nothing

Python 3 , 62 60 49 bytes

-5 bytes gracias a Jo King .
-8 bytes gracias a pLOPeGG .

Después de estas mejoras, esta respuesta ahora es similar a la respuesta de Jonathan Allan .

print(*[ord(c)%32for c in input()if c.isalpha()])

Pruébalo en línea!

R , 55 50 bytes

cat(utf8ToInt(gsub("[^A-Za-z]","",scan(,"")))%%32)

Pruébalo en línea!

Lee la entrada de stdin, convierte a mayúsculas, elimina letras alfabéticas no mayúsculas , convierte a puntos de código, resta a 64 mods por 32 e imprime a stdout, separados por espacios.

¡Gracias a Kevin Cruijssen por el golf!

APL (Dyalog Unicode) , 24, 20, 14 13 bytes

-4 bytes gracias a Zacharý (y al Sr. Xcoder)!

-6 bytes gracias a Adám!

-1 byte gracias a ngn!

⎕A⍳⎕A∩⍨≡819⌶⊢

Pruébalo en línea!

Explicación:

        ≡819⌶⊢  - to uppercase
   ⎕A∩⍨         - intersect with the letters A-Z (args swapped to preserve the order)
   ⍳              - index in
⎕A               - the A-Z letters list

Mi solución inicial:

APL (Dyalog Unicode) , 24 20 bytes

{⍵/⍨27>⍵}⎕A⍳1(819⌶)⊢

Pruébalo en línea!

Explicación:

             ⍳           indices of     
              1(819⌶)⊢  the right argument (⊢) changed to uppercase
          ⎕A            in the list of uppercase letters
{⍵/⍨     }              copy (filter) those items from the list of indeces
     27>⍵               which are smaller than 27 (all non A-Z chars will have index 27)

No te rías de mí, soy nuevo en APL :)

Python 2 , (45?) 55 bytes

^{11 bytes agregados para formatear la salida, lo que también hace que esto sea incompatible con Python 3)}

lambda s:' '.join(`ord(c)%32`for c in s if c.isalpha())

Otro puerto de mi respuesta Jelly.

Pruébalo en línea!

Versión sin formato (que devuelve una lista de enteros):

lambda s:[ord(c)%32for c in s if c.isalpha()]

JavaScript (Node.js) , 69 55 54 bytes

t=>t.match(/[a-z]/gi).map(i=>parseInt(i,36)-9).join` `

Pruébalo en línea!

Explicación

t =>                       // lambda function accepting a string as input
    t.match(/a-z/gi).      // returns all parts of string that match as an array 
        map(i=>            // map over that array with argument i 
            parseInt(i,36) // convert to base 36 
                - 9        // and subtract 9 from it
        ).                 // end map
        join` `            // convert to space separated string

11 bytes guardados gracias a @Kevin

1 bytes más gracias a @Neil

Puede agregar soporte para números para algunos bytes adicionales (gracias a @neil)

JavaScript (Node.js) , 62 bytes

t=>t.match(/[^_\W]/g).map(i=>(parseInt(i,36)+26)%36+1).join` `

Pruébalo en línea!

Jalea , (7?) 8 bytes

^{El byte más a la derecha es el formato de salida}

fØẠO%32K

Un programa completo que acepta una cadena en formato Python que imprime el resultado en STDOUT

Pruébalo en línea!

¿Cómo?

fØẠO%32K - Main Link: list of characters (created from the string input)
 ØẠ      - yield the alphabet = ['A','B',...,'Z','a','b',...,'z']
f        - filter keep (discard non alphabet characters)
   O     - ordinals          ('A':65, 'Z':90, 'a':97, 'z':122, etc.)
     32  - literal thirty-two
    %    - modulo            (65:1,   90':26,  97:1,  122:26,  etc.)
       K - join with spaces (makes a list of characters and integers)
         - implicit print

Japt v2.0a0 -S, 12 10 bytes

r\L ¨c uH

Intentalo

Explicación

r              :Remove
 \L            :  Non-letter characters
    ¬          :Split to array
     ®         :Map
      c        :  Character code
        u      :  Modulo
         H     :  32
               :Implicitly join with spaces and output

código de operación x86, 35 bytes

0080h: AC 3C 24 75 04 88 45 FF C3 0C 20 2C 60 76 F1 D4
0090h: 0A 0D 30 30 86 E0 3C 30 74 01 AA 86 E0 AA B0 20
00a0h: AA EB DD                                       

f:  lodsb
    cmp al, '$'
    jnz @f
        mov [di-1], al
        ret
    @@:
    or al, 32
    sub al, 96
    jbe f
    aam
    or ax, 3030H
    xchg ah, al
    cmp al, 48
    jz @f
        stosb
    @@:
    xchg ah, al
    stosb
    mov al, 32
    stosb
    jmp f

Suponiendo que el resultado contenga al menos una letra, y no {|}~

40 bytes, permitiendo todos los caracteres ASCII

0080h: AC 3C 24 75 04 88 45 FF C3 0C 20 2C 60 76 F1 3C
0090h: 1A 77 ED D4 0A 0D 30 30 86 E0 3C 30 74 01 AA 86
00a0h: E0 AA B0 20 AA EB D9                           

Stax , 9 10 9 bytes

üpÉÿ%}},√

Ejecutar y depurarlo

-1 byte gracias a @recursive

Explicación:

v{VaIvm0-J Full program, unpacked, implicit input
v          Lowercase
 {    m    Map:
  VaI        Index in lowercase alphabet (0-based, -1 for not found)
     ^       Increment
       0-  Remove zeroes
         J Join by space
           Implicit output

Stax , 7 bytes

É▌Xl»↔"

Ejecutar y depurarlo

Este da salida a nueva línea separada. Expandida: vmVaI^|c. Similar, pero con el mapa, que sale implícitamente con una nueva línea final.

Espacio en blanco , 152 117 bytes

-35 bytes gracias a @Lynn .

[N
S S N
_Create_Label_LOOP][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S N
S _Duplicate_input][S S S T S S S S S N
_Push_32][T S T T   _Modulo][S N
T   _Swap_top_two][S S S T  T   T   T   T   T   N
_Push_63][T S T S _Integer_divide][T    S S N
_Multiply][S N
S _Duplicate][S S S T   T   S T T   N
_Push_27][S T   S S T   N
_Copy_1st][S S S T  N
_Push_1][T  S S S _Add][T   S T S _Integer_divide][T    S S N
_Mulitply][N
T   S N
_If_0_Jump_to_Label_LOOP][T N
S T _Print_as_number][S S S T   S S S S S N
_Push_32_space][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

Explicación en pseudocódigo:

Start LOOP:
  Character c = STDIN as character
  Integer n = (c modulo-32) * (c integer-divided by 63)
  Integer m = 27 integer-divided by (n + 1) * n;
  If(m == 0):
    Go to next iteration of LOOP
  Else:
    Print n as integer to STDOUT
    Print a space to STDOUT
    Go to next iteration of LOOP

05AB1E , 8 bytes

láÇ96-ðý

Pruébalo en línea!

o, si podemos devolver una matriz:

05AB1E , 6 bytes

láÇ96-

Explicación:

l         Lowercase
 á        Only letters
  Ç       Codepoints
   96-    Subtract 96.

Pruébalo en línea!

o si quieres que cuente números:

05AB1E , 13 bytes

lAžh«DŠÃSk>ðý

Pruébalo en línea!

05AB1E , 14 bytes

Maneja números también

žKÃlvžKlÙyk>ðJ

Pruébalo en línea!

Carbón de leña , 21 bytes

≔⁺β⭆χιβＦ↧Ｓ¿№βι«Ｉ⊕⌕βι→

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

≔⁺β⭆χιβ

Agregue los dígitos a la variable minúscula predefinida.

Ｆ↧Ｓ

Pase sobre la entrada en minúsculas.

¿№βι«

Si el carácter actual es una letra o dígito,

Ｉ⊕⌕βι

imprime su índice indexado 1,

→

y deja un espacio para el siguiente valor.

Rojo , 93 bytes

func[s][a: charset[#"a"-#"z"]parse lowercase s[any[copy c a(prin[-96 + to-char c""])| skip]]]

Pruébalo en línea!

Perl 5 , 47 bytes

Con el desafío adicional de analizar dígitos:

print map{(ord(uc)-64)%43," "}<>=~/([A-Z\d])/gi

Pruébalo en línea!

Reducido a 38 bytes al ignorar dígitos

print map{ord()%32," "}<>=~/([A-Z])/gi

PHP , 70 bytes

for(;$c=$argv[1][$i++];)if(($c=ord($c))>64&($c%=32)>0&$c<27)echo"$c ";

Pruébalo en línea!

-5 bytes gracias a Kevin

Perl 5 -p , 35 bytes

$_="@{[map{(-64+ord uc)%43}/\w/g]}"

Pruébalo en línea!

Incluye la porción extra sobre los dígitos.

Japt 2.0 -S, 9 bytes

f\l ®c %H

Ejecútalo en línea

Explicación:

f\l ®c %H                                    Input: "Hello..."
f            Match:
 \l             [A-Za-z]                     ["H","e","l","l","o"]
    ®        Map Z over the results:
     c         char-code of Z                [72,101,108,108,111]
       %H      mod 32                        [8,5,12,12,15]
-S           Join the chars with a space     8 5 12 12 15

Perl 6 , 32 bytes (alfa), 41 bytes (alfa + dígito)

{~(.uc.comb(/<:L>/)».ord X-64)}

Pruébalo (32 bytes alfa)

{~((.uc.comb(/<:L+:N>/)».ord X-64)X%43)}

Pruébelo (41 bytes alfa + dígito)

Expandido:

32 bytes alfa

{  # bare block lambda with implicit parameter $_

  ~( # coerce to string (space separated)

      .uc                      # uppercase
      .comb( / <:L > / )\      # get letters as a sequence
      ».ord                    # get the ordinal of each
      X- 64                    # subtract 64 from each
  )
}

41 bytes alfa + dígito

{  # bare block lambda with implicit parameter $_

  ~( # coerce to string (space separated)
    (
      .uc                      # uppercase
      .comb( / <:L + :N > / )\ # get letters and numbers as a sequence
      ».ord                    # get the ordinal of each
      X- 64                    # subtract 64 from each
    ) X% 43                    # modulus 43 for each
  )
}

Tcl , 93 bytes

puts [lmap c [split $argv ""] {if [string is alp $c] {expr ([scan $c %c]-64)%32} {continue}}]

Pruébalo en línea!

PHP 108105 Bytes

Pruébelo en línea (108 bytes)

Tri it en línea (105 Bytes)

-3 Bytes, gracias a @manassehkatz (Cambiar el nivel de strtolower y eliminar AZ de regex)

Código, trató de evitar cualquier bucle

<?=strtr(implode(" ",str_split(preg_replace(
"/[^a-z]/",'',strtolower($argv)))),array_flip(range("`",z)));

Explicación

$string = preg_replace("/[^a-z]/",'',strtolower($argv))  
//the string only contains letters

$string = implode(" ",str_split($string)); 
//the string has a space after every letter

$string = strtr($string, array_flip(range("`",z)));  
//replace every letter   acording to the array

$replacementArray = array_flip(range("`",z));
//this array contains the ansi characters from "`" to the "z"
//array_flip to change the keys with the values
//final array ["`"=>0,"a"=>1, "b"=>2...."z"=>26]

Python 3 , 84 bytes

print(*filter(int,['abcdefghijklmnopqrstuvwxyz'.find(c)+1for c in input().lower()]))

Pruébalo en línea!

Python 2, 110 bytes 104 bytes , con entrada del usuario

a="abcdefghijklmnopqrstuvwxyz";print" ".join(str(a.index(l)+1)for l in list(input().lower())if l in a)

Pruébalo en línea!

Python 2, 105 bytes 104 bytes 96 bytes , donde testá predefinido:

a="abcdefghijklmnopqrstuvwxyz";print" ".join(str(a.index(l)+1)for l in list(t.lower())if l in a)

Pruébalo en línea!

Vamos a desglosarlo con una versión más legible:

alphabet = "abcdefghijklmnopqrstuvwxyz"
foo = [str(alphabet.index(letter) + 1) for letter in list(t.lower()) if letter in alphabet]
print " ".join(foo)

Primero, definimos alphabetcomo ser, bueno, el alfabeto.

A continuación, usamos la comprensión de listas para:

1. Haga una lista donde cada elemento es un carácter en minúscula de t
2. Para cada letra, si no está en el alfabeto, deséchela.
3. Si es así, encuentre su índice en el alfabeto,
4. agregue uno (porque comenzamos a contar en 1)
5. y hazlo una cuerda.

Finalmente, lo unimos todo y lo imprimimos.

Editar: cambiado a print(y pérdida de portabilidad) para guardar bytes y hacer que funcione fuera de una función

Edición 2: se agregó una versión con input()variables predefinidas en lugar de

Edición 3: Eliminado 8 bytes en las Soluciones 1 y 2 gracias a Jo King

PowerShell , 63 bytes

"$(([char[]]"$args".ToUpper()|%{$_-($_,64)[$_-in65..90]})-ne0)"

Pruébalo en línea!

(Parece largo ...)

Toma datos $args, los convierte en .ToUppermayúsculas y minúsculas , los convierte en una charmatriz y los introduce en un for eachbucle. Dentro del bucle, restamos por sí mismo o 64 desde el valor (int ASCII), en función de si o no el valor actual es -inel rango 65de 90(es decir, se trata de una letra mayúscula ASCII). Esos valores se dejan en la tubería, y usamos -not equal para eliminar los valores que no son letras (porque todos son cero). Esos números están encapsulados en una cadena, ya que la cadena de caracteres predeterminada de una matriz es separarla en el espacio, por lo que lo obtenemos de manera bastante económica. Esa cadena se deja en la tubería y la salida es implícita.

MS-SQL, 133 bytes

SELECT STRING_AGG(ASCII(substring(upper(s),number+1,1))-64,' ')FROM
spt_values,t WHERE type='P'AND substring(s,number+1,1)LIKE'[a-z]'

Según nuestras reglas de E / S , la entrada se toma a través de una tabla t preexistente con campos varchar s .

Se requiere SQL 2017 o posterior. También se debe ejecutar en la masterbase de datos, porque estoy aprovechando una tabla del sistema llamada spt_values, que (cuando se filtra por type='P') contiene números de conteo del 0 al 2047.

Básicamente, estoy uniendo una tabla de números con la cadena de entrada usando SUBSTRING(), que devuelve una fila separada para cada carácter individual. Esto se filtra para usar solo letras LIKE'[a-z]', luego obtenemos su valor ASCII y restamos 64. Estos números se unen nuevamente en una cadena usando la función (nuevo en SQL 2017) STRING_AGG.

Pyth , 10 bytes

jdfTmhxGr0

Estoy bastante seguro de que esto se puede jugar un poco ... -2 bytes si puedo generar una lista, algunas respuestas parecen pero no están en la especificación

Pruébalo en línea!

C (gcc) , 67 bytes

c;f(char*s){for(;*s;)(c=tolower(*s++)-96)>0&c<27&&printf("%d ",c);}

Pruébalo en línea!

Convierte cada carácter en minúsculas, compensa su código en -96 y, si cae en el rango del alfabeto indexado en 1, imprime el código de desplazamiento

jq , 45 bytes

[gsub("\\W";"")|explode[]%32|@text]|join(" ")

 gsub("\\W";"")                                # remove non-alpha characters
               |explode[]                      # get decimal values of characters
                         %32                   # get positions in alphabet
                            |@text             # convert back to string
[                                 ]|join(" ")  # join with a space

Pruébalo en línea