15

एक नंबर और स्ट्रिंग दिए गए साइफर उत्पन्न करें

आपका कार्य सरल है। एक स्ट्रिंग sऔर 0 <= n <= 9इनपुट के रूप में एक संख्या को देखते हुए , स्ट्रिंग nसमय के प्रत्येक चरित्र के बीच एक छद्म यादृच्छिक मुद्रण योग्य ASCII चरित्र डालें । ऐसा है कि sवहाँ के प्रत्येक चरित्र के लिए nउनके बीच यादृच्छिक वर्ण हैं। रिक्त स्थान छंटनी चाहिए।

इनपुट:

स्ट्रिंग sवाक्यांश को सिफर में एन्क्रिप्ट करने के लिए
nकी सीमा में पूर्णांक0 <= n <= 9

उदाहरण:

इनपुट:

The treasure is here
2

आउटपुट:

T ! 0 h 32 e F4 t 0i r lk e hm a 7y s # 0 u * & r * h e ! 2 i H ^ s B! ज ! @ ई 0) आर $ ज ई

यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है! गुड लक और मजा करें!

— jacksonecac
स्रोत

3

यादृच्छिक मुद्रण योग्य ASCII चरित्र आपको यह परिभाषित करने की आवश्यकता है कि यहां यादृच्छिक का क्या मतलब है। सभी मुद्रण योग्य ASCII वर्णों की समान संभावना है? क्या उन्हें सांख्यिकीय रूप से स्वतंत्र होना चाहिए? इस बारे में हमारे पास क्या लचीलापन है?

— लुइस मेंडो

3

@jacksonecac मैं असहमत हूं। केवल यादृच्छिक कहना पर्याप्त नहीं है। उदाहरण के लिए, यदि मैं केवल ASCII कोडों के साथ यादृच्छिक वर्ण चुनता हूं, तो यह अभी भी यादृच्छिक है, लेकिन यह संभवतः स्वीकार नहीं किया जाता है (या इसे नहीं?) यदि nवर्णों की प्रत्येक श्रृंखला में nसमान यादृच्छिक वर्ण की प्रतियां शामिल हैं , तो वे अभी भी यादृच्छिक हैं, लेकिन वे सांख्यिकीय रूप से स्वतंत्र नहीं। और इतने पर

— लुइस मेंडू

5

@jacksonecac "यादृच्छिक" एक बहुत व्यापक शब्द है। क्या मैं पात्रों को एक सामान्य वितरण के साथ चुन सकता हूं, ताकि चारों ओर के अक्षरO स्थान रिक्त स्थान की तुलना में अधिक संभावित हों या ~? यदि इसे समान होना है, तो आपको स्पष्ट रूप से कहना चाहिए। और अगर यह एकरूप होना जरूरी नहीं है, तो आपको कम से कम कुछ ऐसा करना चाहिए जैसे प्रत्येक चरित्र में गैर-शून्य संभावना हो। तुम भी एक पिछली टिप्पणी में कहा गया गया है कि हर किरदार करता है एक स्वतंत्र रूप से वितरित होती है, यदि ऐसा है तो यह महत्वपूर्ण है, यह चुनौती में उल्लेख किया जाना चाहिए। यादृच्छिकता का एक बहुत व्यापक स्पेक्ट्रम है।

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

3

यह वास्तव में एक सिफर नहीं है। यह स्टेग्नोग्राफ़िक है, शायद।

— ग्रेग मार्टिन

2

