लक्ष्य

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

इनपुट

एक गैर-शून्य, सकारात्मक पूर्णांक n<= 100

उत्पादन

एक यादृच्छिक स्ट्रिंग, या वर्णों की सूची लौटाएं, जो लंबाई के एक संभव, वैध पिच स्ट्रिंग का प्रतिनिधित्व करते हैं n। उपयोग किए जाने वाले पात्र होंगे:

बी - बॉल। यदि आप इनमें से 4 को जमा करते हैं, तो बल्लेबाज को चलता किया जाता है और बल्लेबाजी समाप्त होती है।
एस - हड़ताल। यदि आप इनमें से 3 जमा करते हैं, तो बल्लेबाज आउट हो जाता है और बल्लेबाजी समाप्त हो जाती है।
एफ - बेईमानी। स्ट्राइक काउंट को भी बढ़ाएगा लेकिन बल्लेबाज को आउट नहीं कर सकता। यानी, आपके पास एक वैध स्ट्रिंग में एक अंतिम बेईमानी नहीं हो सकती है। किसी भी बेईमानी से दो स्ट्राइक / फाउल्स पिछले स्ट्राइक काउंट को नहीं बढ़ाएंगे (बल्लेबाज के पास उस समय 2 स्ट्राइक होंगे और एक थ्री उसे आउट कर देगा)।
एच - हिट। बल्लेबाज ने एक गेंद को खेल में मारा है और बल्लेबाजी समाप्त हो गई है।

(यह थोड़ा सरल है लेकिन क्या आप इसके बारे में चिंता नहीं करते हैं)

वैध पिच तार वे होते हैं जो स्ट्राइक-आउट, वॉक या हिट में समाप्त होते हैं।

यानी, एक अमान्य पिच स्ट्रिंग या तो है

4 गेंद, 3 स्ट्राइक या हिट के बाद अतिरिक्त पिच
4 वीं गेंद, 3 स्ट्राइक, या हिट उत्पन्न करने से पहले समाप्त।

नियम

आपका प्रोग्राम किसी दिए गए इनपुट के लिए सभी संभावित परिणाम तैयार करने में सक्षम होना चाहिए।
आपका कार्यक्रम समान रूप से यादृच्छिक होना आवश्यक नहीं है लेकिन फिर भी पिछले नियम का पालन करना चाहिए।
यह कोड-गोल्फ है ।

उदाहरण

Input => Possible Outputs
1 => [H] #Can only end with a hit
2 => [S,H], [B,H], [F,H] #Can only end with a hit
3 => [S,S,S], [F,F,S], [B,B,H], ... #Can now strike-out, otherwise must end with a hit
4 => [B,B,B,B], [S,B,S,S], [B,F,S,S], [B,B,B,H], ... #Can now be walked, struck-out, or get a hit
6 => [S,B,S,B,B,H], [F,F,F,F,F,S], ... #Can now have a full-count (3 balls, 2 strikes) before finishing 

Input => Invalid Outputs
1 => [S], [B]    #Not enough for a strike-out/walk
2 => [S,S]       #Not enough for a strike-out/walk
2 => [H,H]       #Batter has already scored a hit
3 => [S,S,F]     #Fouls will not cause a strike-out
4 => [S,S,S,H]   #Batter has already struck out
5 => [B,B,B,B,B] #Batter has already walked

code-golf sequence random

— Veskah
स्रोत

1

तो हमें 1 से अनंत एफ तक कहीं भी उत्पादन करने में सक्षम होना चाहिए?

— क्विंटेक

स्ट्रिंग अधिकतम 100 वर्णों पर होगी। Fouls ऐसी लंबी पिचिंग स्ट्रिंग्स की अनुमति देता है, जैसे 99 Fs और Sएक स्ट्राइक-आउट है

— Veskah

ओह, समझ गया, वह छूट गया

— क्विंटेक

@ क्विंट ने हाल ही में इसे थोड़ा और स्पष्ट करने के लिए पुरस्कृत किया

— Veskah

4

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

from random import*
def g(n):
 x=i=S=0;r=''
 while(S>2)+x<3>=i-S:x=randint(0,3);r+='BFSH'[x];S+=x>0;i+=1
 return(i==n)*r or g(n)

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

जब तक बल्लेबाज नहीं किया जाता है, तब तक बेतरतीब ढंग से पिच स्ट्रिंग उत्पन्न करें, अगर यह सही लंबाई निकलता है, तो इसे आउटपुट करें, और अन्यथा खरोंच से फिर से प्रयास करें।

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

from random import*
def g(n):
 B=H=F=S=0;r=''
 while(F+S<3or'S'>x)>B/4+H:x=choice('BHFS');r+=x;exec x+"+=1"
 return(len(r)==n)*r or g(n)

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

— XNOR
स्रोत

