एक स्ट्रिंग को देखते हुए जिसमें केवल लोअरकेस अक्षर होते हैं, उस स्ट्रिंग को वर्णमाला सिफर के साथ एनकोड करते हैं।

वर्णमाला सिफर के साथ सांकेतिक शब्दों में बदलना (मैं उदाहरण का उपयोग किया जाएगा hello):

पहले, वर्ण में प्रत्येक अक्षर को वर्णमाला में उसकी स्थिति के आधार पर संख्या में परिवर्तित करें ( a= 1, b= 2, आदि) उदाहरण:8 5 12 12 15
प्रत्येक संख्या को दो वर्णों के साथ पैड करें 0। उदाहरण:08 05 12 12 15
में शामिल हों। उदाहरण:0805121215

परीक्षण के मामलों

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

याद रखें, यह कोड-गोल्फ है , इसलिए सबसे कम संख्या में बाइट्स जीतता है।

— ओलिवर नी
स्रोत

सम्बंधित।

— ओलिवर नी

23

05AB1E , 11 6 बाइट्स

कोड:

Ç4+€¦J

स्पष्टीकरण:

सबसे पहले, हम स्ट्रिंग को उनके ASCII मानों में बदलते हैं। codegolfबन जाएगा:

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

वर्णमाला के सूचकांकों के लिए, आप घटाते हैं 96:

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

शून्य के साथ पैड करने के लिए, 100प्रत्येक तत्व में जोड़ें और प्रत्येक इंट के पहले चरित्र को हटा दें। उपरोक्त उदाहरण के लिए, +100यह होगा:

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

और प्रत्येक के पहले चरित्र को हटाने से निम्न होगा:

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

हम ऊपर ( -96और +100) भाग दोनों चरणों को सिर्फ मर्ज कर सकते हैं +4। कोड के लिए:

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

इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

¦फिर क्या करता है?

— मैजिक ऑक्टोपस यूरिन

@carusocomputing एक स्ट्रिंग, सूची, आदि के पहले तत्व को निकालता है

— अदनान

प्रतिभा से परे ...

— मैजिक ऑक्टोपस Urn

12

पायथन 2, 42 बाइट्स

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

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

5

गैर पुनरावर्ती, एक ही बाइट गिनती:lambda s:''.join(`ord(x)+4`[1:]for x in s)

— जोनाथन एलन

8

अजगर, 11 10 बाइट्स

