Đưa ra một vị trí với một hàng rooks và / hoặc khoảng trống, xuất ra bao nhiêu bước di chuyển khác nhau có thể. Một tân binh có thể di chuyển sang trái hoặc phải đến một khoảng trống, nhưng không phải là một yêu cầu vượt qua một tân binh khác. Khi một tân binh di chuyển, các tân binh khác vẫn giữ nguyên vị trí.

Ví dụ: từ vị trí này, có thể di chuyển 6 bước :

.R..RRR.

• Rook đầu tiên (ngoài cùng bên trái) có thể di chuyển 1 khoảng trắng bên trái hoặc 1 hoặc 2 khoảng trắng bên phải (3 di chuyển)
• Rook tiếp theo chỉ có thể di chuyển 1 hoặc 2 khoảng trống còn lại (2 di chuyển)
• Rook thứ ba hoàn toàn không thể di chuyển bởi vì nó bị ép giữa hai rook khác (0 di chuyển)
• Rook cuối cùng chỉ có thể di chuyển 1 khoảng trắng bên phải (1 di chuyển)

Lưu ý rằng một vị trí có thể không có tân binh nào cả, hoặc không có khoảng trống nào cả.

Dữ liệu vào: Một danh sách không trống (chuỗi, mảng, v.v.) của rooks và khoảng trống. Bạn có thể biểu thị chúng dưới dạng True/ False, 1/ 0, 'R'/ '.'hoặc bất kỳ hai ký tự byte đơn riêng biệt nhất quán hoặc số có một chữ số nào bạn chọn. Tùy thuộc vào bạn, cái nào có nghĩa là tân binh và có nghĩa là không gian trống.

Đầu ra: Một số nguyên không âm. Phao số nguyên cũng ổn.

Các trường hợp thử nghiệm

Đầu ra là số bên trái.

6 .R..RRR.
0 .
0 R
4 R..RR
3 ...R
8 ..R..R..
0 ......

Đối với nhiều trường hợp thử nghiệm, đây là tất cả các đầu vào lên đến chiều dài 5.

0 .
0 R
0 ..
1 .R
1 R.
0 RR
0 ...
2 ..R
2 .R.
1 .RR
2 R..
2 R.R
1 RR.
0 RRR
0 ....
3 ...R
3 ..R.
2 ..RR
3 .R..
3 .R.R
2 .RR.
1 .RRR
3 R...
4 R..R
3 R.R.
2 R.RR
2 RR..
2 RR.R
1 RRR.
0 RRRR
0 .....
4 ....R
4 ...R.
3 ...RR
4 ..R..
4 ..R.R
3 ..RR.
2 ..RRR
4 .R...
5 .R..R
4 .R.R.
3 .R.RR
3 .RR..
3 .RR.R
2 .RRR.
1 .RRRR
4 R....
6 R...R
5 R..R.
4 R..RR
4 R.R..
4 R.R.R
3 R.RR.
2 R.RRR
3 RR...
4 RR..R
3 RR.R.
2 RR.RR
2 RRR..
2 RRR.R
1 RRRR.
0 RRRRR

Võng mạc , 14 9 byte

w`_+R|R_+

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Sử dụng _cho không gian trống vì đó là nhân vật phi regex dễ chịu nhất. Hoạt động bằng cách đếm số lượng chuỗi con tương ứng với di chuyển Rook hợp lệ. Chuỗi con là một di chuyển Rook hợp lệ nếu nó chứa ít nhất một _cộng với một lần duy nhất Rở đầu hoặc cuối.

Python 3 , 30 29 byte

lambda s:sum((s+s).strip())/9

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

-1 byte nhờ @JoKing

Hàm lấy một chuỗi byte Python làm đầu vào. Mỗi không gian trống được mã hóa dưới dạng một tab và mỗi rook được mã hóa dưới dạng một byte b'\x00'có giá trị 0.

Tính toán tương đương với lambda s:(s+s).strip().count(b'\t')trong khi có số byte thấp hơn.

JavaScript (ES6),  38  33 byte

Đã lưu 5 byte nhờ @JoKing

Đưa đầu vào dưới dạng một chuỗi. Mong đợi một không gian cho một hình vuông trống và bất kỳ nhân vật nào khác cho một tân binh.

s=>(s+s).trim().split` `.length-1

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

Đã bình luận

s =>          // s = input, e.g. " R  RRR "
  (s + s)     // double -> " R  RRR  R  RRR "
  .trim()     // remove leading and trailing spaces -> "R  RRR  R  RRR"
  .split` `   // split on spaces -> [ 'R', '', 'RRR', '', 'R', '', 'RRR' ]
  .length - 1 // return the length - 1 -> 6

Python 2 ,  40  33 byte

Đã lưu 7 byte nhờ @Grimy

lambda s:(s+s).strip().count(' ')

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

Japt , 5 byte

²x èS

Thử nó

²x èS        Implicit input string of U
²            U + U
 x           Remove trailing and leading whitespace
   èS        Number of spaces

Perl 6 , 16 byte

{+m:ex/s+R|Rs+/}

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

Một regex phù hợp với tất cả các trường hợp đầy đủ của các tân binh theo sau là khoảng trắng hoặc khoảng trắng theo sau là một rook và trả về số lượng trận đấu.

05AB1E , 5 byte

«ðÚð¢

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

«       # concatenate the input with itself
 ðÚ     # remove leading and trailing spaces
   ð¢   # count spaces

Võng mạc , 23 15 byte

Nhân đôi số khoảng trắng giữa các rooks, grep lines với ít nhất một rook, sau đó đếm số khoảng trắng.

R.+R
$0$0
G`R
 

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

