एक फ्लैट अनुमान लगाने का खेल

13

एक खेल है जो मुझे खेलना पसंद है। यह परिमित आकार के ग्रिड पर होता है (लेकिन इसे एक गोले की तरह लपेटा जाता है)। उस ग्रिड पर, एक यादृच्छिक (पूर्णांक-केवल) बिंदु चुना जाता है। फिर, मैं, उपयोगकर्ता, एक समन्वित इनपुट के लिए प्रेरित हूं। यदि मेरा इनपुट यादृच्छिक बिंदु से बिल्कुल मेल खाता है, तो मुझे बताया गया है कि मैं जीत गया हूं। अन्यथा, मुझे अपने इनपुट और यादृच्छिक बिंदु के बीच बिंदुवार दूरी बताई जाती है। उदाहरण के लिए, अगर मैंने अनुमान लगाया (2,2)और यादृच्छिक बिंदु पर था (4,3), तो दूरी होगी sqrt[(3-2)^2 + (4-2)^2] = sqrt[5]।

खिलाड़ी के सही स्थान पर पहुंचने तक खेल जारी रहता है।

उद्देश्य ऊपर वर्णित खेल का एक कार्यात्मक संस्करण बनाएँ। ऐसा करने के लिए आपको एक पूर्ण कार्यक्रम बनाना होगा। यहां बताया गया है कि आपका कार्यक्रम क्या करना चाहिए:

  1. दो इनपुट का अनुरोध करें: बोर्ड की ऊंचाई और चौड़ाई। मूल बोर्ड के शीर्ष-बाईं ओर है। ये इनपुट अधिक नहीं होंगे 1024।
  2. उस बोर्ड पर एक यादृच्छिक बिंदु का चयन करें; यह अनुमान लगाया जाने वाला बिंदु होगा।
  3. एक मोड़ अनुकरण इनपुट स्वीकार करें। इनपुट या तो अंतरिक्ष-पृथक जोड़ी पूर्णांक या दो अलग पूर्णांक इनपुट होंगे। इस इनपुट के जवाब में, कार्यक्रम दो चीजों में से एक करेगा:
    1. यदि इनपुट चयनित यादृच्छिक बिंदु से मेल खाता है, तो उपयोगकर्ता की जीत का संकेत देने वाला संदेश आउटपुट करता है। मेरा सुझाव है कि "आप जीत गए!"।
    2. अन्यथा, उपयोगकर्ता के इनपुट बिंदु और यादृच्छिक बिंदु के बीच की दूरी को आउटपुट करें।
    किसी भी स्थिति में, आपको टर्न काउंटर को बढ़ाना होगा।
  4. उपयोगकर्ता द्वारा जीत हासिल करने के बाद, उपयोगकर्ता ने जितने भी मोड़ लिए, उन्हें प्रदर्शित करें। फिर कार्यक्रम से बाहर निकल गया।

बोनस

बोनस इस क्रम में लागू होते हैं कि वे इस सूची में दिखाई देते हैं

  • -150 बाइट्स यदि आपका प्रोग्राम एक इनपुट पूर्णांक लेता है जो Dउस आयाम का वर्णन करता है जिसमें खेल होता है। जैसे, यदि D = 3, तो आप 3पूर्णांक का एक यादृच्छिक बिंदु बनाते हैं, 3पूर्णांक इनपुट लेते हैं, और उन बिंदुओं के बीच की दूरी को आउटपुट करते हैं।
  • -50% (या + 50% यदि score < 0) यदि आप बोर्ड (ASCII या चित्र) का एक ग्राफिकल प्रतिनिधित्व प्रदान करते हैं जो दिखाता है कि उपयोगकर्ता ने पहले दिए गए आयामों की ग्रिड और टर्न काउंटर पर अनुमान लगाया है। (यदि आप पहले बोनस के लिए जाते हैं, तो यह बोनस केवल 2Dऔर 1Dमोड पर लागू होता है । यदि आप एक 3 डी ग्राफिकल आउटपुट जोड़ते हैं, तो आपको अतिरिक्त -50% मिलता है।)
  • -60 बाइट्स यदि आप एक गेममोड प्रदान कर सकते हैं (शुरुआत में एक इनपुट द्वारा चयनित; 0अर्थात्, जब दिया जाता है 1, तो नियमित गेममोड निष्पादित करें; जब दिया जाता है , तो इस गेम को निष्पादित करें) जिसमें बिंदु 1 इकाई को एक यादृच्छिक कक्ष दिशा में घुमाता है।

लपेटने पर अधिक