यह @MartinEnder के मान्य बिंदु के लिए एक उपयुक्त प्रतिक्रिया नहीं है। एक समाधान स्पष्ट रूप से निर्दिष्ट करना होगा कि पात्रों को एक-दूसरे के समान और सांख्यिकीय रूप से स्वतंत्र होना चाहिए और टिप्पणियां बंद हो जाएंगी। एक वैकल्पिक (लेकिन दुर्व्यवहार के लिए अधिक खुला) विनिर्देशन होगा कि तिरछा वितरण या जहां वर्ण एक दूसरे पर निर्भर हैं, ठीक है, जब तक कि सभी वर्णों में गैर-मूर्तिकला होने की संभावना न हो। कोड में गोल्फ विनिर्देश निष्पक्षता के लिए महत्वपूर्ण है। जैसा कि आप अन्यथा एक अच्छी चुनौती पर इन वैध टिप्पणियों को संबोधित करने के लिए अनिच्छुक लगते हैं, I`m मतदान बंद करने के लिए।

— लेवल रिवर सेंट

7

सी #, 141 131 बाइट्स

@ Geobit के जावा उत्तर के समान सुंदर , वर्तमान में छोड़कर :(

(I,n)=>{var R=new System.Random();var o="";int i,r;foreach(var c in I)if(c>32)for(i=r=0,o+=c;i++<n;){r=R.Next(33,127);o+=(char)r;}return o;};

पूर्ण लंबोदर सामान:

Func<string, int, string> a = (I,n) =>
{
    var R=new System.Random();
    var o="";
    int i;
    foreach(var c in I)
        if(c>32)
            for(i=0,o+=c;i++<n;o+=(char)R.Next(33,127));
    return o;
};

— Yodle
स्रोत

क्यों R=...आप सीधे new System.Random().Next(...)मुझे लगता है कि उपयोग कर सकते हैं

— रोमन ग्रैफ़

2

@ RomanGräf msdn.microsoft.com/en-us/library/h343ddh9(v=vs.110).aspx C #, बिना बीज के रैंडम क्लास, सिस्टम क्लॉक का उपयोग करेगा, इसलिए यदि तेजी से उत्तराधिकार में कॉल करें (जैसे कि भीतर लूप)), अधिकांश मूल्य समान हैं, जो ज्यादातर मामलों में काम नहीं करेंगे :( मेरा विश्वास करो, मैं हमेशा कोशिश करता हूं और फिर याद आता हूं।

— Yodle

7

05AB1E , 11 बाइट्स

ð-vy²FžQ.RJ

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

व्याख्या

ð-           # remove spaces from input string
  v          # for each char in the string
   y         # push the char
    ²F       # input-2 number of times do:
      žQ.R   # push a random ascii character
          J  # join to string

— Emigna
स्रोत

बंद करे! रिक्त स्थान ट्रिम! :)

— जैक्सनसेक

@ जेकसनसेक: उस हिस्से को माफ कर दिया। अब निश्चित है :)

— एमिगॉन

अच्छी नौकरी! यह काम करता है!

— जैक्सनसेक

1

@carusocomputing: यह अंतिम अक्षर के साथ-साथ यादृच्छिक वर्ण जोड़ता है। सिर्फ अक्षरों के बीच में नहीं।

— एमिगा

1

@Emigna इस सवाल के तहत हाल ही में एक टिप्पणी के बाद यह ठीक लगता है :)

— geisterfurz007

6

जावा 7, 132 124 बाइट्स

String f(int n,char[]a){String o="";int i;for(char b:a)if(b>32)for(i=0,o+=b;i++<n;o+=(char)(33+Math.random()*94));return o;}

कुछ भी नहीं फैंसी, बस एक डबल पाश की तरह आप उम्मीद करेंगे। बाहरी लूप को स्ट्रिंग, भीतरी भाग में भरने के लिए:

String f(int n,char[]a){
    String o="";
    int i;
    for(char b:a)
        if(b>32)
            for(i=0,
                o+=b;
                    i++<n;
                        o+=(char)(33+Math.random()*94));
    return o;
}

— Geobits
स्रोत

इसके लिए कोई ज़रूरत नहीं है k:

String f(int n,char[]a){String o="";for(char b:a)if(b>32){o+=b;for(int i=0;i++<n;o+=(char)(33+Math.random()*94));}return o;}

(125 बाइट्स)

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

ऊँ दाहिने। मैं इसे एक अलग तरीके के साथ इस्तेमाल कर रहा था। जब मैं charकलाकारों के साथ गया तो इसे बाहर निकालने के बारे में नहीं सोचा । धन्यवाद!

— Geobits

मेरी गलती। मैंने दुस्साहस किया, मेरा सुझाव भी 124 बाइट्स का था: मैंने लंबाई के बजाय कॉलम की जाँच की;)

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

हाँ, मैंने देखा कि जब दोनों की तुलना :)

— Geobits

5

पाइके, 12 11 9 बाइट्स

d-FQV~KHs

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

d-        -  remove spaces from input
  F       - for i in ^:
   QV     -  repeat (number) times:
     ~KH  -    random_from(printable)
        s -   sum(^)

ओपी के अनुसार रैंडम रैंडम कैरेक्टर ठीक हैं।

— नीला
स्रोत

5

ऑक्टेव, 43 बाइट्स

@(s,n)[s(s>32);33+94*rand(n,nnz(s>32))](:)'

यह एक स्ट्रिंग sऔर एक पूर्णांक nको इनपुट के रूप में लेता है । ऑक्टेव में एक स्ट्रिंग पात्रों की एक सरणी है। किसी भी गैर-अंतरिक्ष अराजकों के लिए s>32एक तार्किक नक्शा है 1। कोड nपंक्तियों के साथ एक मैट्रिक्स को जोड़ता है और उसी संख्या में कॉलम s(s>32)है, जिसमें 33 और 126 के बीच फ्लोटिंग पॉइंट नंबर होते हैं। यह अंतर्निहित रूप से पूर्णांकों के लिए गोलाकार होता है और स्ट्रिंग के साथ इसे जोड़ने पर ASCII- वर्णों में परिवर्तित हो जाता है s। (:)'इसे वर्णों के एक क्षैतिज सरणी में सीधा करता है।

इसे यहाँ टेस्ट करें!

— स्टीवी ग्रिफिन
स्रोत

1

अधूरा गोलाई! नाइस

— लुइस मेंडो

4

अजगर 2, 123 122 118 114 98 बाइट्स

यार, काश randomइतना महंगा न होता (और हमें स्पेस के लिए फिल्टर नहीं करना पड़ता)। अब हमारे पास अंत में सिफर पात्रों की अनुमति देने से बड़ी बचत है :) वैसे भी, यहाँ फिर से जाएं:

from random import*
f=lambda s,n:s and(' '<s[0])*eval('s[0]'+'+chr(randint(32,126))'*n)+f(s[1:],n)

— Kade
स्रोत

4

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30+), 96 बाइट्स

(s,n)=>s.replace(/. */g,x=>x[0]+String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32]))

शुद्ध ES6 दो बाइट्स लंबा है:

(s,n)=>s.replace(/. */g,x=>x[0]+String.fromCharCode(...[...Array(n)].map(_=>Math.random()*95+32)))

यहाँ एक बहुत ही अच्छा तरीका है जो दुख की बात है कि 26 बाइट्स लम्बी हैं:

(s,n)=>String.raw({raw:s.split` `.join``},...[for(_ of s)String.fromCharCode(...[for(_ of Array(n))Math.random()*95+32])])

— ETHproductions
स्रोत

कड़ाई से बोलना /. *(?=.)/रिक्त स्थान की शुरुआत या समाप्ति के लिए काम नहीं करता है, न कि किसी को परवाह है। (अब आपको यादृच्छिक वर्णों की अनुगामी बनाने की भी अनुमति है।)

— नील

@ नील ट्रेलिंग यादृच्छिक वर्णों की अनुमति है? मुझे लगता है कि मैं बस को हटा सकता हूं (?=.)जो स्ट्रिंग्स के अंत में रिक्त स्थान की देखभाल करता है।

— ETHproductions

कल्पना इतनी स्पष्ट नहीं है, लेकिन मुझे लगता है कि आप खाली स्थान डालने से बचते हैं, इसलिए 94+33इसके बजाय95+32

— edc65

3

आर, 97 बाइट्स

इनपुट्स x(स्ट्रिंग) और फंक्शन ले रहे हैं n।

function(x,n,l=nchar(x))for(i in 1:l)cat(substr(x,i,i),if(i<l)intToUtf8(sample(32:126,n)),sep="")

इसे आर-फिडल पर आज़माएं

— Billywob
स्रोत

3

सीजाम , 21 18 बाइट्स

lS-(ol~f{{95mrSc+\}*}

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

nयादृच्छिक अनुगामी पात्रों को प्रिंट करता है ।

व्याख्या

lS-        e# Read line and remove spaces.
l~         e# Read and evaluate another line.
f{         e# For each character (passing in N)...
  {        e#   Do this N times...
    95mr   e#     Push random integer in [0, 95).
    Sc+    e#     Add to space character, giving a random printable ASCII character.
  }*
}
           e# All characters remaining on the stack are printed implicitly
           e# at the end of the program.

— मार्टिन एंडर
स्रोत

3

बैश, 124 बाइट्स

शुद्ध बैश + Coreutils , कोई नियंत्रण प्रवाह संरचनाएं, कोई उप-भाषाएं, कोई "eval" नहीं

golfed

E() { N=${1// /};paste <(fold -1<<<$N) <(tr -cd "\\40-\\176"<\/dev\/urandom|head -c$(($2*${#N}-$2))|fold -$2)|tr -d '\t\n';}

परीक्षा

>E "The treasure is here" 2
TkZhf(e&Rt@FrS,edha+-sJTuh.rX@eVKi+3s<7hftey8r*/e

— टसेपेल्लिन
स्रोत

3

क्यू / केडीबी +, ~~३ ९ ३६~~ ३४ बाइट्स

~~raze{""sv(raze x;`char$40+n?87)}prior s (,/)({""sv((,/)x;`char$40+n?87)}':)s~~

(,/)({""sv((,/)x;10h$40+n?87)}':)s

उपयोग में चर:

s:"The treasure is here"
n:2

यह पूर्ववर्ती क्रिया का उपयोग करता है , जो प्रत्येक आइटम को दाईं ओर और उसके पूर्ववर्ती के बीच फ़ंक्शन को लागू करता है। (अनिवार्य रूप से, प्रत्येक वर्ण के बीच दाईं ओर बाईं ओर फ़ंक्शन लागू होता है।)

40 और 126 के बीच n यादृच्छिक संख्या उत्पन्न करें और फिर उन्हें एक वर्ण के रूप में परिवर्तित करें: (q केवल इन के लिए वर्ण हैं)

`char$40+n?87

//Possible characters.
()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~

उदाहरण आउटपुट:

TVghrveVp Rpti+r0sea3a9nsIjuRXrAReJ; +di=ys`{ ikhKTe4trTZesz

EDIT:
क्ष संकेतन का उपयोग करके q के विस्फ़ोटक (/) में परिवर्तित करके 3 बाइट्स को सहेजा गया और इसी तरह से पूर्व में बदल दिया गया: अद्यतन के लिए @slackwear के लिए धन्यवाद, 2 बाइट्स मुंडा :)

— एडम जे
स्रोत

1

के साथ कास्टिंग करके बाइट्स के एक जोड़े को बचा सकता है10h$

— skeevey

2

जावा 8, 114 बाइट्स

golfed

(n,s)->s.chars().forEach((c)->{if(c>32)for(int i=0;i<=n;)System.out.print((char)(++i==1?c:33+Math.random()*94));})

लैम्ब्डा जो एक इंटेगर और एक स्ट्रिंग को स्वीकार करता है। जावा 7 उत्तर से प्रेरित, कुछ जावा 8 स्ट्रीम सिंटैक्स का उपयोग करके डबल लूप (String.chars कुछ बाइट्स को बचाने के लिए ) ।

इनपुट

3, "Hello world!"

उत्पादन

HfKIedb3l<-Ul%}vod"Bw\"|oa`%rH-}l/-{dMS;!B#X

— Xanderhall
स्रोत

2

स्काला, 95 94 बाइट्स

def c(s:String,i:Int)=s.filter(_>32).mkString(scala.util.Random.alphanumeric.take(i).mkString)

एक स्ट्रिंग पर mkString के उपयोग के अलावा कुछ भी नहीं फैंसी। यह स्ट्रिंग को पात्रों की सूची के रूप में मानता है, और मुझे उनके बीच एक विभाजक डालने की अनुमति देता है। मेरा विभाजक यादृच्छिक रूप से उत्पन्न अल्फ़ान्यूमेरिक वर्णों की उपयुक्त संख्या है।

— एतान
स्रोत

सवाल का जवाब नहीं। Random.alphanumericवसीयत की प्रकृति के कारण प्रत्येक हिस्सा एक जैसा होगा, इसलिए यह एक लंगड़ा सिफर है ... इस उदाहरण को देखें:scala> c("Hello", 1) res0: String = Hbeblblbo

— याकूब

BTW, आप निकाल सकते हैं filter। mkStringएक स्ट्रिंग पर आमंत्रित करना इसे एक चरित्र संग्रह के रूप में माना जाएगा।

— जैकब

@ जैकब सबसे प्रभावी तरीका है जिससे मैं रिक्त स्थान को हटाने के बारे में सोच सकता हूं। मैंने यादृच्छिक को छोड़ दिया क्योंकि यह पर्याप्त लग रहा था, लेकिन अगर मेरे पास समय है तो मैं उचित यादृच्छिक पाठ के लिए एक अलग फ़ंक्शन में जोड़ूंगा।

— ईथन

2

> <> (मछली), १० 107 106 १०३ बाइट्स

<v}:{r&" "
1xv+
2<v+
v}<
<~v!?=&:&:
6.>ol2-?!;a
:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o-+
^3<v ~}}r]~<
.40<

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

