Count rook เคลื่อนไหว 1D

31

เมื่อกำหนดตำแหน่งที่มีแถวของ rooks และ / หรือช่องว่างให้ส่งออกจำนวน rook การเคลื่อนไหวที่แตกต่างกันได้ rook สามารถเลื่อนไปทางซ้ายหรือขวาไปยังพื้นที่ว่างได้ แต่ไม่ใช่ไปยังที่ที่ต้องผ่าน rook อื่น เมื่อ rook เคลื่อนที่ไป rooks อื่นจะยังคงอยู่

ตัวอย่างเช่นจากตำแหน่งนี้สามารถทำได้6 การเคลื่อนไหว :

.R..RRR.
  • rook แรก (ซ้ายสุด) สามารถเลื่อนไปทางซ้าย 1 ช่องหรือ 1 หรือ 2 ช่องทางด้านขวา (3 ย้าย)
  • rook ถัดไปสามารถย้ายได้ 1 หรือ 2 ช่องทางซ้าย (2 ย้าย)
  • rook ตัวที่สามไม่สามารถเคลื่อนที่ได้เลยเพราะมันถูกบีบระหว่าง rooks สองอัน (0 ท่า)
  • โกงครั้งสุดท้ายสามารถย้าย 1 ช่องว่างด้านขวา (1 ย้าย)

โปรดทราบว่าตำแหน่งอาจไม่มีการโกงเลยหรือไม่มีการเว้นว่างเลย

อินพุต:รายการที่ไม่ว่างเปล่า (สตริง, อาร์เรย์, ฯลฯ .. ) ของ rooks และช่องว่าง คุณสามารถแทนพวกเขาเป็นTrue/ False, 1/ 0, 'R'/ '.'หรือสองอักขระไบต์เดียวที่แตกต่างกันที่สอดคล้องกันหรือตัวเลขหนึ่งหลักที่คุณเลือก มันขึ้นอยู่กับคุณว่าอันไหนหมายถึงโกงและพื้นที่ว่างเปล่า

เอาต์พุต:จำนวนเต็มที่ไม่เป็นลบ ลอยจำนวนทั้งหมดก็ดี

กรณีทดสอบ

เอาต์พุตคือหมายเลขทางด้านซ้าย

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

สำหรับกรณีทดสอบเพิ่มเติมนี่คืออินพุตทั้งหมดที่มีความยาวสูงสุด 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
code-golf  counting  chess 
— XNOR
แหล่งที่มา

คำตอบ:

9

Retina , 14 9 ไบต์

w`_+R|R_+

ลองออนไลน์! ลิงค์มีกรณีทดสอบ ใช้_พื้นที่ว่างเนื่องจากเป็นอักขระที่ไม่ใช่ regex ที่น่าพอใจที่สุด ทำงานโดยการนับจำนวนของสตริงย่อยที่สอดคล้องกับการย้าย Rook ที่ถูกต้อง สตริงย่อยคือการย้าย Rook ที่ถูกต้องหากมันมีอย่างน้อยหนึ่ง_บวกหนึ่งRที่จุดเริ่มต้นหรือจุดสิ้นสุด

— นีล
แหล่งที่มา
โอ้คุณคิดวิธีการทำสิ่งที่ฉันพูดถึงในคำตอบของฉัน Idk ทำไมฉันไม่คิดอย่างนั้น
— mbomb007
9

Python 3 , 30 29 ไบต์

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

ลองออนไลน์!

-1 ไบต์ขอบคุณ @JoKing

ฟังก์ชันใช้สตริง Python byte เป็นอินพุต แต่ละพื้นที่ว่างจะถูกเข้ารหัสเป็นแท็บและแต่ละคนโกงจะถูกเข้ารหัสเป็นไบต์มีค่าb'\x00'0

การคำนวณเทียบเท่ากับlambda s:(s+s).strip().count(b'\t')ในขณะที่มีจำนวนไบต์ที่ต่ำกว่า

— โจเอล
แหล่งที่มา
6

JavaScript (ES6),  38  33 ไบต์

บันทึก 5 ไบต์ด้วย @JoKing

รับอินพุตเป็นสตริง คาดว่าพื้นที่สำหรับสี่เหลี่ยมที่ว่างเปล่าและอักขระอื่น ๆ สำหรับเกมโกง

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

ลองออนไลน์!

แสดงความคิดเห็น

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 ไบต์

บันทึกแล้ว 7 ไบต์ขอบคุณ @Grimy

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

ลองออนไลน์!

— Arnauld
แหล่งที่มา
1
รุ่น Python ควรใช้countแทนsplit( TIO )
— Grimmy
@Grimy ขอบคุณ :)
— Arnauld
4

Perl 6 , 16 ไบต์

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

ลองออนไลน์!

regex ที่ตรงกับอินสแตนซ์ครบถ้วนสมบูรณ์ทั้งหมดของ rooks ตามด้วยช่องว่างหรือช่องว่างตามด้วย rook และส่งคืนจำนวนการจับคู่

— โจคิง
แหล่งที่มา
3

เรติน่า23 23ไบต์

เพิ่มจำนวนช่องว่างระหว่าง rooks, grep บรรทัดด้วยอย่างน้อยหนึ่ง rook จากนั้นนับจำนวนช่องว่าง

R.+R
$0$0
G`R

