कंप्यूटर सिफर

Question

परिचय:

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

---

एक कंप्यूटर सिफर दिए गए पाठ को दिए गए 'यादृच्छिक' वर्ण समूहों में शामिल करेगा length। यदि इस तरह के समूह में एक अंक होता है, तो वह उस अंक का उपयोग अपने स्वयं के समूह में अनुक्रमित वर्ण के लिए अनुक्रमित करने के लिए करेगा। यदि कोई अंक समूह में मौजूद नहीं है, तो इसका मतलब है कि पहले वर्ण का उपयोग किया जाता है।

उदाहरण के लिए, मान लें कि हम पाठ this is a computer cipherको दी गई लंबाई के साथ जोड़ना चाहते हैं 5। यह एक संभावित आउटपुट है (ध्यान दें: संख्या नीचे उदाहरण में 1-अनुक्रमित है):

t     h     i     s     i     s     a     c     o     m     p     u     t     e     r     c     i     p     h     e     r       (without spaces of course, but added as clarification)
qu5dt hprit k3iqb osyw2 jii2o m5uzs akiwb hwpc4 eoo3j muxer z4lpc 4lsuw 2tsmp eirkr r3rsi b5nvc vid2o dmh5p hrptj oeh2l 4ngrv   (without spaces of course, but added as clarification)

आइए कुछ समूहों को उदाहरण के रूप में समझाएं कि समूह को कैसे समझा जाए:

• qu5dt: इस समूह में एक अंक होता है 5, इसलिए (1-अनुक्रमित) इस समूह का 5 वाँ वर्ण दशानुकूल पाठ के लिए प्रयुक्त वर्ण है t:।
• hprit: इस समूह में कोई अंक नहीं है, इसलिए इस समूह के पहले वर्ण का उपयोग दशांश पाठ के लिए किया जाता है h:।
• osyw2: इस समूह में एक अंक होता है 2, इसलिए (1-अनुक्रमित) इस समूह का दूसरा वर्ण दशानुकूल पाठ के लिए प्रयुक्त वर्ण है s:।

चुनौती:

एक पूर्णांक lengthऔर स्ट्रिंग को देखते हुए word_to_encipher, जैसा कि ऊपर वर्णित है , एक यादृच्छिक enciphered स्ट्रिंग आउटपुट करता है।

आप केवल दिया कूटलेखन के लिए है lengthऔर word_to_encipherइतनी के रूप में अच्छी तरह से एक गूढ़ रहस्य कार्यक्रम / समारोह बनाने की आवश्यकता,। मैं भविष्य में हालांकि डिक्रिप्शन के लिए एक भाग 2 चुनौती बना सकता हूं।

चुनौती नियम:

• आप मान सकते हैं lengthकि सीमा में इच्छाशक्ति है [3,9]।
• आप मान सकते हैं कि word_to_encipherवसीयत में केवल अक्षर होंगे।
• आप पूर्ण लोअरकेस या पूर्ण अपरकेस का उपयोग कर सकते हैं (कृपया बताएं कि आपने अपने उत्तर में किसका उपयोग किया है)।
• आपके आउटपुट, प्रत्येक समूह और एक समूह में अंकों की स्थिति (यदि मौजूद है) समान रूप से यादृच्छिक होनी चाहिए । तो वर्णमाला के सभी यादृच्छिक अक्षरों को होने का एक ही मौका है; प्रत्येक समूह में enciphered पत्र की स्थिति होने की समान संभावना है; और अंक की स्थिति में होने की समान संभावना है (सिवाय इसके कि यह पहला वर्ण है और कोई अंक मौजूद नहीं है, और यह स्पष्ट रूप से एक ही स्थिति पर नहीं हो सकता है)।
• आपको 1-अनुक्रमित के बजाय 0-अनुक्रमित अंकों का उपयोग करने की भी अनुमति है। कृपया बताएं कि आपने अपने उत्तर में दोनों में से किसका उपयोग किया है।
• अंक 1(या 0जब 0-अनुक्रमित) आउटपुट में कभी भी मौजूद नहीं होगा। तो b1ndhचरित्र 'बी' को समृद्ध करने के लिए एक वैध समूह नहीं है। हालांकि, b4tbwमान्य है, जहां है 4enciphers b4 (1-अनुक्रमित) की स्थिति, और अन्य पात्रों पर b, t, wयादृच्छिक (जो संयोगवश यह भी एक शामिल हैं b)। के अन्य संभावित वैध समूहों length5 कूटलेखन के लिए चरित्र 'बी' हैं: abcd2, ab2de, babbk, hue5b, आदि

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

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

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

