Ispirato al Codewars Kata .

Il tuo obiettivo è prendere una stringa di input come questa:

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

e restituisce una stringa contenente la posizione di ciascun carattere dell'alfabeto, separata da spazi e ignorando i caratteri non alfabetici, in questo modo:

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

Per un'ulteriore sfida, puoi sostituire qualsiasi carattere numerico nella stringa originale con se stessi + 27. Ad esempio, "25"diventerebbe "29, 32". Questo è completamente opzionale.

È necessario utilizzare 1-indicizzazione ( 'a'==1, 'b'==2, ecc)

Regole aggiuntive:

• È necessario restituire una stringa, non un array.

• Lo spazio bianco finale è OK.

Il vincitore ha il conteggio di byte più basso.

In bocca al lupo!

05AB1E , (5?) 7 byte

^{I due byte più a destra indicano la formattazione dell'output}

áÇ32%ðý

Una porta della mia risposta Jelly , ma O5AB1E è più conciso per il filtro alfabetico.

Provalo online!

Come?

áÇ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 byte

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

-13 byte grazie a @ OlivierGrégoire .

Provalo online.

Spiegazione:

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 byte

-5 byte grazie a Jo King .
-8 byte grazie a pLOPeGG .

Dopo questi miglioramenti, questa risposta è ora simile a quella di Jonathan Allan s' risposta .

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

Provalo online!

R , 55 50 byte

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

Provalo online!

Legge input da stdin, converte in maiuscolo, rimuove lettere alfabetiche non maiuscole , converte in punti di codice, sottrae 64 mod da 32 e stampa in stdout, separati da spazi.

Grazie a Kevin Cruijssen per il golf!

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

-4 byte grazie a Zacharý (e al signor Xcoder)!

-6 byte grazie ad Adám!

-1 byte grazie a ngn!

⎕A⍳⎕A∩⍨≡819⌶⊢

Provalo online!

Spiegazione:

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

La mia soluzione iniziale:

APL (Dyalog Unicode) , 24 20 byte

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

Provalo online!

Spiegazione:

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

Non ridere di me, sono nuovo di APL :)

Python 2 , (45?) 55 byte

^{11 byte aggiunti per formattare l'output, il che rende anche questo incompatibile con Python 3)}

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

Un'altra porta della mia risposta Jelly.

Provalo online!

Versione non formattata (che restituisce un elenco di numeri interi):

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

JavaScript (Node.js) , 69 55 54 byte

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

Provalo online!

Spiegazione :

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 byte salvati grazie a @Kevin

1 byte in più grazie a @Neil

Puoi aggiungere il supporto per i numeri per alcuni byte aggiuntivi (grazie a @neil)

JavaScript (Node.js) , 62 byte

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

Provalo online!

Jelly , (7?) 8 byte

^{Il byte più a destra è la formattazione dell'output}

fØẠO%32K

Un programma completo che accetta una stringa in formato Python che stampa il risultato su STDOUT

Provalo online!

Come?

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 byte

r\L ¨c uH

Provalo

Spiegazione

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

Opcode x86, 35 byte

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

Supponendo che il risultato contenga almeno una lettera e n {|}~

40 byte, consentendo tutti i caratteri 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 byte

üpÉÿ%}},√

Esegui ed esegui il debug

-1 byte grazie a @recursive

Spiegazione:

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 byte

É▌Xl»↔"

Esegui ed esegui il debug

Questo produce output separati da nuova riga. Unpacked: vmVaI^|c. Simile, ma con mappa, che genera implicitamente output con newline finale.

Spazio bianco , 152 117 byte

-35 byte grazie 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]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Spiegazione in pseudo-codice:

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 byte

láÇ96-ðý

Provalo online!

oppure, se possiamo restituire un array:

05AB1E , 6 byte

láÇ96-

Spiegazione:

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

Provalo online!

o se vuoi contare i numeri:

05AB1E , 13 byte

lAžh«DŠÃSk>ðý

Provalo online!

05AB1E , 14 byte

Gestisce anche i numeri

žKÃlvžKlÙyk>ðJ

Provalo online!

Carbone , 21 byte

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

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

≔⁺β⭆χιβ

Aggiungi le cifre alla variabile di lettere minuscole predefinita.

Ｆ↧Ｓ

Passa sopra l'ingresso in minuscolo.

¿№βι«