ลองออนไลน์!

แม้ว่าโปรแกรมจะใช้ช่องว่างแทนจุด แต่ฉันเพิ่มรหัสคำนำหน้าเพื่อให้กรณีทดสอบที่ให้ไว้อาจถูกวางและใช้งานได้ง่าย

ฉันหวังว่าฉันจะสามารถใช้การจับคู่ที่ซ้อนทับกัน(?<=R.*) | (?=.*R)ได้ แต่การทับซ้อนนั้นค่อนข้างก้าวร้าว มันจะต้องนับวิธีที่เป็นไปได้ทั้งหมดที่การแข่งขันจะได้รับเพื่อที่จะส่งกลับผลลัพธ์ที่ถูกต้องด้วยวิธีการนั้น

— mbomb007
แหล่งที่มา
1
ดูเหมือนว่าจะให้ผลที่ไม่ถูกต้อง.R.R.R.ถึงแม้ว่าการเปลี่ยนบรรทัดแรกเป็นR.+Rอาจช่วยได้อย่างไร
— Neil
@ คงที่คงที่ ขอบคุณ
— mbomb007
2

เยลลี่ 6 ไบต์

t1;ḟẠS

ลองออนไลน์!

ลิงก์ monadic ที่แสดงรายการ0สำหรับ rook และ1สำหรับช่องว่างและส่งคืนจำนวนเต็มที่มีจำนวนการย้าย ลิงก์ TIO ใช้รายการวางของบอร์ดที่เป็นไปได้ที่กำหนดไว้ในคำถามแปลงเป็นรูปแบบที่ถูกต้องแล้วออกคำตอบที่คำนวณและถูกต้อง

คำอธิบาย

t1     | Trim 1s from end
  ;    | Concatenate to input
   ḟẠ  | Filter out 1s if all input were 1s, otherwise filter out 0s
     S | Sum
— นิคเคนเนดี
แหล่งที่มา
2

เยลลี่ 5 ไบต์

ḲẈ+ƝS

ลองออนไลน์!

-1 ขอบคุณที่โจนาธานอัลลัน

0แสดงถึง rook 1หมายถึงพื้นที่ว่าง

— Erik the Outgolfer
แหล่งที่มา
1
หากคุณใช้อักขระเว้นวรรคสำหรับ Rook และอีกหนึ่งอักขระสำหรับช่องว่างคุณสามารถใช้Ẉเพื่อรับห้า:ḲẈ+ƝS
— Jonathan Allan
@JanathanAllan LOL ไม่คิดอย่างนั้น และก่อนหน้านั้นฉันกำลังทดลองẈใช้ แต่ใช้ṣ0แทน ...
— Erik the Outgolfer
2

C (เสียงดังกราว) , 57 ไบต์

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

ลองออนไลน์!

  • บันทึกแล้ว 1 ขอบคุณ @ceilingcat

ฉันรู้ว่ามันใช้ไม่ได้กับรายการว่าง .. ตอนนี้ใช้งานได้! รวมทั้งบันทึกไบต์!

1 = โกง 0 = พื้นที่

สำหรับ (.. i + = n ++? - i: 1) // นับช่องว่างหรือรีเซ็ตการย้ายพิเศษ => i = - ~ i ! * n ++ (@ceilingcat)

o + = n * r = 1, i:? R; // เพิ่มไปยังเอาต์พุต -i- (การเลื่อนพิเศษ) เมื่อพบ rook บวกกับชุด -r- (พบ rook), -i- จะถูกล้างเพื่อเพิ่มประโยค

เพิ่ม -r- สำหรับทุกพื้นที่ (รับประกันแบบโกง)

— AZTECCO
แหล่งที่มา
โขดหิน? หินของคุณเคลื่อนไหวหรือไม่?
— เสา
1
@ เสาใหญ่ขอโทษ! แก้ไข
— AZTECCO
2

Haskell , 36 ไบต์

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

ลองออนไลน์!

ใช้ 1 สำหรับพื้นที่ว่าง 0 สำหรับ rook นับจำนวนของ 1 ที่ไม่อยู่ในช่วงเริ่มต้นของบล็อกและเพิ่มเข้าไปในผลลัพธ์ของสตริงที่กลับด้าน

— XNOR
แหล่งที่มา
2

Haskell , 33 ไบต์

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

ลองออนไลน์!

ฟังก์ชันไม่ระบุชื่อที่รับอินพุตเป็นรายการ 1s (ช่องว่าง) และ 0s (rooks) ตัดขอบช่องว่างจากจุดเริ่มต้นและจุดสิ้นสุดของรายการจากนั้นเชื่อมทั้งสองรุ่นของรายการและรวมเข้าด้วยกัน

