Hedef

Pozitif bir tamsayı alan bir program veya işlev yazın nve rastgele uzunluk dizisi (bundan böyle bir Pitch dizesi olarak adlandırılır) uzunluk oluşturur n.

Giriş

Sıfır olmayan, pozitif bir tam sayı n<= 100

Çıktı

Olası, geçerli bir uzunluk aralığı dizisini temsil eden rastgele bir dize veya karakter listesi döndürün n. Kullanılan karakterler:

• B - Top. Bunlardan 4 tanesini biriktirirseniz, hamur yürür ve vuruş bitirilir.
• S - Grev. Bunlardan 3 tane biriktirirseniz, hamur biter ve vuruş bitirilir.
• F - Faul. Ayrıca Grev sayısını artıracak ancak meyilli dışarı çıkamaz. Yani, geçerli bir karakter dizisinin son adımı faul olamaz. İki vuruş / faulü aşan fauller, Grev sayısını artırmayacaktır (meyilli zaten bu noktada 2 vuruş yapar ve 3'üncü onu çıkarır).
• H - Vur. Hamur topu oyuna soktu ve vuruşunu bitirdi.

(Bu biraz basitleştirildi, ancak bunun için endişelenme)

Geçerli zift dizeleri, grev, yürüyüş veya isabetle sonuçlanan dizelerdir.

Yani, geçersiz bir karakter dizisi ya

• 4. Top, 3. Vuruş veya Vuruştan sonra ek sahalar
• 4. top, 3. vuruş veya İsabet oluşturmadan önce sonlandırıldı.

kurallar

• Programınız belirli bir giriş için olası tüm sonuçları üretebilmelidir.
• Programınızın aynı şekilde rasgele olması gerekmez, ancak yine de bir önceki kurala uymalıdır.
• Bu kod golfü .

Örnekler

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

Python 2 , 128 bayt

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)

Çevrimiçi deneyin!

Hamur bitinceye kadar zift dizisini rastgele oluşturun, doğru uzunluğu çıkarırsa çıktı alın, aksi takdirde sıfırdan tekrar deneyin.

Python 2 , 136 bayt

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)

Çevrimiçi deneyin!

05AB1E ,  44  50 44 bayt

^{Çarpıldı &nbsp;44&nbsp;artık 44 :)}

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

Port of @xnor 'un Python 2 cevabı , bu yüzden bu cevabı beğendiyseniz de onu oyladığınızdan emin olun!
Bir hata düzeltmesi nedeniyle +6 bayt ve bundan sonra da -6 bayt @xnor sayesinde beklediğim gibi geçici çözümümle karşılaştırıldığında daha etkili bir düzeltme yolunu taşıyarak . ;)

Çevrimiçi deneyin veya daha rastgele çıktılar doğrulayın .

Açıklama:

[                # 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)

R , 148 bayt

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}

Çevrimiçi deneyin!

Sonucun olası bir adım dizisi olduğundan emin olmak için örnekleme veri kümelerine koşullu dahil etme kullanarak dizeyi oluşturur.

Muhtemelen reddetme örneklemesi yapmak ( xnor'ın python cevabı gibi ) daha kısadır.

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.

Bu harflerden birini her yazdığımda kafamda çalmaya devam eden rastgele "F ve S" referansı ...

JavaScript (SpiderMonkey) , 137 bayt

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

Çevrimiçi deneyin!

Pyth, 53 bayt

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

Çevrimiçi deneyin Burada .

Bu çok uzun geliyor, bence başka bir yaklaşım gerekebilir.

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

JavaScript (ES6),  107 106  99 bayt

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])

Çevrimiçi deneyin!

Yorumlananlar

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

Mürekkep , 120 119 116 117 bayt

=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}}->->

Çevrimiçi deneyin!

Muhtemelen hala golf oynayabilir.

Ungolfed (hafif yeniden biçimlendirilmiş)

=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}}->->

Düzenlemeler

1. İle bitirerek bir byte Kaydedilen ->->yerine ->END.
2. nDaha önce azalarak üç bayt kaydedildi .
3. @Veskah tespit ettiği için yanlış yerlerde darbelere neden olan bir hata düzeltildi (+1 bayt)

APL (Dyalog Unicode) , 77 bayt ^SBCS

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

Çevrimiçi deneyin!

Kömür , 57 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

≔⁰η≔⁰ζ

0 top ve 0 vuruş ile başlayın.

Ｆ⊖Ｎ«

Sonuncusu hariç tüm teslimatları gerçekleştirin.

≔‽⁺²‹ζ³ι

Üçten az top varsa, 0'dan 2'ye rastgele bir sayı üretin, aksi takdirde 0 ile 1 arasında birlikte yerleştirin.

¿›ι¹≦⊕ζ≦⊕η

Rastgele 2 değeri bir toptur, aksi takdirde vuruş sayısını arttırır.

§SFB∨ι›η²»

Üç ile çarpma olursa, bunun yerine faul yazdırılır. (Yukarıda dört top hariç tutulmuştur.)

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

Bir vuruş veya topun hamuru alıp almayacağını belirleyin ve bunlardan veya bir vuruştan uygun olanı seçin.

Perl 5 , 122 bayt

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]

Çevrimiçi deneyin!

C (GCC) 164 145 142 bayt

-3 bayt tavan kedisi

#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)}}}

Çevrimiçi deneyin