Mặc dù chương trình sử dụng khoảng trắng thay vì dấu chấm, tôi đã thêm mã tiền tố để các trường hợp kiểm tra được cung cấp có thể dễ dàng dán và sử dụng.

Tôi đã hy vọng tôi có thể sử dụng các trận đấu chồng chéo với nhau (?<=R.*) | (?=.*R), nhưng trùng lặp không quá mạnh mẽ. Nó sẽ cần phải đếm tất cả các cách có thể có được một trận đấu để có thể trả về kết quả chính xác với phương pháp đó.

Thạch , 6 byte

t1;ḟẠS

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

Một liên kết đơn âm lấy một danh sách 0cho rook và 1cho không gian và trả về một số nguyên với số lần di chuyển. Liên kết TIO lấy danh sách đã dán của các bảng có thể có trong câu hỏi, chuyển đổi sang định dạng đúng và sau đó đưa ra các câu trả lời được tính toán và chính xác.

Giải trình

t1     | Trim 1s from end
  ;    | Concatenate to input
   ḟẠ  | Filter out 1s if all input were 1s, otherwise filter out 0s
     S | Sum

Japt , 6 byte

Không gian cho không gian, bất kỳ nhân vật khác cho tân binh.

²x ¸ÊÉ

Thử nó

Ốc, 7 byte

Ít nhất là nó đánh bại Retina :)

o
\.+\R

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

Thạch , 5 byte

ḲẈ+ƝS

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

-1 cảm ơn Jonathan Allan .

0đại diện cho một tân binh, 1đại diện cho một không gian trống.

Stax , 7 6 5 byte

àσQ█ε

Chạy và gỡ lỗi nó

Sử dụng tab cho hình vuông trống và bất kỳ ký tự nào khác cho rook.

C (tiếng kêu) , 57 byte

i,r,o;g(*n,z){for(o=r=i=0;z--;i=-~i*!*n++)o+=*n?r=1,i:r;}

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

• Đã lưu 1 nhờ @ceilingcat

Tôi nhận ra nó không hoạt động cho các danh sách trống .. Bây giờ nó hoạt động! Cộng với một số byte!

1 = tân binh. 0 = không gian.

for (.. i + = n ++? - i: 1) // đếm khoảng trắng hoặc đặt lại các bước di chuyển thêm => i = - ~ i ! * n ++ (@ceilingcat)

o + = * n? r = 1, i: r; // thêm vào đầu ra -i- (di chuyển thêm) khi một rook được đáp ứng cộng với các tập -r- (rook met), -i- sẽ bị xóa trong câu tăng dần.

thêm -r- cho mọi không gian (rook đáp ứng được đảm bảo)

Haskell , 36 byte

f s=sum$snd.span(>0)=<<[s,reverse s]

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

Sử dụng 1 cho không gian trống, 0 cho rook. Đếm số lượng 1 không trong một khối ban đầu và thêm số đó vào kết quả cho chuỗi đảo ngược.

Haskell , 33 byte

sum.(t.reverse<>t)
t=snd.span(>0)

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

Hàm ẩn danh nhận đầu vào là danh sách 1s (dấu cách) và 0s (rooks). Điều này cắt khoảng trắng từ đầu và cuối danh sách, sau đó nối hai phiên bản của danh sách và tính tổng chúng.

Điều này sử dụng GHC 8.4.1 trở lên để có quyền truy cập vào <>toán tử mà không cần nhập nó.

Python 2 , 59 byte

def f(r):S=map(len,r.split('R'));return sum(S)*2-S[0]-S[-1]

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

Japt , 6 byte

²x ¸ÊÉ

Dùng thử trực tuyến

Ngôn ngữ Wolfram (Mathicala) , 43 38 byte

