एक नौ-स्तरीय शब्द अनुमान लगाने का खेल बनाएं

Question

मूल बातें:

आपको सबसे कम संभव वर्णों में एक नौ-स्तरीय शब्द अनुमान लगाने का खेल प्रदान करना होगा (अपनी पसंद की भाषा में)।

मीट्रिक:

• एक शब्द-सूची (एक शब्द प्रति पंक्ति, एक नई पंक्ति से अलग) प्रदान करें (जैसे /usr/share/dict/wordsया ऐसा कर सकते हैं)। किसी फ़ाइल नाम या शब्दसूची को अपने समाधान में पाइप करना ठीक है।
• शब्द लंबाई बढ़ाने के साथ 9 स्तर प्रदान करें (4 वर्ण ->12 वर्णों वाले शब्द ):

स्तर 1: 4 अक्षरों वाले शब्दसूची से एक यादृच्छिक शब्द
स्तर 2: 5 अक्षरों वाले शब्दसूची से एक यादृच्छिक शब्द
... ...
स्तर 8: 11 अक्षरों वाले शब्दसूची से एक यादृच्छिक शब्द
स्तर 9: 12 अक्षरों वाले शब्दसूची से एक यादृच्छिक शब्द

• हर स्तर में, सूची से एक बेतरतीब ढंग से चुने गए शब्द को (एक विशिष्ट शब्द की लंबाई के साथ) ओफ़्सेट करें और एक निश्चित संख्या में वर्णों को बदल दें *। बदलने के लिए वर्णों की संख्या : current_word_length / 3(नीचे दौर)। रैंडमाइज करें कि कौन से कैरेक्टर को रिप्लेस करना है।
• खिलाड़ी को शब्द (केवल एक tryस्तर प्रति) का अनुमान लगाने दें , प्रतिक्रिया दें ( correctया wrong) और उसके अनुसार अंक दें। सही होने पर, खिलाड़ी को लाभ होता है number_of_obfuscated_characters * 10 points।
• प्रत्येक स्तर के अंत में वर्तमान स्कोर प्रिंट करें।

प्रारूप (और नमूना I / O):

सुनिश्चित करें कि आप निम्न प्रारूपण योजना का पालन करते हैं:

स्तर 1 # स्तर शीर्ष लेख
======= # 
g * ek # आपत्तिजनक शब्द
geek # उपयोगकर्ता इनपुट
सही # अनुमान सत्यापन
स्कोर: 10 # प्रिंट स्कोर
            #  
लेवल 2
=======
एल * nux
linux
सही बात
स्कोर: 20

स्तर 3
=======
दौड़ा ** मीटर
बिना सोचे समझे
सही बात
स्कोर: 40

...

स्तर 9
=======
sem *** अधिनियम * ve
semiinactive
गलत
स्कोर: 90

विजेता:

सबसे छोटा समाधान (कोड वर्ण गणना द्वारा)। मज़ा गोल्फ है!

Comments

Sem ** act ve, BTW का क्या समाधान है ?

— जो जे।

@JoeZ। शायद sem***act*ve==>semelfactive

— देव-माशिह

Answer 1

पर्ल, 180 चर

@w=<>;for$n(4..12){@x=grep/^.{$n}$/,@w;$_=$w=$x[rand@x];vec($_,rand$n,8)=42while($==$n/3)>y/*//;print"Level @{[$n-3]}
=======
$_";say<>eq$w?($@+=$=)&& correct:wrong,"
score: $@0
"}

रूबी की धड़कन पर्ल? वो ऐसा नहीं करेगा! :-)

Jsvnm के रूबी समाधान की तरह, लेकिन जोएल बर्जर के पर्ल कोड के विपरीत, यह स्क्रिप्ट कमांड लाइन पैरामीटर के रूप में शब्द सूची का फ़ाइल नाम लेती है। यही है, आपको इसे इस तरह चलाना चाहिए:

perl -M5.010 guessword.pl /usr/share/dict/words

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

@w = <>;
for $n (4..12) {
    @x = grep /^.{$n}$/, @w;
    $_ = $w = $x[rand@x];
    vec($_, rand $n, 8) = 42 while ($= = $n/3) > y/\*//;
    print "Level @{[ $n-3 ]}\n=======\n$_";
    say <> eq $w ? ($@ += $=) && correct : wrong, "\nscore: $@0\n"; 
}

