Étant donné une chaîne qui ne contient que des lettres minuscules, codez cette chaîne avec le chiffre de l'alphabet.

Pour encoder avec le chiffre de l'alphabet (je vais utiliser l'exemple hello):

1. Tout d'abord, convertissez chaque lettre de la chaîne en un nombre en fonction de sa position dans l'alphabet ( a= 1, b= 2, etc.) Exemple:8 5 12 12 15
2. Remplissez chaque nombre de deux caractères avec 0s. Exemple:08 05 12 12 15
3. Joindre. Exemple:0805121215

Cas de test

helloworld -> 08051212152315181204
codegolf -> 0315040507151206
alphabetcipher -> 0112160801020520030916080518
johncena -> 1015081403051401

N'oubliez pas qu'il s'agit de code-golf , donc le code avec le moins d'octets gagne.

05AB1E , 11 6 octets

Code:

Ç4+€¦J

Explication:

Tout d'abord, nous convertissons la chaîne en leurs valeurs ASCII. codegolfdeviendrait:

[99, 111, 100, 101, 103, 111, 108, 102]

Pour accéder aux index de l'alphabet, vous soustrayez 96:

[3, 15, 4, 5, 7, 15, 12, 6]

Pour ajouter des zéros, ajoutez 100à chaque élément et supprimez le premier caractère de chaque entier. Pour l'exemple ci-dessus, +100serait:

[103, 115, 104, 105, 107, 115, 112, 106]

Et la suppression du premier caractère de chacun entraînerait:

[03, 15, 04, 05, 07, 15, 12, 06] 

Nous pouvons fusionner les deux étapes ci-dessus (la -96et la +100) partie juste +4. Pour le code:

Ç       # Convert to an array of ASCII code points
 4+     # Add four to each element in the array
   €¦   # Remove the first character of each element
     J  # Join to a single string

Essayez-le en ligne!

Python 2, 42 octets

f=lambda s:s and`ord(s[0])+4`[1:]+f(s[1:])

Testez-le sur Ideone .

Pyth, 11 10 octets

FNwpt`+4CN

Essayez! Mon premier rendez-vous chez Pyth.

FNwpt`+4CN
FNw         # For N in w (w is input, N will be single char)
   p        # Print without newline
        CN  # Int with code point `N`
      +4CN  # Add 4 to int with code point N
     `+4CN  # representation of above (basically to string)
    t`+4CN  # Tail (All but first character)

Équivalent Python:

for N in input():
    print(repr(ord(N) + 4)[1:], end='')

C, 55 43 octets

f(char*c){for(;*c;)printf("%02d",*c++-96);}

ideone

Python, 46 octets

lambda x:"".join("%02i"%(ord(j)-96)for j in x)

Assez simple. Essayez-le sur repl.it!

Gelée , 9 7 octets

O+4ṾḊ$€

TryItOnline

Comment?

O+4ṾḊ$€ - Main link: s                                e.g. hello
O       - cast to ordinals                            e.g. [ 104,  101,  108,  108,  111]
 +4     - add 4                                       e.g. [  108,  109,  112,  112,  115]
     $€ - last two links as a monad for €ach
   Ṿ    -    uneval, effectively converts to strings  e.g. ["108","109","112","112","115"]
    Ḋ   -    dequeue, remove the leading '1'          e.g. [ "08", "09", "12", "12", "15"]
        - implicit print                              e.g. "0809121215"

Haskell, quarante - quatre 30 28 octets

(>>=tail.show.(+4).fromEnum)

En utilisant le +4 approche de la réponse d' Adnan permet d'économiser 14 octets.

Essayez-le sur Ideone.Usage:

> (>>=tail.show.(+4).fromEnum)"codegolf"
"0315040507151206"

Deux octets de moins grâce à xnor . Ancienne version:

f a=['0'|a<'k']++(show$fromEnum a-96)
(f=<<)

Perl, 29 octets

28 octets de code + -nindicateur.

printf"%02s",-96+ord for/./g

Courir avec :

perl -ne 'printf"%02s",-96+ord for/./g' <<< "helloworld"

JavaScript (ES6), 52 49 octets

f=s=>s&&(s.charCodeAt()+4+f(s.slice(1))).slice(1)

