Diberi dua daftar gulungan dadu untuk pertempuran di Risiko, program atau fungsi Anda harus menampilkan berapa banyak pasukan yang hilang setiap pemain.

Latar Belakang

^{Anda tidak harus membaca ini, karena itu hanya latar belakang. Lewati ke "Tugas" subjudul untuk melanjutkan tanpa henti.}

Dalam permainan Risiko , satu pemain dapat menyerang pemain lain (pada kenyataannya, ini diperlukan untuk menang). Hasil pertempuran ditentukan oleh lemparan dadu. Setiap pertempuran terjadi sebagai suksesi dari sub-pertempuran di mana setiap pemain dapat kehilangan 2bagian pasukannya.

Dalam sub-pertempuran, bek dan penyerang masing-masing melempar beberapa dadu yang jumlahnya mungkin bervariasi berdasarkan keadaan yang tidak relevan dengan tantangan ini. Mati penyerang bernilai tertinggi dibandingkan dengan mati bek yang bernilai tertinggi. Jika mati penyerang lebih tinggi dari mati bek, bek kehilangan satu bagian. Jika tidak, penyerang kehilangan satu potong.

Kemudian, jika kedua pemain memiliki setidaknya dua dadu, dadu bernilai tertinggi kedua dari kedua pemain dibandingkan. Sekali lagi, jika mati penyerang lebih tinggi dari mati bek, bek kehilangan satu bagian. Jika tidak, penyerang kehilangan satu potong.

(Defender menang ikatan. Jika bek dan penyerang melempar 4, maka penyerang kehilangan sepotong.)

_{Dalam sub-pertempuran dari artikel Wikipedia ini, dadu penyerang berwarna merah dan dadu pembela putih. Dadu penyerang tertinggi adalah 4dan dadu pembela tertinggi adalah 3. Karena penyerang lebih tinggi, bek kehilangan sepotong. Tertinggi kedua adalah 3untuk penyerang dan 2untuk bek. Karena penyerang sekali lagi lebih tinggi, bek kehilangan bagian lain. Jadi dalam sub-pertempuran ini, penyerang tidak kehilangan bagian dan bek kalah2 bagian.}

Perhatikan bahwa potongan tertinggi ketiga tidak dibandingkan. Ini karena bek tidak memiliki lebih dari dua dadu dalam satu sub-pertempuran, sehingga tidak ada potongan tertinggi ketiga yang bisa dibandingkan.

Tugas

Mengingat gulungan dadu yang tidak disortir (bilangan bulat dalam kisaran 1 hingga 6 inklusif) dari penyerang dan pembela sub-pertempuran Risiko dalam bentuk apa pun yang mudah, mengeluarkan jumlah bidak tentara yang hilang setiap pemain. Outputnya mungkin dalam bentuk apa pun, asalkan memiliki output yang berbeda untuk menunjukkan lima kemungkinan. Anda harus menunjukkan apa output yang berbeda dalam pertanyaan Anda.

Output ditentukan sebagai berikut: Mulai dengan def=0dan atk=0. Jika nilai terbesar dari daftar gulungan dadu penyerang lebih besar dari nilai terbesar dari daftar gulungan dadu dari pembela, maka kenaikan def. Kalau tidak, increment atk.

Jika kedua daftar gulungan dadu memiliki panjang setidaknya 2, maka: jika nilai terbesar kedua dari daftar gulungan dadu penyerang lebih besar dari nilai terbesar kedua dari daftar, maka kenaikan defdan penambahan atk.

Akhirnya, program atau fungsi harus menampilkan pengidentifikasi unik untuk masing-masing dari 5 kemungkinan keluaran berikut:

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

Contoh

Defender: [3, 2] Penyerang: [2, 4, 1] Maksimal bek 3dan maks penyerang adalah 4. 4>3, jadi def=1 Bek 2kedua adalah dan penyerang kedua adalah 2. Not(2>2), Jadi atk=1. Outputnya kemudian bisa [1,1].

Uji Kasus

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]

Implementasi sampel

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

Spesifikasi