बयान vec($_, rand $n, 8) = 42 while ($= = $n/3) > y/*//में कुछ दिलचस्प ट्रिक्स हैं। सबसे पहले, 42 तारांकन चिह्न का ASCII कोड है; यह पता चला है कि vecएक तार में एकल वर्णों को संशोधित करने का उपयोग करने के साथ कम है substr। दूसरा, चर $=केवल पूर्णांक मान लेता है, इसलिए इसका उपयोग करके छिपे हुए अक्षरों की संख्या को संग्रहीत करने के लिए मुझे बचाता है int। अंत में, y/*//लिप्यंतरण ऑपरेटर का उपयोग करके तार में तारिकाओं की संख्या की गणना करने का एक छोटा तरीका है।

संपादित करें: $@स्कोर को 10 से विभाजित करके स्टोर करने के लिए 7 वर्णों का उपयोग करके सहेजा गया और आउटपुट के दौरान उस पर एक शून्य जोड़ दिया गया (जो कि इसके बारे में सोचते हैं, पिछले संस्करण की तुलना में कम होगा, भले ही मैंने एक सामान्य चर का उपयोग किया हो) ।

संपादित करें 2: आउटपुट स्ट्रिंग्स में शाब्दिक नई सूचियों को एम्बेड करना एक गड़बड़ है $,।

Answer 2

रूबी (188)

तर्क के रूप में शब्दों को पढ़ने के लिए फ़ाइल नाम लेता है।

