Учитывая два списка бросков костей для битвы в Риск, ваша программа или функция должны выводить, сколько войск теряет каждый игрок.
Фон
Вам не нужно читать это, потому что это просто фон. Перейдите к подзаголовку «Задача», чтобы продолжить без изменений.
В игре Risk один игрок может атаковать другого игрока (на самом деле это необходимо для победы). Исход битвы определяется броском костей. Каждое сражение происходит как последовательность под-сражений, в которых каждый игрок может потерять 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]
. - Поскольку это код-гольф , выигрывает самый короткий код на каждом языке ! Вы не дайте ответы на языках гольфа отговорить вас от проводки ответов на других языках.
источник
Ответы:
NAND Gates, 237
Создано с Logisim
Входы являются 3-битными беззнаковыми двоичными данными, вводится слева. Выходы (2 бита) находятся справа.
Он слишком большой, чтобы поместиться на экране, и Logisim не может увеличить изображение, поэтому изображение черно-белое. Извини :(
Работает для всех тестовых случаев.
Вероятно, есть лучший способ сделать это с использованием некоторой схемы памяти, позволяющей повторно использовать большие разделы.
источник
Желе ,
1211 байтМонадическая ссылка, содержащая список
Defender, Attacker
бросков (каждый в виде списков), возвращающий целое число между-2
и2
включительно (потери защитника - потери атакующего):Попробуйте онлайн! или посмотрите набор тестов (который отображает результаты в формат OP).
Как?
источник
Сетчатка , 82 байта
Попробуйте онлайн! Первая строка ввода - игральные кости атакующего, вторая - игральные кости защитника. Возвращает (на отдельных линиях)
AA
,AD
,DD
,A
илиD
в зависимости от обстоятельств.источник
Python 2 ,
8375 байтПопробуйте онлайн!
Выход - потери защитника - потери атакующего
источник
MATL , 23 байта
Попробуйте онлайн!
Не знаю, почему защитникам разрешено больше кубиков, чем атакующим, но, возможно, я не очень хорошо разбираюсь в риске. Основная программа проста
>t~,sD
, все остальные байты предназначены для разной длины ввода, с добавлением небольшого количества сортировки. За входом следует атакующий, затем защитник, выходные данные - потери атакующего, за которыми следуют потери защитника.источник
JavaScript (SpiderMonkey) ,
978378 байтПопробуйте онлайн!
-4 байта и исправлено благодаря @ovs и @Craig Ayre
-1 байт благодаря @Shaggy
источник
d=>a=>{for(u=v=0;d.sort()>[]&a.sort()>[];)a.pop()>d.pop()?u++:v++;return[u,v]}
Шелуха , 10 байт
Попробуйте онлайн!
Ввод в виде двух отдельных списков рулонов, вывод, как в оп.
объяснение
¤z>Ö>
сортирует каждый список по убыванию, а затем архивирует их, сравнивая соответствующие элементы (и обрезая длинный список).M#eI¬
создает 2-элементный список (e
) с#
count ( ) истинных значений (через идентичностьI
) и ложных значений (через логическое отрицание¬
)источник
Perl 5 , 66 + 1 (-a) = 67 байт
Попробуйте онлайн!
Входные данные:
Две строчки Первая строка - защитник (игрок 1), вторая - атакующий (игрок 2). Отдельные рулоны разделены пробелами.
Выход:
Указывает на эффективное изменение силы защитника по сравнению с атакующим.
источник
Желе , 30 байт
Попробуйте онлайн!
Веееееееее, разгулялся! > _ <
Выводит значения в точности как в тестовых примерах.
источник
R , 46 байт
Попробуйте онлайн!
Все это делает три вида и одно сравнение ... плюс извлечение первых двух элементов в середине.
Ввод двух векторов бросков костей.
Выход кодируется следующим образом:
Работает, потому что извлечение в R не перезагружает свой аргумент, но дополняет результат
NA
до нужной длины.источник