Trận chiến rủi ro: Đi xuống


16

Đưa ra hai danh sách các cuộn súc sắc cho một trận chiến trong Rủi ro, chương trình hoặc chức năng của bạn phải xuất ra số lượng quân mà mỗi người chơi bị mất.

Lý lịch

Bạn không cần phải đọc cái này, vì nó chỉ là nền tảng. Bỏ qua phân nhóm "Nhiệm vụ" để tiếp tục không suy giảm.

Trong trò chơi Rủi ro , một người chơi có thể tấn công người chơi khác (thực tế, điều này là cần thiết để giành chiến thắng). Kết quả của một trận chiến được xác định bằng việc tung xúc xắc. Mỗi trận chiến xảy ra như một chuỗi các trận chiến phụ, trong đó mỗi người chơi có thể thua tối đa 2quân đội của mình.

Trong một trận chiến phụ, người phòng thủ và kẻ tấn công mỗi người tung vài con xúc xắc có số lượng có thể thay đổi tùy theo hoàn cảnh không liên quan đến thử thách này. Cái chết có giá trị cao nhất của kẻ tấn công được so sánh với cái chết có giá trị cao nhất của người phòng thủ. Nếu cái chết của kẻ tấn công cao hơn cái chết của người phòng thủ, thì người phòng thủ sẽ mất một mảnh. Nếu không, kẻ tấn công mất một mảnh.

Sau đó, nếu cả hai người chơi có ít nhất hai con xúc xắc, thì con xúc xắc có giá trị cao thứ hai của hai người chơi được so sánh. Một lần nữa, nếu cái chết của kẻ tấn công cao hơn cái chết của người phòng thủ, thì người phòng thủ sẽ mất một mảnh. Nếu không, kẻ tấn công mất một mảnh.

(Người bảo vệ giành được mối quan hệ. Nếu cả người phòng thủ và kẻ tấn công lăn một 4, thì kẻ tấn công sẽ mất một mảnh.)

So sánh súc sắc

Trong trận chiến phụ từ bài viết trên Wikipedia, xúc xắc của kẻ tấn công có màu đỏ và xúc xắc của người phòng thủ có màu trắng. Cao nhất của xúc xắc của kẻ tấn công là 4và cao nhất của người phòng thủ là 3. Vì kẻ tấn công cao hơn, người phòng thủ mất một mảnh. Cao thứ hai là 3cho kẻ tấn công và 2cho người phòng thủ. Vì kẻ tấn công lại cao hơn, nên người phòng thủ mất một mảnh khác. Do đó, trong trận chiến phụ này, kẻ tấn công không mất quân cờ và kẻ phòng thủ mất quân 2cờ.

Lưu ý rằng các phần cao thứ ba không được so sánh. Điều này là do người bảo vệ không có nhiều hơn hai con xúc xắc trong một trận chiến phụ, do đó không có quân cờ nào cao thứ ba để so sánh.

Bài tập

Với các cuộn xúc xắc chưa được sắp xếp (các số nguyên trong phạm vi từ 1 đến 6) của cả kẻ tấn công và người bảo vệ một trận chiến Rủi ro phụ dưới bất kỳ hình thức thuận tiện nào, hãy xuất ra số quân đội mỗi người chơi bị mất. Đầu ra có thể ở bất kỳ dạng thuận tiện nào, miễn là nó có đầu ra khác nhau để chỉ ra năm khả năng. Bạn phải cho biết những đầu ra khác nhau trong câu hỏi của bạn là gì.

Đầu ra được xác định như sau: Bắt đầu với def=0atk=0. Nếu giá trị lớn nhất của danh sách cuộn xúc xắc của kẻ tấn công lớn hơn giá trị lớn nhất của danh sách cuộn xúc xắc của người phòng thủ, thì hãy tăng dần def. Nếu không, tăng lên atk.

Nếu cả hai danh sách cuộn xúc xắc có độ dài ít nhất 2, thì: nếu giá trị lớn thứ hai của danh sách cuộn xúc xắc của kẻ tấn công lớn hơn giá trị lớn thứ hai của danh sách, sau đó tăng defvà ngược lại atk.

