风险之战:崩溃


16

给定两个用于在Risk中进行战斗的掷骰子清单,您的程序或功能必须输出每个玩家损失的部队数量。

背景

您不必阅读本手册,因为它只是背景知识。跳至“任务”子标题,继续保持原样。

风险游戏中,一个玩家可以攻击另一位玩家(实际上,这是获胜的必要条件)。战斗的结果取决于掷骰子。每次战斗都是连续进行的子战,每个玩家可能会损失最多2的军队。

在一个子战中,防御者和攻击者各自掷出几个骰子,其骰子数量可能根据与该挑战无关的情况而变化。将攻击者的最高价值的骰子与防御者的最高价值的骰子进行比较。如果攻击者的死亡人数高于防御者的死亡人数,则防御者将输掉一件。否则,攻击者将丢失一件。

然后,如果两个玩家都至少有两个骰子,则比较两个玩家中第二高价值的骰子。同样,如果攻击者的死率高于防御者的死率,则防御者将输掉一件。否则,攻击者将丢失一件。

(防御者赢得平局。如果防御者和攻击者都掷出a 4,则攻击者将输掉一块。)

骰子比较

在Wikipedia文章的子战斗中,攻击者的骰子为红色,而防御者的骰子为白色。攻击者的最高骰子是4,防御者的最高骰子是3。由于攻击者更高,因此防御者输了一块。第二高的是3攻击者和2防御者。由于攻击者再次处于较高位置,因此防御者输了另外一块。因此,在此子战斗中,攻击者没有损失,防御者也没有损失2

请注意,不比较第三高的片段。这是因为后卫在一个子战中最多有两个骰子,因此没有第三高的骰子可供比较。

任务

给定攻击者和防御者的未分类骰子掷骰(整数在1到6之间,包括1到6),以任何方便的形式输出每个玩家损失的军队数量。输出可以采用任何方便的形式,只要它具有指示五种可能性的不同输出即可。您必须指出问题中有哪些不同的输出。

输出确定如下:以def=0和开头atk=0。如果攻击者的掷骰子列表的最大值大于防御者的掷骰子列表的最大值,则增加def。否则,增加atk

如果两个骰子列表的长度都至少为2,则:如果攻击者的骰子列表的第二个最大值大于列表的第二个最大值,则递增def,否则递增atk

最后,程序或函数必须为以下5种输出可能性中的每一种输出唯一的标识符:

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

防御者:[3, 2] 攻击者:[2, 4, 1] 防御者3最大为,攻击者最大为44>3因此def=1 ,防守方的2第二是进攻方的是2Not(2>2)所以atk=1。输出可能是[1,1]

测试用例

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]

实施范例

Python 2或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]    

技术指标

  • 输入可以采取任何形式,只要能清楚地编码防御者的掷骰和攻击者的掷骰。
  • 输出可以是为上面列出的五种可能性中的每一种提供唯一输出的任何形式。
  • 防守方掷骰是一组12整数的列表[1,2,3,4,5,6]。攻击者的掷骰是集合中1to 3整数的列表[1,2,3,4,5,6]
  • 由于这是,因此每种语言中最短的代码将获胜!千万不能让高尔夫球语言答案不鼓励你在其他语言中张贴的答案。

在沙盒上看到这个问题,很好的问题
Noah Cristino


如果攻击者的最大掷骰数等于防御者的最大掷骰数,那么攻击者会输,对吗?
Xcoder先生17年

1
是@Xcoder先生,防守者赢得了平局。
fireflame241

因此,我删除了评论:)
Xcoder先生,2017年

Answers:


8

与非门,237

Logisim创建

输入为3位无符号二进制,输入在左侧。输出(2位)在右侧。

它太大而无法容纳在屏幕上,Logisim无法缩放,因此图像是黑白的。对不起:(

适用于所有测试用例。

可能有更好的方法使用一些存储电路来做到这一点,从而可以重用较大的部分。


4

果冻 12  11 字节

NṢ€>/Ṡḟ-o-S

单点链接,其中包含掷骰列表Defender, Attacker(每个都是列表),并返回介于-2和之间的整数2(防御者损失-攻击者损失):

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

在线尝试!或查看测试套件(将结果映射到OP格式)。

怎么样?

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

视网膜,82字节

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

1+D
A
O`.

在线尝试!输入的第一行是攻击者的骰子,第二行是防御者的骰子。返回(在单独的行)AAADDDAD作为合适的。



2

MATL,23字节

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

在线尝试!

不知道为什么允许防御者比攻击者拥有更多的骰子,但也许我对风险一无所知。核心程序就是>t~,sD,所有其他字节都允许不同的输入长度,并进行了一些排序。输入是攻击者,后面是防御者,输出是攻击者损失,然后是防御者损失。

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字节

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

在线尝试!

-4个字节,由于@ovs和@Craig Ayre而得到了固定,由于@Shaggy而得到了
-1个字节


对于一名攻击者对两名防御者而言无效。
尼尔

哦,我没想到。我会解决
WaffleCohn '17

2
可能有效。
ovs '17

@ovs的解决方案通过了所有测试案例,您也可以节省一些字节(tio链接太大):d=>a=>{for(u=v=0;d.sort()>[]&a.sort()>[];)a.pop()>d.pop()?u++:v++;return[u,v]}
Craig Ayre

不需要第一行换行,并且要花一个字节。
毛茸茸的

2

外壳,10字节

M#eI¬¤z>Ö>

在线尝试!

输入为两个独立的纸卷列表,输出如前所述。

说明

¤z>Ö> 按降序对每个列表进行排序,然后将它们压缩以比较相应的元素(并截断较长的列表)。

M#eI¬创建一个2元素列表(e),其中#包含真实值(通过身份I)和虚假值(通过逻辑否定¬)的计数()


1

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

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

在线尝试!

输入:

两行。第一行是防御者(玩家1),第二行是攻击者(玩家2)。各个纸卷之间用空格隔开。

输出:

表示防守方实力与进攻方实力的有效变化。

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

“程序或函数必须为5种输出可能性中的每一种输出唯一的标识符。” 您的[1,1]有两个输出。请修改您的答案以解决此问题(只是排序或求和)
fireflame241

六个怎么了?更具体。:)我以6个字节的成本进行了更改。
Xcali '17


0

R,46个字节

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

在线尝试!

所有这一切都是三类和一个比较……再提取中间的前两个元素。

输入是两个骰子向量。

输出编码如下:

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

之所以可行,是因为R中的提取不会回收其参数,而是将结果NA填充以达到请求的长度。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.