Codifique a cifra do alfabeto

24

Dada uma sequência que contém apenas letras minúsculas, codifique essa sequência com a cifra do alfabeto.

Para codificar com a cifra do alfabeto (usarei o exemplo hello):

  1. Primeiro, converta cada letra da string em um número, dependendo da sua posição no alfabeto ( a= 1, b= 2, etc.) Exemplo:8 5 12 12 15
  2. Coloque cada número com dois caracteres com 0s. Exemplo:08 05 12 12 15
  3. Junte-se. Exemplo:0805121215

Casos de teste

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

Lembre-se, isso é , portanto o código com o menor número de bytes vence.

Oliver Ni
fonte
Relacionado.
Oliver Ni

Respostas:

23

05AB1E , 11 6 bytes

Código:

Ç4+€¦J

Explicação:

Primeiro, convertemos a string em seus valores ASCII. codegolfse tornaria:

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

Para chegar aos índices do alfabeto, subtraia 96:

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

Para preencher com zeros, adicione 100a cada elemento e remova o primeiro caractere de cada int. Para o exemplo acima, +100seria:

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

E remover o primeiro caractere de cada um levaria a:

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

Podemos mesclar os dois passos acima (o -96e o +100) da parte apenas +4. Para o código:

Ç       # 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

Experimente online!

Adnan
fonte
O que ¦faz de novo?
Magic Octopus Urn
@carusocomputing Remove o primeiro elemento de uma string, lista etc.
Adnan
Além gênio ...
Magia Octopus Urna
12

Python 2, 42 bytes

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

Teste em Ideone .

Dennis
fonte
5
Não recursivo, mesma contagem de bytes:lambda s:''.join(`ord(x)+4`[1:]for x in s)
Jonathan Allan
8

Pitão, 11 10 bytes

