Inspirado pelo Codewars Kata .

Seu objetivo é usar uma string de entrada como esta:

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

e retorne uma string contendo a posição de cada caractere no alfabeto, separada por espaços e ignorando caracteres não 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 um desafio adicional, você pode substituir qualquer caractere numérico na sequência original por eles mesmos + 27. Por exemplo, "25"se tornaria "29, 32". Isto é completamente opcional.

Você deve usar 1-indexação ( 'a'==1, 'b'==2, etc)

Regras adicionais:

• Você deve retornar uma sequência, não uma matriz.

• O espaço em branco à direita está OK.

O vencedor tem a menor contagem de bytes.

Boa sorte!

05AB1E , (5?) 7 bytes

^{Dois bytes à direita são formatação de saída}

áÇ32%ðý

Uma porta da minha resposta Jelly , mas o O5AB1E é mais conciso para a filtragem do alfabeto.

Experimente online!

Como?

áÇ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 graças a @ OlivierGrégoire .

Experimente online.

Explicação:

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 graças a Jo King .
-8 bytes graças a pLOPeGG .

Após estas melhorias, esta resposta agora é semelhante ao Jonathan Allan 's resposta .

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

Experimente online!

R , 55 50 bytes

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

Experimente online!

Lê a entrada do stdin, converte para maiúsculas, remove letras alfabéticas não maiúsculas , converte para pontos de código, subtrai para 64 mods por 32 e imprime para stdout, separados por espaços.

Obrigado a Kevin Cruijssen pelo golfe!

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

-4 bytes graças ao Zacharý (e ao Sr. Xcoder)!

-6 bytes graças a Adám!

-1 byte graças a ngn!

⎕A⍳⎕A∩⍨≡819⌶⊢

Experimente online!

Explicação:

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

Minha solução inicial:

APL (Dyalog Unicode) , 24 20 bytes

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

Experimente online!

Explicação:

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

Não ria de mim, eu sou novo no APL :)

Python 2 , (45?) 55 bytes

^{11 bytes adicionados para formatar a saída, o que também torna isso incompatível com o Python 3)}

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

Outra porta da minha resposta Jelly.

Experimente online!

Versão não formatada (retornando uma lista de números inteiros):

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` `

Experimente online!

Explicação:

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 salvos graças a @Kevin

Mais 1 bytes graças a @Neil

Você pode adicionar suporte para números para alguns bytes adicionais (graças a @neil)

JavaScript (Node.js) , 62 bytes

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

Experimente online!

Gelatina , (7?) 8 bytes

^{Byte mais à direita é a formatação de saída}

fØẠO%32K

Um programa completo que aceita uma string no formato Python que imprime o resultado em STDOUT

Experimente online!

Como?

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

Tente

Explicação

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

x86 opcode, 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

Supondo que o resultado contenha pelo menos uma letra e não {|}~

40 bytes, permitindo todos os 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Éÿ%}},√

Execute e depure

-1 byte graças a @recursive

Explicação:

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»↔"

Execute e depure

Este gera uma nova linha separada. Descompactada: vmVaI^|c. Semelhante, mas com o mapa, que gera implicitamente com a nova linha à direita.

Espaço em branco , 152 117 bytes

-35 bytes graças 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]

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).

Explicação em pseudo-có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-ðý

Experimente online!

ou, se pudermos retornar uma matriz:

05AB1E , 6 bytes

láÇ96-

Explicação:

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

Experimente online!

ou se você quiser contar números:

05AB1E , 13 bytes

lAžh«DŠÃSk>ðý

Experimente online!

05AB1E , 14 bytes

Lida com números também

žKÃlvžKlÙyk>ðJ

Experimente online!

Carvão , 21 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

≔⁺β⭆χιβ

Anexe os dígitos à variável de letras minúsculas predefinidas.

Ｆ↧Ｓ

Faça um loop sobre a entrada em minúsculas.

¿№βι«

Se o caractere atual for uma letra ou dígito,

Ｉ⊕⌕βι