q=*$<
s=0
4.upto(12){|n|o=''+w=q.grep(/^#{?.*n}$/).sample
[*0..n-1].sample(c=n/3).map{|i|o[i]=?*}
puts"Level #{n-3}",?=*7,o
puts STDIN.gets==w ?(s+=c;"correct"):"wrong","score: #{s}0",""}

Comments

एक अच्छा (रूबी पिटाई पर्ल, कि कोड गोल्फ में एक परिचित घटना नहीं है ;-)

— ChristopheD

अपने बचाव में मैंने वह कोशिश नहीं की। ग्लैड इल्मरी करोनन ने मेरी पीठ थपथपाई थी।

— जोएल बर्जर

Answer 3

बैश, 350 चरस

S=0
for L in {4..12}
do
echo -e Level $(($L-3))\\n=======
W=$(grep -E ^.{$L}$ /usr/share/dict/words|shuf|tail -1)
G=$W
while [ `sed 's/[^*]//g'<<<$G|wc -c` -le $(($L/3)) ]
do
P=$(bc<<<$RANDOM*$L/32767)
G=$(sed "s/\(.\{$P\}\)./\1*/"<<<$G)
done
echo $G
read U
if [ x$U == x$W ]
then
echo correct
S=$(($S+$L/3*10))
else
echo wrong
fi
echo score: $S
done

Comments

बेईमानी नहीं! यह नोटपैड ++ के अनुसार 371 वर्ण है।

— nyuszika7h

@ Nyuszika7H: 21 \ r वर्ण सहित, है ना? यह यूनिक्स के लिए है, जहां एक नई लाइन एक सिंगल लाइनफीड चार है।

— नवजाल

@ninjalj: हाँ, लेकिन अपने दिमाग में रखें कि हर कोई यूनिक्स लाइन ब्रेक प्रारूप का उपयोग नहीं करता है। हमें निष्पक्ष रहना होगा। meta.codegolf.stackexchange.com/questions/167/…

— nyuszika7h

@ Nyuszika7H: यदि आप इसका उपयोग कर सकते हैं, तो हर तरह से आपको एक कोड गोल्फ में होना चाहिए। यदि आपकी भाषा में कुछ करने के दो समान तरीके हैं और एक छोटा है, तो क्या आप लंबे समय तक उपयोग करते हैं क्योंकि कुछ लोग छोटे को नहीं जानते हैं? रेखा विखंडन के लिए, यदि आपके पास CRLF की आवश्यकता वाली भाषाएँ हैं , तो आप भाग्य से बाहर हैं, लेकिन मुझे ऐसी किसी भी भाषा की जानकारी नहीं है।

— जॉय

क्या आप लगभग हमेशा नए सिरे से डब्ल्यू / अर्धविराम या रिक्त स्थान नहीं बदल सकते हैं?

— बैरीकेटर

Answer 4

पर्ल: 266

@ARGV='/usr/share/dict/words';@w=<>;$"='';while($l<9){$o=1+int++$l/3;@s=grep{$l+4==length}@w;@g=split//,$t=$s[rand$#s+1];my%r;$r{rand$#g}++while keys%r<$o;$g[$_]='*'for keys%r;print"Level $l\n=======\n@g";print<>eq$t?do{$p+=$o*10;"Correct"}:"Wrong","\nScore: $p\n"}

या थोड़ी अधिक सफेद जगह के साथ

@ARGV='/usr/share/dict/words';
@w=<>;
$"='';
while($l<9){
  $o=1+int++$l/3;
  @s=grep{$l+4==length}@w;
  @g=split//,$t=$s[rand$#s+1];
  my%r;
  $r{rand$#g}++while keys%r<$o;
  $g[$_]='*'for keys%r;
  print"Level $l\n=======\n@g";
  print<>eq$t?do{$p+=$o*10;"Correct"}:"Wrong","\nScore: $p\n"
}

और मुझे लगता है कि एक छोटे से काम के साथ यह और भी बेहतर हो सकता है!

Answer 5

आर, 363 वर्ण

w=tolower(scan("/usr/share/dict/words",what="c"));l=nchar(w);score=0;for(i in 1:9){mw=sample(w[l==i+3],1);cat("Level",i,"\n=======\n",replace(strsplit(mw,"")[[1]],sample(nchar(mw),floor(nchar(mw)/3)),"*"),"\n");v=scan(what="c",n=1,quiet=T);if(length(v)!=0&&v==mw){score=score+10*floor(nchar(mw)/3);cat("correct\n")} else cat("wrong\n");cat("score:",score,"\n\n")}

Answer 6

पायथन 335

मुझे पता है कि मुझे पार्टी में थोड़ी देर हो गई है, लेकिन अजगर का प्रतिनिधित्व नहीं है, इसलिए मुझे लगा कि बिल्ली क्या है:

import sys
import random
D=open(sys.argv[1]).read().split()
random.shuffle(D)
z=0
for L in range(1,10):
 M=L+3;N=M/3;w=[c for c in D if len(c)==M][0];U=list(w)
 for i in[random.randint(0,M-1)for i in range(N)]:U[i]='*'
 print"\nLevel %d\n=======\n"%L+''.join(U);k=raw_input()==w;z+=[0,N*10][k];print["wrong","correct"][k]+"\nscore:",z

और अर्ध-अपराजित:

import sys
import random
words = open(sys.argv[1]).read().split()
random.shuffle(words)
score=0
for L in range(1,10):
   M=L+3
   N=M/3
   w=[c for c in words if len(c)==M][0]
   obfus=list(w)
   for i in [random.randint(0,M-1) for i in range(N)]: obfus[i]='*'
   obfus=''.join(obfus)
   print"\nLevel %d\n=======\n"%L+obfus
   correct=raw_input()==w
   score+=[0,N*10][correct]
   print["wrong","correct"][correct]+"\nscore:",score

Answer 7

के, 198

वर्तमान कार्य निर्देशिका में एक शब्दकोश d मान लेता है।

{O:{@[x;(-_c%3)?c:#x;:;"*"]}',/W:{1?x@&y=#:'x}[_0:`d]'4+!9;i:1+S:0;while[#O;-1"Level ",$i;-1"=======";-1@*O;$[(**W)~0:0;[-1"correct";S+:10*+/"*"=*O];-1"wrong"];-1"score: ",$S;-1"";W:1_W;O:1_O;i+:1]}

Ungolfed:

{
        /W = wordlist; O = obfuscated
        O:{@[x;(-_c%3)?c:#x;:;"*"]}',/W:{1?x@&y=#:'x}[_0:`d]'4+!9;     
        i:1+S:0;                            
        while[#O;
                -1"Level ",$i;
                -1"=======";
                -1@*O;
                $[(**W)~0:0;              /Read user input and compare to the first word
                        [-1"correct";
                        S+:10*+/"*"=*O];  /if correct, increment score
                        -1"wrong"];
                -1"score: ",$S;
                -1"";
                W:1_W;                    /knock one off the top of both word lists
                O:1_O;
                i+:1]
}