FNwpt`+4CN

Tente! Minha primeira vez em 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)

Equivalente em Python:

for N in input():
    print(repr(ord(N) + 4)[1:], end='')
Artyer
fonte
Bom trabalho no seu primeiro programa Pyth!
HyperNeutrino
7

C, 55 43 bytes

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

ideona

o79y
fonte
11
printf("%02d",*c++-96);}é mais curto e válido se não me engano.
Dada
6

Python, 46 bytes

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

Bem direto. Experimente em repl.it!

Loovjo
fonte
11
Uau, duas tentativas completamente diferentes com o mesmo byte de contagem;)
Kade
6

Geléia , 9 7 bytes

O+4ṾḊ$€

TryItOnline

Quão?

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"
Jonathan Allan
fonte
Eu vim com O+4DḊ€FṾ€a mesma contagem, talvez golfable
ETHproductions
@ETHproductions O+4Ṿ€Ḋ€economiza 2 bytes.
Dennis
@ Dennis Eu apenas fiz o mesmo (ish) ...
Jonathan Allan
4

Haskell, quarenta e quatro 30 28 bytes

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

Usar a +4abordagem da resposta de Adnan economiza 14 bytes.

Experimente em Ideone. Uso:

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

Dois bytes de desconto graças ao xnor . Versão antiga:

f a=['0'|a<'k']++(show$fromEnum a-96)
(f=<<)
Laikoni
fonte
Você não precisa do segundo conjunto de parênteses.
Xnor
3

Perl, 29 bytes

28 bytes de código + -nsinalizador.

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

Correr com :

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

JavaScript (ES6), 52 49 bytes

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

A recursão acabou sendo 3 bytes menor que .replace:

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

parseInt(s,36)é um pouco mais longo para cada abordagem, porque você precisa mudar 4para 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)
ETHproductions
fonte
3

Japonês, 10 bytes

¡4+Xc)s s1

Provavelmente não fica mais curto que isso ...

Teste online!

Explicação

¡           // 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
ETHproductions
fonte
3

Java 7,60 bytes

void f(char[]s){for(int i:s)System.out.printf("%02d",i-96);} 
Numberknot
fonte
Esta resposta pode não ser válida porque leva um em char[]vez de a String.
HyperNeutrino
@MartinEnder Okay. Obrigado pelo esclarecimento. Esta resposta tem o meu voto positivo.
HyperNeutrino
3

MATL, 12 11 bytes

1 byte salvo graças a @Luis

4+!V4LZ)!le

Experimente Online

Suever
fonte
3

Hexagonia , 33 bytes

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

Experimente Online!

Mm .. tenho algumas no-ops no Hexagon, então eu coloquei a data de hoje.

Formulário expandido com data substituída por no-ops

   1 0 } {
  ' a ( { =
 ! { { \ . @
. . $ \ , < .
 - " : ! \ >
  . . . \ %
   . . . .
  1. Inicialize ae 10mova o Ponteiro de Memória para algum lugar ...
  2. $pula o espelho e ,lê um byte. <ramos:
  3. Se o final da string ( -1que não é positivo) vai @e finaliza o programa.
  4. Caso contrário, subtrai 95(diminui a) e depois imprimimos result / 10(divisão inteira) e fazemos um result % 10loop novamente.
Sunny Pun
fonte
2

Vim, 60 pressionamentos de tecla

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

Uma solução quase inteiramente baseada em regex. Como sempre, o uso do registro eval o torna obscenamente longo.

DJMcMayhem
fonte
2

PHP, 58 bytes

foreach(str_split($argv[1])as$c)printf("%02d",ord($c)%32);
Jörg Hülsermann
fonte
você pode -8 bytes iterando como uma seqüência de 50 bytes TIO ou -11 bytes de entrada via $argn 47 bytes TIO .
640KB
2

PowerShell v2 +, 44 bytes

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

Pega entrada $args[0], lança como um chararray, alimenta um loop. A cada iteração, tomamos o $_módulo de caractere atual 32, que é convertido implicitamente como o valor ASCII. Convenientemente ;-), isso alinha assim a = 1, b = 2, etc. Isso é alimentado no -foperador ormat, operando na string "{0:D2}", que especifica um mínimo de dois dígitos (ou seja, ele precede um zero à esquerda, se necessário). Essas cadeias de dígitos são encapsuladas em parênteses, -joinagrupadas em uma cadeia e deixadas no pipeline. A saída via implícita Write-Outputacontece na conclusão do programa.

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
AdmBorkBork
fonte
2

Perl, 24 bytes

Inclui +1 para -p

Dê entrada no STDIN:

encode.pl <<< hello

encode.pl

#!/usr/bin/perl -p
s/./substr 4+ord$&,1/eg
Ton Hospel
fonte
Bem feito. Eu acho que você provavelmente quis dizer em 4+ord$&vez de 5+ord$&;-) #
Dada
@Dada direito, colado a versão do meu trecho tampão em vez da versão testada novamente
Ton Hospel
Acontece! :) Posso fazer uma pergunta não relacionada? Você tem alguma idéia de qual é a solução perl de 8 bytes para esta pergunta (inverta a entrada) (na anarquia)?
Dada
@ Dadá eu diria que é impossível em perl puro, então espero que seja algum abuso do sistema automatizado nesse lado. Por exemplo, se a entrada veio de STDIN você poderia fazerexec rev
Ton Hospel
Certo, isso faz sentido, obrigado! Eu estava tendo dificuldade para descobrir isso, já que printsão 5 bytes, <>são mais 2, então eu queria saber qual era o byte de 1 byte para reverter do qual nunca tinha ouvido falar!
Dada
2

DASH , 27 bytes

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

Exemplo de uso:

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

Explicação

@ (                         #. 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
  )
)
Mama Fun Roll
fonte
2

Lote, 256 239 237 bytes

@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%

Recebe entrada em STDIN.

Neil
fonte
2

Conjunto IBM PC DOS 8088, 33 28. 27 bytes

Binário montado:

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

Desmontado:

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

Executável autônomo do PC DOS. String de entrada da linha de comando, saída para o console.

E / S:

insira a descrição da imagem aqui

640KB
fonte
1

MATL , 11 bytes

96-OH&YA!1e

Experimente online!

         % 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
Luis Mendo
fonte
1

Ruby, 53 46 bytes

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

dkudriavtsev
fonte
1

R, 71 51 bytes

Economizou 20 bytes graças a Billywob. Leva a entrada de stdin e as saídas para stdout.

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

Exemplos:

helloworld -> 08051212152315181204

codegolf -> 0315040507151206

alfabetocifra -> 0112160801020520030916080518

johncena -> 1015081403051401

rturnbull
fonte
Você pode usar em utf8toInt(scan(,"))-96vez da coisa toda da partida. Não pense que há uma maneira melhor de lidar com o preenchimento.
Billywob #
@Billywob Thanks! Para o preenchimento, tentei usar formatCmais cedo, mas funcionou como necessitando de mais um byte do que a abordagem atual.
rturnbull
1

Na verdade , 10 bytes

Usando o algoritmo puro na resposta 05AB1E de Adnan . Sugestões de golfe são bem-vindas. Experimente online!

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.
Sherlock9
fonte
0

Groovy, 51 bytes

{it.collect{(((int)it-96)+"").padLeft(2,"0")}.join()}
Urna de polvo mágico
fonte
0

Labirinto, 40 bytes

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

Befunge-98, 19 bytes

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

Groovy - 31 bytes

Conversão groovy da solução da NumberKnot em java:

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

Exemplo aqui usando várias opções:

http://ideone.com/vd0dTX

GolfIsAGoodWalkSpoilt
fonte
0

Pyke, 7 bytes

F.oOO`t

Experimente aqui!

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

C #, 54 bytes

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