สิ่งนี้ใช้ GHC 8.4.1 ขึ้นไปเพื่อให้สามารถเข้าถึง<>โอเปอเรเตอร์โดยไม่ต้องนำเข้า

— โจคิง
แหล่งที่มา
1

Java 11, 35 32 ไบต์

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

ท่าเรือ@Joelหลาม 3 คำตอบ
-3 ไบต์ขอบคุณ @Joelเช่นกัน

ใช้ NULL-ไบต์ ( \0) สำหรับ Rooks และแท็บ ( \t) เพื่อเว้นวรรค

ลองออนไลน์

ฉันพยายามใช้s->(s+s).trim().chars().sum()/9ตอนแรกเป็น 31 byter แต่วิธีนี้ใช้ไม่ได้เพราะString#trimbuiltinไม่เพียง แต่ลบช่องว่างที่นำหน้าและต่อท้าย / แท็บ / บรรทัดใหม่ แต่ยังไบต์อื่น ๆ ทั้งหมดที่เล็กกว่าหรือเท่ากับU+0020(unicode 32; a space) ดังนั้นมันจะลบ NULL-bytes เช่นกัน
ขอบคุณJoelสำหรับการแนะนำ Java 11+ String#stripbuiltin ใหม่ (ซึ่งฉันลืมว่าเพิ่ม) เป็นทางเลือก อันนี้ยังลบส่วนต่อท้าย / นำหน้า แต่ในกรณีนี้มีเพียงช่องว่างเท่านั้นดังนั้น NULL-bytes จะถูกเก็บไว้

คำอธิบาย:

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
— Kevin Cruijssen
แหล่งที่มา
1
Java 11+ อนุญาตให้ใช้String.strip()เพื่อลบเฉพาะช่องว่าง: 32 ไบต์
— Joel
@ Joo Ah ลืมเรื่องนี้ไปหมดแล้ว! ขอบคุณ :)
— Kevin Cruijssen
1

C # (Visual C # Interactive คอมไพเลอร์) , 27 ไบต์

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

บันทึกเป็นไบต์ด้วย @someone

ลองออนไลน์!

— ศูนย์รวมแห่งความไม่รู้
แหล่งที่มา
1
Afaik คุณสามารถใช้แท็บเพื่อบันทึกไบต์ (รหัสที่สั้นกว่า) แต่ฉันใช้โทรศัพท์
— สรรพนามของฉันคือ monicareinstate
1

C , 183 156 151 137 96 91 ไบต์

ขอบคุณ ceilingcat สำหรับ 91 ไบต์

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 คือโกงทุกอย่างอื่นคือพื้นที่

TIO

— girobuz
แหล่งที่มา
บางสิ่ง - อนุญาตให้ใช้ฟังก์ชั่น (แทนโปรแกรมเต็มรูปแบบ) คุณสามารถพึ่งพาพฤติกรรมที่ไม่ได้กำหนด (เช่นการ zeroing โดยอัตโนมัติ) ตราบใดที่โปรแกรมของคุณทำงานอย่างถูกต้องกับคอมไพเลอร์อย่างน้อยหนึ่งตัว 82แทนหรือ'R'ก็สั้นลง ใช้e+e*dกว่าe*(1+d), e=0,d=1;else e++; can be changed to e = -1, d = 1; e ++; , and b [a] `และb[++a]สามารถถูกแทนที่ด้วย*bและ*++b
— ASCII-only
0

x86-64 - 26 ไบต์

อินพุตเป็นอาร์เรย์มากถึง 32 บิตและจำนวนเต็มแทนจำนวนสี่เหลี่ยมจัตุรัส 1 ค่าเป็น rook และ 0 เป็นค่าว่าง

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

คัดลอกบิตเพื่อที่จะถูกเพิ่มทางด้านซ้ายของมันและลบบิตศูนย์ต่อท้าย จากนั้นรับจำนวนศูนย์บิตนำและลบออกจากจำนวนศูนย์บิตทั้งหมด

x86-64 รหัสเครื่อง - 22 ไบต์ - หมากรุกความยาวปกติจัดอันดับเท่านั้น

อินพุตเป็นจำนวนเต็ม 32 บิตโดยมีไบต์ที่มีนัยสำคัญน้อยที่สุดซึ่งทำจาก 8 บิตที่เป็นตัวแทนของ rooks 1 คือโกง, 0 ว่างเปล่า

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

คัดลอกบิตลงในไบต์ที่มีนัยสำคัญถัดไปและลบบิตศูนย์ต่อท้าย จากนั้นรับจำนวนศูนย์บิตนำและลบออกจากจำนวนศูนย์บิตทั้งหมด

— ผม'
แหล่งที่มา
ดังนั้นมันจึงใช้ได้กับแถวที่มีความยาว 8 เท่านั้น ถ้าใช่นั่นดูเหมือนจะยากเกินไปสำหรับความท้าทาย
— ar4093
สันนิษฐานว่าบังเอิญพวกเขาติดอันดับโกงประจำตอนนี้
— ฉัน
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.