• Input dapat diambil sebagai bentuk apa pun yang hanya mengkodekan dengan jelas gulungan pembela dan gulungan penyerang.
• Output mungkin dalam bentuk apa pun yang menyediakan output unik untuk masing-masing dari lima kemungkinan yang tercantum di atas.
• Gulungan bek adalah daftar 1atau 2bilangan bulat di set [1,2,3,4,5,6]. Gulungan penyerang adalah daftar 1untuk 3bilangan bulat di set[1,2,3,4,5,6] .
• Karena ini adalah kode-golf , kode terpendek di setiap bahasa menang! Jangan tidak membiarkan jawaban dalam bahasa golf mencegah Anda dari jawaban postingan dalam bahasa lain.

Gerbang NAND, 237

Dibuat dengan Logisim

Input adalah binary unsigned 3-bit, yang dimasukkan di sebelah kiri. Output (2 bit) ada di sebelah kanan.

Ukurannya terlalu besar untuk dipasangkan di layar dan Logisim tidak dapat memperbesar, jadi gambarnya hitam-putih. Maaf :(

Berfungsi untuk semua kasus uji.

Kemungkinan ada cara yang lebih baik untuk melakukan ini menggunakan beberapa sirkuit memori, yang memungkinkan bagian besar untuk digunakan kembali.

Jelly ,  12  11 byte

NṢ€>/Ṡḟ-o-S

Tautan monadik yang mengambil daftar Defender, Attackergulungan (masing-masing sebagai daftar), mengembalikan bilangan bulat di antara -2dan 2inklusif (kerugian bek - kerugian penyerang):

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

Cobalah online! atau lihat test suite (yang memetakan hasilnya ke format OP).

Bagaimana?

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

Retina , 82 byte

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

1+D
A
O`.

Cobalah online! Baris input pertama adalah dadu penyerang, kedua dadu pemain bertahan. Pengembalian (pada baris yang berbeda) AA, AD, DD, Aatau Dyang sesuai.

Python 2 , 83 75 byte

x=0
k=map(sorted,input())
while all(k):x+=cmp(*map(list.pop,k))or 1
print-x

Cobalah online!

Output adalah kerugian bek - kerugian penyerang

MATL , 23 byte

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

Cobalah online!

Tidak yakin mengapa para pembela dibolehkan lebih banyak dadu daripada penyerang, tetapi mungkin saya tidak terlalu berpengalaman dalam Risiko. Program intinya adalah hanya >t~,sD, semua byte lainnya ada untuk memungkinkan panjang input yang berbeda, dengan sedikit penyortiran. Input adalah penyerang diikuti oleh bek, output adalah kerugian penyerang diikuti oleh kerugian bek.

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.

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]}

Cobalah online!

-4 byte dan diperbaiki berkat @ovs dan @Craig Ayre
-1 byte berkat @Shaggy

Sekam , 10 byte

M#eI¬¤z>Ö>

Cobalah online!

Input sebagai dua daftar roll yang terpisah, output seperti pada op.

Penjelasan

¤z>Ö> mengurutkan masing-masing daftar dalam urutan menurun dan kemudian zip mereka membandingkan elemen yang sesuai (dan memotong daftar yang lebih panjang).

M#eI¬membuat daftar 2-elemen ( e) dengan jumlah ( #) dari nilai-nilai kebenaran (melalui identitas I) dan nilai-nilai palsu (melalui negasi logis ¬)

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

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

Cobalah online!

Memasukkan:

Dua baris. Baris pertama adalah bek (pemain 1), kedua adalah penyerang (pemain 2). Gulungan individual dipisahkan oleh spasi.

Keluaran:

Menunjukkan perubahan efektif dalam kekuatan lawan vs penyerang.

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

Jelly , 30 byte

0,0‘⁸Ṁ€</¤¦‘⁸ḟ"Ṁ€⁺</¤¦⁸L€Ṃ>1¤¡

Cobalah online!

Veeeeeeeery ungolfed! > _ <

Nilai output persis seperti dalam kasus uji.

R , 46 byte

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

Cobalah online!

Semua ini dilakukan adalah tiga macam dan satu perbandingan ... ditambah mengekstraksi dua elemen pertama di tengah.

Input adalah dua vektor gulungan dadu.

Output dikodekan sebagai berikut:

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

Berfungsi karena ekstraksi dalam R tidak mendaur ulang argumennya, tetapi menyesuaikan hasilnya dengan NAuntuk mencapai panjang yang diminta.