위험 전투 : 추락


16

Risk에서 전투에 사용할 주사위 목록이 두 개라면, 프로그램이나 기능은 각 플레이어가 잃은 부대 수를 출력해야합니다.

배경

당신은 이것을 읽을 필요가 없습니다. 단지 배경 일뿐입니다. 줄이지 않고 계속 진행하려면 "작업"부제목으로 건너 뛰십시오.

Risk 게임에서는 한 플레이어가 다른 플레이어를 공격 할 수 있습니다 (사실,이기는 데 필요합니다). 전투 결과는 주사위 굴림에 의해 결정됩니다. 모든 전투는 각 플레이어 2가 자신의 군대 를 잃을 수있는 하위 전투의 연속으로 발생합니다 .

서브 배틀에서 수비수와 공격자는 각각이 도전과 관련이없는 상황에 따라 숫자가 다를 수있는 여러 주사위를 굴립니다. 공격자의 최고 가치 주사위는 방어자의 최고 가치 주사위와 비교됩니다. 공격자의 주사위가 방어자의 주사위보다 높으면 방어자는 한 조각을 잃습니다. 그렇지 않으면 공격자가 한 조각을 잃습니다.

그런 다음 두 선수가 둘 이상의 주사위를 가지고 있다면 두 선수 중 두 번째로 높은 주사위를 비교합니다. 공격자의 주사위가 방어자의 주사위보다 높으면 방어자는 한 조각을 잃습니다. 그렇지 않으면 공격자가 한 조각을 잃습니다.

(수비수는 동점입니다. 수비수와 공격자가 모두를 굴리면 4공격자는 조각을 잃습니다.)

주사위 비교

Wikipedia 기사 의이 하위 전투에서 공격자의 주사위는 빨간색이고 방어자의 주사위는 흰색입니다. 공격자의 주사위 4중 최고가이고 수 비자의 최고가입니다 3. 공격자가 높을수록 수비수는 한 조각을 잃습니다. 두 번째로 높은 것은 3공격자와 2방어자를위한 것입니다. 공격자가 다시 높아졌기 때문에 방어자는 다른 조각을 잃습니다. 따라서이 하위 전에서 공격자는 조각을 잃지 않고 방어자는 2조각을 잃는다 .

세 번째로 높은 조각은 비교되지 않습니다. 수비수가 하나의 서브 배틀에서 주사위를 2 개 이상 가지고 있지 않기 때문에 비교할 수있는 가장 높은 조각이 없습니다.

직무

공격자와 수비수의 하위 전투의 방어자 모두가 편리한 형태로 분류되지 않은 주사위 롤 (1 ~ 6 범위의 정수)을 고려할 때 각 플레이어가 잃은 군대 조각의 수를 출력하십시오. 출력은 5 가지 가능성을 나타내는 다른 출력을 갖는 한 편리한 형태 일 수있다. 질문에 다른 결과가 무엇인지 표시해야합니다.

출력은 다음과 같이 결정됩니다 . 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최대이고 최대 수비수는 입니다 4. 4>3따라서 def=1 두 번째 수비수는 두 번째 수비수 2입니다 2. Not(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]

샘플 구현

파이썬 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]    

명세서

  • 입력은 명확하게 인코딩 어떤 형태로 할 수있다 에만 수비수의 롤과 공격자의 롤.
  • 출력은 위에 나열된 5 가지 가능성 각각에 대해 고유 한 출력을 제공하는 모든 형식 일 수 있습니다.
  • 수비수의 롤은 세트의 목록 1또는 2정수입니다 [1,2,3,4,5,6]. 공격자의 롤의 목록입니다 13세트의 정수 [1,2,3,4,5,6].
  • 이것은 이므로 각 언어에서 가장 짧은 코드 승리합니다! 마십시오 하지 골프의 언어로 답변을 다른 언어로 게시 답변에서 당신을 낙담 할 수 있습니다.

샌드 박스에서 이것을 보았습니다. 좋은 질문
Noah Cristino


최대 롤이 수비수의 최고 롤과 같으면 공격자가 패배합니다.
Mr. Xcoder

1
예, Mr.Xcoder, 수비수 가 동점입니다.
fireflame241

따라서 나는 의견을 삭제했다 :)
Mr. Xcoder

답변:


8

낸드 게이트, 237

Logisim으로 생성

입력은 3 비트 부호없는 이진수이며 왼쪽에 입력됩니다. 출력 (2 비트)은 오른쪽에 있습니다.

화면에 맞지 않아 너무 커서 Logisim에서 확대 / 축소 할 수 없으므로 이미지가 흑백입니다. 죄송합니다 :(

모든 테스트 사례에서 작동합니다.

일부 메모리 회로를 사용하여 더 나은 방법을 사용하여 큰 섹션을 재사용 할 수 있습니다.


4

젤리 ,  12  11 바이트

NṢ€>/Ṡḟ-o-S

목록 복용 모나드 링크 Defender, Attacker사이의 정수를 반환 롤 (목록 등 각) -22(앞뒤로 손실 - 공격자 손실)을 포함 :

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`.

온라인으로 사용해보십시오! 첫 번째 입력 라인은 공격자의 주사위이고, 두 번째 입력은 방어자의 주사위입니다. (별도의 줄에) 반환 AA, AD, DD, A또는 D적절.



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

자바 스크립트 (SpiderMonkey) , 97 83 78 바이트

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

온라인으로 사용해보십시오!

@ovs 및 @Craig Ayre 덕분에 -4 바이트 및 고정 @Shaggy 덕분에
-1 바이트


두 명의 방어자에 대해 한 명의 공격자에게는 작동하지 않습니다.
Neil

오, 나는 그것에 대해 생각하지 않았다. 수정하겠습니다
WaffleCohn

2
작동 할 수 있습니다.
ovs

@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>Ö>

온라인으로 사용해보십시오!

두 개의 별도 롤 목록으로 입력하고 op에서와 같이 출력합니다.

설명

¤z>Ö> 각 목록을 내림차순으로 정렬 한 다음 해당 요소를 비교하여 더 긴 목록을 자릅니다.

M#eI¬진실성 값 (정체성 )과 허위 값 (논리적 부정 )의 e수 ( #)로 2 요소 목록 ( )을 만듭니다.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에 무슨 문제가 있습니까? 더 구체적입니다. :) 6 바이트의 비용으로 변경했습니다.
Xcali


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요청 된 길이에 도달하기 위해 결과 를 채 웁니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.