Mục tiêu

Viết chương trình hoặc hàm lấy số nguyên dương nvà tạo ngẫu nhiên một chuỗi các nốt hợp pháp (từ đó được gọi là chuỗi sân) có độ dài n.

Đầu vào

Một số nguyên khác không, dương n<= 100

Đầu ra

Trả về một chuỗi ngẫu nhiên hoặc danh sách các ký tự đại diện cho một chuỗi độ dài hợp lệ có thể, hợp lệ n. Các ký tự được sử dụng sẽ là:

• B - Bóng. Nếu bạn tích lũy được 4 trong số này, người đánh bóng được đi bộ và đánh xong.
• S - Tấn công. Nếu bạn tích lũy được 3 trong số này, người đánh bóng đã ra ngoài và đánh xong.
• F - hôi. Cũng sẽ tăng số lần tấn công nhưng không thể đánh bại. Tức là, bạn không thể có một lỗi là nốt cuối cùng trong một chuỗi hợp lệ. Bất kỳ pha phạm lỗi nào trong hai lần tấn công / phạm lỗi sẽ không làm tăng số lần Đột kích (người đánh bóng đã có 2 lần tấn công vào thời điểm đó và lần thứ 3 sẽ khiến anh ta bị loại).
• H - Trúng. Người đánh bóng đã đánh một quả bóng vào chơi và kết thúc trận đấu.

(Điều này được đơn giản hóa một chút nhưng bạn không lo lắng về điều đó)

Các chuỗi cao độ hợp lệ là những chuỗi kết thúc bằng một cú đánh, đi bộ hoặc một cú đánh.

Tức là, một chuỗi pitch không hợp lệ có một trong hai

• các nốt bổ sung sau Quả bóng thứ 4, Đột kích thứ 3 hoặc Lượt
• chấm dứt trước khi tạo ra quả bóng thứ 4, cú đánh thứ 3 hoặc Hit.

Quy tắc

• Chương trình của bạn phải có khả năng tạo ra tất cả các kết quả có thể cho một đầu vào nhất định.
• Chương trình của bạn không nhất thiết phải ngẫu nhiên nhưng vẫn phải tuân theo quy tắc trước đó.
• Đây là môn đánh gôn .

Ví dụ

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 byte

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)

Hãy thử trực tuyến!

Tạo ngẫu nhiên chuỗi cao độ cho đến khi bột được hoàn thành, xuất nó nếu nó có độ dài phù hợp và nếu không hãy thử lại từ đầu.

Python 2 , 136 byte

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)

Hãy thử trực tuyến!

05AB1E ,  44  50 44 byte

^{Bỏ qua &nbsp;44&nbsp;không còn 44 :)}

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

Câu trả lời Python 2 của @xnor , vì vậy hãy đảm bảo nâng cấp anh ấy nếu bạn thích câu trả lời này!
+6 byte do sửa lỗi và sau đó -6 byte một lần nữa nhờ @xnor bằng cách chuyển cách khắc phục hiệu quả hơn so với công việc tạm thời của tôi, như tôi mong đợi. ;)

Hãy thử trực tuyến hoặc xác minh một số đầu ra ngẫu nhiên hơn .

Giải trình:

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

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}

Hãy thử trực tuyến!

Tạo chuỗi, sử dụng bao gồm có điều kiện trong các bộ dữ liệu lấy mẫu để đảm bảo rằng kết quả là một chuỗi cao độ có thể.

Có thể thực hiện lấy mẫu từ chối (như câu trả lời python của xnor ) ngắn hơn.

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.

Tham chiếu "F và S" ngẫu nhiên cứ phát trong đầu tôi mỗi khi tôi gõ một trong những chữ cái đó ...

JavaScript (SpiderMonkey) , 137 byte

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

Hãy thử trực tuyến!

Bình thường, 53 byte

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

Hãy thử trực tuyến tại đây .

Điều này cảm thấy quá dài, tôi nghĩ rằng một cách tiếp cận khác có thể được yêu cầu.

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 byte

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

Hãy thử trực tuyến!

Đã bình luận

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ực , 120 119 116 117 byte

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

Hãy thử trực tuyến!

Có lẽ vẫn chơi golf.

Ungolfed (định dạng lại nhẹ)

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

Chỉnh sửa

1. Đã lưu một byte bằng cách hoàn thành với ->->thay vì ->END.
2. Lưu ba byte bằng cách giảm ntrước đó.
3. Đã sửa lỗi gây ra các cuộc đình công ở những nơi không chính xác, nhờ @veskah đã phát hiện ra nó (+1 byte)

APL (Dyalog Unicode) , 77 byte ^SBCS

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

Hãy thử trực tuyến!

Than , 57 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

≔⁰η≔⁰ζ

Bắt đầu với 0 quả bóng và 0 cú đánh.

Ｆ⊖Ｎ«

Lặp lại tất cả các giao hàng ngoại trừ cuối cùng.

≔‽⁺²‹ζ³ι

Nếu có ít hơn ba quả bóng, thì hãy tạo một số ngẫu nhiên từ 0 đến 2, nếu không thì chỉ là coinflip trong khoảng từ 0 đến 1.

¿›ι¹≦⊕ζ≦⊕η

Giá trị ngẫu nhiên là 2 là một quả bóng nếu không nó sẽ tăng số lần tấn công.

§SFB∨ι›η²»

Các giá trị 0 đến 2 bản đồ để tấn công, phạm lỗi và bóng, ngoại trừ nếu có ba cú đánh thì thay vào đó sẽ được in lỗi. (Bốn quả bóng được loại trừ ở trên.)

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

Xác định xem một cú đánh hoặc bóng sẽ đưa người đánh bóng ra và chọn từ những cú đánh đó hay một cú đánh phù hợp.

Perl 5 , 122 byte

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]

Hãy thử trực tuyến!

C (GCC) 164 145 142 byte

-3 byte trần

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

Dùng thử trực tuyến