#PlatziCodingChallenge Dia #30 - Risk

Python

from random import randint
defgame():
    atacante = sorted([randint(1,7) for x in range(3)], reverse=True)
    defensor = sorted([randint(1,7) for x in range(2)], reverse=True)

    print("Atacante:",atacante)
    print("Defensor:",defensor)

    for i in range(2):
        if atacante[i] > defensor[i]:
            diferencia = atacante[i] -defensor[i]
            print(f"Defensor pierde: {diferencia} ({atacante[i]} es mayor que {defensor[i]})")
        elif defensor[i] > atacante[i]:
            diferencia = defensor[i] -atacante[i]
            print(f"Atacante pierde: {diferencia} ({defensor[i]} es mayor que {atacante[i]})")
        else:
            print(f"Empate: ({defensor[i]} y {atacante[i]} son iguales)")

if __name__ == "__main__":
    game()

En Python:

""" Programa para simular dados de Risk y determinar cuantos soldados pierde cada jugador.
Program to simulate Risk dices and determine how many soldiers each player loses. """import random

defcompare_dice_list(attack_dice_list, defense_dice_list):
    soldier_attack_lost = 0
    soldier_defense_lost =0for i in range(0,2):
        if attack_dice_list[i] > defense_dice_list[i]:
            soldier_defense_lost +=1else:
            soldier_attack_lost += 1return soldier_attack_lost, soldier_defense_lost

defroll_dices(dices):
    dice_list = []
    for i in range(0,dices):
        dice = random.randint(1,6)
        dice_list.append(dice)
        print(dice)
    return sorted(dice_list, reverse=1)    

if __name__ == "__main__":
    print('RISK SIMULATOR!!!')
    input('Enter any key to roll the attack dices: ')
    attack_dice_list = roll_dices(3)
    input('Enter any key to roll the defend dices: ')
    defense_dice_list = roll_dices(2)
    print('Attacking dices {} vs {} Defending dices' .format(attack_dice_list[0:2], defense_dice_list))
    soldier_attack_lost, soldier_defense_lost = compare_dice_list(attack_dice_list, defense_dice_list)
    print('Attacking player loses {} soldier(s), defending player loses {} soldier(s).' .format(soldier_attack_lost, soldier_defense_lost))

hola comunidad,

entiendo que cuando el numero es igual, ¿ninguna parte pierte soldados cierto?

Risk en JavaScript y en Python:

//Risk en JavaScriptfunctiontirarDados(numeroDados) {
    let resultados = newArray()
    for (let i = 0; i < numeroDados; i++) {
        resultados.push(Math.ceil(Math.random() * 6))
    }
    return resultados.sort((a, b) => b - a)
}

functionrisk() {
    const ataque = tirarDados(3)
    console.log(`Atacante: ${ataque.join(' ')}`)
    const defensa = tirarDados(2)
    console.log(`Defensor: ${defensa.join(' ')}`)
    let soldadosPerdidosAtacante = 0let soldadosPerdidosDefensor = 0for (const i in [0, 1]) {
        if (ataque[i] > defensa[i]) {
            soldadosPerdidosDefensor++
        } else {
            soldadosPerdidosAtacante++
        }
    }
    console.log(`Atacante pierde ${soldadosPerdidosAtacante} soldado(s)`)
    console.log(`Defensor pierde ${soldadosPerdidosDefensor} soldado(s)`)
}

//Ejecutando la función
risk()
/* Atacante: 5 3 2 (numeros aleatorios)
Defensor: 6 2 (numeros aleatorios)
Atacante pierde 1 soldado(s)
Defensor pierde 1 soldado(s) */

# Risk en Pythonfrom random import choice

deftirarDados(numeroDados):
    resultados = []
    for i in range(0, numeroDados):
        resultados.append(choice(range(1, 7)))
    return resultados

defrisk():
    ataque = tirarDados(3)
    print('Atacante: {}'.format(ataque))
    defensa = tirarDados(2)
    print('Defensor: {}'.format(defensa))
    soldadosPerdidosAtacante = 0
    soldadosPerdidosDefensor = 0for i in [0, 1]:
        if ataque[i] > defensa[i]:
            soldadosPerdidosDefensor += 1else:
            soldadosPerdidosAtacante += 1
    print('Atacante pierde {} soldado(s)'.format(soldadosPerdidosAtacante))
    print('Defensor pierde {} soldado(s)'.format(soldadosPerdidosDefensor))

