कंप्यूटर एक ताज़ा कुकी का स्वाद कभी नहीं लेगा

11

से प्रेरित होकर github.com/JackToaster/Reassuring-Parable-Generator , बारी में से प्रेरित xkcd.com/1263 । संभावित शब्द उस भंडार के reassuring.cfg से लिए गए हैं ।

Reassuring.cfg (12 वीं प्रतिबद्ध का उपयोग करें) पर एक नज़र रखने से व्याकरण को आउटपुट मैचों को देखने का सुझाव दिया जाता है (आउटपुट व्याकरण से मेल खाते सभी तारों की एक सूची है)।

टास्क: आपके प्रोग्राम को पस्टैबिन pastebin.com/2SNAJ1VH में निहित सटीक टेक्स्ट के सभी 7968 केस-संवेदी लाइनों को आउटपुट करना होगा । पास्टबिन की एक कॉपी वेबैक मशीन में सहेजी गई है

यहाँ pastebin से 33 प्रेरक लाइनों का एक नमूना है: 

Computers can't enjoy a salad.
Computers can't enjoy a cake.
Computers can't enjoy a ice cream cone.
Computers can't enjoy a meal.
Computers can't enjoy a drink.
Computers can't enjoy a steak.
Computers can't enjoy a chicken dinner.
Computers can't enjoy a piece of cake.
Computers can't enjoy a piece of pie.
Computers can't enjoy a cookie.
Computers can't enjoy a sandwich.
Computers can't taste a salad.
Computers can't taste a cake.
Computers can't taste a ice cream cone.
Computers can't taste a meal.
Computers can't taste a drink.
Computers can't taste a steak.
Computers can't taste a chicken dinner.
Computers can't taste a piece of cake.
Computers can't taste a piece of pie.
Computers can't taste a cookie.
Computers can't taste a sandwich.
Computers can't experience eating a salad.
Computers can't experience eating a cake.
Computers can't experience eating a ice cream cone.
Computers can't experience eating a meal.
Computers can't experience eating a drink.
Computers can't experience eating a steak.
Computers can't experience eating a chicken dinner.
Computers can't experience eating a piece of cake.
Computers can't experience eating a piece of pie.
Computers can't experience eating a cookie.
Computers can't experience eating a sandwich.

चुनौती नियम:

  • लाइनों का उत्पादन किसी भी तरह से आप चाहते हैं, लेकिन उनमें से सभी 7968 को शामिल किया जाना चाहिए।
  • आउटपुट एकल फ्लैट स्ट्रिंग के रूप में होना चाहिए, न कि स्ट्रिंग्स की सूची के रूप में।
  • आपके प्रोग्राम को कोई इनपुट या खाली अप्रयुक्त इनपुट स्वीकार नहीं करना चाहिए।
  • आपका प्रोग्राम किसी भी ऑनलाइन स्रोत से डेटा प्राप्त नहीं कर सकता है।
  • एक एकल अनुगामी न्यूलाइन वैकल्पिक है।

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

code-golf  string  kolmogorov-complexity  grammars 
— fireflame241
स्रोत
— जेम्स
4
No computer {can} {action}.दो बार दोहराया जाता है, और Computers {cannot_present}"कंप्यूटर अक्षम है" जैसे वाक्यांशों का उत्पादन करता है। जानबूझकर?
— darrylyeo
पास्टबिन में किसी भी स्पष्ट गलतियों को सभी कार्यक्रमों के लिए आउटपुट में शामिल किया जाना चाहिए (हम पिछले कार्यक्रमों के लिए विनिर्देशों को नहीं बदल सकते हैं)। Reassuring.cfg सिर्फ एक नमूना व्याकरण है जो कम से कम काफी सटीक है।
— Fireflame241
इस आईडी में प्रतिस्पर्धा करने के लिए इनपुट के लिए एक पार्सर लिखना है जो कि केवल अनियंत्रित लोल को सूचीबद्ध करता है।
— मैजिक ऑक्टोपस Urn
संदर्भ के लिए, बबलगम समाधान के लिए टीआईओ लिंक एक जवाब में डालने के लिए बहुत लंबा है। स्रोत कोड 23270 बाइट्स है।
— संगीतज्ञ ५२३