रैपिंग केवल तब होती है, जब तीसरे बोनस में, चलती बिंदु किसी भी सीमा के पार जाती है; इस स्थिति में, चलती बिंदु को संबंधित बिंदु पर भेज दिया जाता है, जैसे:

...              ...
..R (move right) R..
...              ...

यह रैपिंग व्यवहार उपयोगकर्ता के अनुमान को प्रभावित नहीं करता है, इस तथ्य से तय करता है कि बिंदु ने दिशा बदल दी है।

लीडरबोर्ड

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

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक स्कोर अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  game 
— कोनोर ओ ब्रायन
स्रोत
7
माइनर नाइटपिक: आप शायद इसका मतलब यह है कि यह एक क्षेत्र की तरह एक धार की तरह लपेटता है। असंगतता पैदा किए बिना एक गोले पर 2 डी ग्रिड लपेटना असंभव है।
— एलिस्टेयर बुक्सटन
2
इसके अलावा अगर बोर्ड लपेटता है तो एक किनारे को पार करके अनुमान और लक्ष्य के बीच एक छोटा रास्ता हो सकता है।
— एलिस्टर बैक्सटन
1
@NBZ हाँ, आप कर सकते हैं।
— कॉनर ओ'ब्रायन
1
@ एनबीजेड 1 ने इसे एक एकल दिशा प्रदान की।
— कॉनर ओ'ब्रायन
2
1. मुझे अभी भी यकीन नहीं है कि टोपोलॉजी क्या है। स्पष्ट चीजों की मदद करने के लिए, यदि बोर्ड है 10x10, तो यादृच्छिक बिंदु है (9,4), और मुझे लगता (2,2)है, दूरी है sqrt(13)या sqrt(53)? (भविष्य के लिए ध्यान दें: यदि आप कुछ अजीब कर रहे हैं, तो यादृच्छिकता को शामिल न करें क्योंकि यह परीक्षण मामलों की आपूर्ति करना लगभग असंभव बना देता है)। 2. तीसरे बोनस में, पॉइंट चाल के पहले या बाद में दूरी की गणना और आउटपुट होना चाहिए?
— पीटर टेलर

जवाबों:

8

CJam, -113 -139 -152 -157 -159 बाइट्स

l~]:B:mr{_ea:i~mr0a*W2mr#+*.+B:,.=_[l~].-:mh_p}g],(

कार्यक्रम 51 बाइट्स लंबा है और -150 बाइट्स और -60 बाइट्स बोनस के लिए योग्य है ।

गेम मोड और आयामों की संख्या को कमांड-लाइन तर्क के रूप में पढ़ा जाता है, एसटीडीआईएन से प्रत्येक आयाम में आकार। चूंकि जीत संदेश मनमाना है , यह 0.0इंगित करने के लिए कि खेल खत्म हो गया है, कार्यक्रम प्रिंट (लक्ष्य की दूरी) होगा।

टेस्ट चलता है

$ cjam game.cjam 0 3; echo
2 2 2
1 1 1
1.4142135623730951
1 1 0
1.7320508075688774
1 0 1
1.0
0 0 1
0.0
4
$ cjam game.cjam 1 3; echo
2 2 2
0 0 0
1.0
0 0 0
0.0
2

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

l~]       e# Read a line from STDIN, evaluate it and collect the result.
:B        e# Save the resulting array in B. The result is [B1 ... Bd],
          e# where Bk is the board size in dimension k.