risk()
# Atacante: [5, 5, 6]# Defensor: [5, 6]# Atacante pierde 2 soldado(s)# Defensor pierde 0 soldado(s)

Risk en java ☕️ ☕️ 😃

public class Risk {
    public static void main(String[] args) {
        Integer[] arrayAtacante = new Integer[3];
        Integer[] arrayDefensor = new Integer[2];int numMayorA, numA;int numMayorD, numD;int defensor, atacante;//Llenar el array del atacantefor (int i = 0; i < arrayAtacante.length; i++) {
            arrayAtacante[i] = (int) ((Math.random() * (6 - 1 + 1)) + 1);
        }
        //Llenar el array del defensorfor (int i = 0; i < arrayDefensor.length; i++) {
            arrayDefensor[i] = (int) ((Math.random() * (6 - 1 + 1)) + 1);
        }
        //Ordenarlos de mayor a menor
        Arrays.sort(arrayAtacante, Collections.reverseOrder());
        Arrays.sort(arrayDefensor, Collections.reverseOrder());

        numMayorA = arrayAtacante[0];
        numA = arrayAtacante[1];

        numMayorD = arrayDefensor[0];
        numD = arrayDefensor[1];System.out.println("Atacante" + Arrays.toString(arrayAtacante));System.out.println("Defensor" + Arrays.toString(arrayDefensor));if (numMayorA > numMayorD && numA > numD) {
            defensor = numMayorA - numMayorD;
            defensor += numA - numD;System.out.println("El defensor pierde: " + defensor);
        } elseif (numMayorA > numMayorD && numA < numD) {
            defensor = numMayorA - numMayorD;
            atacante = numD - numA;System.out.println("El atacante pierde:" + atacante + " y el defensor:" + defensor);
        } elseif (numMayorA < numMayorD && numA > numD) {
            atacante = numMayorD - numMayorA;
            defensor = numA - numD;System.out.println("El defensor pierde:" + defensor + " y el atacante:" + atacante);
        } elseif (numMayorA < numMayorD && numA < numD){
            atacante = numMayorD - numMayorA;
            atacante += numD - numA;System.out.println("El atacante pierde:" + atacante);
        } elseif (numMayorA == numMayorD && numA > numD) {
            defensor = numA - numD;System.out.println("El defensor pierde:" + defensor);
        } elseif (numMayorA == numMayorD && numA < numD) {
            atacante = numD - numA;System.out.println("El atacante pierde:" + atacante);
        } elseif (numMayorA == numMayorD) {
            System.out.println("Los números son iguales, la regla dice que gana el defensor");
        }

        //System.out.println("El defensor pierde:" + (defensor));//System.out.println("El atacante pierde");
    }
}

Resultado del programa

My solution on Python. 🐍

import random
numbers = [1, 2, 3, 4, 5, 6]


def generate_dices(number_of_dices):
    dices = []
    for _ inrange(number_of_dices):
        dice = random.choice(numbers)
        dices.append(dice)
    
    return dices


def compare_players(dices_1, dices_2):
    dices_1.sort(reverse = True)
    dices_2.sort(reverse = True)

    print(f'Attacker dices: {dices_1}')
    print(f'Defender dices: {dices_2}')

    challenge_1 = dices_1[0] - dices_2[0]
    challenge_2 = dices_1[1] - dices_2[1]

    return challenge_1, challenge_2


def select_looser(result):
    ifresult == 0:
        message = "Tie."elifresult > 0:
        points = abs(result)
        message = f'Defender looses {points} points.'
    elifresult < 0:
        points = abs(result)
        message = f'Attacker looses {points} points.'
        
    return message


def run():
    player_1_dices = generate_dices(3)
    player_2_dices = generate_dices(2)
    result_1, result_2 = compare_players(player_1_dices, player_2_dices)
    winner1 = select_looser(result_1)
    winner2 = select_looser(result_2)
    print(winner1)
    print(winner2)

if __name__ == "__main__":
    run()

Mi solución en JS y C.

https://github.com/ceporro/PlatziCodingChallenge/tree/master/Day 30