यह सुपर यादृच्छिक नहीं है, लेकिन यह यादृच्छिक है। बस स्ट्रिंग और पूर्णांक को स्टैक पर रखें (उदाहरण: "हैलो वर्ल्ड!", 5)।

Input: "Hello world!", 5
Output: H^\^]^eceeedldcdeclgfffhowhhfggojkkkkrdccedl]]\]\d

पूर्ण व्याख्या

यह कोड का थोड़ा पुराना संस्करण है, जब तक मैं स्पष्टीकरण को अपडेट नहीं करता। यह ज्यादातर एक ही है, शायद पढ़ने में थोड़ा आसान है:

< v}:{r&" "
+1xv
+2<v
   }
:&:<~ v!?=&
?!;a6.>ol2-
:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o+*
^3<v ~}}r]~<
.43<

हम दिखावा करेंगे स्ट्रिंग पैरामीटर है sऔर पूर्णांक पैरामीटर है i।

< v}:{r&" "

<मछली तुरंत स्थानांतरित करने के लिए छोड़ दिया है, जो करने के लिए इर्द-गिर्द घूमती बताता " "है, जो एक अंतरिक्ष ढेर करने के लिए characted कहते हैं। फिर मछली यात्रा करती है &, जो अंतरिक्ष को रजिस्टर में जोड़ती है। rस्टैक को उलट देता है और {:}स्टैक को बाईं ओर रखता है (स्टैक iके अंत पर डालते हुए), स्टैक के अंत पर मूल्य को कॉपी करता है, फिर इसे दाईं ओर शिफ्ट करता है। vमछली को नीचे की ओर बढ़ना शुरू करने के लिए कहता है।

+1xv
+2<v
   }

