Inspiré par le Codewars Kata .

Votre objectif est de prendre une chaîne d'entrée comme celle-ci:

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

et renvoyer une chaîne contenant la position de chaque caractère dans l'alphabet, séparés par des espaces et ignorant les caractères non alphabétiques, comme ceci:

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

Pour un défi supplémentaire, vous pouvez remplacer tous les caractères numériques de la chaîne d'origine par eux-mêmes + 27. Par exemple, "25"deviendrait "29, 32". C'est complètement facultatif.

Vous devez utiliser 1-indexation ( 'a'==1, 'b'==2, etc.)

Règles supplémentaires:

• Vous devez renvoyer une chaîne, pas un tableau.

• La fin des espaces blancs est OK.

Le gagnant a le nombre d'octets le plus bas.

Bonne chance!

05AB1E , (5?) 7 octets

^{Les deux octets les plus à droite sont le formatage de sortie}

áÇ32%ðý

Un portage de ma réponse Jelly , mais O5AB1E est plus concis pour le filtrage alphabétique.

Essayez-le en ligne!

Comment?

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

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

-13 octets grâce à @ OlivierGrégoire .

Essayez-le en ligne.

Explication:

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 octets

-5 octets grâce à Jo King .
-8 octets grâce à pLOPeGG .

Après ces améliorations, cette réponse est maintenant semblable à Jonathan Allan de réponse .

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

Essayez-le en ligne!

R , 55 50 octets

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

Essayez-le en ligne!

Lit l'entrée de stdin, convertit en majuscules, supprime les lettres alphabétiques non majuscules , convertit en points de code, soustrait en 64 mods par 32 et imprime en stdout, séparés par des espaces.

Merci à Kevin Cruijssen pour le golf!

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

-4 octets grâce à Zacharý (et M. Xcoder)!

-6 octets grâce à Adám!

-1 octet grâce à ngn!

⎕A⍳⎕A∩⍨≡819⌶⊢

Essayez-le en ligne!

Explication:

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

Ma première solution:

APL (Dyalog Unicode) , 24 20 octets

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

Essayez-le en ligne!

Explication:

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

Ne te moque pas de moi, je suis nouveau chez APL :)

Python 2 , (45?) 55 octets

^{11 octets ajoutés pour formater la sortie, ce qui rend également cela incompatible avec Python 3)}

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

Un autre port de ma réponse Jelly.

Essayez-le en ligne!

Version non formatée (renvoyant une liste d'entiers):

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

JavaScript (Node.js) , 69 55 54 octets

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

Essayez-le en ligne!

Explication:

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 octets enregistrés grâce à @Kevin

1 octets de plus grâce à @Neil

Vous pouvez ajouter la prise en charge des chiffres pour certains octets supplémentaires (grâce à @neil)

JavaScript (Node.js) , 62 octets

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

Essayez-le en ligne!

Gelée , (7?) 8 octets

^{L'octet le plus à droite est le formatage de sortie}

fØẠO%32K

Un programme complet acceptant une chaîne au format Python qui imprime le résultat sur STDOUT

Essayez-le en ligne!

Comment?

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 octets

r\L ¨c uH

Essayez-le

Explication

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 octets

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

En supposant que le résultat contient au moins une lettre et aucun {|}~

40 octets, autorisant tous les caractères 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 octets

üpÉÿ%}},√

Exécuter et déboguer

-1 octet grâce à @recursive

Explication:

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 octets

É▌Xl»↔"

Exécuter et déboguer

Celui-ci génère des sauts de ligne séparés. Décompressée: vmVaI^|c. Similaire, mais avec map, qui sort implicitement avec une nouvelle ligne de fin.

Espace , 152 117 octets

-35 octets grâce à @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]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté à titre d'explication uniquement.

Essayez-le en ligne (avec des espaces bruts, des tabulations et des nouvelles lignes uniquement).

Explication en pseudo-code:

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 octets

láÇ96-ðý

Essayez-le en ligne!

ou, si nous pouvons retourner un tableau:

05AB1E , 6 octets

láÇ96-

Explication:

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

Essayez-le en ligne!

ou si vous voulez qu'il compte des nombres:

05AB1E , 13 octets

lAžh«DŠÃSk>ðý

Essayez-le en ligne!

05AB1E , 14 octets

Gère également les nombres

žKÃlvžKlÙyk>ðJ

Essayez-le en ligne!

Fusain , 21 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

≔⁺β⭆χιβ

Ajoutez les chiffres à la variable de lettres minuscules prédéfinie.

Ｆ↧Ｓ

Boucle sur l'entrée en minuscules.

¿№βι«

