परिचय:

मेरे पास एक दस्तावेज के रूप में संग्रहीत विभिन्न सिफर का भार है, जिन्हें मैंने एक बार एक बच्चे के रूप में संकलित किया था, मैंने उनमें से कुछ को चुना जो मुझे लगा कि चुनौतियों के लिए सबसे उपयुक्त थे (बहुत तुच्छ नहीं, और बहुत कठिन नहीं) और उन्हें चुनौतियों में बदल दिया। उनमें से ज्यादातर अभी भी सैंडबॉक्स में हैं, और मुझे अभी तक यकीन नहीं है कि मैं उन सभी को पोस्ट करूंगा या केवल कुछ। यहां तीसरा और सबसे आसान एक ( कंप्यूटर सिफर और ट्रायफिड सिफर के बाद मैंने पहले पोस्ट किया है) है।

एक घड़ी सिफर के साथ हम निम्न छवि का उपयोग पाठ को एनिलिश करने के लिए करते हैं:

तो जैसे एक वाक्य this is a clock cipherबन जाएगा:

t  h i s     i s     a     c l  o  c k     c i p  h e r    (without additional spaces of course, but added as clarification)
19:7:8:18:00:8:18:00:AM:00:2:11:14:2:10:00:2:8:15:7:4:17

चुनौती:

एक स्ट्रिंग को देखते हुए sentence_to_encipher, जैसा कि ऊपर बताया गया है, उसे लागू करें।

चुनौती नियम:

आप मान सकते हैं कि sentence_to_encipherवसीयत में केवल अक्षर और स्थान होंगे।
आप पूर्ण लोअरकेस या पूर्ण अपरकेस का उपयोग कर सकते हैं (कृपया बताएं कि आपने अपने उत्तर में किसका उपयोग किया है)।
आप एकल अंक enciphered पत्र के लिए अग्रणी शून्य जोड़ने की अनुमति नहीं कर रहे हैं bके माध्यम से jहै, लेकिन दो शून्य 00रिक्त स्थान के लिए अनिवार्य हैं।
आपको :विभाजक के रूप में उपयोग करना चाहिए , और एक अतिरिक्त अग्रणी या अनुगामी :की अनुमति नहीं है।
आप उपयोग लोअरकेस करने की अनुमति है amऔर pmअपरकेस के बजाय AMऔर PM, जब तक कि यह संगत के रूप में।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
डिफ़ॉल्ट I / O नियमों के साथ आपके जवाब के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
डिफ़ॉल्ट लूपोल्स वर्जित हैं।
यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ना अत्यधिक अनुशंसित है।

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

Input:  "this is a clock cipher"
Output: "19:7:8:18:00:8:18:00:AM:00:2:11:14:2:10:00:2:8:15:7:4:17"

Input:  "test"
Output: "19:4:18:19"

Input:  "what time is it"
Output: "22:7:AM:19:00:19:8:12:4:00:8:18:00:8:19"

Input:  "acegikmoqsuwy bdfhjlnprtvxz"
Output: "AM:2:4:6:8:10:12:14:16:18:20:22:24:00:1:3:5:7:9:11:13:15:17:19:21:23:PM"

Input:  "easy peazy"
Output: "4:AM:18:24:00:15:4:AM:PM:24"

— केविन क्रूज़सेन
स्रोत

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

lambda s:':'.join(['AM','PM','00',`ord(c)-97`]['az '.find(c)]for c in s)

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

सभी लोअरकेस के रूप में इनपुट लेता है

— TFeld
स्रोत

5

05AB1E , 22 21 बाइट्स

„AM24L„PM00)˜Að«s‡':ý

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

कुछ वैकल्पिक 21 बाइट समाधान:

':ýAð«24L„AMš„PMª00ª‡
00„AM24L„PM)˜AIk>è':ý

— Emigna
स्रोत

अच्छा जवाब, मैं कई दृष्टिकोणों के माध्यम से 23 बाइट्स प्राप्त करने में कामयाब रहा (जिनमें से एक मेरा वर्तमान में हटा दिया गया उत्तर था)। यह बाइट बचाने के लिए अपने स्टैक की व्यवस्था करने का एक साफ तरीका है!

— श्री एक्सकोडर

1

हमारे उत्तरों को मिलाकर एक वैकल्पिक 22 बटर: इसे ऑनलाइन आज़माएं!

— श्री एक्सकोडर

@ Mr.Xcoder: मेरा पहला विचार वास्तव में ऐसा ही लग रहा था, लेकिन 2 बाइट्स बदतर थे क्योंकि मुझे याद नहीं ªथा कि वह बदल गया था :)

— Emigna