xमछली को एक यादृच्छिक दिशा में ले जाने के लिए कहता है, जिसके परिणामस्वरूप मछली सही हो रही है और नीचे की ओर जा रही है, 1+या 2+पहले या बाद में गुजरती है । ये स्टैक के अंत में संख्या में क्रमशः 1 या 2 जोड़ते हैं। यदि मछली ऊपर की ओर जाती है, तो वह vफिर से टकराती है और वापस नीचे की ओर यात्रा करती है। }स्टैक को दाईं ओर शिफ्ट करता है, फिर स्टैक iपर स्थिति 1 पर और स्थिति 0 पर नया चर (हम इसे कॉल करेंगे m)।

:&:<~ v!?=&

यह खंड एक फ़ंक्शन है, इसे व्हाट्सएपट्रीमर कहते हैं । यह जहां से शुरू होता है< है। यह बस स्ट्रिप्स के अंत में स्ट्रिप्स (ताकि स्ट्रिंग की शुरुआत) के अंत तक रिक्त स्थान है जब तक कि यह एक गैर-अंतरिक्ष चरित्र में नहीं चलता।

तो तुरंत मछली एक में तैरती है <और बाईं ओर यात्रा करनी चाहिए। यह तब चलता है, :&:&जो स्टैक के अंत में मूल्य को कॉपी करता है, स्टैक के अंत में रजिस्टर से स्थान रखता है, इसे कॉपी करता है, फिर इसे रजिस्टर पर वापस रखता है।