Input:
 Length:           5
 Word to encipher: thisisacomputercipher
Possible output:
 qu5dthpritk3iqbosyw2jii2om5uzsakiwbhwpc4eoo3jmuxerz4lpc4lsuw2tsmpeirkrr3rsib5nvcvid2odmh5phrptjoeh2l4ngrv

Input:
 Length:           8
 Word to encipher: test
Possible output:
 ewetng4o6smptebyo6ontsrbtxten3qk

Input:
 Length:           3
 Word to encipher: three
Possible output:
 tomv3h2rvege3le

Comments

"वर्दी" का अर्थ क्या है

— l4m2

@ l4m2 कि किसी भी आउटपुट के लिए एक समान मौका है। तो वर्णमाला के सभी यादृच्छिक अक्षरों को होने का एक ही मौका है; प्रत्येक समूह में enciphered पत्र की स्थिति होने की समान संभावना है; और अंक की स्थिति में होने की समान संभावना होती है (सिवाय इसके कि यह पहला वर्ण है और कोई अंक मौजूद नहीं है, और यह भी उतने ही पद पर नहीं है)

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

तो abcd2, ab2de, babbkसभी एक ही? भी b1akkमान्य है?

— l4m2

@ l4m2 हां, तीनों संभव चरित्र 'बी' चरित्र enciphering हैं। जैसा कि b1akkमैं नहीं कहूँगा। स्पष्ट करने के लिए चुनौती विवरण में इसे संपादित करेंगे। यदि पहला वर्ण एक है, तो कोई अंक मौजूद नहीं होना चाहिए।

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

उदाहरण के लिए, जब लंबाई = 3, चार = "ए"; प्रपत्र "a??"676 संभव परिणाम है, लेकिन "1a?", "?a1", "2?a", "?2a", है only104 का परिणाम है। इसलिए, अगर मैं इन सभी 780 परिणामों में से एक परिणाम को चुनने की कोशिश कर रहा हूं, तो "enciphered letter" की स्थिति का वितरण 13: 1: 1 है, न कि 1: 1: 1। और मैं इस पर विचार करूंगा कि "समान रूप से यादृच्छिक" कैसे काम करें।

— tsh

Answer 1

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

smsXWJOQXmOGQJdO-UQJJz

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

लोअरकेस और शून्य-इंडेक्सिंग का उपयोग करता है।

व्याख्या

बहुत सीधा एल्गोरिदम।

                           Implicit: read word in z
                           Implicit: read number in Q
 m                   z     For each char d in z:
      OQ                     Choose a number 0..Q-1
     J                       and call it J.
         m  Q                Make an array of Q
          OG                 random letters.
        X     d              Place d in this string
             J               at position J.
    W                        If J is not 0,
   X                J        place J in this string
               O             at a random position from
                 UQ          0..Q-1
                -  J         except for J.
  s                          Concatenate the letters.
s                          Concatenate the results.

Answer 2

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

->\n{*.&{S:g{.}=(65..90)>>.chr.roll(n).join.subst(/./,$/,:th($!=roll 1..n:)).subst(/./,$!,:th($!-1??(^n+1∖$!).roll!!n+1))}}

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

अपरकेस में इनपुट और आउटपुट लेता है। जैसे, इनपुट क्यूरेड लेता है f(n)(string)। 1 अनुक्रमण का उपयोग करता है।

स्पष्टीकरण:

->\n{*.&{ ...  }}   # Anonymous code block that takes a number n and returns a function
     S:g{.}=        # That turns each character of the given string into
                          .roll(n)      # Randomly pick n times with replacement
            (65..90)>>.chr              # From the uppercase alphabet
                                  .join # And join
            .subst(                         ) # Then replace
                   /./,  ,:th($!=roll 1..n:)  # A random index (saving the number in $!)
                       $/               # With the original character
            .subst(                )    # Replace again
                   /./,$!,:th( ... )    # The xth character with $!, where x is:
                           $!-1??          # If $! is not 1
                                 (^n+1∖$!).roll       # A random index that isn't $!
                                               !!n+1  # Else an index out of range

Answer 3

पायथन 2 , 187 177 176 156 154 148 बाइट्स

lambda l,s:''.join([chr(choice(R(65,91))),c,`n`][(j==n)-(j==i)*(n>0)]for c in s for n,i in[sample(R(l),2)]for j in R(l))
from random import*
R=range

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

अपरकेस अक्षरों और 0-अनुक्रमित संख्याओं का उपयोग करता है।

_{-3 बाइट्स, केविन क्रूज़सेन की बदौलत}

Comments

@KevinCruijssen धन्यवाद :)

— TFeld