मैंने @ Mr.Xcoder के दृष्टिकोण के एक हिस्से का उपयोग करते हुए 20 बटर पाया है , लेकिन इससे पहले कि मैं इसे फिर से खोल दूं, मैं आपको इसे खुद बता दूंगा। :)

— केविन क्रूज़सेन 10

1

@ केविनक्रूजसेन: मैंने कुछ और

— दिखने के

4

पर्ल 6 , 47 बाइट्स

*.ords>>.&{<<00 AM{1..24}PM>>[$_%32]}.join(":")

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

अनाम जो भी लैम्ब्डा है जो किसी भी मामले की एक स्ट्रिंग लेता है और एन्क्रिप्टेड स्ट्रिंग लौटाता है।

स्पष्टीकरण:

*.ords>>.&{                         } # Map the ordinal values to
           <<              >>[$_%32]  # The index in the list
              00 AM{1..24}PM  # 00, AM, the numbers 1 to 24 and PM
                                     .join(":")   # And join with colons

— मजाक कर रहा है
स्रोत

3

पायथ, 25 बाइट्स

j\:m@+++"AM"S24"PM""00"xG

इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

j\:m@+++"AM"S24"PM""00"xGdQ   Implicit: Q=eval(input()), G=lowercase alphabet
                              Trailing dQ inferred
            S24               [1-24]
       +"AM"                  Prepend "AM"
      +        "PM"           Append "PM"
     +             "00"       Append "00" - this is the dictionary
   m                      Q   Map each element of Q, as d, using:
                       xGd      Get the index of d in G, -1 if not present (i.e. space)
    @                           Get the element from the dictionary at the above index
j\:                           Join the result on ":", implicit print

— सोक
स्रोत

3

जावास्क्रिप्ट (Node.js) , 72 बाइट्स

लोअरकेस में इनपुट लेता है।

s=>[...s].map(c=>c<1?'00':(x=Buffer(c)[0]-1&31)>24?'PM':x||'AM').join`:`

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

— Arnauld
स्रोत

3

जावा (JDK) , 95 बाइट्स

s->{int a=0;for(var c:s)System.out.print((a++<1?"":":")+(c<33?"00":c<66?"AM":c>89?"PM":c-65));}

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

क्रेडिट

-1 केविन क्रूज़सेन को धन्यवाद

— ओलिवियर ग्रेजायर
स्रोत

एक आसान गोल्फ: charकरने के लिए var। :)

— केविन क्रूज़सेन 11

धन्यवाद! अब स्पष्ट है कि आप इसे मुझे दिखाते हैं ...

— ओलिवियर ग्राएगोइरे

3

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 70 बाइट्स

s=>string.Join(":",s.Select(a=>a<33?"00":a<66?"AM":a>89?"PM":a%65+""))

लोअरकेस अक्षरों की एक स्ट्रिंग के रूप में इनपुट लेता है। पहले जाँच करता है कि क्या चर एक स्थान है, और यदि यह है, तो इसे धर्मान्तरित करता है 00। इसके बाद, यह जांचता है कि क्या चार एक ए है, और इसे धर्मान्तरित करता है AM। यह Z के लिए फिर से जाँच करता है और PMयदि यह है तो इसे धर्मान्तरित करता है। अंत में, यदि चार्ट सभी चेक पास करता है, तो यह अपने अल्फ़ाबेटिक ऑर्डर -1 में परिवर्तित हो जाता है।

-2 बाइट्स @ डडाना को धन्यवाद

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

// Input taking a string
s => 
// Join the following IEnumerable<char> with a ":" character
string.Join(":", 
// Map all the characters in the string
s.Select(a => 
// Is the char less than 33, aka a space?
a < 33 ? 
// If so, it's a "00"
"00" 
// Else, is this an 'A'?
: a < 66 ?
// If so, convert it to "AM"
"AM" : 
// If it's not 'A' or a space, could it be a 'Z'?
a > 89 ?
// If it is, turn the character into "PM"
"PM" : 
// If it fails all of the checks above, get the characters position in the alphabet and subtract one from that.
a % 65 + ""))

— अज्ञान का अवतार
स्रोत

2

रूबी , 49 बाइट्स

->a{a.map{|c|["00",:AM,*1..24,:PM][c.ord%32]}*?:}

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

पोर्ट ऑफ़ जो किंग का पर्ल उत्तर । इनपुट को वर्णों के रूप में लेता है, अपरकेस में AM / PM के साथ एक स्ट्रिंग देता है।

— किरिल एल।
स्रोत

2

रेड , 124 121 110 109 बाइट्स