Si le caractère actuel est une lettre ou un chiffre,

Ｉ⊕⌕βι

imprimer son index 1 indexé,

→

et laissez un espace pour la valeur suivante.

Rouge , 93 octets

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

Essayez-le en ligne!

Perl 5 , 47 octets

Avec un défi supplémentaire d'analyse des chiffres:

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

Essayez-le en ligne!

Réduit à 38 octets en ignorant les chiffres

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

PHP , 70 octets

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

Essayez-le en ligne!

-5 octets grâce à Kevin

Perl 5 -p , 35 octets

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

Essayez-le en ligne!

Comprend la partie supplémentaire sur les chiffres.

Japt 2.0 -S, 9 octets

f\l ®c %H

Exécutez-le en ligne

Explication:

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 octets (alpha), 41 octets (alpha + chiffre)

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

Essayez-le (32 octets alpha)

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

Essayez-le (41 octets alpha + chiffre)

Étendu:

32 octets alpha

{  # 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 octets alpha + chiffre

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

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

Essayez-le en ligne!

PHP 108105 octets

Essayez-le en ligne (108 octets)

Tri en ligne (105 octets)

-3 octets, grâce à @manassehkatz (Changer le niveau de strtolower et supprimer AZ de regex)

Code, a essayé d'éviter toute boucle

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

Explication

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

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

Essayez-le en ligne!

Python 2, 110 octets 104 octets , avec entrée utilisateur

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

Essayez-le en ligne!

Python 2, 105 octets 104 octets 96 octets , où test prédéfini:

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

Essayez-le en ligne!

Décomposons-le avec une version plus lisible:

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

Premièrement, nous définissons alphabetcomme étant, eh bien, l'alphabet.

Ensuite, nous utilisons la compréhension de liste pour:

1. Faites une liste où chaque élément est un caractère minuscule t
2. Pour chaque lettre, si elle n'est pas dans l'alphabet, jetez-la.
3. Si c'est le cas, trouvez son index dans l'alphabet,
4. ajoutez-en un (car nous commençons à compter à 1)
5. et en faire une chaîne.

Enfin, nous réunissons le tout ensemble et l'imprimons.

Modifier: changé enprint (et perte de portabilité) pour enregistrer les octets et le faire fonctionner en dehors d'une fonction

Edit 2: Ajout d'une version avecinput() au lieu de variables prédéfinies

Edit 3: Suppression de 8 octets dans les solutions 1 et 2 grâce à Jo King

PowerShell , 63 octets

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

Essayez-le en ligne!

(Semble long ...)

Prend l'entrée $args, la convertit en .ToUppercasse , la transforme en chartableau, l'introduit dans une for eachboucle. À l'intérieur de la boucle, nous soustrayons lui-même ou 64 de la valeur (ASCII int), selon que la valeur actuelle est ou non -inla plage (c'est- 65à 90-dire qu'il s'agit d'une lettre majuscule ASCII). Ces valeurs sont laissées sur le pipeline, et nous utilisons un -not equal pour éliminer les valeurs non-lettre (car elles sont toutes nulles). Ces nombres sont encapsulés dans une chaîne car la stringification par défaut d'un tableau consiste à le séparer dans l'espace, nous obtenons donc cela à peu de frais. Cette chaîne est laissée sur le pipeline et la sortie est implicite.

MS-SQL, 133 octets

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

Selon nos règles d'E / S , l'entrée est prise via une table préexistante t avec le champ varchar s .

SQL 2017 ou version ultérieure est requis. Doit également être exécuté dans la masterbase de données, car je profite d'une table système appelée spt_values, qui (lorsqu'elle est filtrée par type='P') contient des nombres de comptage de 0 à 2047.

Fondamentalement, je joins une table numérique avec la chaîne d'entrée en utilisant SUBSTRING(), qui renvoie une ligne distincte pour chaque caractère individuel. Ceci est filtré pour les lettres uniquement en utilisant LIKE'[a-z]', puis nous obtenons leur valeur ASCII et soustrayons 64. Ces nombres sont rejoints en une chaîne à l'aide de la fonction (nouvelle dans SQL 2017) STRING_AGG.

Pyth , 10 octets

jdfTmhxGr0

Je suis assez sûr que cela peut être joué un peu ... -2 octets si je peux sortir sous forme de liste, certaines réponses semblent mais ce n'est pas dans les spécifications

Essayez-le en ligne!

C (gcc) , 67 octets

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

Essayez-le en ligne!

Convertit chaque caractère en minuscules, décale son code de -96 et, s'il tombe dans la plage de l'alphabet indexé 1, imprime le code de décalage

jq , 45 octets

[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

Essayez-le en ligne