फिर मछली हिट करती है =?!v ~, या अधिक विशेष रूप से =, जो पिछले दो मूल्यों (जो हमने अभी बनाया है) को स्टैक से दूर करता है, उनकी तुलना करता है, स्टैक के अंत में 1 रखता है यदि वे बराबर हैं, और एक 0 पर यदि वे अलग हैं तो स्टैक का अंत। ?ढेर के अंत नया मान दिखाई दे, अगर यह 0 यह अगले निर्देश, इस मामले में है जो निष्पादित नहीं करता है !, यह बजाय कार्यान्वित vहै, जो आदेश मछली नीचे की ओर ले जाने के लिए (समारोह से बाहर निकलते समय)।

यदि यह 1 हालांकि है, तो इसे एक जगह मिल गई है, इसलिए यह !एक ट्रम्पोलिन है, और जो मछली को अगले निर्देश को छोड़ देता है, जो कि ए है, इसलिए इसे निष्पादित करता है v, इसलिए मछली जारी है। मछली के सामने, यह देखता है~ कि इसे स्टैक से अंतिम मान पॉप करने के लिए कहता है (एक स्थान होने की पुष्टि की गई है), फिर मछली जारी है, और फिर से फ़ंक्शन चलाता है।

?!;a6.>ol2-

मछली को तुरंत कहा जाता है कि वह दाईं ओर तैरती है >, फिर स्टैक पर अंतिम पात्र का उत्पादन करती हैo (जो, पहली बार यह चलाया जाता है, यह पहला चरित्र है s)। यह स्टैक की लंबाई से प्राप्त होता है l, स्टैक 2के अंत में स्थित होता है, फिर -2 को इससे घटाया जाता है l। यह हिट ?!;करता है, जो यह याद रखता है कि ?मछली किस कारण से छोड़ती है! अगर स्टैक खाली है, और जमीन पर; , जो प्रोग्राम को समाप्त करता है।

