डाउनवर्ड नंबर रेस

10

आपका कार्य एक ऐसा प्रोग्राम बनाना है, जो अंतिम संख्या रेसिंग शोडाउन में पिछले संख्याओं में यादृच्छिक संख्याओं को जोड़ता है।

प्रत्येक रेसर (स्तंभ) 0 से शुरू होता है और दौड़ के प्रत्येक चरण में 1 या 0 से पिछली राशि तक जोड़ता है जब तक कि सभी रेसर जीतने के लिए आवश्यक स्कोर तक नहीं पहुंच जाते। 1 या 0 को यादृच्छिक पर चुना जाना चाहिए (यादृच्छिक की मानक परिभाषा यहां पाई जा सकती है )। आउटपुट रेस का परिणाम दिखाएगा, जिसमें प्रत्येक कॉलम एक रेसर का प्रतिनिधित्व करेगा, इस प्रारूप में:

>> racers:5,score needed:2

0 0 0 0 0 # all racers start at 0
+ + + + + # add
1 0 0 0 1 # random 1 or 0
= = = = = # equals
1 0 0 0 1 # sum
+ + + + +
0 0 0 0 1
= = = = =
1 0 0 0 2 # winner!
+ + + +  
1 1 1 1  
= = = =  
2 1 1 1  
  + + +  
  1 1 1  
  = = =  
  2 2 2   # losers

नोट: केवल संख्या, + और = को आउटपुट में शामिल करने की आवश्यकता है।

इनपुट

आपका कार्यक्रम निम्नलिखित दो मापदंडों को इनपुट के रूप में स्वीकार करेगा:

  1. रेसर (कॉलम) की संख्या, जो दो से अधिक होनी चाहिए
  2. जीतने के लिए आवश्यक स्कोर, जो एक से अधिक होना चाहिए

यह कोड-गोल्फ है - कम से कम बाइट्स जीतने वाला कार्यक्रम।

संपादित करें: 9 का एक गैर-लागू करने योग्य अधिकतम स्कोर है - यह कॉलम की अखंडता को संरक्षित करने के लिए है। साथ ही, आउटपुट के बीच कॉलम के बीच रिक्त स्थान छोड़ा जा सकता है।

code-golf 
— atlasologist
स्रोत
कॉलम की अधिकतम संख्या और अधिकतम स्कोर क्या है जिसे समर्थन देने की आवश्यकता होगी?
— नानोफारड
कोई अधिकतम परिभाषित नहीं है, इसलिए यह न्यूनतम के समान होगा: कम से कम तीन कॉलम और दो का स्कोर।
— एटलसोलॉजिस्ट
3
क्या आवश्यक अंक में दो अंक होंगे?
— लीक नून
4
"केवल संख्या, +, और = को आउटपुट में शामिल करने की आवश्यकता है।" रिक्त स्थान के बारे में क्या?
— लीक नून
रिक्त स्थान को संरक्षित करने की आवश्यकता नहीं है, वे स्पष्टता के लिए उदाहरण में हैं। दो अंकों के बारे में अच्छा प्रश्न - मुझे लगता है कि अधिकतम अंक है, जो नौ है। मैं प्रश्न संपादित करूंगा।
— एटलसोलॉजिस्ट

जवाबों:

5

जेली, 37 36 33 बाइट्स

,‘X
0Ç<³$пµżIFµ“+=”ṁṖ⁸żF
ÇСḊz⁶G

3 बाइट्स डेनिस के लिए धन्यवाद।

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

व्याख्या

,‘X                    Helper link. Argument: n. Radomly return n or n+1.

 ‘                     Increment n
,                      Pair. Yield [n, n+1]
  X                    Return a random item from the pair.

0Ç<³$пµżIFµ“+=”ṁṖ⁸żF   Monadic link. Argument: s. Generate one racer.

0                       Start with value 0.
  <³$пµ                While value is less than s:
 Ç                        Use helper link to increment current value.
                        Collect intermediate results in a list.
         I              Compute consecutive differences.
        ż               Zip intermediate results with their next increment value 0 or 1.
          Fµ            Flatten. Let's call the current list A.
                        Odd items of A are racer state and even items are random 0 or 1.
            “+=”        Yield "+=".
                 Ṗ      Yield A without its last element.
                ṁ       Mold i.e Repeat the characters of the string until it contains length(A)-1 characters.
                  ⁸ż    Zipwith. Pair the elements of A with the correponding characters
                    F   Flatten.