La récursivité s'est avérée être 3 octets plus courte que .replace:

s=>s.replace(/./g,s=>(s.charCodeAt()+4+"").slice(1))

parseInt(s,36)est légèrement plus long pour chaque approche, car vous devez passer 4à 91:

s=>s.replace(/./g,s=>(parseInt(s,36)+91+"").slice(1))
f=s=>s&&(parseInt(s[0],36)+91+f(s.slice(1))).slice(1)

Japt, 10 octets

¡4+Xc)s s1

Probablement pas plus court que ça ...

Testez-le en ligne!

Explication

¡           // Map each char X in the input by this function:
 4+Xc)      //   Take 4 + the char code of X.
      s s1  //   Convert to a string, then remove the first char.
            // Implicit: output last expression

Java 7,60 octets

void f(char[]s){for(int i:s)System.out.printf("%02d",i-96);} 

MATL, 12 11 octets

1 octet enregistré grâce à @Luis

4+!V4LZ)!le

Essayez-le en ligne

Hexagonie , 33 octets

10}{'a({=!{{\.@29$\,<.-":!\>Oct\%

Essayez-le en ligne!

Mm .. a eu quelques no-ops dans l'Hexagone donc j'ai mis la date d'aujourd'hui.

Formulaire étendu avec date remplacée par aucune opération

   1 0 } {
  ' a ( { =
 ! { { \ . @
. . $ \ , < .
 - " : ! \ >
  . . . \ %
   . . . .

1. Initialiser un 10et déplacer le pointeur de mémoire quelque part ...
2. $saute le miroir et ,lit un octet. <branches:
3. Si fin de chaîne (-1 qui n'est pas positive) passe à@ et termine le programme.
4. Sinon, il soustrait 95(décrémenté a), puis nous imprimons result / 10(division entière) et result % 10et bouclons à nouveau.

Vim, 60 touches

:s/./\=char2nr(submatch(0))-96."\r"/g
:%s/\<\d\n/0&
V{gJ

Une solution basée presque entièrement sur les regex. Comme d'habitude, l'utilisation du registre eval le rend incroyablement long.

PHP, 58 octets

foreach(str_split($argv[1])as$c)printf("%02d",ord($c)%32);

PowerShell v2 +, 44 octets

-join([char[]]$args[0]|%{"{0:D2}"-f($_%32)})

Prend l'entrée $args[0], la chartransforme en tableau, alimente une boucle. À chaque itération, nous prenons le $_modulo de caractère actuel 32, qui est implicitement converti en valeur ASCII. Idéalement ;-), ces lignes de façon à ce a = 1, b = 2, etc. qui se nourrissaient dans l' -fopérateur Ormat, fonctionnant sur chaîne "{0:D2}", qui spécifie un minimum de deux chiffres (elle est précédée d' un chef de file si nécessaire zéro). Ces chaînes de chiffres sont encapsulées dans des parens, éditées -joinensemble en une seule chaîne et laissées sur le pipeline. La sortie via implicite Write-Outputse produit à la fin du programme.

PS C:\Tools\Scripts\golfing> .\encode-alphabet-cipher.ps1 'hello'
0805121215

PS C:\Tools\Scripts\golfing> .\encode-alphabet-cipher.ps1 'helloworld'
08051212152315181204

PS C:\Tools\Scripts\golfing> .\encode-alphabet-cipher.ps1 'codegolf'
0315040507151206

PS C:\Tools\Scripts\golfing> .\encode-alphabet-cipher.ps1 'johncena'
1015081403051401

Perl, 24 octets

Comprend +1 pour -p

Donnez votre avis sur STDIN:

encode.pl <<< hello

encode.pl

#!/usr/bin/perl -p
s/./substr 4+ord$&,1/eg

DASH , 27 octets

@><""(->@rstr["."""]+4#0)#0

Exemple d'utilisation:

(@><""(->@rstr["."""]+4#0)#0)"helloworld"

Explication

@ (                         #. take input through a lambda
  join "" (                 #. join with newlines the following:
    (map                    #. result of mapping
      @ (                   #. this lambda
        rstr ["." ; ""] (     #. replace first char w/ empty string:
          + 4 #0               #. mapped item's codepoint + 4
        )
      )
    ) #0                    #. over the argument
  )
)

Lot, 256 239 237 octets

@echo off
set/ps=
set r=
set a=abcdefghijklmnopqrstuvwxyz
:g
set c=%a%
for /l %%i in (101,1,126)do call:l %%i
set s=%s:~1%
if not "%s%"=="" goto g
echo %r%
exit/b
:l
set i=%1
if %c:~,1%==%s:~,1% set r=%r%%i:~1%
set c=%c:~1%

Prend entrée sur STDIN.

IBM PC DOS 8088 Assembly, 33 28 27 octets

Binaire assemblé:

00000000: be82 00ac 2c60 7812 d40a 0530 3092 86f2  ....,`x....00...
00000010: b402 cd21 86f2 cd21 ebe9 c3              ...!...!...

Non assemblé:

BE 0082     MOV  SI, 82H        ; point SI to command line string 
        CH_LOOP: 
AC          LODSB               ; load next char into AL
2C 60       SUB  AL, 'a'-1      ; convert ASCII to a=1,b=2...z=26 
78 12       JS   DONE           ; if char is terminator or not valid, exit
D4 0A       AAM                 ; convert binary to BCD 
05 3030     ADD  AX, '00'       ; convert BCD to ASCII 
92          XCHG DX, AX         ; save AX to DX for display 
86 F2       XCHG DH, DL         ; reverse bytes 
B4 02       MOV  AH, 2          ; DOS display char function 
CD 21       INT  21H            ; write first digit 
86 F2       XCHG DH, DL         ; reverse bytes back 
CD 21       INT  21H            ; write second digit 
EB E9       JMP  CH_LOOP        ; restart loop 
        DONE: 
C3          RET                 ; return to DOS

Exécutable PC DOS autonome. Chaîne d'entrée depuis la ligne de commande, sortie vers la console.

E / S:

MATL , 11 octets

96-OH&YA!1e

Essayez-le en ligne!

         % Implicit input
96-      % Subtract 96. So 'a' becomes 1, 'b' becomes 2 etc
OH&YA    % Convert each number to 2 decimal digits. Gives a 2-column matrix
!1e      % Transpose and linearize into a row
         % Implicit display

Rubis, 53 46 octets

->s{s.chars.map{|c|(c.ord-96).to_s.rjust(2,?0)}.join}

->s{s.chars.map{|c|(c.ord+4).to_s[1..2]}.join}

R, 71 51 octets

Enregistré 20 octets grâce à Billywob. Prend les entrées de stdin et les sorties vers stdout.

cat(sprintf("%02d",utf8ToInt(scan(,""))-96),sep="")

Exemples:

helloworld -> 08051212152315181204

codegolf -> 0315040507151206

alphabetcipher -> 0112160801020520030916080518

johncena -> 1015081403051401

En fait , 10 octets

Utilisation de l'algorithme soigné dans la réponse 05AB1E d'Adnan . Suggestions de golf bienvenues. Essayez-le en ligne!

O4+`$pX`MΣ

Ungolfing

         Implicit input s.
O        ord() every char in s.
4+       Add 4 to every ord in s.
`...`M   Map the following function over s. Variable m.
  $        Push str(m).
  pX       Discard the first char of str(m).
           Invariably this is a `1` and we get our ciphered m.
Σ        sum() everything to get one string.
         Implicit return.

Groovy, 51 octets

{it.collect{(((int)it-96)+"").padLeft(2,"0")}.join()}

Labyrinthe, 40 octets

      ,")@
!{_10%! (
/       _
01_}:-69"

Befunge-98, 19 octets

#@~'`-:a/'0+,a%'0+,

Groovy - 31 octets

Conversion Groovy de la solution de NumberKnot en java:

{it.each {printf ("% 02d", it-96)}}

Exemple ici utilisant différentes options:

http://ideone.com/vd0dTX

Pyke, 7 octets

F.oOO`t

Essayez-le ici!

F       -  for i in input:
 .o     -       ord(i)
   OO   -      ^ + 4
     `  -     str(^)
      t -    ^[1:]
        - sum(^)

C #, 54 octets

s=>String.Join("",s.Select(n=>(n<106?"0":"")+(n-96)));