यदि स्टैक पर अभी भी अक्षर हैं, तो हम निष्पादित करते हैं ! जिसके कारण मछलियां उछलती हैं ;और निष्पादित होती हैं a6., जो स्टोर a(AKA 10), और 6स्टैक के अंत में होती हैं, जिसके लिए x, yनिर्देशांक हैं. , जो उन्हें समाप्त होने पर पॉप करता है स्टैक, फिर मछली को टेलीपोर्ट करता है10, 6 और उस पोस्ट के दाईं ओर निर्देश निष्पादित करता है (जैसा कि मछली सही तैर रही है)।

जब आप yस्थिति 6 को महसूस करते हैं तो यह कम जटिल होता है । xस्थिति 10 तो है v, और उस के दाईं ओर है , जो कि एक सेशन नहीं है। यह मछली को तैरना जारी रखने का कारण बनता है और वास्तव में लाइन की शुरुआत में निष्पादन शुरू करता है ...

:{{:}l1-[rv
v2<
<1x|!}:}-1<v!?:{{:o+*
^3<v ~}}r]~<
.43<

तो यह फ़ंक्शन है जो वर्णों के बीच यादृच्छिक पाठ जोड़ता है। यह एक कौर है, लेकिन यह सिर्फ इसलिए है क्योंकि मैंने इसे थोड़ा अतिरिक्त बनाने की कोशिश की थी। इसको बुलाते हैं genRandomChars ।

:{{:}l1-[rvवास्तव में समारोह के लिए सेटअप, और कम-तो वास्तविक समारोह ही एक हिस्सा है। मछली पहले तैरती है, :{{जो स्टैक के अंत में मूल्य को कॉपी करती है, फिर इसे बाईं ओर दो बार स्थानांतरित करती है। यदि आपको याद है कि iस्टैक पर पोस्ट 1 था, तो आपको पता होगाi स्टैक के अंत में अब है।

मछली फिर :}उस प्रतियां पर तैरती है i, और स्टैक को दाईं ओर शिफ्ट करती है, स्टैक iकी शुरुआत और अंत दोनों पर। l1-[मछली ने ढेर के अंत में लंबाई रखी है, उसमें से 1 घटाएं, फिर[ एक नया स्टैक बनाता है, नए स्टैक के l-1लिए मान (स्टैक लंबाई माइनस 1) मान (ताकि iपुराने स्टैक पर बस निकल जाए )। फिर मछली बस हिट करती है rvजो स्टैक को फिर से उलट देती है (मुझे लगता है कि एक नया स्टैक बनाने से यह किसी कारण से उलट हो जाता है), और मछली को एक बार फिर नीचे की ओर तैरने का आदेश देता है, फलस्वरूप फंक्शन की शुरुआत करता है< ।

तो वर्तमान में स्टैक का अंत है mऔर हमारा अस्थायी है i, जिसे हम कॉल करेंगे ti। तुरंत मछली तैरती है 1-}, जो 1 से घटाती हैti और इसे ढेर की शुरुआत में ले जाती है। फिर :}जो बस कॉपी करता है mऔर इसे स्टैक की शुरुआत में ले जाता है (डाल रहा हैti स्टैक स्थिति 1 पर )।

यह तब होता है जब हम इस छोटी सी चीज को मारते हैं:

v2<
<1x|!
^3<

यह वास्तव में मृत सरल है। !मछली को छोड़ने |और निष्पादित करने का कारण बनता है x। क्या याद कर रहे होx करता है, हमें याद है कि यह मछली किसी भी 4 दिशाओं में चलती है। |बस एक दर्पण है, और मछली को वापस तैरने का कारण बनता हैx । तो मूल रूप से, मछली स्टैक के अंत में 1, 2, या 3 जगह लेगी, और बाईं ओर घूमना जारी रखेगा।

मछली तब निष्पादित होती है *+oजो स्टैक पर अंतिम दो मानों को पॉप-अप होने का कारण बनाती है, एक साथ गुणा किया जाता है, और परिणाम फिर से आगे बढ़ता है, फिर एक ही चीज को जोड़ दिया जाता है, फिर अंतिम मूल्य स्टैक से पॉपअप किया जाता है और इसके साथ आउटपुट होता है o। हमारे ढेर अब फिर से अपेक्षाकृत सामान्य है जिसमें सिर्फ [ m, ti,s ]।

:}}:स्टैक के अंत पर मूल्य का कारण बनता है (मूल रूप से sस्थिति 0) ओटी को कॉपी किया जाता है, फिर स्टैक को दाईं ओर दो बार स्थानांतरित किया जाता है ( tiफिर से सामने की तरफ रखकर ), फिर tiकॉपी किया जाता है। ?!vअब तक समझना बहुत आसान होना चाहिए। मूल रूप से यदि ti0 है तो हम फंक्शन से बाहर निकलते हैं v, अन्यथा हम निष्पादित करते हैं !और छोड़ते हैंv (दूसरा लूप करते हुए)।

यदि ti0 है और हम थोड़े यादृच्छिक वर्णों को आउटपुट करते हैं, तो हम निष्पादित करते हैंv और देखते हैं:

   v ~}}r]~<
