Ризикова битва: Зниження


16

З огляду на два списки рулонів кісток для битви за ризик, ваша програма чи функція повинні виводити, скільки військ програє кожен гравець.

Фон

Вам не потрібно це читати, бо це лише фон. Перейдіть до підзаголовка "Завдання", щоб продовжувати роботу без роботи.

У грі ризику один гравець може напасти на іншого гравця (насправді це потрібно для перемоги). Результат бою визначається рухом кісток. Кожен бій відбувається як послідовний підряд, коли кожен гравець може програти до 2армії.

У підраховому бою захисник і нападник кожен перекидає кілька кісток, кількість яких може змінюватись залежно від обставин, що не мають значення для цього виклику. Найвища ціна нападника, що атакується, порівнюється з найвищою ціною загибелі захисника. Якщо загибель нападника вище, ніж загибель захисника, захисник втрачає один шматок. В іншому випадку зловмисник втрачає один шматок.

Потім, якщо в обох гравців принаймні два кубики, порівнюється другий за величиною кісток двох гравців. Знову ж таки, якщо загибель нападника вище, ніж смерть захисника, захисник втрачає один шматок. В іншому випадку зловмисник втрачає один шматок.

(Захисник виграє прив'язки. Якщо і захисник, і нападник переграють 4, тоді нападник втрачає шматок.)

Порівняння кісток

У цьому під-бої зі статті Вікіпедії кістки нападника червоні, а кістки захисника - білі. Найвища кістка нападника, 4а найвища - захисник 3. Оскільки нападник був вищим, захисник втрачає шматок. Другі за висотою - 3для нападника та 2для захисника. Оскільки нападник знову був вище, захисник втрачає ще один шматок. Таким чином, у цій битві нападник не втрачає ні одного шматка, а захисник втрачає 2шматки.

Зауважимо, що треті за розміром шматки не порівнюються. Це тому, що захисник має не більше двох кубиків в одному підраховому бою, тому не існує жодної третьої найвищої фігури для порівняння ніколи.

Завдання

З огляду на несортовані рулони кісток (цілі числа в діапазоні від 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а максимум нападника 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]

Зразок реалізації

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]    

Технічні умови

  • Вхід може бути прийнятий як будь-яка форма, яка чітко кодує лише рулони захисника та рулони нападника.
  • Вихід може бути в будь-якій формі, що забезпечує унікальний вихід для кожної з п'яти перерахованих вище можливостей.
  • Рулони захисника - це перелік 1чи 2цілих чисел у наборі [1,2,3,4,5,6]. Роли атакуючі представляють собою список 1для 3цілих чисел в наборі [1,2,3,4,5,6].
  • Оскільки це , виграє найкоротший код на кожній мові ! Ви НЕ дайте відповіді на мовах гольфу відрадити вас від проводки відповідей на інших мовах.

Побачив це на пісочниці, приємне запитання
Ноа Крістіно


Зловмисник програє, якщо його максимальний крок дорівнює найвищому колу захисника, правда?
Містер Xcoder

1
Так @ Mr.Xcoder, захисник виграє прив'язки.
fireflame241

Тому я видалив коментар :)
Містер Xcoder

Відповіді:


8

NAND ворота, 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]

Спробуйте в Інтернеті! або переглянути тестовий набір (який відображає результати у форматі ОП).

Як?

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

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
-1 байт завдяки @Shaggy


Не працює для одного нападника проти двох захисників.
Ніл

О, хм, я про це не думав. Я це
виправлю

2
Це може спрацювати.
ов

Рішення @ ovs проходить усі тестові випадки, ви також можете зберегти кілька байтів (посилання на tio було занадто великим):d=>a=>{for(u=v=0;d.sort()>[]&a.sort()>[];)a.pop()>d.pop()?u++:v++;return[u,v]}
Craig Ayre

Перший розрив рядка зайвий і коштує вам байта.
Shaggy

2

Лушпиння , 10 байт

M#eI¬¤z>Ö>

Спробуйте в Інтернеті!

Введіть як два окремих списки рулонів, виведіть як у опції.

Пояснення

¤z>Ö> сортує кожен список у порядку зменшення, а потім посилає на них, порівнюючи відповідні елементи (та скорочуючи довший список).

M#eI¬створює двоелементний список ( 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


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щоб дістатися до потрібної довжини.

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.