क्या sample(R(l),2)[::1|-(random()<.5)]मतलब है?

— l4m2

@ l4m2 यह 2 नंबर लेता है range(l), और उन्हें फेरबदल करता है। लेकिन जाहिरा तौर पर नमूना आदेश की गारंटी नहीं देता है, इसलिए इसकी आवश्यकता नहीं है :)

— TFeld

क्या आप कोष्ठक को दूर नहीं कर सकते (j==i)*(n>0)? घटाव पर ऑपरेटर की व्यापकता है न?

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

@ केविनक्रूजसेन हाँ, मैं उन्हें दूर करना भूल गया, जब मुझे कुछ समस्याएँ थीं

— TFeld

Answer 4

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

n=>f=([c,...s])=>c?(g=n=>n?g(--n)+(n-p?n-q|!p?(r(26)+10).toString(36):p:c):'')(n,r=n=>Math.random()*n|0,p=r(n),q=r(n-1),q+=q>=p)+f(s):s

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

धन्यवाद 1B के लिए Arnauld

Answer 5

आर , 134 132 123 बाइट्स

function(S,n,s=sample)for(k in utf8ToInt(S)){o=k+!1:n
P=s(n,1)
o[-P]=s(c(P[i<-P>1],s(17:42,n-1-i,T)))+48
cat(intToUtf8(o))}

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

अपरकेस ले जाता है।

पुराने कोड की व्याख्या (ज्यादातर एक ही दृष्टिकोण):

function(S,n){s=sample				# alias
K=el(strsplit(S,""))				# split to characters
o=1:n						# output array
for(k in K){					# for each character in the string
P=s(n,1)					# pick a Position for that character
o[-P]=						# assign to everywhere besides P:
      s(					# a permutation of:
	c(P[i<-P>1],				# P if it's greater than 1
		s(letters,n-1-i,T)))		# and a random sample, with replacement, of lowercase letters
o[P]=k						# set k to position P
cat(o,sep="")}}					# and print

Answer 6

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

s->n->s.flatMap(c->{int a[]=new int[n],i=n,x=0;for(;i-->0;)a[i]+=Math.random()*26+97;a[i+=Math.random()*n+1]=c;x+=Math.random()*~-n;if(i>0)a[x<i?x:x+1]=48+i;return java.util.Arrays.stream(a);})

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

• सूचकांक 0-आधारित हैं।
• यह प्रविष्टि इनपुट के रूप में IntStream(के माध्यम से प्राप्त String::chars) का उपयोग करती है , साथ ही एक संख्या और दूसरे को लौटाती है IntStream।
• से डाले doubleकरने intकी वजह से अनावश्यक हैं +=हैक।

Answer 7

जाप , 29 बाइट्स

;£=VöJ;CöV hUÎX hUÅÎUÎ?UÎs:Cö

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

शून्य अनुक्रमित।

स्पष्टीकरण:

;                                :Set C = [a...z]
 £                               :For each character of the input:
  =VöJ;                          : Get two different random indexes from [0,length)
       CöV                       : Get 5 random letters
           hUÎX                  : Replace one at random with the character from the input
                hUÅÎ             : Replace a different random character with:
                    UÎ?          :  If the input character was not placed at 0:
                       UÎs       :   The index of the input character
                          :      :  Otherwise:
                           Cö    :   A random letter
                                 :Implicitly join back to a string

Answer 8

सी, 115 बाइट्स

g(_,n)char*_;{int i=rand(),j=i%~-n,k=0;for(i%=n;k<n;k++)putchar(k-i?!i|i<k^k-j?rand()%26+97:48+i:*_);*++_&&g(_,n);}

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

0-अनुक्रमित, लोअरकेस।

थोड़ा असंयमित और विस्तारित:

g(char*_,int n) {
    int i = rand(), j = i%(n-1), k = 0;
    for(i = i%n; k<n; k++)
        putchar(k!=i ? i!=0 || k==j + (k>i)
                          ? rand()%26 + 'A'
                          : i + '0')
                    : *_);
    if (*++_!=0) g(_,n);
}

कोड बहुत सीधा होना चाहिए। एक कॉल में उत्पन्न दो रैंडम i, gcd ( , ) = 1 के बाद से स्वतंत्र हैं और बड़े हैं।jrand()n~-nRAND_MAX

Comments

PPCG में आपका स्वागत है! :)

— झबरा

Answer 9

स्वच्छ , 256 बाइट्स

import StdEnv
s::!Int->Int
s _=code {
ccall time "I:I"
ccall srand "I:I"
}
r::!Int->Int
r _=code {
ccall rand "I:I"
}
$n|s 0<1#k=map\e.r e rem n
=flatten o map\c.hd[map(\i|i==x=c=toChar if(i==y&&x>0)(x+48)(r i rem 26+97))[0..n-1]\\x<-k[0..]&y<-k[0..]|x<>y]

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