imprima seu índice indexado em 1,

→

e deixe um espaço para o próximo valor.

Vermelho , 93 bytes

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

Experimente online!

Perl 5 , 47 bytes

Com o desafio adicional de analisar dígitos:

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

Experimente online!

Reduzido para 38 bytes ignorando 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 ";

Experimente online!

-5 bytes graças a Kevin

Perl 5 -p , 35 bytes

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

Experimente online!

Inclui a parte extra sobre os dígitos.

Japt 2.0 -S, 9 bytes

f\l ®c %H

Execute on-line

Explicação:

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

Experimente (alfa de 32 bytes)

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

Experimente (41 bytes alfa + dígito)

Expandido:

Alfa de 32 bytes

{  # 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}}]

Experimente online!

PHP 108 105 Bytes

Experimente online (108 bytes)

Tri-lo online (105 bytes)

-3 bytes, graças a @manassehkatz (altere o nível do strtolower e remova o AZ do regex)

Código, tentou evitar qualquer loop

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

Explicação

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

Experimente online!

Python 2, 110 bytes 104 bytes , com entrada do usuário

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

Experimente Online!

Python 2, 105 bytes 104 bytes 96 bytes , ondeté predefinido:

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

Experimente Online!

Vamos dividir com uma versão mais legível:

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

Primeiro, definimos alphabet como sendo, bem, o alfabeto.

Em seguida, usamos a compreensão da lista para:

1. Faça uma lista em que cada item é um caractere minúsculo t
2. Para cada letra, se não estiver no alfabeto, descarte-a.
3. Se for, encontre seu índice no alfabeto,
4. adicione um (porque começamos a contar com 1)
5. e faça disso uma string.

Finalmente, juntamos tudo e imprimimos.

Editar: alterado paraprint (e perdeu a portabilidade) para salvar bytes e fazê-lo funcionar fora de uma função

Editar 2: adicionada uma versão cominput() variáveis ​​predefinidas em vez de

Edit 3: Removidos 8 bytes nas Soluções 1 e 2 graças a Jo King

PowerShell , 63 bytes

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

Experimente online!

(Parece longo ...)

Pega entrada $args, converte .ToUppermaiúsculas e minúsculas, lança como uma charmatriz, alimenta isso em um for eachloop. Dentro do loop, subtraímos por si própria ou 64 a partir do valor (ASCII int), com base em se ou não o valor atual é -ina gama 65de 90(ou seja, é uma letra maiúscula ASCII). Esses valores são deixados no pipeline e usamos -not ot epara eliminar os valores que não são letras (porque todos são zero). Esses números são encapsulados em uma cadeia de caracteres, pois a string padrão de uma matriz é separá-la com espaço, de modo que obtemos isso muito mais barato. Essa cadeia é deixada no pipeline e a saída é 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]'

De acordo com nossas regras de IO , a entrada é obtida por meio de uma tabela preexistente t com campos varchar s .

É necessário o SQL 2017 ou posterior. Também deve ser executado no masterbanco de dados, porque estou aproveitando uma tabela do sistema chamada spt_values, que (quando filtrada por type='P') contém números contados de 0 a 2047.

Basicamente, estou ingressando em uma tabela numérica com a string de entrada using SUBSTRING(), que retorna uma linha separada para cada caractere individual. Isso é filtrado apenas para letras usando LIKE'[a-z]', então obtemos seu valor ASCII e subtraímos 64. Esses números são reunidos novamente em uma string usando a função (new to SQL 2017) STRING_AGG.

Pitão , 10 bytes

jdfTmhxGr0

Tenho certeza de que isso pode ser jogado um pouco ... -2 bytes, se eu puder exibir como uma lista, algumas respostas parecem, mas não estão na especificação

Experimente online!

C (gcc) , 67 bytes

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

Experimente online!

Converte cada caractere em minúscula, compensa o código em -96 e, se estiver no intervalo do alfabeto indexado em 1, imprime o código de deslocamento

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

Experimente online