Cuối cùng, chương trình hoặc chức năng phải xuất ra một mã định danh duy nhất cho mỗi 5 khả năng đầu ra sau đây:

  ╔═══╦═══╗
  ║atk║def║
  ╠═══╬═══╣
  ║ 1 ║ 0 ║
  ║ 0 ║ 1 ║
  ║ 2 ║ 0 ║
  ║ 1 ║ 1 ║
  ║ 0 ║ 2 ║
  ╚═══╩═══╝

Thí dụ

Defender: [3, 2] Attacker: [2, 4, 1] Max của defender là 3và max của kẻ tấn công là 4. 4>3, vì vậy def=1 Thứ hai của hậu vệ là 2và thứ hai của kẻ tấn công là 2. Not(2>2), Vì vậy atk=1. Đầu ra sau đó có thể là [1,1].

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

Defender
Attacker
Output (as [def,atk])
-----
[1]
[1]
[0,1]
-----
[6,6]
[1,1,1]
[0,2]
-----
[1,2]
[5,2,3]
[2,0]
-----
[5]
[3,4]
[0,1]
-----
[4]
[4,5]
[1,0]
-----
[1,3]
[1,2,3]
[1,1]
-----
[4]
[4,5,6]
[1,0]
-----
[4,5]
[6,2]
[1,1]
-----
[5]
[6,1,3]
[1,0]
-----
[5,5]
[4,4,1]
[0,2]
-----
[2,5]
[2,2]
[0,2]
-----
[6,6]
[4,4,3]
[0,2]
-----
[2,1]
[4,3]
[2,0]
-----
[4]
[1,5]
[1,0]
-----
[1]
[5,2]
[1,0]
-----
[6,2]
[4]
[0,1]
-----
[4,2]
[2,5,5]
[2,0]
-----
[2]
[6,6,2]
[1,0]
-----
[6]
[2,6]
[0,1]
-----
[3,1]
[1]
[0,1]
-----
[6,2]
[3,5,2]
[1,1]
-----
[4,2]
[1,1]
[0,2]
-----
[4,3]
[5,4,1]
[2,0]
-----
[5,6]
[1,2]
[0,2]
-----
[3,2]
[4,4]
[2,0]
-----
[2]
[6,3,4]
[1,0]
-----
[1,4]
[6,2,4]
[2,0]
-----
[4,2]
[2,5,4]
[2,0]
-----
[5]
[6,2,1]
[1,0]
-----
[3]
[2,5,4]
[1,0]
-----
[5,4]
[2]
[0,1]
-----
[6,3]
[2,6,5]
[1,1]
-----
[3,1]
[4]
[1,0]
-----
[4]
[6,6,5]
[1,0]
-----
[6,3]
[4,2]
[0,2]
-----
[1,6]
[5,4]
[1,1]
-----
[3,6]
[4,4]
[1,1]
-----
[5,4]
[5,1,1]
[0,2]
-----
[6,3]
[5,4]
[1,1]
-----
[2,6]
[1,2]
[0,2]
-----
[4,2]
[3,5,5]
[2,0]
-----
[1]
[1,2,1]
[1,0]
-----
[4,5]
[1,6]
[1,1]
-----
[1]
[3,5,1]
[1,0]
-----
[6,2]
[6,2]
[0,2]

Mẫu thực hiện

Python 2 hoặc 3

def risk(atk_rolls,def_rolls):
    # set the rolls in descending order, e.g. [5,3,2]
    atk_rolls = sorted(atk_rolls,reverse = True)
    def_rolls = sorted(def_rolls,reverse = True)
    # minimum length.
    minlen = min(len(atk_rolls),len(def_rolls))
    atk_lost = 0
    def_lost = 0
    # compare the highest-valued rolls
    if atk_rolls[0]>def_rolls[0]:
        def_lost += 1
    else:
        atk_lost += 1
    if minlen == 2:
        # compare the second-highest-valued rolls
        if atk_rolls[1] > def_rolls[1]:
            def_lost += 1
        else:
            atk_lost += 1
    return [def_lost, atk_lost]    