Count[Subsequences@#,{0,1..}|{1..,0}]&

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

Giải pháp Retina của cảng Neil . Sử dụng 1 cho khoảng trắng và 0 cho rooks.

Haskell , 68 58 54 byte

(n#y)(a:x)|a<1=n+(0#1)x|m<-n+1=y+(m#y)x
(_#_)x=0
f=0#0

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

Màu đỏ , 46 byte

func[s][length? next split trim append s s sp]

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

Chỉ là một cổng đỏ của các giải pháp JavaScript / Python của Arnauld . Có một không gian như một hình vuông trống.

Java 11, 35 32 byte

s->(s+s).strip().chars().sum()/9

Cổng câu trả lời Python 3 của @Joel .
-3 byte cũng nhờ @Joel .

Sử dụng NULL-byte ( \0) cho Rooks và tab ( \t) cho khoảng trắng.

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

Tôi đã thử sử dụng s->(s+s).trim().chars().sum()/9lúc đầu là 31-byter, nhưng điều này không hoạt động vì String#trimnội dung không chỉ loại bỏ các khoảng trống / tab / dòng mới hàng đầu mà còn tất cả các byte khác nhỏ hơn hoặc bằng U+0020(unicode 32; một khoảng trắng ) , do đó, nó cũng sẽ loại bỏ các byte NULL ..
Cảm ơn Joel đã giới thiệu cho tôi bản String#stripdựng sẵn Java 11+ mới (mà tôi quên chúng đã thêm) thay thế. Cái này cũng loại bỏ các phần đuôi / phần đầu, nhưng trong trường hợp này chỉ có các khoảng trắng , do đó các byte NULL được giữ lại.

Giải trình:

s->                              // Method with String as parameter & integer return-type
  (s+s)                          //  Concatenate the input to itself
       .strip()                  //  Then trim all leading and trailing tabs
               .chars().sum()    //  Sum the unicode values of the remaining characters
                             /9  //  And divide it by 9 to get the amount of remaining tabs

Perl 5 -MList::Util=sum -pF/R/ , 40 byte

$\=2*sum map$_=y///c,@F}{$\-="@F"+$F[-1]

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

C # (Trình biên dịch tương tác Visual C #) , 27 byte

x=>(x+x).Trim().Sum(d=>d)/9

Đã lưu một byte nhờ @someone

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

Stax , 7 6 byte

-1 byte nhờ đệ quy

╣ë|óêπ

Chạy và gỡ lỗi nó

Befunge-98 (PyFunge) , 73 byte

#;ep10fp#;>#v~:'.-#v_$1+0k
v0+ge0*gf0$_v#!-R':<
>ep20fp   v >0fg1-*0eg+.@

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

C , 183 156 151 137 96 91 byte

Nhờ trần nhà cho 91 byte.

c,e;char*z,b[9];main(d){for(gets(z=b);e=*z>81?c-=e*~!d,d=0:e+1,*++z;);printf("%i",d?:c+e);}

R là một tân binh, mọi thứ khác là một không gian.

TIO

Bình thường , 7 byte

/r6*2Qd

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

Lấy một chuỗi Rcho các tân binh, (khoảng trắng) cho các khoảng trống

/     d  # Count spaces in
 r6      #  Strip spaces from
   *2Q   #   2 * input() (= concatenation)

x86-64 - 26 byte

Đầu vào là một mảng có tối đa 32 bit và một số nguyên biểu thị số ô vuông, 1 đại diện cho rook, 0 đại diện cho trống.

C4 E2 69 F7 C1       shlx        eax,ecx,edx
0B C1                or          eax,ecx  
F3 0F BC C8          tzcnt       ecx,eax  
D3 E8                shr         eax,cl  
F3 0F BD C8          lzcnt       ecx,eax  
F7 D0                not         eax  
F3 0F B8 C0          popcnt      eax,eax  
2B C1                sub         eax,ecx  
C3                   ret  

Sao chép các bit sao cho nó được thêm vào bên trái của nó và loại bỏ các bit zero. Sau đó nhận được số bit 0 hàng đầu và trừ nó khỏi tổng số bit không.

x86-64 Mã máy - 22 byte - chỉ xếp hạng cờ dài thông thường.

Đầu vào là một số nguyên 32 bit với byte có ý nghĩa nhỏ nhất được tạo thành từ 8 bit đại diện cho các rooks. 1 là một tân binh, 0 là trống rỗng.

8A E9                mov         ch,cl  
91                   xchg        eax,ecx
F3 0F BC C8          tzcnt       ecx,eax
D3 E8                shr         eax,cl 
F3 0F BD C8          lzcnt       ecx,eax
F7 D0                not         eax  
F3 0F B8 C0          popcnt      eax,eax
2B C1                sub         eax,ecx
C3                   ret  

Sao chép các bit vào byte đáng kể tiếp theo và loại bỏ các bit zero. Sau đó nhận được số bit 0 hàng đầu và trừ nó khỏi tổng số bit không.