चुनता:

• एक यादृच्छिक x(खंड में चरित्र की स्थिति)
• एक यादृच्छिक yजो xखंड में अंक की स्थिति के बराबर नहीं है
• जब तक शून्य न हो प्रत्येक पद के लिए एक यादृच्छिक लोअरकेस अक्षर बराबर xऔर बराबर नहींyx

Answer 10

जावास्क्रिप्ट, 134 बाइट्स

l=>w=>w.replace(/./g,c=>eval("for(s=c;!s[l-1]||s[t?t-1||9:0]!=c;t=s.replace(/\\D/g,''))s=(p=Math.random()*36**l,p-p%1).toString(36)"))

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

इस उत्तर ने एन्कोडिंग स्ट्रिंग को सभी संभव एन्कोडेड स्ट्रिंग से समान रूप से चुना। तो पहले अक्षर के रूप में एन्कोडेड पत्र बनाना अधिक संभव है।

Answer 11

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

s=>n=>{var r=new Random();return s.SelectMany(c=>{int i=r.Next(n),j=r.Next(n-1);j+=j<i?0:1;return new int[n].Select((_,k)=>(char)(i==k?c:j==k&i>0?i+49:r.Next(26)+97));});}

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

स्पष्टीकरण ...

// s is the input string
// n is the input length
s=>n=>{
  // we need to create an instance
  // of Random and use throughout
  var r=new Random();
  // iterate over s, each iteration
  // returns an array... flatten it
  return s.SelectMany(c=>{
    // i is the position of the letter
    // j is the position of the number
    int i=r.Next(n), j=r.Next(n-1);
    // ensure i and j are different
    j+=j<i?0:1;
    // create an iterable of size n
    return new int[n]
      // iterate over it with index k
      .Select((_,k)=>(char)(
        // return the letter
        i==k?c:
        // return the number
        j==k&i>0?i+49:
        // return a random letter
        r.Next(26)+97)
      );
  });
}

Answer 12

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

ＮθＦＳ«≔‽θη≔∧η‽Φθ⁻κηζＦθ≡κζＩηηι‽β

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। 0 अनुक्रमित। स्पष्टीकरण:

Ｎθ

लंबाई इनपुट करें।

ＦＳ«

वर्णों पर शब्द और लूप इनपुट करें।

≔‽θη

डिकिफ़र्ड अक्षर के लिए एक यादृच्छिक स्थिति चुनें।

≔∧η‽Φθ⁻κηζ

अंक के लिए एक अलग यादृच्छिक स्थिति चुनें, जब तक कि अक्षर 0 की स्थिति में न हो, उस स्थिति में अंक को 0 पर भी रखें।

Ｆθ≡κ

प्रत्येक आउटपुट चरित्र के लिए एक बार लूप करें और स्थिति पर स्विच करें।

ζＩη

यदि यह अंक की स्थिति है तो डिक्रिप्ड अक्षर की स्थिति को आउटपुट करें।

ηι

लेकिन अगर यह डिकिफ़र्ड अक्षर की स्थिति है तो पत्र को आउटपुट करें। यह अंक की स्थिति पर पूर्वता लेता है क्योंकि चारकोल अंतिम प्रविष्टि लेता है यदि एकाधिक स्विच मामलों में समान मूल्य होता है।

‽β

अन्यथा एक यादृच्छिक पत्र का उत्पादन।

Answer 13

05AB1E , 26 बाइट्स

ε²Ý¨Ω©A.r²£Šǝ®Āi®²Ý¨®KΩǝ]J

0 अनुक्रमित।

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

स्पष्टीकरण:

ε            # Map over the characters of the first (implicit) input-string:
 ²Ý¨         #  Create a list in the range [0, second input)
    Ω        #  Get a random item from this list
     ©       #  Store it in the register (without popping)
 A           #  Push the lowercase alphabet
  .r         #  Shuffle it
    ²£       #  Leave only the first second input amount of characters
      Š      #  Triple swap, so the stack order becomes:
             #  random index; random string; map-character
       ǝ     #  Insert the map-character at this random index into the random string
 ®Āi         #  If the random index was NOT 0:
    ®        #   Push the random index
    ²Ý¨      #   Push the list in the range [0, second input) again
       ®K    #   Remove the random index from this list
         Ω   #   Get a random item from this list
          ǝ  #   Insert the first random index at the second random index into the string
]            # Close both the if-else and map
 J           # Join all strings together (and output implicitly)