Thông số kỹ thuật

  • Đầu vào có thể được thực hiện dưới dạng bất kỳ hình thức nào chỉ mã hóa rõ ràng các cuộn của người phòng thủ và cuộn của kẻ tấn công.
  • Đầu ra có thể ở bất kỳ dạng nào cung cấp một đầu ra duy nhất cho mỗi năm khả năng được liệt kê ở trên.
  • Cuộn của hậu vệ là một danh sách 1hoặc 2số nguyên trong tập hợp [1,2,3,4,5,6]. Cuộn của kẻ tấn công là một danh sách 1để 3nguyên trong tập [1,2,3,4,5,6].
  • Vì đây là , mã ngắn nhất trong mỗi ngôn ngữ sẽ thắng! Đừng không để cho câu trả lời trong ngôn ngữ chơi golf không khuyến khích bạn đăng tải câu trả lời trong các ngôn ngữ khác.

Nhìn thấy cái này trên hộp cát, một câu hỏi hay
Noah Cristino


Kẻ tấn công thua nếu cuộn tối đa của nó bằng cuộn cao nhất của người phòng thủ, phải không?
Ông Xcoder

1
Có @ Mr.Xcoder, hậu vệ thắng quan hệ.
fireflame241

Do đó tôi đã xóa bình luận :)
Ông Xcoder

Câu trả lời:


8

Cổng NAND, 237

Được tạo bằng Logisim

Đầu vào là nhị phân không dấu 3 bit, được nhập ở bên trái. Đầu ra (2 bit) ở bên phải.

Nó quá lớn để vừa với màn hình và Logisim không thể phóng to, vì vậy hình ảnh có màu đen trắng. Lấy làm tiếc :(

Hoạt động cho tất cả các trường hợp thử nghiệm.

Có khả năng là một cách tốt hơn để làm điều này bằng cách sử dụng một số mạch bộ nhớ, cho phép các phần lớn được sử dụng lại.


4

Thạch ,  12  11 byte

NṢ€>/Ṡḟ-o-S

Một liên kết đơn lấy một danh sách các Defender, Attackercuộn (mỗi danh sách), trả về một số nguyên giữa -22bao gồm (tổn thất của người phòng thủ - tổn thất của kẻ tấn công):

result : [def, atk]
    -2 : [  0,   2]
    -1 : [  0,   1]
     0 : [  1,   1]
     1 : [  1,   0]
     2 : [  2,   0]

Hãy thử trực tuyến! hoặc xem bộ kiểm tra (ánh xạ kết quả sang định dạng OP).

Làm sao?

NṢ€>/Ṡḟ-o-S - Link: list [list Def, list Atk]
N           - negate all the rolls
 Ṣ€         - sort €ach of the lists of -1*rolls (max rolls are to the left now)
    /       - reduce by:
   >        -   is greater than?  (when len(Atk) > len(Def) leaves trailing negatives)
     Ṡ      - sign (maps all negatives to -1; zeros and ones of comparison unchanged)
       -    - literal -1
      ḟ     - filter discard (remove the -1s)
         -  - literal -1
        o   - logical or, vectorises (replaces the zeros with minus ones)
          S - sum

2

Võng mạc , 82 byte

%O^`.
((.)+).*(¶(?<-2>.)+)(?(2)(?!)).*
$1$3
O$`.
$.%`
\d
$*1D
(1+)D1*\1

1+D
A
O`.

Hãy thử trực tuyến! Dòng đầu tiên là xúc xắc của kẻ tấn công, thứ hai là xúc xắc của người phòng thủ. Returns (trên dòng riêng biệt) AA, AD, DD, Ahoặc Dcho phù hợp.



2

MATL , 23 byte

oH2$S1&Y)Y&t1M>t~b,Y&sD

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

Không chắc chắn tại sao những người bảo vệ được phép xúc xắc nhiều hơn những kẻ tấn công, nhưng có lẽ tôi không rành về Rủi ro. Chương trình cốt lõi chỉ là >t~,sD, tất cả các byte khác đều ở đó để cho phép các độ dài đầu vào khác nhau, với một chút sắp xếp được đưa vào. Đầu vào là kẻ tấn công theo sau bởi người bảo vệ, đầu ra là tổn thất của kẻ tấn công, sau đó là tổn thất của kẻ phòng thủ.