.43<

यहां कुछ भी नहीं फैंसी। हम tiस्टैक से हटाते हैं ~। फिर ]नया है, यह स्टैक से हमारे सभी मूल्यों को पॉप करता है और उन्हें पुराने स्टैक पर रखता है! उलट मुद्दा हम साथ रिवर्स की वजह से rहै, तो साथ सही दो बार ढेर बदलाव }}~, सही करने के लिए ढेर shufting, हमें दे रही है [ m, i, s], ~अतिरिक्त दोहराया दूर करने के लिए है s[0]समारोह में पहले से जैसा कि हम इसे अगर आवश्यकता होगी हम एक लूप कर रहे थे (लेकिन हम नहीं, हम बाहर निकल रहे हैं)। vमछली को नीचे तैरने के लिए और >34.(निष्पादन आदेश दिखाने के लिए उल्टा) बताता है, जो मछली को बस बाईं और तैरने के लिए कहता है 3, 4(क्योंकि , जो एकदम सही है क्योंकि हम बाईं ओर यात्रा कर रहे हैं।. यह एक कूद है!)। 3, 4वास्तव में सिर्फ शुरुआत के अधिकार के लिए हैwhitespaceTrimmer

इस सारे तर्क के बाद हम मछली का पालन कर सकते हैं जब तक कि स्टैक अंततः खाली नहीं हो जाता है और प्रोग्राम whitespaceTrimmerनिष्पादित होने के बाद ही बाहर निकलता है।

— redstarcoder
स्रोत

हम्म मैंने नहीं देखा कि चरित्र को प्रिंट करने योग्य होना चाहिए। इसके लिए मामूली संशोधन की आवश्यकता होगी जो इसे कम यादृच्छिक और छोटा बना सकता है।

— redstarcoder

यह वास्तव में पूरी तरह से बहुत कम यादृच्छिक नहीं दिखता है। मेरा मानना है कि इसे ज्यादातर मामलों में काम करना चाहिए, मैंने अभी तक इसे विफल नहीं किया है। यह सुनिश्चित करने के लिए किसी भी पूंजी या लोअरकेस पत्र और कुछ प्रतीकों के साथ काम करेगा। मुझे पूरा यकीन है कि यह चुनौती की आवश्यकताओं को पूरा करता है।

— Redstarcoder

2

पर्ल 5, 81 बाइट्स

($_,$n)=<>;chomp;y/ //d;$\=chop;print map{$_,map{chr 33+int rand 94}1..$n}split//

मुझे आशा है कि निम्नलिखित आपको यह समझने में मदद करेंगे कि वन-लाइनर क्या करता है:

($_, $n) = <STDIN>;  # Reads in the string into $_,
                     # and the number into $n, from standard input.
                     # (<STDIN> works slightly different from <>.)
chomp($_);           # Removes the newline from the string.
$_ =~ tr/ //d;       # `Tr/`ansliterates ASCII space characters
                     # into nothing, effectively `/d`eleting them.
$\ = chop($_);       # Chop()s off the last character out of $_ and
                     # appends it to the output when print()ing.
                     # (Perl always prints $\ after you call print().)
