टेर्नेरी अंकों को सायकल करके पाठ को बाधित करना


28

इस चुनौती का लक्ष्य इनपुट पाठ लेने के लिए सबसे छोटा फ़ंक्शन / प्रोग्राम लिखना है, इसे नीचे दी गई विधि का उपयोग करके एन्क्रिप्ट करें, और परिणाम लौटाएं।

एक उदाहरण के रूप में, मैं स्ट्रिंग का उपयोग करूंगा hello world

सबसे पहले , इनपुट टेक्स्ट प्राप्त करें।

hello world

दूसरा , स्ट्रिंग को टर्नरी (बेस 3) में परिवर्तित करें। इस कुंजी का उपयोग करें:

a = 000
b = 001
c = 002
d = 010
e = 011
f = 012
g = 020

...

w = 211
x = 212
y = 220
z = 221
[space] = 222

इस कुंजी के साथ, hello worldहो जाता है 021011102102112222211112122102010, जैसा कि नीचे देखा।

 h   e   l   l   o       w   o   r   l   d
021 011 102 102 112 222 211 112 122 102 010

तीसरा , पहले अंक को अंत तक ले जाएं।

021011102102112222211112122102010
becomes
210111021021122222111121221020100

चौथा , उसी कुंजी का उपयोग करके संख्या को वापस स्ट्रिंग में परिवर्तित करें।

210 111 021 021 122 222 111 121 221 020 100
 v   n   h   h   r       n   q   z   g   j

अंत में , एन्क्रिप्ट किए गए पाठ को वापस करें।

vnhhr nqzgj

यहाँ कुछ नमूना पाठ और उनके आउटपुट दिए गए हैं:

the turtle ==> dvo fh ego

python ==> uudwqn

code golf ==> hpjoytqgp

चूंकि यह कोड गोल्फ है, बाइट्स में सबसे कम प्रविष्टि जीतती है। यदि अक्षरों में से कुछ अक्षर या स्थान नहीं है तो त्रुटियों की अनुमति है। यह मेरी पहली चुनौती है, इसलिए कोई भी सुझाव मददगार से अधिक होगा।

सौभाग्य!

लीडरबोर्ड:

var QUESTION_ID=54643;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),e.has_more?getAnswers():process()}})}function shouldHaveHeading(e){var a=!1,r=e.body_markdown.split("\n");try{a|=/^#/.test(e.body_markdown),a|=["-","="].indexOf(r[1][0])>-1,a&=LANGUAGE_REG.test(e.body_markdown)}catch(n){}return a}function shouldHaveScore(e){var a=!1;try{a|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(r){}return a}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading),answers.sort(function(e,a){var r=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0],n=+(a.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0];return r-n});var e={},a=1,r=null,n=1;answers.forEach(function(s){var t=s.body_markdown.split("\n")[0],o=jQuery("#answer-template").html(),l=(t.match(NUMBER_REG)[0],(t.match(SIZE_REG)||[0])[0]),c=t.match(LANGUAGE_REG)[1],i=getAuthorName(s);l!=r&&(n=a),r=l,++a,o=o.replace("{{PLACE}}",n+".").replace("{{NAME}}",i).replace("{{LANGUAGE}}",c).replace("{{SIZE}}",l).replace("{{LINK}}",s.share_link),o=jQuery(o),jQuery("#answers").append(o),e[c]=e[c]||{lang:c,user:i,size:l,link:s.share_link}});var s=[];for(var t in e)e.hasOwnProperty(t)&&s.push(e[t]);s.sort(function(e,a){return e.lang>a.lang?1:e.lang<a.lang?-1:0});for(var o=0;o<s.length;++o){var l=jQuery("#language-template").html(),t=s[o];l=l.replace("{{LANGUAGE}}",t.lang).replace("{{NAME}}",t.user).replace("{{SIZE}}",t.size).replace("{{LINK}}",t.link),l=jQuery(l),jQuery("#languages").append(l)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*\s*([^,]+)/;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table></div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table></div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody></table><table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody></table>


3
ध्यान दें कि यह तकनीकी रूप से अपभ्रंश है, एन्क्रिप्शन नहीं है। यहां कोई एन्क्रिप्शन कुंजी नहीं है।
जॉन ड्वोरक

@JDDvorak "सिफर" काम करेगा?
कछुए

@ जनवेदक की टिप्पणी पर निर्माण करने के लिए, मैं इसे "एन्कोडिंग" के रूप में वर्णित करूंगा, जो एक अलग प्रारूप में डेटा को व्यक्त करने का एक मानक तरीका है (उदाहरण के लिए, आप हेक्साडेसिमल एन्कोडिंग, या बेस 64 एन्कोडिंग के साथ थोड़ा स्ट्रिंग व्यक्त कर सकते हैं)।
अप्सिलर्स

1
@JDDvorak सहमत - मुझे "एन्कोडिंग" (भले ही यह दोनों परिभाषाओं को संतुष्ट करता है) के बजाय ROT13 " ओफ़्फ़क्यूशन " कहने की अधिक संभावना है । संभवत: सबसे सटीक शीर्षक "Obfuscate text by ..." होगा
apsillers

2
@ द टर्टल यह विचार था कि पात्रों को एक बड़े पूर्णांक ( uint64) में शक्तियों को बढ़ाने के लिए पैक किया जाए 27। एक अंक द्वारा विस्थापन तब इस बड़े पूर्णांक को गुणा करने के बराबर होगा 3, और दूसरे छोर पर पहले अंक का परिचय बस एक अतिरिक्त होगा। लेकिन जटिलताएं हैं, जैसे कि अंतिम "कैरी" (शायद एक modऑपरेशन के माध्यम से ) को त्यागना , और मैं इसे कुछ बाइट्स के साथ काम करने के लिए नहीं मिला
लुइस मेंडो

जवाबों:


16

पायथ, 23 22 बाइट्स

sXc.<sXz=+GdJ^UK3K1KJG

इसे ऑनलाइन आज़माएं: नियमित इनपुट / टेस्ट सूट

@ बसाक को एक बाइट के लिए धन्यवाद।

स्पष्टीकरण:

sXc.<sXz=+GdJ^UK3K1KJG
        =+Gd             append a space the G (preinitialized with the alphabet)
               K3        assign 3 to K
            J^UK K       assign all 3-digit ternary numbers 
                         [[0,0,0], [0,0,1],...,[2,2,2]] to J
      Xz  G J            translate input from G to J
     s                   sum (join all ternary numbers to one big list)
   .<             1      rotate by 1
  c                K     split into lists of size 3
 X                  JG   translate from J to G
s                        join chars to string and print

1
हमारा भी यही विचार था। मैंने अपने CJam का एक Pyth पोर्ट लिखा, फिर नीचे स्क्रॉल किया और आपका उत्तर देखा: /
Andrea Biondo

1
आप उदाहरण Gके लिए उपयोग करने के बजाय संवर्धित असाइनमेंट करके एक बाइट को बचा सकते हैं । N=+Gd
isaacg

@ इस्साक धन्यवाद।
जकुबे

14

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

J+Gds@LJiR3c.<s.DR9xLJz1 2

Pyth संकलक / निर्वाहक में इसे ऑनलाइन का प्रयास करें: डेमो | परीक्षण के मामलों

विचार

मान लें कि सभी इनपुट वर्ण पहले से ही पूर्णांक में मैप किए गए हैं जो चरण 2 निर्दिष्ट करता है।

प्रत्येक 3-अंकीय त्रैमासिक संख्या के लिए, हमारे पास xyz 3 = 9x + 3y + z है , इसलिए 9 भाग भाग x और अवशेष 3y + z द्वारा मॉड्यूलर विभाजन ।

इनपुट है एबीसी 3 डीईएफ़ 3 GHI 3 प्रत्येक पैदावार के लिए मॉड्यूलर विभाजन को लागू करने, एक, 3 बी + सी, डी, 3E + एफ, जी, 3 ज i +

सूची को एक इकाई के ऊपर से बाईं ओर घुमाने के बाद, हम पूर्णांकों को जोड़ियों में समूहित कर सकते हैं। यह सूची (3b + c, d), (3e + f, g), (3h + i, a) की पैदावार देता है ।

अब, यदि हम आधार 3 से पूर्णांक में (3y + z, w) परिवर्तित करते हैं, तो हम 3 (3y + z) + w = ​​9y + 3z + w = ​​zyw 3 प्राप्त करते हैं

इस प्रकार, जोड़े की सूची में आधार रूपांतरण आवेदन करने हमें देता है बीसीडी 3 EFG 3 Hia 3 है, जो ठीक बाईं ओर श्रेणीबद्ध त्रिगुट अंक एक इकाई घूर्णन का परिणाम है।

सभी ऐसा करने के लिए छोड़ दिया गया है जिसके परिणामस्वरूप पूर्णांकों को वर्णों पर वापस लाया जा रहा है।

कोड

J+Gd                        Concatenate "a...z" (G) with " " (d) and save in J.
                    L z     For each character in the input(z):
                   x J        Compute its index in J.
                 R          For each index I:
               .D 9           Compute (I / 9, I % 9).
              s             Concatenate the resulting pairs.
            .<         1    Rotate the resulting list one unit to the left.
           c             2  Split it back into pairs.
         R                  For each pair:
        i 3                   Perform conversion from base 3 to integer.
      L                     For each resulting integer:
     @ J                      Select the element of J at that index.
    s                       Concatenate the resulting characters.

येश, कुछ ही घंटों में मुझे सीजेम और पायथ ने हरा दिया। : /
kirbyfan64sos

वाह! क्या आप इस बात की व्याख्या लिख ​​सकते हैं कि यह कैसे काम करता है? मैं उत्सुक हूँ। :)
कछुए

@ द टर्टल मैंने अपना उत्तर संपादित कर दिया है।
डेनिस

10

पायथन 2, 96

s=input()
r=y=''
for c in s+s[0]:x=(ord(c)-97)%91;r+=y and chr((y%9*3+x/9-26)%91+32);y=x
print r

धर्मान्तरित एक चरित्र cएक मूल्य के xरूप में x=(ord(c)-97)%91, सापेक्ष केवल स्थान को प्रभावित यह 26. रिवर्स रूपांतरण में बदलने के लिए के साथ है iकरने के लिए chr((i-26)%91+32)सापेक्ष केवल प्रभावित करने के साथ, i=26यह रिक्त स्थान बन बनाने के लिए।

हम पात्रों के माध्यम से लूप करते हैं, वर्तमान मूल्य xऔर पिछले मूल्य को देखते हुए y। हम के अंतिम दो त्रिगुट अंकों का उपयोग y, के रूप में पाया y%9, और का पहला त्रिगुट अंकों x, के रूप में पाया x/9। संघटन का मूल्य है y%9*3+x/997अंतरिक्ष के स्थानांतरण और परिवर्तन के साथ इस अंकगणित के संयोजन में शायद कुछ अनुकूलन हैं।

हम इस लूप को चारों ओर बनाते हैं, हम अंत में स्ट्रिंग के पहले चरित्र पर लौटते हैं। हम पिछले मूल्य में लिखने के लिए एक तैयारी लूप भी करते हैं y, पहले लूप के लिए चरित्र को दबाते हैं जब yअभी तक आरंभ नहीं किया गया है।


8

सीजेएम, 39 29 बाइट्स

इस बारे में एक अच्छी बात यह है कि यह आधार रूपांतरण का भी उपयोग नहीं करता है।

q'{,97>S+:XZZm*:Yere_(+3/YXer

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

मुझे बस एहसास हुआ कि मुझे जकूबे के पाइथ के उत्तर के समान विचार था। मैंने वास्तव में उनके पोस्ट को देखने से पहले इस CJam कोड को 25 बाइट्स के साथ समाप्त करते हुए Pyth में पोर्ट किया था। यह देखते हुए कि यह मेरा पहला Pyth गोल्फ था, मुझे लगता है कि यह बहुत बुरा नहीं है।

व्याख्या

                              e# Z = 3
q                             e# Push input string
 '{,                          e# Push ['\0' ... 'z']
    97>                       e# Keep ['a' ... 'z']
       S+                     e# Append space
         :X                   e# Assign "a...z " to X
           ZZm*               e# Push 3rd cartesian power of [0 1 2]
                              e# i.e. all 3-digit permutations of 0, 1, 2
                              e# (in lexicographical order)
               :Y             e# Assign those permutations to Y
                 er           e# Translate input from X to Y
                   e_         e# Flatten resulting 2D array
                     (+       e# Rotate first element to the end
                       3/     e# Split back into 3-digit elements
                         YXer e# Translate from Y to X

7

सीजेएम, 30 29 27 बाइट्स

q'{,97>S+:Af#9fmd(+2/3fbAf=

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

दृष्टिकोण मेरे अन्य उत्तर के समान है , जो कि इस कोड का एक हिस्सा है।

यह काम किस प्रकार करता है

q                           e# Read from STDIN.
 '{,                        e# Push ['\0' ... 'z'].
    97>                     e# Remove the first 97 elements (['\0' - '`']).
       S+:A                 e# Append a space and save in A.
           f#               e# Find the index of each input character in A.
             9fmd           e# Apply modular division by 9 to each index.
                 (+         e# Shift out the first quotient and append it.
                   2/       e# Split into pairs.
                     3fb    e# Convert each pair from base 3 to integer.
                        Af= e# Select the corresponding elements from A.


6

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

एक-लाइनर!

"चर vपुरस्कार का अति प्रयोग , कोई भी?"

अद्यतन: अब कुल भ्रम के लिए केवल चर नाम का उपयोग करता vहै!

6 बाइट्स बचाने के लिए @vihan को धन्यवाद!

धन्यवाद @ बाइट 27 बाइट बचाने के लिए !!

v=>(([...v].map(v=>(v<"V"?53:v.charCodeAt()-70).toString(3).slice(1)).join``)+v[0]).slice(1).match(/..?.?/g).map(v=>(v=String.fromCharCode(parseInt(v,3)+97))>"z"?" ":v).join``

एक अनाम फ़ंक्शन को परिभाषित करता है। उपयोग करने के लिए, v=फ़ंक्शन को एक नाम देने के लिए कोड से पहले जोड़ें , और इसे कॉल करेंalert(v("hello world"))


आप .slice(-3)6 बाइट को बचाने के लिए उपयोग कर सकते हैं , जिस बिंदु पर आप "00"+vकिसी अन्य बाइट को बचाने के लिए उपयोग कर सकते हैं । (आप एक टेम्पलेट के साथ सम्‍मिलित कर सकते हैं लेकिन परिणामी लंबाई समान होती है।)
नील

दरअसल, आप आधार को तीन में बदलने से पहले अपने मूल्यों में 27 जोड़कर बाइट्स की एक पूरी गुच्छा को बचा सकते हैं, क्योंकि यह पर्याप्त अंकों की गारंटी देता है। .map(v=>(v<"V"?26:v.charCodeAt()-97).toString(3)).map(v=>("000"+v).slice(v.length))तब बन जाता है .map(v=>(v<"V"?53:v.charCodeAt()-70).toString(3).slice(1))
नील

@ नील वाह, कि वास्तव में कोड छोटा! इसने एकमात्र मध्यवर्ती चर को हटाकर इसे एक 'वन-लाइनर' भी बना दिया। धन्यवाद!
22

5

जूलिया, 149 137 बाइट्स

मेरा पहला गोल्फ!

s->(j=join;b=j([base(3,i==' '?26:i-'a',3)for i=s]);r=b[2:end]*b[1:1];j([i==26?" ":i+'a'for i=[parseint(r[i:i+2],3)for i=1:3:length(r)]]))

(आंशिक रूप से) अपुष्ट:

f = s -> (
    # join the ternary represenations:
    b = join([base(3, i == ' ' ? 26 : i - 'a',3) for i = s]);
    # rotate:
    r = b[2:end] * b[1:1];
    # calculate the new numbers:
    n = [parseint(r[i:i+2],3) for i = 1:3:length(r)];
    # convert back to characters:
    join([i == 26 ? " " : 'a' + i for i = n])
)
assert(f("hello world") == "vnhhr nqzgj")
assert(f("the turtle")  == "dvo fh ego")
assert(f("python")      == "uudwqn")
assert(f("code golf")   == "hpjoytqgp")

आप उपयोग कर सकते हैं =के बजाय inछोरों के लिए और आप उपयोग कर सकते हैं b[1]के स्थान पर b[1:1]। आपको क्लोजिंग पैरेंस और के बीच एक स्थान की आवश्यकता नहीं है for
एलेक्स ए।

@AlexA। के लिए चीयर्स =, लेकिन b[1]एक चरित्र देता है, जिसे एक स्ट्रिंग के साथ जोड़ा नहीं जा सकता है *
केविन्सा 5

ओह ठीक है, उस बारे में भूल गया।
एलेक्स ए।

@AlexA। forचाल गंधा है। आप इसे सीधे एक करीबी उद्धरण के बाद भी ले सकते हैं। मुझे एहसास नहीं था कि पार्सर वह लचीला था।
केविन्सा 5

यह सीधे एक संख्यात्मक शाब्दिक का पालन भी कर सकता है, जैसा कि कर सकता है end
एलेक्स ए।

4

जावास्क्रिप्ट (ईएस 6), 178 , 172 , 170

p=>{p=p.replace(' ','{');c="";l=p.length;for(i=0;i<l;){c+=String.fromCharCode(((p.charCodeAt(i)-97)%9)*3+(((p.charCodeAt((++i)%l)-97)/9)|0)+97)}return c.replace('{',' ')}

एक बिटवाइज़ या के साथ बदला हुआ Math.floor। एक अनाम फ़ंक्शन बनाया गया। अगर मैं सही ढंग से समझ रहा हूं, तो यह मेरी नीचता को कुछ हद तक ठीक करना चाहिए (धन्यवाद डेनिस!) और मुझे एक और 2 बाइट्स प्राप्त करें।


3

जूलिया, 169 166 बाइट्स

s->(J=join;t=J(circshift(split(J([lpad(i<'a'?"222":base(3,int(i)-97),3,0)for i=s]),""),-1));J([c[j:j+2]=="222"?' ':char(parseint(c[j:j+2],3)+97)for j=1:3:length(t)]))

असंगठित + स्पष्टीकरण:

function f(s::String)
    # Convert the input into a string in base 3, with space mapping to 222
    b = join([lpad(i < 'a' ? "222" : base(3, int(i) - 97), 3, 0) for i = s])

    # Split that into a vector of single digits and shift once
    p = circshift(split(b, ""), -1)

    # Join the shifted array back into a string
    t = join(p)

    # Convert groups of 3 back into characters
    c = [t[j:j+2] == "222" ? ' ' : char(parseint(t[j:j+2], 3) + 97) for j = 1:3:length(t)]

    # Return the joined string
    join(c)
end

3

हास्केल, 160 बाइट्स

a!k|Just v<-lookup k a=v
x=['a'..'z']++" "
y="012";z=mapM id[y,y,y]
m(a:u:r:i:s)=[u,r,i]:m(a:s)
m[e,a,t]=[[a,t,e]]
main=interact$map(zip z x!).m.(>>=(zip x z!))

ऊह, यह बहुत लंबा रास्ता तय करता है, लेकिन कम से कम मैं ... किसी तरह अजगर को मार रहा हूं। और रूबी।


3

जावास्क्रिप्ट (ईएस 6), 141 124 120 बाइट्स

इस पर विश्वास करें या नहीं.... :-)

(t,i=0,c=w=>(t.charCodeAt(w)-123)%91+26)=>String.fromCharCode(...[...t].map(k=>(c(i)%9*3+c(++i%t.length)/9+65|0)%91+32))

मेरे अन्य उत्तर के रूप में, यह एक अनाम फ़ंक्शन है, और इसे उपयोग किए जाने से पहले एक चर को सौंपा जाना चाहिए। इसे यहाँ आज़माएँ:

मैंने सोचा कि मैं एक अलग तकनीक का उपयोग करके अपने पिछले उत्तर को एक दो बाइट्स से दाढ़ी बनाने में सक्षम हो सकता हूं, इसलिए मैंने टेकग्नो के समान एक के साथ शुरुआत की और अपना सिर वहाँ से हटा दिया। मैंने फ़ंक्शन के तर्क अनुभाग में कुछ चर को इनिशियलाइज़ किया, और फिर से .mapफंक्शन में सब कुछ भर दिया । तब मुझे एहसास हुआ कि String.fromCharCodeबाहर बहुत अधिक कुशल होगा .map। सब के बाद कहा और किया गया था, मैं 30 से अधिक 45 बाइट्स मुंडा था !

संपादित करें 1:.replace s से छुटकारा पाकर 17 बाइट्स बचाए, जो xnor के पायथन समाधान के समान तकनीक का उपयोग करता है।

ठीक है, शायद यह एक और चुनौती पर आगे बढ़ने का समय है ...।


2

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

यह समाधान बहुत महंगा होने के कारण आदर्श नहीं है। यह पता लगाने की कोशिश की जा रही है कि इससे कैसे बचा जाए।

b=lambda k:k and b(k/3)*10+k%3
s=''.join('%03d'%b(ord(x)-6-91*(x>' '))for x in input())
print`[chr(int((s[1:]+s[0])[i:i+3],3)+97)for i in range(0,len(s),3)]`[2::5].replace('{',' ')

इनपुट की तरह है "hello world"


आपको इनपुट में आवश्यक उद्धरण चिह्नों के लिए 2 बाइट्स गिनने की आवश्यकता है, है ना?
mbomb007

@ mbomb007 यह वही है जो मैंने पहले सोचा था, लेकिन कई लोगों ने मुझे बताया है कि मुझे उसके लिए खाते की आवश्यकता नहीं है।
काडे

2

गणितज्ञ, 162 बाइट्स

r=Append[#->IntegerDigits[LetterNumber@#-1,3]~PadLeft~3&/@Alphabet[]," "->{2,2,2}];StringJoin[Partition[RotateLeft[Characters@#/.r//Flatten,1],3]/.(#2->#1&@@@r)]&

(Re) Ruleअंकों की सूचियों को वर्णों और पीठ में बदलने के लिए a का उपयोग करना ।


2

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

s=>[...s+s[0]].map(q=>`00${(q<'a'?26:q.charCodeAt(0)-97).toString(3)}`.slice(-3)).join``.slice(1,-2).match(/..?.?/g).map(q=>q>221?' ':String.fromCharCode(parseInt(q,3)+97)).join``

रेगेक्स के लिए विहान को सहारा .match


1

रूबी, 177

each_charविधि के लिए कम से कम रूबी 1.9 की आवश्यकता है

l=[*('a'..'z'),' '];n=(0..26).map{|m|m=m.to_s(3).rjust 3,'0'};s='';gets.chomp.each_char{|x|s+=n[l.index x]};puts("#{s[1..-1]}#{s[0]}".scan(/.../).map{|i|i=l[n.index i]}.join '')

1

जावा, 458 449 बाइट्स

इससे मुझे यह जानकर थोड़ा दुख हुआ कि मैं जावा 8 स्ट्रीम और map()विधि का उपयोग करके 10 बाइट्स नहीं हटा सकता ।

यहाँ गोल्फ संस्करण है:

import org.apache.commons.lang.ArrayUtils;class A{public static void main(String[]a){int b=0;String[] c=new String[27];for(;b<27;++b)c[b]=String.format("%03d",Integer.valueOf(Integer.toString(b,3)));String d=a[0],e="abcdefghijklmnopqrstuvwxyz ",f="",g="";for(b=0;b<d.length();++b)f+=c[e.indexOf(d.substring(b,b+1))];f=f.substring(1)+f.charAt(0);for(b=0;b<f.length();b+=3)g+=e.charAt(ArrayUtils.indexOf(c,f.substring(b,b+3)));System.out.println(g);}}

यहाँ बहुत कम गोल्फ वाला संस्करण है। यह पठनीय होने का इरादा है, लेकिन मैं कोई गारंटी नहीं देता हूं।

import org.apache.commons.lang.ArrayUtils;
class A {
    public static void main(String[] a) {
        int b=0;
        String[] c = new String[27];
        for (; b < 27; ++b)
            c[b] = String.format("%03d", Integer.valueOf(Integer.toString(b, 3)));
        String
            d = a[0],
            e = "abcdefghijklmnopqrstuvwxyz ",
            f = "",
            g = "";
        for (b = 0; b < d.length(); ++b)
            f += c[e.indexOf(d.substring(b, b + 1))];
        f = f.substring(1) + f.charAt(0);
        for (b = 0; b < f.length(); b += 3)
            g += e.charAt(ArrayUtils.indexOf(c, f.substring(b, b + 3)));
        System.out.println(g);
    }
}

यह प्रोग्राम कमांड-लाइन तर्क के रूप में बदलने के लिए स्ट्रिंग लेता है। यदि आप अपने इनपुट में स्थान रखना चाहते हैं, तो आपको इसे दोहरे उद्धरण चिह्नों से घेरना होगा।

मैं कमांड लाइन से इसका उपयोग करने का एक उदाहरण प्रदान करना चाहता था, लेकिन मैं ग्रहण के बाहर काम करने के लिए इस कोड को प्राप्त करने में असमर्थ था। मैंने कमांड लाइन ^ _ ^ से जावा का उपयोग करना कभी नहीं सीखा; आप शायद बहुत अधिक परेशानी के बिना अपनी पसंद के आईडीई के अंदर इसे चला सकते हैं।


यदि आप केवल एक बार कोड के अंदर पूरी तरह से योग्य नाम का उपयोग करके ArrayUtils का उपयोग करते हैं, तो वह आयात विवरण से कम है। देखें: codegolf.stackexchange.com/a/16100/10801 (जुड़े हुए उत्तर का निचला भाग)
मास्टरएक्स 244

1

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

t=>((x=[...t].map(k=>`00${(k<'!'?26:k.charCodeAt(0)-97).toString(3)}`.slice(-3)).join``).slice(1)+x[0]).match(/.../g).map(j=>j>221?' ':String.fromCharCode(parseInt(j,3)+97)).join``

यह एक अनाम फ़ंक्शन है, इसलिए इसका उपयोग करने से पहले इसे एक नाम दिया जाना चाहिए। (जैसे encrypt=t=>...) इसे यहाँ आज़माएँ:

मैंने forइसके बजाय कई चर और छोरों का उपयोग करना शुरू कर दिया .map। फिर मैंने एल्गोरिथ्म को बदलने के बिना इसे हर संभव तरीके से तैयार किया, जिसने मुझे लगभग 217 बाइट्स में डाल दिया। UndefinedFunction के उत्तर पर एक नज़र डालने के बाद, मैं इसे 195 तक नीचे लाने में कामयाब रहा, और डेंड्रोबियम के उत्तर के कुछ निरीक्षण के परिणामस्वरूप 14 और गोल्फ हो गए।

जहां तक ​​मुझे जानकारी है, मैं आगे नहीं जा सकता या मेरा परिणाम व्यावहारिक रूप से डेंड्रोबियम के समान होगा (केवल एक वर्ण को छोड़कर!)। किसी को भी जगह मिल सकती है जहाँ मैंने एक चार को बचाया है? :-)

हमेशा की तरह, सुझावों का सहर्ष स्वागत है!


रेगेक्स टिप के लिए धन्यवाद! मुझे यकीन नहीं है कि लूप के लिए वास्तव में इस एक-लाइन फ़ंक्शन में कैसे काम किया जा सकता है, लेकिन शायद यह वैसे भी कुछ जगह बचाएगा। आप चाहें तो अपने वर्जन को पोस्ट कर सकते हैं।
ETHproductions

0

मतलाब, 113 बाइट्स

x=dec2base(strrep(input('','s'),' ','{')-97,3)';strrep(char(base2dec(reshape(x([2:end 1]),3,[])',3)+97)','{',' ')

इनपुट स्टड के माध्यम से है।

उदाहरण:

>> x=dec2base(strrep(input('','s'),' ','{')-97,3)';strrep(char(base2dec(reshape(x([2:end 1]),3,[])',3)+97)','{',' ')
hello world
ans =
vnhhr nqzgj

0

जूलिया - 92 87 61 54 बाइट्स

s->join(32+(3(i=[s...]%91+579)%27+i[[2:end,1]]÷9)%91)

Ungolfed:

function f(s)
  t=[s...];       # Convert the string into a char array
                      #
  i=t%91+579          # Mod 91 drops the alpha characters to sit just
                      # below space, then 579 is added as a trick,
                      # equivalent to subtracting 6 and adding 9*65
  v1=3i%27            # This shifts the bottom two ternary digits up
                      # and removes the first ternary digit
  v2=i[[2:end,19    # This shifts the first ternary digit down and
                      # removes the bottom two ternary digits. [2:end,1]
                      # rotates the array to put the first value at the end
  N=(v1+v2)%91+32     # this combines the ternary digits, then returns
                      # the values to the correct ASCII values
  j=join(N)           # join the char array back to a string
  return j
end

चाल आपको भ्रमित कर सकती है। मॉड के बाद 6 चाल 'ए' को घटाकर शून्य तक ले जाना। 9 * 65 को जोड़ना 65 से v1 + v2 को जोड़ने के बराबर है, जो उनके एएससीआई मूल्यों को बहाल करने की प्रक्रिया का हिस्सा है। आप बदल सकते i=t%91+579के साथ i=t%91-6, और उसके बाद की जगह N=(v1+v2)%91+32के साथ N=(v1+v2+65)%91+32एक ही परिणाम प्राप्त करने के लिए, लेकिन यह एक अतिरिक्त चरित्र की आवश्यकता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.