Cho một chuỗi chỉ chứa các chữ cái viết thường, mã hóa chuỗi đó bằng mật mã bảng chữ cái.

Để mã hóa bằng mật mã bảng chữ cái (tôi sẽ sử dụng ví dụ hello):

1. Đầu tiên, chuyển đổi từng chữ cái trong chuỗi thành một số tùy thuộc vào vị trí của nó trong bảng chữ cái ( a= 1, b= 2, v.v.) Ví dụ:8 5 12 12 15
2. Pad mỗi số đến hai ký tự với 0s. Thí dụ:08 05 12 12 15
3. Tham gia. Thí dụ:0805121215

Các trường hợp thử nghiệm

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

Hãy nhớ rằng, đây là mã golf , vì vậy mã có số byte ít nhất sẽ thắng.

05AB1E , 11 6 byte

Mã số:

Ç4+€¦J

Giải trình:

Đầu tiên, chúng tôi chuyển đổi chuỗi thành giá trị ASCII của chúng. codegolfsẽ trở thành:

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

Để đến các chỉ số của bảng chữ cái, bạn trừ đi 96:

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

Để đệm với số không, thêm 100vào từng phần tử và xóa ký tự đầu tiên của mỗi int. Đối với ví dụ trên, +100sẽ là:

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

Và loại bỏ ký tự đầu tiên của mỗi sẽ dẫn đến:

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

Chúng ta có thể hợp nhất cả hai bước trên (phần -96và phần +100) thành +4. Đối với mã:

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

Hãy thử trực tuyến!

Python 2, 42 byte

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

Kiểm tra nó trên Ideone .

Bình thường, 11 10 byte

FNwpt`+4CN

Thử nó! Chuyến đi đầu tiên của tôi tại 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)

Python tương đương:

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

C, 55 43 byte

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

thần tượng

Python, 46 byte

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

Khá đơn giản. Hãy thử nó trên repl.it!

Thạch , 9 7 byte

O+4ṾḊ$€

Dùng thử

Làm sao?

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, bốn mươi 30 28 byte

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

Sử dụng +4cách tiếp cận từ câu trả lời của Adnan giúp tiết kiệm 14 byte.

Hãy thử nó trên Ideone. Sử dụng:

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

Hai byte tắt nhờ xnor . Phiên bản cũ:

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

Perl, 29 byte

28 byte mã + -ncờ.

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

Chạy với:

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

JavaScript (ES6), 52 49 byte

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

Đệ quy hóa ra ngắn hơn 3 byte so với .replace:

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

parseInt(s,36)dài hơn một chút cho mỗi cách tiếp cận, vì bạn phải thay đổi 4thành 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 byte

¡4+Xc)s s1

Có lẽ không được ngắn hơn thế này ...

Kiểm tra nó trực tuyến!

Giải trình

¡           // 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 byte

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

MATL, 12 11 byte

Lưu 1 byte nhờ @Luis

4+!V4LZ)!le

Dùng thử trực tuyến

Lục giác , 33 byte

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

Hãy thử trực tuyến!

Mm .. có một vài no-op trong Hexagon vì vậy tôi đưa ngày hôm nay vào.

Biểu mẫu được mở rộng với ngày được thay thế bằng no-ops

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

1. Khởi tạo a 10và di chuyển Con trỏ Bộ nhớ đến một nơi nào đó ...
2. $bỏ qua gương và ,đọc một byte. <chi nhánh:
3. Nếu kết thúc chuỗi ( -1không tích cực), nó đi đến @và chấm dứt chương trình.
4. Mặt khác, nó trừ 95(giảm a), và sau đó chúng tôi in result / 10(chia số nguyên) result % 10và lặp lại.

Vim, 60 tổ hợp phím

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

Một giải pháp dựa trên regex gần như hoàn toàn. Như thường lệ, sử dụng thanh ghi eval làm cho nó dài một cách khó hiểu.

PHP, 58 byte

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

PowerShell v2 +, 44 byte

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

Đưa đầu vào $args[0], biến nó thành một char-array, đưa vào một vòng lặp. Mỗi lần lặp lại, chúng ta lấy $_modulo ký tự hiện tại 32, ngầm định là giá trị ASCII. Thuận tiện ;-), dòng này lên như vậy a = 1, b = 2, v.v. Điều đó được đưa vào -ftoán tử ormat, hoạt động trên chuỗi "{0:D2}", trong đó chỉ định mức tối thiểu hai chữ số (nghĩa là, nó có số 0 đứng đầu nếu cần). Các chuỗi chữ số đó được gói gọn trong các ô, -joinghép lại thành một chuỗi và để lại trên đường ống. Đầu ra thông qua ngầm Write-Outputxảy ra ở kết luận chương trình.

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 byte

Bao gồm +1 cho -p

Cung cấp đầu vào trên STDIN:

encode.pl <<< hello

encode.pl

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

DASH , 27 byte

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

Ví dụ sử dụng:

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

Giải trình

@ (                         #. 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
  )
)

Hàng loạt, 256 239 237 byte

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

Đưa đầu vào vào STDIN.

Hội đồng IBM PC DOS 8088, 33 28 27 byte

Lắp ráp nhị phân:

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

Chưa được lắp ráp:

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

PC DOS độc lập thực thi. Chuỗi đầu vào từ dòng lệnh, đầu ra đến bàn điều khiển.

Tôi / O:

MATL , 11 byte

96-OH&YA!1e

Hãy thử trực tuyến!

         % 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

Ruby, 53 46 byte

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

Đã lưu 20 byte nhờ Billywob. Đưa đầu vào từ stdin và đầu ra thành thiết bị xuất chuẩn.

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

Ví dụ:

hellowworld -> 08051212152315181204

cá tuyết -> 0315040507151206

bảng chữ cái mật mã -> 0112160801020520030916080518

johncena -> 1015081403051401

Trên thực tế , 10 byte

Sử dụng thuật toán gọn gàng trong câu trả lời 05AB1E của Adnan . Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

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 byte

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

Mê cung, 40 byte

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

Befunge-98, 19 byte

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

Groovy - 31 byte

Chuyển đổi Groovy của giải pháp NumberKnot trong java:

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

Ví dụ ở đây sử dụng các tùy chọn khác nhau:

http://ideone.com/vd0dTX

Pyke, 7 byte

F.oOO`t

Hãy thử nó ở đây!

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

C #, 54 byte

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