ÇСṫ2z” G               Main link. Arguments: s (score needed), r (#racers)

ÇС                     Call the link above r times.
                        Generate a list of r racers.
   Ḋ                    Remove first element of the list (its a garbage s value)
    z⁶                  Transpose with space as fill value.
      G                 Grid. Format the result.
— Essari
स्रोत
आप पहले हेल्पर लिंक को बदल सकते हैं ,‘X(वृद्धि एन , यादृच्छिक विकल्प के साथ जोड़ी )। मुख्य लिंक में (dequeue) और चर के साथ ṫ2प्रतिस्थापित किया जा सकता है । Ḋ” ⁶
— डेनिस
2

TSQL, 367 345 341 बाइट्स

golfed

DECLARE @r int=20, -- racers
        @g char=2  -- goal

DECLARE @ varchar(99)=REPLICATE('0',@r)a:PRINT @
DECLARE @A varchar(99)='',@s varchar(99)='',@i int=0WHILE @i<@r
SELECT
@i+=1,@A+=char(43-x*11),@s+=IIF(x=1,' ',LEFT(y,1)),@=RIGHT(@,@r-1)+IIF(x=1,' ',REPLACE(LEFT(@,1)+y,@g+1,' '))FROM(SELECT
IIF(LEFT(@,1)IN('',@g),1,0)x,ROUND(RAND(),0)y)z
PRINT @A+'
'+@s+'
'+REPLACE(@A,'+','=')IF @>''goto a

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

Ungolfed:

DECLARE @r int=10, -- racers
        @g char=2  -- goal

DECLARE @ varchar(99)=REPLICATE('0',@r)
a:
PRINT @
DECLARE @A varchar(99)='',@s varchar(99)='',@i int=0

WHILE @i<@r
  SELECT
    @i+=1,
    @A+=char(43-x*11),
    @s+=IIF(x=1,' ',LEFT(y,1)),
    @=RIGHT(@,@r-1)+IIF(x=1,' ',REPLACE(LEFT(@,1)+y,@g+1,' '))
  FROM(SELECT IIF(LEFT(@,1)IN('',@g),1,0)x,ROUND(RAND(),0)y)z

PRINT @A+'
'+@s+'
'+REPLACE(@A,'+','=')

IF @>''GOTO a

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

— t-clausen.dk
स्रोत
1

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

from random import*
def f(n,t):
 x='0'*n,;i=j=0;y=''
 while' '*n!=x[i]:
  if j==n:j=0;x+=y,;y='';print(x[i]);i+=1
  y+=' 'if x[i][j]in(' ',str(t))else eval(["'+'","str(randint(0,1))","'='","str(int(x[i-3][j])+int(x[i-1][j]))"][i%4]);j+=1

एक फ़ंक्शन जो तर्क के माध्यम से इनपुट लेता है और STDOUT पर प्रिंट करता है। यह दृष्टिकोण इस तथ्य का उपयोग करता है कि आउटपुट सभी रेसरों के लिए '+ मान = मान' के रूप में, अवधि चार के एक चक्र का अनुसरण करता है। एक काउंटर मोडुलो चार का उपयोग करके, एक स्ट्रिंग के रूप में प्रत्येक चरण के लिए वांछित मान वाली सूची को अनुक्रमित किया जा सकता है, और पायथन के eval फ़ंक्शन का उपयोग करके परिणाम का मूल्यांकन किया जाता है।

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

from random import*                       Import Python's random module to access the
                                          randint function
def f(n,t):                               Function with input number of racers n and target
                                          number t
x='0'*n,;i=j=0;y=''                       Initialise return tuple storage x, state number
                                          i, racer number j and append string y for x
while' '*n!=x[i]:                         Loop through all j for some i. If the current
                                          state consists only of spaces, all racers have
                                          finished, so stop
y+=...eval([...][i%4])...                 Index into list, using i mod 4, to find the
                                          desired process for the cycle step, and append to
                                          y
(If first step of cycle)
...+...                                   Plus sign
(If second step of cycle)
...str(randint(0,1))...                   Random number from (0,1)
(If third step of cycle)
...=...                                   Equals sign
(If fourth step of cycle)
...str(int(x[i-3][j])+int(x[i-1][j]))...  Addition of random number to previous racer
                                          'score'
...' 'if x[i][j]in(' ',str(t))...         But append space if the racer has previously
                                          finished, or has reached the target
...j+=1                                   Increment j
if j==n:j=0;x+=y,;y='';print(x[i]);i+=1   If j=n, all j must have been looped through.
                                          Reset j, append new state y to x, reset y, print
                                          current state to STDOUT and increment i. When
                                          this first executes, x contains only the initial
                                          state, meaning that this is printed and the cycle
                                          starts with the second state.

Ideone पर इसे आज़माएं

— TheBikingViking
स्रोत
1

पायथन 2 , 191 बाइट्स

from random import*
def c(p,w,r=[],l=0):
 while p:
	p-=1;s='0'
	while`w`>s[-1]:s+="+%s="%randint(0,1);s+=`eval(s[-4:-1])`;l+=2
	r+=[s]
 for z in map("".join,zip(*(t+l*' 'for t in r))):print z

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

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

from random import*
def c(p,w,r=[],l=0):
 while p:
  p-=1;s='0'
  while str(w)>s[-1]:s+="+%s"%randint(0,1);s+="=%s"%eval(s[-3:]);l+=2
  r+=[s]
 for z in map("".join,zip(*(t+l*' 'for t in r))):print(z)

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

— Jitse
स्रोत
0

पायथन 2, 278 बाइट्स

import random
r=5
w=2
s=(0,)*r
while s.count(w)<len(s):
    print ''.join(map(lambda a:str(a),s))+"\n"+'+'*len(s)
    s = tuple(map(lambda x: x<w and x+random.randrange(2) or x,s))
    print ''.join(map(lambda a:str(a), s))+"\n"+'='*len(s)
    s = tuple([x for x in s if x!= w])

जहाँ r नहीं है। रेसर और डब्ल्यू जीतने का स्कोर है

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

— स्वाधिकर सी
स्रोत
2
मैंने आपके कार्यक्रम का परीक्षण किया, यह परिणाम नहीं दिखाता जैसा कि प्रश्न में वर्णित है, सब कुछ बाईं ओर ले जाया गया है।
— t-clausen.dk 12:23
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.