FNwpt`+4CN

कोशिश करो! मेरी पहली पायथ पर है।

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)

पायथन समकक्ष:

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

— Artyer
स्रोत

अपने पहले पायथ कार्यक्रम पर अच्छी नौकरी!

— हायपरनीट्रीनो

7

सी, 55 43 बाइट्स

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

ideone

— o79y
स्रोत

1

printf("%02d",*c++-96);}अगर मैं गलत नहीं हूँ तो छोटा और वैध है।

— दादा

6

पायथन, 46 बाइट्स

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

बहुत सीधा। यह repl.it पर कोशिश करो!

— Loovjo
स्रोत

1

वाह, एक ही बाइट गिनती के साथ दो पूरी तरह से अलग प्रयास;)

— केड

6

जेली , 9 7 बाइट्स

O+4ṾḊ$€

TryItOnline

कैसे?

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"

— जोनाथन एलन
स्रोत

मैं O+4DḊ€FṾ€उसी गिनती के लिए आया था , शायद गोल्फ

— ETHproductions

@ETHproductions O+4Ṿ€Ḋ€2 बाइट्स बचाता है।

— डेनिस

@ डेनिस मैंने अभी भी (ईश) ...

— जोनाथन एलन

4

हास्केल, चालीसफोर 30 28 बाइट्स

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

अदनान के जवाब+4 से दृष्टिकोण का उपयोग करके 14 बाइट्स बचाता है।

Ideone पर इसे आज़माएं। उपयोग:

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

दो बाइट्स xnor के लिए धन्यवाद । पुराना संस्करण:

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

— Laikoni
स्रोत

आपको Parens के दूसरे सेट की आवश्यकता नहीं है।

— xnor

3

पर्ल, 29 बाइट्स

कोड + -nध्वज के 28 बाइट्स ।

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

साथ दौड़ो :

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

— बापू
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 52 49 बाइट्स

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

रिकर्सियन 3 बाइट्स से कम निकला .replace:

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

parseInt(s,36)प्रत्येक दृष्टिकोण के लिए थोड़ा लंबा है, क्योंकि आपको इसे बदलना 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)

— ETHproductions
स्रोत

3

जाप, 10 बाइट्स

¡4+Xc)s s1

शायद इससे कम नहीं मिलता ...

इसे ऑनलाइन टेस्ट करें!

व्याख्या

¡           // 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
स्रोत

3

जावा 7,60 बाइट्स

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

— Numberknot
स्रोत

यह उत्तर मान्य नहीं हो सकता है क्योंकि यह char[]इसके बजाय लेता है String।

— हाइपरन्यूट्रिनो

1

@AlexL। पात्रों की सूचियों को तार माना जाता है।

— मार्टिन एंडर

@MartinEnder ठीक है। स्पष्टीकरण के लिए धन्यवाद। इस उत्तर में मेरा उत्थान है।

— हाइपरनेत्रिनो

3

MATL, 12 11 बाइट्स

1 बाईट ने @Luis को धन्यवाद दिया

4+!V4LZ)!le

इसे ऑनलाइन आज़माएं

— Suever
स्रोत

3

हेक्सागोनी , 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

हम्म .. षट्कोण में कुछ नो-ऑप्स मिले इसलिए मैंने आज की तारीख डाल दी।

नो-ऑप्स द्वारा प्रतिस्थापित तिथि के साथ विस्तारित फॉर्म

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

आरंभिक करें 10और मेमोरी पॉइंटर को कहीं ले जाएं ...
$दर्पण छोड़ देता है और ,एक बाइट पढ़ता है। <शाखाओं:
यदि स्ट्रिंग का अंत ( -1जो गैर-सकारात्मक है) तो यह @कार्यक्रम में जाता है और समाप्त हो जाता है ।
अन्यथा यह घटता 95(घटता a) है, और फिर हम result / 10(पूर्णांक विभाजन) प्रिंट करते हैं result % 10और फिर से लूप करते हैं।

— सनी पुं ०
स्रोत

2

विम, 60 कीस्ट्रोक्स

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

एक लगभग पूरी तरह से रेगेक्स आधारित समाधान। हमेशा की तरह, eval register का उपयोग करने से यह अश्लील हो जाता है।

— DJMcMayhem
स्रोत

2

PHP, 58 बाइट्स

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

— जार्ग हुल्सरमैन
स्रोत

आप एक स्ट्रिंग 50 बाइट्स TIO या $argn 47 बाइट्स TIO के माध्यम से -11 बाइट्स इनपुट के रूप में पुनरावृत्ति कर सकते हैं -8 बाइट्स ।

— 640KB

2

PowerShell v2 +, 44 बाइट्स

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

इनपुट लेता है $args[0], इसे एक char-रे के रूप में रखता है, एक लूप में फीड करता है। प्रत्येक पुनरावृत्ति, हम वर्तमान वर्ण $_मोडुलो को लेते हैं 32, जो संक्षेप में ASCII मान के रूप में आता है। आसानी से ;-), यह रेखाएँ ऐसा करती हैं a = 1, b = 2, इत्यादि, जो -fऑर्माट ऑपरेटर में खिलाया जाता है , स्ट्रिंग पर काम करता है "{0:D2}", जो दो अंकों को न्यूनतम निर्दिष्ट करता है (यानी, यदि आवश्यक हो तो यह एक अग्रणी शून्य को प्रस्तुत करता है)। अंकों के उन तारों को Parens में समझाया जाता है, -joinएक साथ एक स्ट्रिंग में संपादित किया जाता है, और पाइप लाइन पर छोड़ दिया जाता है। निहितार्थ के माध्यम से आउटपुट Write-Outputकार्यक्रम के समापन पर होता है।

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
स्रोत

2

पर्ल, 24 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट दें:

encode.pl <<< hello

encode.pl

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

— टन हास्पेल
स्रोत

अच्छी तरह से किया। मुझे लगता है कि आप शायद 4+ord$&इसके बजाय मतलब 5+ord$&;-)

— दादा

@ दादा राइट, परीक्षण किए गए संस्करण के बजाय मेरे स्निपेट बफर के संस्करण को फिर से चिपकाया गया

— टन एचएसएल

होता है! :) क्या मैं आपसे एक असंबंधित प्रश्न पूछ सकता हूं? क्या आपके पास कोई विचार है कि इस प्रश्न के 8 बाइट्स पर्ल समाधान (इनपुट को उल्टा) (अराजकता पर) क्या है?

— दादा

@ दादा का कहना है कि शुद्ध पर्ल में यह असंभव है, इसलिए मुझे उम्मीद है कि यह उस तरफ स्वचालित प्रणाली का कुछ दुरुपयोग है। उदाहरण के लिए यदि इनपुट STDIN से आता है, तो आप कर सकते हैंexec rev

— Ton Hospel

सही है, कि समझ में आता है, धन्यवाद! मैं एक मुश्किल समय लगा रहा था क्योंकि printयह 5 बाइट्स है, <>2 अधिक है, इसलिए मैं सोच रहा था कि मैं क्या करने के बारे में नहीं सुना था रिवर्स करने के लिए 1 बाइट बिलिन था!

— दादा

2

डीएएसएच , 27 बाइट्स

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

उदाहरण का उपयोग:

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

व्याख्या

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

— मामा फन रोल
स्रोत

2

बैच, 256 239 237 बाइट्स

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

STDIN पर इनपुट लेता है।

— नील
स्रोत

2

आईबीएम पीसी डॉस 8088 विधानसभा, 33 28 27 बाइट्स

इकट्ठे बाइनरी:

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

unassembled:

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

स्टैंडअलोन पीसी डॉस निष्पादन योग्य। कमांड लाइन से इनपुट स्ट्रिंग, कंसोल के लिए आउटपुट।

मैं / हे:

— 640KB
स्रोत

1

MATL , 11 बाइट्स

96-OH&YA!1e

इसे ऑनलाइन आज़माएं!

         % 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

— लुइस मेंडो
स्रोत

1

रूबी, 53 46 बाइट्स

~~->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
स्रोत

1

आर, 71 51 बाइट्स

बिलीवोब के लिए धन्यवाद 20 बाइट्स बचाए। स्टड से इनपुट लेता है और स्टडआउट को आउटपुट देता है।

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

उदाहरण:

हेलोवर्ल्ड -> 08051212152315181204

कोडगॉल्फ -> 0315040507151206

वर्णमाला -> 0112160801020520030916080518

जॉन्सेना -> 1015081403051401

— rturnbull
स्रोत

आप utf8toInt(scan(,"))-96पूरे मैच की चीज के बजाय उपयोग कर सकते हैं । लगता है कि हालांकि गद्दी को संभालने का एक बेहतर तरीका नहीं है।

— बिलीवोब

@ बिलीवॉब थैंक्स! पैडिंग के लिए, मैंने formatCपहले का उपयोग करने की कोशिश की, लेकिन वर्तमान दृष्टिकोण की तुलना में एक और बाइट की आवश्यकता के रूप में काम किया।

— रटर्नबुल

1

दरअसल , 10 बाइट्स

में स्वच्छ एल्गोरिथ्म का उपयोग करना अदनान के 05AB1E उत्तर । गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

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
स्रोत

0

ग्रूवी, 51 बाइट्स

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

— जादू ऑक्टोपस Urn
स्रोत

0

भूलभुलैया, 40 बाइट्स

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

— ninjalj
स्रोत

0

Befunge-98, 19 बाइट्स

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

— ninjalj
स्रोत

0

ग्रूवी - 31 बाइट्स

जावा में NumberKnot के समाधान का Groovy रूपांतरण:

{{It.each printf ( "% 02d", यह-96)}}

विभिन्न विकल्पों का उपयोग करके यहां उदाहरण:

http://ideone.com/vd0dTX

— GolfIsAGoodWalkSpoilt
स्रोत

0

Pyke, 7 बाइट्स

F.oOO`t