जवाबों:

7

Zsh , 765 बाइट्स

यह पहली चीज हो सकती है जो मैंने कभी भी zsh में लिखी है, लेकिन इसमें ब्रेस एक्सपेंशन को सरणियों में बदलने में सक्षम होने की अविश्वसनीय रूप से सुविधाजनक विशेषता है (हालांकि यह उतना सुविधाजनक नहीं है जितना कि यह होना चाहिए ... )। साथ चलाएं zsh -P(+1 बाइट के रूप में गिना जाता है), जो चालू होता है RC_EXPAND_PARAM।

a=able\ to
b=" be $a"
d=wonderful
i=ing\ a
o=omputer
n="No c$o "
r=ever
p=capable\ of
u=will
w=$u\ n$r
x=experienc
e=(\ {{{enjoy,tast,$x'ing eat'}$i,tast$i\ {delicious,fresh,tasty,refreshing,$d}}\ {salad,cake,'ice cream cone',meal,drink,steak,chicken\ dinner,'piece of '{cake,pie},cookie,sandwich},{understand$i,{enjoy,$x}$i{,\ {beautiful,$d,{inspir,amaz}ing,superb}}}\ {son{net,g},poem,story,play,'piece of music'}}.)
f=(${e:s/cing/ce/:s/sting/ste/:s/ding/d/:s/ying/y})
l=($w won\'t$b {$w,n$r\ $u}{$b,' have the ability to'})
v=($l "won't $r$b")
k=({ca,wo}n\'t $l is{"n't ",\ un}$a)
c=(C$o\s A\ c$o)
printf %s\\n $c\ $k$f C$o's '$v$f $n{can,is\ $a,$u\ $r$b,"is $r going to",{can,$u}\ $r}$f{,} $c\ {is{\ in,"n't "}$p,"cannot $x"e}$e $n{{is,$u\ be}\ $p,"can $x"e}$e

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

— एंडर्स कसीर्ग
स्रोत
4

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

यह एक अच्छी बाइट गिनती शुरू करने के लिए है! उस विशाल तार को नीचे गिराने का समय।

f=

_=>(G=`beautiful|wonderful|inspiring|amazing|superb
sonnet|poem|story|play|song${p=`|piece of `}music
cake${p}cake${p}pie|salad|ice cream cone|meal|drink|steak|chicken dinner|cookie|sandwich
delicious|fresh|tasty|refreshing|wonderful
can|is ${a=`able to`}|is ever going to|can ever|will ever${b=` be `+a}|will ever
is ${C=`capable of`}|will be ${C}|can${E=` ${e=`experience`}
${w=`will never`}${b}|${w}${h=` have the ability to|never will`}${h}${b}|won't${b}|${w}|won't`} ever${b}
isn't ${C}|is in${C}|cannot${E}|can't|isn't ${a}|is un${a}`.split`
`.map(l=>l.split`|`),F=S=>[].concat(...S.split`|`.map(s=>eval(s.match(/\d/g).map(n=>`for(f[${n}]of G[${n}])`).join``+`A.push(s.replace(/\\d/g,n=>' '+f[n]));A`,A=[]))),G[9]=F(p=`enjoy a2|taste a2|${e} eating a2|taste a32|enjoy a1|${e} a1|enjoy a01|understand a1|${e} a01`),G[9]=F(p=`${e=`enjoy`} a2|taste a2|${e} eating a2|taste a32|enjoy a1|${e} a1|enjoy a01|understand a1|${e} a01`),G[0]=F(p.replace(/([^g])e? (a|e)/g,'$1ing $2')),F(`C${o=`omputer`}s89.|A c${o}89.|C${o}s69.|No c${o}49.|C${o}s70.|A c${o}70.|No c${o}50.|No c${o}49.`).join`
`)

document.write('<pre>'+f())
स्निपेट का विस्तार करें

कम गोल्फ वाला:

f=

_=>(

G=`beautiful|wonderful|inspiring|amazing|superb
sonnet|poem|story|play|song${p=`|piece of `}music
cake${p}cake${p}pie|salad|ice cream cone|meal|drink|steak|chicken dinner|cookie|sandwich
delicious|fresh|tasty|refreshing|wonderful
can|is ${a=`able to`}|is ever going to|can ever|will ever${b=` be `+a}|will ever
is ${C=`capable of`}|will be ${C}|can${E=` ${e=`experience`}
${w=`will never`}${b}|${w}${h=` have the ability to|never will`}${h}${b}|won't${b}|${w}|won't`} ever${b}
isn't ${C}|is in${C}|cannot${E}|can't|isn't ${a}|is un${a}`.split`
`.map(l=>l.split`|`),

F=S=>[].concat(...S.split`|`.map(s=>eval(s.match(/\d/g).map(n=>`for(f[${n}]of G[${n}])`).join``+`A.push(s.replace(/\\d/g,n=>' '+f[n]));A`,A=[]))),

G[9]=F(p=`enjoy a2|taste a2|${e} eating a2|taste a32|enjoy a1|${e} a1|enjoy a01|understand a1|${e} a01`),
G[9]=F(p=`${e=`enjoy`} a2|taste a2|${e} eating a2|taste a32|enjoy a1|${e} a1|enjoy a01|understand a1|${e} a01`),

G[0]=F(p.replace(/([^g])e? (a|e)/g,'$1ing $2')),

F(`C${o=`omputer`}s89.|A c${o}89.|C${o}s69.|No c${o}49.|C${o}s70.|A c${o}70.|No c${o}50.|No c${o}49.`).join`
`

)

document.write('<pre>'+f())
स्निपेट का विस्तार करें

कैसे?

(यह अब तक के मेरे सबसे पसंदीदा गोल्फरों में से एक है!)

व्याकरण को सरणी में संग्रहीत किया जाता है G, जो इसका मूल्यांकन करता है:

[["beautiful","wonderful","inspiring","amazing","superb"],
 ["sonnet","poem","story","play","song","piece of music"],
 ["salad","cake","ice cream cone","meal","drink","steak","chicken dinner","piece of cake","piece of pie","cookie","sandwich"],
 ["delicious","fresh","tasty","refreshing","wonderful"],
 ["is capable of","can experience","will be capable of"],
 ["can","is able to","is ever going to","can ever","will ever be able to","will ever"],
 ["will never be able to","will never have the ability to","never will have the ability to","never will be able to","won't ever be able to","will never","won't be able to"],
 ["is incapable of","isn't capable of","cannot experience"],
 ["can't","won't","will never","won't be able to","will never be able to","will never have the ability to","never will have the ability to","never will be able to","isn't able to","is unable to"]]

Fएक ऐसा कार्य है जो सीमांकक द्वारा एक स्ट्रिंग को विभाजित करता है |और इसके माध्यम से पुनरावृत्त करता है। अब तक सब ठीक है।

F=S=>[].concat(...S.split`|`.map( ... )),

अब इस आंतरिक कार्य के साथ क्या हो रहा है?

s=>eval(
    s.match(/\d/g).map(n=>`for(F[${n}]of G[${n}])`).join``+
    `A.push(s.replace(/\\d/g,n=>F[n]));A`,
    A=[]
)

पहले हम एक सरणी को इनिशियलाइज़ करते हैं A। फिर हम पास किए गए स्ट्रिंग में सभी अंकों को ढूंढते हैं sऔर एक उप-प्रोग्राम बनाते हैं: प्रत्येक अंक का उपयोग करते हुए n, हम एक for- ofलूप उत्पन्न करते हैं जो प्रविष्टियों के माध्यम से पुनरावृत्त करता है G[n](के गुणों के रूप में संग्रहीत किया जाता है F, क्योंकि जावास्क्रिप्ट में फ़ंक्शन भी ऑब्जेक्ट हैं)। छोरों को फिर एक के बाद एक जोड़ दिया जाता है।

उदाहरण के लिए, s="1 2 3"इस तरह से शुरू होने के लिए उत्पन्न उप-कार्यक्रम :

for(F[1]of G[1])for(F[2]of G[2])for(F[3]of G[3])

प्रत्येक पुनरावृत्ति पर, उप-प्रोग्राम प्रत्येक अंक sको उसके संबंधित प्रतिस्थापन के साथ बदल देता है, जिसमें संग्रहीत किया जाता है F[n]और परिणाम को धक्का दिया जाता है A। उप-कार्यक्रम evalएड है और Aइसे स्पष्ट रूप से लौटाया जाता है।

for(F[1]of G[1])for(F[2]of G[2])for(F[3]of G[3])A.push(s.replace(/\d/g,n=>F[n]));A

का उपयोग करते हुए F, बाकी कार्यक्रम केवल उत्पादन नियमों से शेष व्याकरण का निर्माण करता है जो पहले से मौजूद हैं; प्रतिस्थापन को केवल एकल-अंक सूचकांक द्वारा परिभाषित किया गया है G।

— darrylyeo
स्रोत
अच्छा है! लेकिन ऐसा लगता है कि अगर फंक्शन को नहीं बुलाया गया तो क्रैश हो जाएगा f। तो, f=बाइट की गिनती में जोड़ा जाना चाहिए।
— अरनुलद
(मुझे लगता है कि Fइसके बजाय पुन: उपयोग करके इसे ठीक किया जा सकता है f।)
— अरनौल्ड
@ अरनुलद गुड कैच।
— darrylyeo
4

PHP, 877 बाइट्स

आह कि मज़ा आ गया!

for($p="piece of ";$c="AEIMQUY]aeBFJNRVZ^bfQUY]iIMCGKOSWmqunrvoswCGKOSW"[$m++];)foreach([409,T19,"71 eat59",T19delicious,T1916,T19Ty,T19re165,T1914,409,719,40912,40914,409105,409115,40913,understand09,71912,71914,719105,719115,71913]as$i=>$v)foreach($i<8?[salad,cake,"ice cream cone",meal,drink,steak,"chicken dinner",$p.cake,$p.pie,cookie,sandwich]:[sonnet,poem,story,play,song,$p.music]as$u)echo trim(strtr([C17s,"A c17","No c17"][$o=3&$d=ord($c)-65]." ".($o&2?[6,is3,"is 8 go5 to","6 8","2 8 be3","2 8",11=>"is 15","6 7e","2 be 15"]:["6't",$t="won't",$w="2 n8","$t be3","2 n8 be3",$w.$z=" have the ability to","n8 2$z","n8 2 be3","isn't3","is unable to","$t 8 be3","is in15","isn't 15","6not 7e"])[$d/4]." $v",($c>l?[ing,ing]:["",e])+[2=>will," able to",enjoy,ing,can,experienc,ever," a ",inspir,amaz,beautiful,superb,wonderful,"capable of",fresh,omputer,T=>tast]))," $u.
";

यदि आप कर सकते हैं एक और बाइट खुदाई करने के लिए स्वतंत्र महसूस करें।

ungolfed

while($c="AEIMQUY]aeBFJNRVZ^bfQUY]iIMCGKOSWmqunrvoswCGKOSW"[$p++])
    foreach(["enjoy0 a","tast1 a","experienc1 eating a","tast1 a delicious","tast1 a fresh","tast1 a tasty","tast1 a refreshing","tast1 a wonderful",
    "enjoy0 a","experienc1 a","enjoy0 a beautiful","enjoy0 a wonderful","enjoy0 a inspiring","enjoy0 a amazing","enjoy0 a superb",
    "understand0 a","experienc1 a beautiful","experienc1 a wonderful","experienc1 a inspiring","experienc1 a amazing","experienc1 a superb"]as$i=>$v)
        foreach($i<8
            ?[salad,cake,"ice cream cone",meal,drink,steak,"chicken dinner","piece of cake","piece of pie",cookie,sandwich]
            :[sonnet,poem,story,play,song,"piece of music"]
        as$u)
            echo[Computers,"A computer","No computer"][$o=3&$d=ord($c)-65]," ",
                ($o&2
                    ?[can,"is able to","is ever going to","can ever","will ever be able to","will ever",11=>"is capable of","can experience","will be capable of"]
                    :["can't","won't","will never","won't be able to","will never be able to","will never have the ability to","never will have the ability to","never will be able to","isn't able to","is unable to","won't ever be able to","is incapable of","isn't capable of","cannot experience"]
                )[$d/4]," ",
                strtr($v,$c>l?[ing,ing]:["",e]),
                " $u.\n"
            ;

व्याख्या

आउटपुट को 166 लाइनों में से प्रत्येक के 48 भाग में विभाजित किया जा सकता है। प्रत्येक हिस्सा भीतर, प्रत्येक पंक्ति में से एक के साथ शुरू होता Computers|A computer|No computer14 नकारात्मक (के लिए में से एक के द्वारा पीछा किया Computersऔर A computer) या 9 सकारात्मक (के लिए No computer) क्षमताओं।
मैंने इन चंक्सों को 6 बिट प्रत्येक (3 अलग-अलग विषयों -> निचले 2 बिट्स; सकारात्मक और नकारात्मक कैप्स साझा कुंजियों -> ऊपरी 4 बिट्स) में एन्कोड किया, और ASCII कोड के रूप में मूल्यों का उपयोग करने के लिए 65 जोड़ा।

इन विखंडों के भीतर, 11 विभिन्न खाद्य पदार्थों के लिए 8 क्रिया / विशेषण संयोजन और 6 अलग-अलग कलाओं के लिए 13 अलग-अलग संयोजन, हमेशा एक ही क्रम में; तो वे बस के माध्यम से पाला जा सकता है, क्रिया / विशेषण कुंजी का उपयोग करके पता लगाने के लिए कि मुझे अगले लूप में खाद्य पदार्थों या पेय को सूचीबद्ध करना है।

एक मुश्किल हिस्सा बना रहा: कुछ कैप्स को क्रिया के गेरुंड रूप की आवश्यकता होती है; और कुछ क्रियाएं eपरिवर्तन में खो जाती हैं । कैप इंडेक्स वेदर को बताता है कि आवश्यक है या नहीं।
(और एन्कोडिंग में बिट्स के आदेश के लिए धन्यवाद मैं बस तुलना के लिए एएससीआईआई चरित्र का उपयोग कर सकता हूं)।
पर कैसे? थोड़ी देर के लिए रेग्जेस के साथ करतब दिखाने के बाद, मैंने बस एक 1जगह रख दी है, जहां से eउसे बदलना पड़ता है ingऔर एक 0जगह ingपर एप्लाई करना पड़ता है और strtrकाम करने देना पड़ता है।

ऊपर के अनगढ़ संस्करण की कहानी। (1199 बाइट्स पैक)

गोल्फ 3 चरणों में मुख्य रूप से शामिल हैं:

  1. अधिकांश इस्तेमाल किए गए चरित्र अनुक्रमों को चर तक संग्रहीत किया गया था।
  2. strtrचर को स्थानांतरित करने के लिए विषय को छोड़कर सब कुछ के लिए बढ़ाया गया था strtr।
  3. अधिकांश अनुक्रम चर से स्थानांतरित कर दिए गए थे strtr।

19 वें शब्द को, tastएक जोड़े के अंक से छुटकारा पाने के लिए बड़े अक्षर के साथ बदल दिया गया था।

मुझे आश्चर्य है कि अगर मैं क्रिया / विशेषण संयोजनों का भी उपयोग करूं तो क्या होगा।
शायद मैं Zsh को हरा सकता था; लेकिन मुझे यकीन नहीं है कि अगर मैं कोशिश करने के लिए पर्याप्त आश्चर्यचकित हूं।

— टाइटस
स्रोत
1

रेटिना, 1249 1192 बाइट्स


CFs 1 5.¶A cF 1 5.¶C O nG beH 5.¶C O nGKtheJto 5.¶C nG OKtheJto 5.¶C nG O beH 5.¶C won't G beH 5.¶C O nG 5.¶C won't beH 5.¶nNo cF 3 5.¶C 2 6.¶A cF 2 6.¶nNo cF 4 6.¶nNo cF 3 5.
1
can't$%'¶$%`won't$%'¶$%`O nG$%'¶$%`won't beH$%'¶$%`O nG beH$%'¶$%`O nGKtheJto$%'¶$%`nG OKtheJto$%'¶$%`nG O beH$%'¶$%`isn'tH$%'¶$%`is unIto
2
is incapIof$%'¶$%`isn't capIof$%'¶$%`cannot De
3
can$%'¶$%`isH$%'¶$%`is G goQ to$%'¶$%`can G$%'¶$%`O G beH$%'¶$%`O G
4
is capIof$%'¶$%`can De$%'¶$%`O be capIof
5
E a 8$%'¶$%`Le a 8$%'¶$%`De eatQ a 8$%'¶$%`Le a 7 8$%'¶$%`E a 9$%'¶$%`De a 9$%'¶$%`E a B 9$%'¶$%`P a 9$%'¶$%`De a B 9
6
EQ a 8$%'¶$%`LQ a 8$%'¶$%`DQ eatQ a 8$%'¶$%`LQ a 7 8$%'¶$%`EQ a 9$%'¶$%`DQ a 9$%'¶$%`EQ a B 9$%'¶$%`PQ a 9$%'¶$%`DQ a B 9
7
delicious$%'¶$%`fresh$%'¶$%`Ly$%'¶$%`refreshQ$%'¶$%`wonderful
8
salad$%'¶$%`cake$%'¶$%`ice cream cone$%'¶$%`meal$%'¶$%`drink$%'¶$%`steak$%'¶$%`chicken dinner$%'¶$%`Mof cake$%'¶$%`Mof pie$%'¶$%`cookie$%'¶$%`sandwich
9
sonnet$%'¶$%`poem$%'¶$%`story$%'¶$%`play$%'¶$%`song$%'¶$%`Mof music
B
beautiful$%'¶$%`wonderful$%'¶$%`inspirQ$%'¶$%`amazQ$%'¶$%`superb
D
experienc
E
enjoy
F
omputer
G
ever
H
 Ito
I
able 
J
 ability 
K
 have 
L
tast
M
piece 
O
will
P
understand
Q
ing

आउटपुट TIO सीमाओं से अधिक है। मैं %`सभी से बचने के लिए चरणों का उपयोग करना चाहता था , $%'¶$%`लेकिन किसी कारण से जो मैं चाहता हूं वह नहीं करता है। संपादित करें: @ फायरफ्लेम 241 के लिए 57 बाइट्स का धन्यवाद।

— नील
स्रोत
अभी भी संपीड़न के लिए कुछ जगह है: ingऔर `इतो` प्रत्येक का कई बार उपयोग किया जाता है। प्रत्येक कॉल टू 1, 2और 5 पूर्ववर्ती है और उसके बाद एक स्थान है, इसलिए इन्हें प्रतिस्थापन में रखा जा सकता है। इसी तरह, 6और 7हमेशा एक अवधि के बाद होते हैं। 3केवल एक बार उपयोग किया जाना प्रतीत होता है।
— Fireflame241
@ fireflame241 मैं अंकों को संशोधित नहीं कर सकता क्योंकि उन्हें कई बार अपने प्रतिस्थापन को दोहराने की आवश्यकता होती है लेकिन अन्य विचारों के लिए धन्यवाद!
— नील
0

बबलगम , 23353 बाइट्स

हाँ। ज्यादातर यह एक जवाब में फिट नहीं होगा ... दोनों कोड और TIO लिंक चिपकाया जाता है।

कोड ( कोड का एक हेक्सडंप)

TIO लिंक (आउटपुट TIO की सीमाओं से अधिक है)

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