func[s][replace/all form collect[forall s[keep switch/default
c: -97 + s/1[0['AM]25['PM]-65["00"]][c]]]sp":"]

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

— गैलेन इवानोव
स्रोत

2

05AB1E , 20 बाइट्स

':ýð00:A24L„AMš„PMª‡

बहुत से प्रेरित @ Mr.Xcoder द्वारा मौजूदा 05AB1E जवाब की टिप्पणी में की 22-byter @Emigna ।

इनपुट को लोअरकेस वर्णों की सूची के रूप में लेता है ( Sयदि मैं एक स्ट्रिंग के रूप में इनपुट लेता हूं तो एक अग्रणी के साथ 21 बाइट्स होंगे )।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

':ý            '# Join the (implicit) input list of characters by ":"
                #  i.e. ["e","a","s","y"," ","p","e","a","z","y"] → "e:a:s:y: :p:e:a:z:y"
ð00:            # Replace all spaces " " with "00"
                #  i.e. "e:a:s:y: :p:e:a:z:y" → "e:a:s:y:00:p:e:a:z:y"
A               # Push the lowercase alphabet
 24L            # Push a list in the range [1,24]
    „AMš        # Prepend "AM" at the start of this list
        „PMª    # And append "PM" at the end of the list
            ‡   # Transliterate; mapping letters to the list-items at the same indices
                # (and output the result implicitly)
                #  i.e. "e:a:s:y:00:p:e:a:z:y" → "4:AM:18:24:00:15:4:AM:PM:24"

— केविन क्रूज़सेन
स्रोत

1

आह येस। अलग से जगह की जगह एक बाइट बचाता है। मुझे वह कोशिश करनी चाहिए थी। नाइस :)

— एमिगाना

1

Tcl , 100 बाइट्स

proc C s {join [lmap c [split $s ""] {scan $c %c v
expr $v==65?"AM":$v==90?"PM":$v==32?00:$v-65}] :}

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

— sergiol
स्रोत

1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 98 बाइट्स

s=>string.Join(':',s.Select(c=>"az ".Contains(c)?new[]{"AM","PM","00"}["az ".IndexOf(c)]:c-97+""))

एक (लोअरकेस) चार सरणी के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

— मेरा सर्वनाम monicareinstate है
स्रोत

82 बाइट्स s=>string.Join(':',s.Select(c=>new[]{c-97+"","AM","PM","00"}["az ".IndexOf(c)+1])):।

— दाना

1

चारकोल , 26 बाइट्स

ＵＢ:Ｆθ«→≡ι ×0²a¦AM¦z¦PMＩ⌕βι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। कम मामले में इनपुट लेता है (तुच्छ रूप से ऊपरी मामले में बदला जा सकता है)। स्पष्टीकरण:

ＵＢ:

करने के लिए पृष्ठभूमि चरित्र सेट करें :। यह सही मूवमेंट द्वारा निर्मित आउटपुट मानों के बीच अंतराल में भरता है।

Ｆθ«→

हर बार एक अंतराल को छोड़ते हुए, प्रत्येक वर्ण पर लूप करें। (पहली चाल का कोई प्रभाव नहीं है क्योंकि इस बिंदु पर कैनवास अभी भी खाली है।)

≡ι ×0²a¦AM¦z¦PM

चरित्र पर स्विच करें और यदि यह स्थान है, aया zफिर उपयुक्त कोड आउटपुट करें। मैं यहाँ के ×0²बजाय उपयोग करते 00हैं क्योंकि बाद में अतिरिक्त विभाजक में दो बाइट खर्च होंगे।

Ｉ⌕βι

अन्यथा स्ट्रिंग के रूप में निचले मामले के वर्णमाला में पत्र के 0-अनुक्रमित स्थिति को आउटपुट करता है।

— नील
स्रोत

0

जेली , 24 बाइट्स

«"⁾PMµØAḊiȯ⁾00µe?€⁾AZj”:

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

— आउटगोल्फ को एरिक करें
स्रोत

घड़ी (अनुवादक) सिफर

परिचय:

चुनौती:

चुनौती नियम:

सामान्य नियम:

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

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

05AB1E , 22 21 बाइट्स

पर्ल 6 , 47 बाइट्स

स्पष्टीकरण:

पायथ, 25 बाइट्स

जावास्क्रिप्ट (Node.js) , 72 बाइट्स

जावा (JDK) , 95 बाइट्स

क्रेडिट

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 70 बाइट्स

रूबी , 49 बाइट्स

रेड , 124 121 110 109 बाइट्स

05AB1E , 20 बाइट्स

Tcl , 100 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 98 बाइट्स

चारकोल , 26 बाइट्स

जेली , 24 बाइट्स