:mr       e# Pseudo-randomly select a non-negative integer below Bk,
          e# for each k between 1 and d.
{         e# Do:
  _       e#   Copy the item on the stack. The original becomes a dummy value
          e#   that will be used to count the number of turns.
  ea      e#   Push the array of command-line arguments.
  :i~     e#   Cast each to integer and dump them on the stack.
          e#   This pushes m (game mode) and d (number of dimensions).
  mr      e#   Pseudo-randomly select a non-negative integer below d.
  0a*     e#   Push an array of that many zeroes.
  W2mr#   e#   Elevate -1 to 0 or 1 (selected pseudo-randomly).
  +       e#   Append the result (1 or -1) to the array of zeroes.
  *       e#   Repeat the array m times.
  .+      e#   Perform vectorized addition to move the point.
  B:,.=   e#   Take the k-th coordinate modulo Bk.
  _[l~]   e#   Push a copy and an evaluated line from STDIN.
  .-:mh   e#   Compute their Euclidean distance.
  _p      e#   Print a copy.
}g        e# While the distance is non-zero, repeat the loop.
],(       e# Get the size of the stack and subtract 1.
          e# This pushes the number of turns.
— डेनिस
स्रोत
2
और डेनिस ने सबको पछाड़ दिया है। फिर।
— सद्रुस
1
आपने गलती से स्कोर को 152 की बजाय -152 पर अपडेट कर दिया, जो आपको लीडरबोर्ड पर लाकर खड़ा कर देता है
— मूस
7

पायथ, 91 (-150 -60) = -119

VvwaYOvw;JY#IqQ1=dOlY XYd@S[0 @Jd +@Yd?O2_1 1)1)=T[)VYaT^-Nvw2)=ZhZ=b@sT2Iqb0Bb;p"Won in "Z

पुराना घोल: (54-150 = -96)

JYVQaYOvw;#=J[)VYaJ^-Nvw2)=ZhZ=b@sJ2Iqb0Bb;p"Won in "Z

सभी इनपुट एक नई लाइन पर होते हैं।

  • सबसे पहले पूर्णांक (खेल मोड का प्रतिनिधित्व करता है या तो 1या0 )
  • पहला दूसरा पूर्णांक Dनाटक के आयामों का प्रतिनिधित्व करता है।
  • अगला Dइनपुट फ़ील्ड आकार का प्रतिनिधित्व करता है
  • Dइस बिंदु से हर इनपुट अनुमान हैं

सैंपल प्ले (वास्तविक कार्यक्रम में संकेत दिखाई नहीं देते हैं):

  #Hint: Gamemode (1 or 0)
1
  #Hint: Dimensions
3
  #Hint: X-size
4
  #Hint: Y-size
4
  #Hint: Z-size
4
  #Hint: Guesses
  #Hint:[3, 2, 1]
3
2
2
1.0
  #Hint:[3, 2, 1]
3
2
1
1.0
  #Hint:[2, 2, 1]
2
2
1
1.0
  #Hint:[3, 2, 1]
3
2
1
Won in 4
— मूस
स्रोत
दूसरी चाल जीत नहीं होनी चाहिए?
— JNF
@ जेएनएफ बिंदु गेममोड 1 (-60 बाइट्स बोनस) में स्थानांतरित हो सकता है
— जकूबे
पवित्र मोली, वह कुछ लंबा अजगर कोड है। हालांकि वास्तव में गोल्फ नहीं है। उदाहरण के लिए, मुझे दो स्थान दिखाई देते हैं, जिन्हें हटाया जा सकता है। इसके अलावा: आप इसके J=YmOvwvwबजाय उपयोग कर सकते हैं VvwaYOvw;JY, जो 2 बाइट्स छोटा है। मैंने अन्य कोड को नहीं देखा है, लेकिन मुझे लगता है कि आप वहां कुछ चीजों को छोटा कर सकते हैं।
— जकूबे
@ जकुबे, मैं मान रहा था कि संकेत हमें बताता है कि वर्तमान में बिंदु कहां है
— JNF
3

पिप, 43 42 बाइट्स - 150 = -108

बोर्ड आयामों को कमांड-लाइन तर्कों के रूप में लेती है (डी के साथ आर्ग की संख्या से निहित)। स्टैक पर अंतरिक्ष-पृथक संख्याओं के रूप में अनुमान लगाता है।

YRR_MgWd:++i&RT$+(y-(q^s))**2Pd"Won in ".i

यह कोड पिप की सरणी-प्रोग्रामिंग सुविधाओं का भारी लाभ उठाता है। Cmdline args का एरे स्टोर किया जाता है g। हम रैन्डरेंज ऑपरेटर को मैप करके अनुमान लगाने की बात उत्पन्न करते RRहैं g, और परिणामी सूची को yचर में घुमाते हैं । फिर लूप के दौरान मुख्य आता है, जहां स्थिति इस प्रकार है:

d:++i&RT$+(y-(q^s))**2

  ++i&                  Increment i, the guess counter; the result is always > 0, so the
                          short-circuiting & operator evaluates the next expression:
              q         Read a line from stdin
               ^s       Split on spaces
           y-(   )      Subtract from our chosen point itemwise
          (       )**2  Square, itemwise
        $+              Fold on +, summing the list of squares
      RT                Square root
d:                      Assign this distance to d

यदि दूरी नॉनजरो थी, तो लूप के अंदर यह प्रिंट करता है। यदि यह शून्य था, तो हमने लक्ष्य बिंदु मारा है; लूप हाल्ट, और प्रोग्राम जीत संदेश और घुमावों की संख्या को आउटपुट करता है।

उदाहरण रन:

C:\Users\dlosc> pip.py -f guessing.pip 10 5 6 4
5 2 3 2
3.1622776601683795
6 2 3 2
4.123105625617661
3 2 3 2
1.4142135623730951
3 1 3 2
2.23606797749979
3 2 2 2
1.7320508075688772
2 2 3 2
1
2 2 3 1
1.4142135623730951
2 3 3 2
Won in 8
— DLosc
स्रोत
2

आर, 134 - 150 = -16 बाइट्स

function(...){G=sapply(list(...),sample,1)
C=0
repeat{g=scan()
C=C+1
if(any(G!=g))cat(sqrt(sum((G-g)^2)))else{cat("Won in",C);break}}}
— flodel
स्रोत
2

हास्केल, 240 - 150 = 90

import System.Random
r x=randomRIO(0,x-1)
m=map read.words
g=getLine
main=do g;(fmap m g::IO[Int])>>=mapM r>>=b 1
b c v=do i<-fmap(sqrt.fromIntegral.sum.map(^2).zipWith(-)v.m)g;if i==0 then putStrLn$"Won in "++show c else do print i;b(c+1)v
— डेमियन
स्रोत
1

डायलॉग एपीएल , 77 71 - 210 = -139

S F M
P←?S
{P←S|P+(?D)⌽D↑Mׯ1 1[?2]
C+←1
P≢G←⎕:0⊣⎕←.5*⍨+/2*⍨P-G
C}⍣≢C←0

ठीक है:

ध्यान दें कि यह इंडेक्स ओरिजिन 0 ( ⎕IO←0) में चलता है जो कई एपीएल में डिफॉल्ट है।
बूलियन मोड को सही तर्क ( M), और आयाम के आकार को बाएं तर्क के रूप में ले जाता है ( S)।
आयामों की संख्या है D, जिसे D←3ओपी के अनुसार, कॉल करने से पहले (जैसे ) सेट किया जाना चाहिए ।
P←?Sलक्ष्य को श्रेणी 1 में यादृच्छिक बिंदु मिलता है, हालांकि प्रत्येक आयाम सीमा में होता है
{... }⍣≢C←0फ़ंक्शन को तब तक दोहराते हैं जब तक कि परिणाम अलग न हो C, जो शुरू में 0
?2यादृच्छिक संख्या 0 या 1 प्राप्त करता है
¯1 1[... ]दो नंबर की सूची से सूचकांक
M×मोड द्वारा गुणा करें; बनाता है 0जब मोड होता है 0
D↑साथ पैड 0आयाम की संख्या से मिलान करने के रों
(?D)⌽(आयाम -1 की संख्या के माध्यम से 0) बेतरतीब ढंग से बारी बारी से सूची
P+वर्तमान लक्ष्य को समायोजित
S|दुनिया आकार मापांक
P←नया लक्ष्य बिंदु को बचाने
C+←1वेतन वृद्धि काउंटर
P≢G←⎕:इनपुट अनुमान, और अगर यह तो लक्ष्य बिंदु से अलग है ...
P-Gप्रत्येक आयाम में दूरी
2*⍨चुकता
+/उन्हें योग
.5*⍨वर्ग जड़
⎕←प्रिंट कि
0⊣वापसी 0 (यानी प्रारंभिक मूल्य के समान है, इसलिए दोहराएं)
C... और, अनुमानों की संख्या लौटाएं (जो कि 0 से भिन्न होने पर, लूपिंग बंद कर देता है और अंतिम मान लौटाता है)

— एडम
स्रोत
@ डेनिस वास्तव में, मैंने इसे तब तोड़ दिया जब मैंने इसे एक समारोह बनाया, इसलिए अब यह फिर से एक कार्यक्रम है। मैंने "प्रोग्राममी" के रूप में कई बाइट्स को सहेजा, मुझे सूचकांक मूल 0 पर स्विच करके लागत आई, जिसे ओपी अनुमति देता है।
— 21
1
ठीक। जिज्ञासा से बाहर: यह कौन सी बोली है? मुझे नहीं पता कि पहली पंक्ति को क्या करना है ...
— डेनिस
@ डेनिस ड्यालोग। यह एक पारंपरिक फ़ंक्शन है, पहली पंक्ति है लाइन [0], अर्थात फ़ंक्शन हेडर, लेकिन यह असामान्य दिखता है क्योंकि इसमें बाएं-आरएनजी fn-name राइट-एर्ग है, लेकिन कोई परिणाम नहीं है।
— 14
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.