print( map {         # Each element of [List 1] will be mapped to:
    $_,              #   -- Itself, and
                     # (When mapping, each element is available as $_.)
    map {            # (`map` resembles `foreach` but returns a list.)
        chr(         #   -- A random ASCII character, in the range
          33 + int(rand(94)) ) # from 33 (!, hex 21) to 126 (~, hex 7E)
    } 1..$n          # ...$n times! (Over the range 1 to $n, actually.)
} split(//, $_) );   # [List 1] is $_, split() into characters.

— g4v3
स्रोत

1

क्लोजर, 126 123 118 122 117 बाइट्स

(defn c[m n](apply str(remove #(=\space %)(mapcat #(apply str %(for [_(range n)](char(rand-nth(range 32 127)))))m))))

संदेश पर नक्शे, यादृच्छिक अक्षरों को सम्मिलित करता है, फिर परिणाम को संक्षिप्त करता है।

निर्देश बताते हैं कि परिणाम स्ट्रिंग से सभी रिक्त स्थान छीन लिए जाने चाहिए। यदि मूल संदेश से केवल रिक्तियाँ छीनी जाएँ, तो मैं इसे बदल सकता हूँ।

Ungolfed:

(defn cipher [message n]
  (apply str
    (remove #(= \space %)
        (mapcat #(apply str %
                     (for [_ (range n)]
                       (char (rand-nth (range 32 127)))))
                message))))

— Carcigenicate
स्रोत

1

पायथन 3, 127 बाइट्स

import random
a,b=input(),input()
print(''.join([x+''.join([chr(random.randint(33,126))for c in range(int(b))]) for x in a]))

शायद जरूरत से ज्यादा लंबा रास्ता, लेकिन यह मेरा अब तक का गोल्फ है।

— Vedvart1
स्रोत

1

यह पहले वर्ण के सामने यादृच्छिक वर्ण जोड़ता है, और रिक्त स्थान को छंटनी नहीं की जाती है। मुझे लगता है कि ये दोनों चीजें नियमों को तोड़ती हैं।

— स्टिव ग्रिफिन

1

PHP, 96 बाइट्स

स्ट्रिंग को तर्क 1 और संख्या को तर्क 2 के रूप में लेता है

for(;($s=str_replace(' ','',$argv[1]))[$j]>'';)echo$i++%($argv[2]+1)?chr(rand(33,127)):$s[$j++];

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

— क्रिप्टो
स्रोत

1

पायथन 3, 133 बाइट्स

from random import *
c=int(input())
print(''.join([i+''.join([chr(randint(33,126))for i in range(c)])for i in input().strip(' ')])[:-c])

— sonrad10
स्रोत

1

नोड.जेएस, 88 बाइट्स

(s,n)=>s.replace(/./g,c=>c!=" "?c+crypto.randomBytes(n).toString`base64`.substr(0,n):"")

उदाहरण आउटपुट:

f("The treasure is here", 2)
// THphdwekAtMArbSeU1aDTsZWuqnr2yek1iyUsKshqXewvrVCeTi

f("The treasure is here", 2)
// TYshlcep6t4Iru7e29aQ1sl/uvQrlzeSJihysDhhOLe1urpte1m

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

— फ्लोरेंट
स्रोत

1

सी, 102 100 बाइट्स

स्किपिंग के लिए -2 बाइट्स continue।

i;f(char*s,int n){do{while(*s==32)++s;putchar(*s);i=n;while(i--)putchar(32+rand()%95);}while(*s++);}

Ungolfed:

i;
f(char*s,int n){
 do{
  while(*s==32)++s;
  putchar(*s);
  i=n;
  while(i--)
    putchar(32+rand()%95);
 }while(*s++);
}

उपयोग:

main(){
  char a[]="A   A A";
  f(a,3);
}

— कार्ल नेफ
स्रोत

एक सिफर उत्पन्न करें

सी #, 141 131 बाइट्स

05AB1E , 11 बाइट्स

जावा 7, 132 124 बाइट्स

पाइके, 12 11 9 बाइट्स

ऑक्टेव, 43 बाइट्स

अजगर 2, 123 122 118 114 98 बाइट्स

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30+), 96 बाइट्स

आर, 97 बाइट्स

सीजाम , 21 18 बाइट्स

व्याख्या

बैश, 124 बाइट्स

जावा 8, 114 बाइट्स

golfed

इनपुट

उत्पादन

स्काला, 95 94 बाइट्स

> <> (मछली), १० 107 106 १०३ बाइट्स

पूर्ण व्याख्या

पर्ल 5, 81 बाइट्स

क्लोजर, 126 123 118 122 117 बाइट्स

पायथन 3, 127 बाइट्स

PHP, 96 बाइट्स

पायथन 3, 133 बाइट्स

नोड.जेएस, 88 बाइट्स

सी, 102 100 बाइट्स