Se il carattere corrente è una lettera o una cifra,

Ｉ⊕⌕βι

stampa il suo indice 1-indicizzato,

→

e lasciare uno spazio per il valore successivo.

Rosso , 93 byte

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

Provalo online!

Perl 5 , 47 byte

Con la sfida aggiuntiva di analizzare le cifre:

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

Provalo online!

Ridotto a 38 byte ignorando le cifre

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

PHP , 70 byte

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

Provalo online!

-5 byte grazie a Kevin

Perl 5 -p , 35 byte

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

Provalo online!

Include la parte aggiuntiva relativa alle cifre.

Japt 2.0 -S, 9 byte

f\l ®c %H

Eseguilo online

Spiegazione:

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 byte (alfa), 41 byte (alfa + cifra)

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

Provalo (32 byte alfa)

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

Provalo (41 byte alfa + cifra)

Allargato:

32 byte 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 byte alfa + cifra

{  # 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 byte

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

Provalo online!

PHP 108 105 byte

Provalo online (108 byte)

Tri online (105 byte)

-3 byte, grazie a @manassehkatz (Cambia il livello di potenza e rimuovi AZ da regex)

Codice, ha cercato di evitare qualsiasi ciclo

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

Spiegazione

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

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

Provalo online!

Python 2, 110 byte 104 byte , con input utente

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

Provalo online!

Python 2, 105 byte 104 byte 96 byte , dove tè predefinito:

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

Provalo online!

Analizziamolo con una versione più leggibile:

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

Innanzitutto, definiamo alphabet l'alfabeto.

Successivamente, utilizziamo la comprensione dell'elenco per:

1. Crea un elenco da cui ogni elemento è un carattere minuscolo t
2. Per ogni lettera, se non è presente nell'alfabeto, scartala.
3. Se lo è, trova il suo indice nell'alfabeto,
4. aggiungine uno (perché iniziamo a contare da 1)
5. e trasformalo in una stringa.

Infine, uniamo tutto insieme e lo stampiamo.

Modifica: modificato in print(e perso portabilità) per salvare byte e farlo funzionare al di fuori di una funzione

Modifica 2: aggiunta una versione con input()anziché variabili predefinite

Modifica 3: rimossi 8 byte nelle soluzioni 1 e 2 grazie a Jo King

PowerShell , 63 byte

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

Provalo online!

(Sembra lungo ...)

Prende input $args, converte il .ToUppercase, lo lancia come un chararray, lo inserisce in un for eachloop. All'interno del ciclo, sottraiamo o direttamente o 64 dal valore (ASCII int), in base a se il valore corrente è -inil campo 65a 90(vale a dire, si tratta di una lettera maiuscola ASCII). Quei valori vengono lasciati sulla pipeline e usiamo -not equal per eliminare i valori non letter (perché sono tutti zero). Quei numeri sono incapsulati in una stringa poiché la stringa di default di un array è di separarlo nello spazio, quindi lo otteniamo abbastanza a buon mercato. Quella stringa viene lasciata sulla pipeline e l'output è implicito.

MS-SQL, 133 byte

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

Secondo le nostre regole IO , l'input viene preso tramite una tabella preesistente t con varchar field s .

È richiesto SQL 2017 o versioni successive. Deve anche essere eseguito nel masterdatabase, perché sto sfruttando una tabella di sistema chiamata spt_values, che (quando filtrata da type='P') contiene i numeri di conteggio da 0 a 2047.

Fondamentalmente sto unendo una tabella numerica con la stringa di input utilizzando SUBSTRING(), che restituisce una riga separata per ogni singolo carattere. Questo viene filtrato solo per le lettere che utilizzano LIKE'[a-z]', quindi otteniamo il loro valore ASCII e sottraggiamo 64. Questi numeri vengono riuniti in una stringa utilizzando la funzione (new to SQL 2017) STRING_AGG.

Pyth , 10 byte

jdfTmhxGr0

Sono abbastanza sicuro che questo possa essere giocato un po 'a golf ... -2 byte se riesco a produrre un elenco, alcune risposte sembrano, ma non è nelle specifiche

Provalo online!

C (gcc) , 67 byte

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

Provalo online!

Converte ogni carattere in minuscolo, sposta il suo codice di -96 e, se rientra nell'intervallo dell'alfabeto 1-indicizzato, stampa il codice di offset

jq , 45 byte

[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

Provalo online