केविन के बंदरगाह ने मुझे यह एहसास कराया कि यह उच्च संख्या के लिए टूट गया है। अंत n=8में Fs की एक श्रृंखला उत्पन्न कर सकते हैं

— Veskah

2

@Veskah अच्छा कैच। मैंने स्ट्राइक काउंट (गिनती की बेईमानी) का हिसाब नहीं दिया था, संभवतः 6 तक जा रहा था, और इसे ठीक S/3करने के लिए बदल रहा (S>2)था।

— xnor

4

05AB1E , 44 50 44 बाइट्स

^{बाहर पार  44 अब 44 नहीं है :)}

[õ0U.µ["BFSH"3ÝΩ©è«®ĀX+U¼X2›®+3@¾X-3›~#}I¾Q#

पोर्ट ऑफ @xnor पायथन 2 का उत्तर है , इसलिए यदि आप इस उत्तर को पसंद करते हैं, तो उसे उभारना सुनिश्चित करें!
बग-फिक्स के कारण +6 बाइट्स, और उसके बाद -6 बाइट्स के बाद फिर से @xnor के लिए धन्यवाद, मेरे अस्थायी कार्य-की तुलना में अपने कुशल तरीके को और अधिक कुशल फिक्स के रूप में, जैसा कि मैं उम्मीद कर रहा था। ;)

इसे ऑनलाइन आज़माएं या कुछ और यादृच्छिक आउटपुट सत्यापित करें ।

स्पष्टीकरण:

[                # Start an infinite loop:
 õ               #  (Re)set the result-string to an empty string ""
 0U              #  (Re)set variable `X` to 0
 .µ              #  Reset the counter_variable to 0
   [             #  Start an inner infinite loop:
    "BFSH"       #   Push string "BFSH"
          3ÝΩ    #   Push a random integer in the range [0,3]
             ©   #   Store this random integer in variable `r` (without popping)
              è  #   Index it into the string "BFSH"
               « #   Append it to the result-string
    ®Ā           #   If `r` is NOT 0:
      X+U        #    Increase `X` by 1
    ¼            #   Increase the counter_variable by 1
    X2›®+        #   Calculate `X`>2 (1 if truthy; 0 if falsey) + `r`
         3@      #   Check if this is larger than or equal to 3
    ¾X-          #   Calculate counter_variable - `X`
       3›        #   Check if this is larger than 3
    ~            #   If either of the two checks above is truhy:
     #           #    Stop the inner infinite loop
   }             #  After the inner infinite loop:
    I¾Q          #  If the input and counter_variable are equal:
       #         #   Stop the outer infinite loop
                 # (and output the result-string at the top of the stack implicitly)

— केविन क्रूज़सेन
स्रोत

1

@Veskah मैं अब के लिए एक सीधे आगे तय किया है। मुझे लग रहा है कि xnor एक छोटे से फिक्स करने में सक्षम है, इसलिए मैं शायद बाद में कुछ बाइट्स को बचाने के लिए उसके फिक्स को पोर्ट करूँगा। :)

— केविन क्रूज़सेन

1

आप इसे ठीक कर सकते हैं जैसे मैंने बदलकर X/3किया X>2।

— xnor

@xnor धन्यवाद, फिर से 44 बाइट्स के लिए वापस। मुझे पता था कि आपको कुछ कम मिलेगा। ; पी

— केविन क्रूज़सेन

3

आर , 148 बाइट्स

function(n){`~`=paste0
`*`=sample
o=""
while(nchar(o)<n-1){a=c("B"[T<4],"F","S"[F<2])*1
F=F+(a>"E")
T=T+(a<"F")
o=o~a}
o~c("B"[T>3],"H","S"[F>1])*1}

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

नमूना डेटासेट में सशर्त समावेश का उपयोग करके स्ट्रिंग उत्पन्न करता है ताकि यह सुनिश्चित हो सके कि परिणाम संभव पिच अनुक्रम है।

संभवतः अस्वीकृति नमूनाकरण ( xnor के अजगर जवाब करता है ) छोटा है।

function(n){`~`=paste0		# alias
`*`=sample			# alias
o=""				# empty string for output
while(nchar(o)<n-1){		# do n-1 times:
a=c("B"[T<4],"F","S"[F<2])*1	# sample 1 from the string "BFS", conditionally including B or S if the ball/strike count is 3/2	
F=F+(a>"E")			# increment F (strike count) if sampled character is F or S
T=T+(a<"F")			# increment T (ball count) if sampled character is B
o=o~a}				# append a to output

o~c("B"[T>3],"H","S"[F>1])*1}	# append the sampled "BHS", conditionally including B or S if the ball/strike count is 3/2.

रैंडम "एफ और एस" संदर्भ जो मेरे सिर में हर बार खेलता रहता था, मैंने उनमें से एक अक्षर टाइप किया था ...

— ग्यूसेप
स्रोत

2

जावास्क्रिप्ट (स्पाइडरमोनी) , 137 बाइट्स

f=(n,o='',i=Math.random()*4|0,r=/^(?!.*((B.*){4}|([SF].*){2}S|H).)/)=>r.test(o)?n?f(n-1,o+'BSFH'[i%4])||i<8&&f(n,o,i+1):!r.test(o+1)&&o:0

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

— TSH
स्रोत

2

पायथ, 53 बाइट्स

u+GO?H+W<K/G\B3+W<Jl@"SF"G2\F\S\B+WqK3+WgJ2\H\S\B_UQ[

इसे यहाँ ऑनलाइन आज़माएँ ।

यह बहुत लंबा लगता है, मुझे लगता है कि एक और दृष्टिकोण की आवश्यकता हो सकती है।

u+GO?H+W<K/G\B3+W<Jl@"SF"G2\F\S\B+WqK3+WgJ2\H\S\B_UQ[   Implicit: Q=eval(input())
                                                 _UQ    Reversed range from Q-1 to 0
u                                                   [   Reduce the above, with initial value G=[], next value as H:
                    @"SF"G                                Keep elements of G which are in "SF"
                   l                                      Length of the above
                  J                                       Store in J - this is the number of strikes and fouls so far
          /G\B                                            Count number of "B"s in G
         K                                                Store in K - this is the number of balls so far
    ?H                                                    If H is not 0 (i.e. not final pitch):
                           \F                               Start with "F" (foul is always available in non-final pitch)
                W<J       2                                 If J<2...
               +             \S                             ... append "S"
       W<K    3                                             If K<3...
      +                        \B                           ... append "B"
                                                          Else:
                                           \H               Start with "H" (hit is always available in final pitch)
                                       WgJ2                 If J >= 2...
                                      +      \S             ... append "S"
                                  WqK3                      If K == 3...
                                 +             \B           ... append "B"
   O                                                      Choose one element at random from the available options
 +G                                                       Append the above to G
                                                        Implicit print the result of the reduce operation

— सोक
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 107 106 99 बाइट्स

f=(n,k=p=s=0,o='')=>p&&p>2|k-s>3|s>2&p<2?k-n?f(n):o:f(n,k+1,o+'FSBH'[p=Math.random()*4|0,s+=p<2,p])

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

टिप्पणी की गई

f = (                       // f = recursive function taking:
  n,                        //   n = requested length
  k =                       //   k = pitch counter, initialized to 0
  p =                       //   p = last pitch
  s = 0,                    //   s = sum of strikes and fouls
  o = ''                    //   o = output string
) =>                        //
  p &&                      // if the last pitch was not a foul
  p > 2 |                   // AND the last pitch was a hit
  k - s > 3 |               //     OR we have 4 balls (or 3 balls + 1 hit)
  s > 2 & p < 2 ?           //     OR more than 2 strikes or fouls, ending with a strike:
    k - n ?                 //   if k is not equal to n:
      f(n)                  //     valid series but bad timing: try again from scratch
    :                       //   else:
      o                     //     success: return o
  :                         // else:
    f(                      //   do a recursive call:
      n,                    //     n is unchanged
      k + 1,                //     increment k
      o + 'FSBH'            //     append the pitch letter to o
        [ p = Math.random() //     pick a new random pitch
              * 4 | 0,      //     in [0..3]
          s += p < 2,       //     increment s if the pitch is a foul or a strike
          p ]               //     actual index in 'FSBH'
    )                       //   end of recursive call

— Arnauld
स्रोत

2

इंक , 120 119 116 117 बाइट्स

=f(n)
->g(n,3,2)
=g(n,b,s)
~n--
{n:{~{b:b->g(n,b-1,s)}|{s:s->g(n,b,s-1)}|}f->g(n,b,s-(s>0))|{~{b:h|b}|{s:h|s}|h}}->->

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

शायद अभी भी गोल्फ है।

अघोषित (मामूली रूप से सुधारित)

=f(length) // Define a stitch f, with one parameter which specifies the length of the created string. This is the intended entry point.
->g(length,3,2) // Instantly divert to g, defined below, with some extra parameters

=g(length,balls_left,strikes_left) // Define a stitch g, with three parameters.
~ length--                         // Decrement remaining length
{
    - length: // If this is not to be the last character in the string
              // randomly do one of the following:
              // 1. If balls_left is nonzero, print a b and recurse
              // 2. If strikes_left is nonzero, print an s and recurse
              // 3. Do nothing
              // If we did not divert earlier, print an f and recurse.
        {~{balls_left:b->g(length,balls_left-1,strikes_left)}|{strikes_left:s->g(length,balls_left,strikes_left-1)}|}f->g(length,balls_left,strikes_left-(strikes_left>0)) 
    - else: // Randomly do one of the following
            // 1. If a ball would result in a walk, print a b, otherwise an h.
            // 2. If a strike would result in a strikeout, print an s, otherwise an h.
            // 3. Just print an h.
            // And finally, halt.
        {~{balls_left:h|b}|{strikes_left:h|s}|h}}->->

संपादित करता

के ->->बजाय के साथ खत्म करके एक बाइट को बचाया ->END।
nपहले से घटाकर तीन बाइट्स बचाए ।
एक बग को निर्धारित किया जो गलत स्थानों पर हड़ताल का कारण बना, इसके लिए @veskah को धन्यवाद (+1 बाइट)

— सारा जे
स्रोत

1

राइट-अप और आउटपुट के आधार पर, ऐसा लगता है कि यह बेईमानी से हड़ताल-गिनती को सही ढंग से बढ़ाने में कारक नहीं है

— Veskah

1

@veskah अच्छी तरह से देखा, अब तय किया जाना चाहिए, धन्यवाद

— सारा जे

1

एपीएल (Dyalog यूनिकोड) , 77 बाइट्स ^SBCS

{'HBSF'[{⍺←⍬⋄∨/((⊃⌽⍺)=⍳3)∧1,4 3≤(⊃s),+/1↓s←⍺∘(+/=)¨1+⍳3:⍺⋄∇⍨⍺,?4}⍣{i=≢⍺}i←⍵]}

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

— voidhawk
स्रोत

1

चारकोल , 57 बाइट्स

≔⁰η≔⁰ζＦ⊖Ｎ«≔‽⁺²‹ζ³ι¿›ι¹≦⊕ζ≦⊕η§SFB∨ι›η²»⊞υHＦ›η¹⊞υSＦ›ζ²⊞υB‽υ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔⁰η≔⁰ζ

0 गेंदों और 0 स्ट्राइक से शुरू करें।

Ｆ⊖Ｎ«

अंतिम को छोड़कर सभी डिलीवरी पर लूप।

≔‽⁺²‹ζ³ι

यदि तीन गेंदों से कम हो गया है, तो 0 से 2 तक एक यादृच्छिक संख्या उत्पन्न करें, अन्यथा केवल 0 और 1 के बीच मेल-मिलाप करें।

¿›ι¹≦⊕ζ≦⊕η

2 का एक यादृच्छिक मूल्य एक गेंद है अन्यथा यह स्ट्राइक काउंट बढ़ाता है।

§SFB∨ι›η²»

स्ट्राइक, फाउल और बॉल पर 0 से 2 मैप का मान, सिवाय इसके कि अगर तीन स्ट्राइक होंगे तो फाउल को प्रिंट किया जाता है। (चार गेंदों को ऊपर रखा गया है।)

⊞υHＦ›η¹⊞υSＦ›ζ²⊞υB‽υ

निर्धारित करें कि क्या स्ट्राइक या बॉल बल्लेबाज को आउट करेगी और उनमें से एक हिट या उपयुक्त के रूप में चुनेगी।

— नील
स्रोत

1

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

map{$B=$S=$H=0;while($B<4&&$S<3&&!$H&&/./g){${$&}++;$S+=$&eq F&&$S<2}y///c>pos||push@a,$_}glob"{B,F,H,S}"x<>;say$a[rand@a]

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

— Xcali
स्रोत

1

@Veskah मैं उस हिस्से को याद किया। ठीक कर दिया।

— Xcali

1

सी (जीसीसी) 164 145 142 बाइट्स

-3 बाइट्स छत

#define A(a)!i&&!r--?puts(#a),++a,--n:0;
b,s,f,h,i,r;p(n){srand(time(0));for(i=n;i--;){for(n=1;n;){r=rand()&3;b>2^!A(b)s+f>1^!A(s)!A(f)A(h)}}}

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

— rtpax
स्रोत

के &nबजाय सुझावtime(0)

— छत

एक बेसबॉल पिच स्ट्रिंग उत्पन्न करें

लक्ष्य

इनपुट

उत्पादन

नियम

उदाहरण

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

05AB1E , 44 50 44 बाइट्स

आर , 148 बाइट्स

जावास्क्रिप्ट (स्पाइडरमोनी) , 137 बाइट्स

पायथ, 53 बाइट्स

जावास्क्रिप्ट (ईएस 6), 107 106 99 बाइट्स

टिप्पणी की गई

इंक , 120 119 116 117 बाइट्स

अघोषित (मामूली रूप से सुधारित)

एपीएल (Dyalog यूनिकोड) , 77 बाइट्स SBCS

चारकोल , 57 बाइट्स

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

सी (जीसीसी) 164 145 142 बाइट्स

एपीएल (Dyalog यूनिकोड) , 77 बाइट्स ^SBCS