यहाँ यह कोशिश करो!

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

— नीला
स्रोत

0

सी #, 54 बाइट्स

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

— downrep_nation
स्रोत

वर्णमाला सिफर को एनकोड करें

परीक्षण के मामलों

05AB1E , 11 6 बाइट्स

पायथन 2, 42 बाइट्स

अजगर, 11 10 बाइट्स

सी, 55 43 बाइट्स

पायथन, 46 बाइट्स

जेली , 9 7 बाइट्स

कैसे?

हास्केल, चालीसफोर 30 28 बाइट्स

पर्ल, 29 बाइट्स

जावास्क्रिप्ट (ईएस 6), 52 49 बाइट्स

जाप, 10 बाइट्स

व्याख्या

जावा 7,60 बाइट्स

MATL, 12 11 बाइट्स

हेक्सागोनी , 33 बाइट्स

नो-ऑप्स द्वारा प्रतिस्थापित तिथि के साथ विस्तारित फॉर्म

विम, 60 कीस्ट्रोक्स

PHP, 58 बाइट्स

PowerShell v2 +, 44 बाइट्स

पर्ल, 24 बाइट्स

डीएएसएच , 27 बाइट्स

व्याख्या

बैच, 256 239 237 बाइट्स

आईबीएम पीसी डॉस 8088 विधानसभा, 33 28 27 बाइट्स

MATL , 11 बाइट्स

रूबी, 53 46 बाइट्स

आर, 71 51 बाइट्स

दरअसल , 10 बाइट्स

ग्रूवी, 51 बाइट्स

भूलभुलैया, 40 बाइट्स

Befunge-98, 19 बाइट्स

ग्रूवी - 31 बाइट्स

Pyke, 7 बाइट्स

सी #, 54 बाइट्स