Risk en Python 😃

import random
dado1=[1,2,3,4,5,6]
dado2=[1,2,3,4,5,6]
dado3=[1,2,3,4,5,6]
dado4=[1,2,3,4,5,6]
dado5=[1,2,3,4,5,6]
ataque1=random.choice(dado1)
ataque2=random.choice(dado2)
ataque3=random.choice(dado3)
ataque4=random.choice(dado4)
ataque5=random.choice(dado5)
print(f'El dado 1 del atacante salió {ataque1}')print(f'El dado 2 del atacante salió {ataque2}')print(f'El dado 3 del atacante salió {ataque3} (numero de soldados)')print(f'El dado 1 del defensor salió {ataque4}')print(f'El dado 2 del defensor salió {ataque5}')if ataque1<ataque4:
    res1='atacante'
elif ataque1>ataque4:
    res1='defensor'
elif ataque1==ataque4:
    res1='atacante'#empate en 1else:
    pass
if ataque2<ataque5:
    res2='atacante'
elif ataque2>ataque5:
    res2='defensor'
elif ataque2==ataque5:
    res2='atacante'else:
    pass
if res1==res2:
    print(f'El {res1} pierde {ataque3} soldados')
else:
    print(f'El {res1} pierde {ataque3} soldados y {res2} pierde {ataque3} soldados')```

Mi solución en JS:

//La funcion recibe dos arreglos con los resultados de los dadosfunctionrisk(attacker, defender) {
  let attackerSoldiersLost = 0;
  let defenderSoldiersLost = 0;
  //Ordena los dados del atacante de mayor a menor para compararlos con el defensor
  attacker.sort((a, b) => b - a);

  //comparaciónfor (let i = 0; i < 2; i++) {
    if (attacker[i] > defender[i]) {
      defenderSoldiersLost += 1;
    } elseif (attacker[i] < defender[i]) {
      attackerSoldiersLost += 1;
    }
  }

  console.log(`Attacker soldiers lost: ${attackerSoldiersLost}`);
  console.log(`Defender soldiers lost: ${defenderSoldiersLost}`);
}

const atacante = [5, 3, 1];
const defensor = [4, 4];
risk(atacante, defensor);

Reto: Use unas imagenes, aquí dejaré el código, y también aquí la página: https://risk.imfast.io/

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Risk</title></head><style>
  * {
    margin: 0;
    padding: 0;
  }

  .contenedor {
    width: 100%;
    height: 100vh;
    min-width: 750px;
    display: grid;
    grid-template-columns: 50%50%;
    grid-template-rows: 85%15%;
    grid-template-areas: 
    "atacante defensor""botonContainer botonContainer";
  }

  .centrado {
    display: flex;
    flex-flow: column;
    align-items: center;
    justify-content: space-around;
  }

  #atacante {
    background-color: rgba(0, 247, 255, 0.253);
    grid-area: atacante;
  }

  #defensor {
    background-color: rgba(255, 0, 0, 0.253);
    grid-area: defensor;
  }

  #botonContainer {
    background-color: coral;
    grid-area: botonContainer;
  }

  .btn {
    margin: 8px;
    border-radius: 15px;
    outline: none;
    font-size: 36px;
    border: none;
    color: #000504;
    text-align: center;
    padding: 16px;
  }

  .btn:hover {
    cursor: pointer;
    background-color: rgba(0, 0, 0, 0.397);
    color: white;
    transform: scale(1.1);
  }
  
</style><bodyid='body'><divclass="contenedor"><divclass='centrado'id='atacante'><h3>Atacante</h3></div><divclass='centrado'id='defensor'></div><divclass='centrado'id='botonContainer'><buttonclass="btn"type="button"onclick="jugar()">Jugar</button></div></div><script>const img1 = new Image(); img1.src = './utils/lado1.png'const img2 = new Image(); img2.src = './utils/lado2.png'const img3 = new Image(); img3.src = './utils/lado3.png'const img4 = new Image(); img4.src = './utils/lado4.png'const img5 = new Image(); img5.src = './utils/lado5.png'const img6 = new Image(); img6.src = './utils/lado6.png'functionjugar(){
      const atacante = document.getElementById('atacante')
      const defensor = document.getElementById('defensor')
      atacante.innerHTML = ''
      defensor.innerHTML = ''let attack = []
      let defense = []

      for (let i = 0; i < 3; i++){
        attack.push(Math.floor(Math.random()*6)+ 1)
      }
      for (let i = 0; i < 2; i++){
        defense.push(Math.floor(Math.random()*6)+ 1)
      }

      attack.sort((a, b) => b - a)
      defense.sort((a, b) => b - a)

      console.log(attack, defense)

      attack.map( diceFace => {
        cara(diceFace, atacante)
      })
      defense.map( diceFace => {
        cara(diceFace, defensor)
      })

      setTimeout(() => {
        resultado(attack, defense)
      }, 200);
    }

    functioncara(caraDado, jugador) {
      switch(caraDado){
        case1:
          const image1 = img1.cloneNode()
          jugador.appendChild(image1)
          break;
        case2:
          const image2 = img2.cloneNode()
          jugador.appendChild(image2)
          break;
        case3:
          const image3 = img3.cloneNode()
          jugador.appendChild(image3)
          break;
        case4:
          const image4 = img4.cloneNode()
          jugador.appendChild(image4)
          break;
        case5:
          const image5 = img5.cloneNode()
          jugador.appendChild(image5)
          break;
        case6:
          const image6 = img6.cloneNode()
          jugador.appendChild(image6)
          break;
      }
    }

    functionresultado(attack, defense) {
      if (attack[0] > defense[0]){
        alert(`El Atacante saco ${attack[0]} y el Defensor ${defense[0]}, por ende gana el atacante`)
      } elseif (attack[0] < defense[0]){
        alert(`El Atacante saco ${attack[0]} y el Defensor ${defense[0]}, por ende gana el defensor`)
      } else {
        alert(`El Atacante saco ${attack[0]} y el Defensor ${defense[0]}, por ende es un empate`)
      }

      if (attack[1] > defense[1]){
        alert(`El Atacante saco ${attack[1]} y el Defensor ${defense[1]}, por ende gana el atacante`)
      } elseif (attack[1] < defense[1]){
        alert(`El Atacante saco ${attack[1]} y el Defensor ${defense[1]}, por ende gana el defensor`)
      } else {
        alert(`El Atacante saco ${attack[1]} y el Defensor ${defense[1]}, por ende es un empate`)
      }
    }
  </script></body></html>

En C#

using System;

namespace Reto_31_Risk
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] atacante = new int[3];int[] defensor = new int[2];

            tirarDados(atacante, defensor);
            bubbleSort(atacante, defensor);
            imprimirDados(atacante, defensor);
            juego(atacante,defensor);
        }
        static void juego(int[] atacante, int[] defensor)
        {
            for(int i = 0; i < 2; i++)
            {
                if (atacante[i] > defensor[i])
                {
                    Console.WriteLine("atacante gana ronda " + (i+1));
                }elseif(atacante[i] < defensor[i])
                {
                    Console.WriteLine("defensor gana ronda " + (i+1));
                }
                else
                {
                    Console.WriteLine("Empate en la ronda " + (i+1));
                }
            }
        }
        static void tirarDados(int[] atacante, int[] defensor)
        {
            for (int i = 0; i < atacante.Length; i++)
            {
                Random random = new Random();int numero = random.Next(10);
                atacante[i] = numero;
            }
            for (int i = 0; i < defensor.Length; i++)
            {
                Random rd = new Random();int numero2 = rd.Next(10);
                defensor[i] = numero2;
            }
        }

        static void bubbleSort(int[] atacante, int[] defensor)
        {
            bool cambio = true;while (cambio)
            {
                cambio = false;for (int i = 0; i < (atacante.Length) - 1; i++)
                {
                    if (atacante[i] < atacante[i + 1])
                    {
                        int aux = atacante[i];
                        atacante[i] = atacante[i + 1];
                        atacante[i + 1] = aux;
                        cambio = true;
                    }
                }
            }
            for (int i = 0; i < (defensor.Length) - 1; i++)
            {
                if (defensor[i] < defensor[i + 1])
                {
                    int aux = defensor[i];
                    defensor[i] = defensor[i + 1];
                    defensor[i + 1] = aux;
                }
            }

        }

        static void imprimirDados(int[] atacante, int[] defensor)
        {
            string linea = "atacante= ";for (int i = 0; i < atacante.Length; i++)
            {
                linea += atacante[i] + " ";
            }
            Console.WriteLine(linea);
            string linea2 = "defensor= ";for (int i = 0; i < defensor.Length; i++)
            {
                linea2 += defensor[i] + " ";
            }
            Console.WriteLine(linea2);
        }
    }
}

Reto 30: Risk
Repositorio del reto: PlatziCodingChallengeRepo
GitHub pages: PlatziCodingChallengePages

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><metahttp-equiv="X-UA-Compatible"content="IE=edge"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Reto 30: Risk</title></head><style>body {
		display: flex;
		flex-direction: column;
		align-items: center;
	}
</style><body><h1>Risk</h1><h2>Atacante</h2><buttonid="atacante"type="button"onclick="handleAtacante()">Lanza los dados</button><h2id="result1"></h2><h2>Defensor</h2><buttonid="defensor"type="button"onclick="handleDefensor()">Lanza los dados</button><h2id="result2"></h2><h2id="result"></h2><script>let dados = 6;
		let atacante = [];
		let defensor = [];
		functionsimulador(repeat) {
			let random, values = [];
			for (let i = 0; i < repeat; i++) {
				random = 0;
				while (random === 0) {
					random = Math.floor(Math.random() * 6);
				}
				values.push(random);
			}

			return values;
		}
		functionmayorNumero(array) {
			let numero = 0;
			let indice;
			array.map((item, key) => {
				if (item > numero) {
					numero = item;
					indice = key;
				}
			});
			return indice;
		}
		functioncomparar(atacante, defensor) {
			let message1 = "";
			let message2 = "";
			let message3 = "";
			let cont1 = 0; cont2 = 0;
			for (let i = 0; i < 2; i++) {
				numero1 = atacante.splice(mayorNumero(atacante), 1);
				numero2 = defensor.splice(mayorNumero(defensor), 1);
				if (numero1 < numero2) {
					cont1++;
					if (message1 !== "") {
						message1 = message1.replace(":cont", 2);
						message1 = message1.replace(":message", ` y ${numero2} es mayor que ${numero1}`);
					} else {
						message1 = `El atacante pierde :cont (${numero2} es mayor que ${numero1}:message)`;
					}
				} elseif (numero2 < numero1) {
					cont2++;
					if (message2 !== "") {
						message2 = message2.replace(":cont", 2);
						message2 = message2.replace(":message", ` y ${numero1} es mayor que ${numero2}`);
					} else {
						message2 = `El defensor pierde :cont (${numero1} es mayor que ${numero2}:message)`;
					}
				} else {
					if (message3 !== "") {
						message3 = message3.replace(":message", ` y ${numero1} es igual que ${numero2}`);
					} else {
						message3 = `Ni defensor ni atacante pierden (${numero1} es igual que ${numero2}:message)`;
					}
				}
			}
			if (cont1 === 1)
				message1 = message1.replace(":cont", cont1);
			else
				message1 = message1.replace(":cont", "").replace(":message", "");
			if (cont2 === 1)
				message2 = message2.replace(":cont", cont2);
			else
				message2 = message2.replace(":cont", "").replace(":message", "");
			message1 = message1.replace(":message", "");
			message2 = message2.replace(":message", "");
			message3 = message3.replace(":message", "");
			return message1 + " " + message2 + " " + message3;
		}

		functionjugar(jugador) {
			if (jugador === 'atacante') {
				let result1 = document.getElementById("result1");
				atacante = simulador(3);
				result1.innerHTML = atacante.join(' ');
			} else {
				let result2 = document.getElementById("result2");
				defensor = simulador(2);
				result2.innerHTML = defensor.join(' ');
			}
			if (atacante.length > 0 && defensor.length > 0) {
				let result = document.getElementById("result");
				let message = comparar(atacante, defensor);
				result.innerHTML = message;
				limpiar();
			}
		}
		functionlimpiar() {
			atacante = [];
			defensor = [];
		}
		functionhandleAtacante() {
			atacante = [];
			jugar("atacante");
		}
		functionhandleDefensor() {
			defensor = [];
			jugar("defensor");
		}
	</script></body></html>