o    % Convert input to numeric array, padding with zeroes 
H2$S % Sort row-wise (specified to prevent 1v1 sorting)
1&Y) % Split attacker/defender
Y&t  % Logical and to filter out excess dice. Duplicate for 'do twice' later.
1M>  % Get throws again, decide who won
t~   % And the inverse to decide who lost
b,   % Bubble filter to the top. Do twice:
  Y& % Apply filter
  sD % Sum of losses. Display.

2

JavaScript (SpiderMonkey) , 97 83 78 byte

d=>a=>{for(u=v=0;d.sort()>[]&a.sort()>[];)a.pop()>d.pop()?u++:v++
return[u,v]}

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

-4 byte và được cố định nhờ @ovs và @Craig Ayre
-1 byte nhờ @Shaggy


Không làm việc cho một kẻ tấn công chống lại hai người bảo vệ.
Neil

Oh hmm, tôi đã không nghĩ về điều đó. Tôi sẽ sửa nó
WaffCohn

2
Điều này có thể làm việc.
trứng

Giải pháp của @ ovs vượt qua tất cả các trường hợp thử nghiệm, bạn cũng có thể lưu một vài byte (liên kết tio quá lớn):d=>a=>{for(u=v=0;d.sort()>[]&a.sort()>[];)a.pop()>d.pop()?u++:v++;return[u,v]}
Craig Ayre

Việc ngắt dòng đầu tiên là không cần thiết và khiến bạn tốn một byte.
Xù xì

2

Husk , 10 byte

M#eI¬¤z>Ö>

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

Nhập dưới dạng hai danh sách cuộn riêng biệt, đầu ra như trong op.

Giải trình

¤z>Ö> sắp xếp từng danh sách theo thứ tự giảm dần và sau đó nén chúng so sánh các yếu tố tương ứng (và cắt ngắn danh sách dài hơn).

M#eI¬tạo danh sách 2 yếu tố ( e) với số lượng ( #) giá trị trung thực (thông qua danh tính I) và giá trị giả (thông qua phủ định logic ¬)


1

Perl 5 , 66 + 1 (-a) = 67 byte

@A=sort split/ /,<>;$b+=@A?pop@A>$_?-1:1:0for reverse sort@F;say$b

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

Đầu vào:

Hai dòng. Dòng đầu tiên là hậu vệ (người chơi 1), thứ hai là kẻ tấn công (người chơi 2). Cuộn riêng lẻ cách nhau bởi không gian.

Đầu ra:

Cho thấy sự thay đổi hiệu quả về sức mạnh của hậu vệ so với kẻ tấn công.

Output Attacker Defender
   2      0        2        Defender wins both
   1      0        1        Defender wins the only roll
   0      1        1        Attacker wins first, defender wins second
  -1      1        0        Attacker wins the only roll
  -2      2        0        Attacker wins both rolls

"Chương trình hoặc chức năng phải xuất ra một mã định danh duy nhất cho mỗi trong số 5 khả năng đầu ra." Bạn có hai đầu ra cho [1,1]. Vui lòng chỉnh sửa câu trả lời của bạn để sửa lỗi này (chỉ cần sắp xếp hoặc tổng hợp)
fireflame241

Có gì sai với sáu? Nó cụ thể hơn. :) Tôi đã thay đổi nó với chi phí 6 byte.
Xcali


0

R , 46 byte

function(x,y)s(s(y,T)[1:2]>s(x,T)[1:2])
s=sort

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

Tất cả điều này là ba loại và một so sánh ... cộng với trích xuất hai yếu tố đầu tiên ở giữa.

Đầu vào là hai vectơ cuộn xúc xắc.

Đầu ra được mã hóa như sau:

╔═══╦═══╗
║atk║def║
╠═══╬═══╣
║ 10TRUE01FALSE20TRUE  TRUE11FALSE TRUE02FALSE FALSE
╚═══╩═══╝

Hoạt động vì trích xuất trong R không tái chế đối số của nó, nhưng đệm kết quả với NAđể đạt được độ dài yêu cầu.

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.