Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Switch

13/22
Recursos

Aportes 1931

Preguntas 77

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Este es mi reto completo del juego piedra-papel-tijera. Obviamente me apoyé de otros videos también para poder lograr entender el tema de las funciones que hasta ahora no lo habíamos visto en el curso 😅 , pero estaba super obsesionada por hacerlo completo y por eso me tomé varios días jajaja.

https://dnfloresc.github.io/rock-paper-scissors-/ (proyecto)
https://github.com/dnfloresc/rock-paper-scissors- (repo)

vamos avanzando""" : )

var pregunta = prompt("Ingresa tu opción: piedra, papel o tijera "); 
var user = pregunta.toLowerCase();
var options = ["piedra", "papel", "tijera"];
var machine = options[Math.floor(Math.random() * 3)];


// let numero = 'a';
//con true los casos van a pasar 
switch (true) {
    case (user === machine):
        console.log('es un empate');
        break;
    case (machine === 'piedra' && user === 'papel'):
        console.log('Ganaste')
        break;
    case (machine === 'papel'  && user === 'tijera'):
        console.log('Ganaste')
        break;
    case (machine === 'tijera' && user === 'piedra'):
        console.log('Ganaste')
        break;
    default:
        console.log('¡Perdiste!');       
}

Aquí dejare mi resultado 😃

Puedes ver el código en este repositorio

Puedes ver la página en este link

Básicamente un switch es como un if pero diferente en su sintaxis y su uso, pero fuera de algunas ocasiones son muy parecidos.

¿Como usar switch?
- La sintaxis de switch es:

switch('valor a validar') {
	case 'opción 1':
				'acción a realizar';
				break;
	}

(El uso de break es importante, ya que si no lo pones accionara todas las opciones dentro del switch, digamos que es como un puente, si no lo pones vas a tener que caminar por un lugar donde cada ‘case’ es una autopista más, mientras que break es un puente directo hacia la siguiente acera).

Un ejemplo seria:

let dia = "Martes";

switch(dia) {
	case "Lunes":
		console.log("Hoy es Lunes");
		break;
	case "Martes":
		console.log("Hoy es Martes");
		break;
	case "Miercoles":
		console.log("Hoy es Miercoles");
		break;
	case "Jueves":
		console.log("Hoy es Jueves");
		break;
	case "Viernes":
		console.log("Hoy es Viernes");
		break;
	case "Sabado":
		console.log("Hoy es Sabado");
		break;
	case "Domingo":
		console.log("Hoy es Domingo");
		break;
	default:
		console.log("Es el fin de los dias");
}

En el caso de que ninguna de las opciones dentro del switch sea la correcta tenemos 2 opciones por hacer que son:

  1. Dejar el código seguir sin hacer nada.

  2. Utilizar default que es como si utilizáramos un else pero para switch.

Este es mi aporte, Si te ayudo dale corazón para que más puedan aprender y si tuve algún error coméntamelo para yo también poder aprender. Gracias.

/* Piedra: 0, papel: 1 o tijera: 2
 parámetros: p = persona, pc = computadora */

// Versión 1: Aunque esta versión es más larga, refleja la verdadera utilidad de un switch
function jugar(p, pc) {
    switch (p) {
        case 0:
            switch (pc) {
                case 0:
                    console.log("Empate");
                    break;
                case 1:
                    console.log("Pierdes");
                    break;
                default:
                    console.log("Ganas");
                    break;
            }
            break;
        case 1:
            switch (pc) {
                case 0:
                    console.log("Ganas");
                    break;
                case 1:
                    console.log("Empate");
                    break;
                default:
                    console.log("Pierdes");
                    break;
            }
            break;
        default:
            switch (pc) {
                case 0:
                    console.log("Pierdes");
                    break;
                case 1:
                    console.log("Ganas");
                    break;
                default:
                    console.log("Empate");
                    break;
            }
            break;
    }
}

// Versión 2
function jugar(p, pc) {
    switch (true) {
        case p === pc:
            console.log("Empate");
            break;
        case p === 0 && pc !== 1:
            console.log("Ganas");
            break;
        case p === 1 && pc !== 2:
            console.log("Ganas");
            break;
        case p === 2 && pc !== 0:
            console.log("Ganas");
            break;
        default:
            console.log("Pierdes");
            break;
    }
}

// Versión 3
function jugar(p, pc) {
    switch (true) {
        case p === pc:
            console.log("Empate");
            break;
        case (p === 0 && pc !== 1) || (p === 1 && pc !== 2) || (p === 2 && pc !== 0):
            console.log("Ganas");
            break;
        default:
            console.log("Pierdes");
            break;
    }
}```

El hacer este reto yo sólo la verdad me hizo sentir muy contento :'v

<var tijeras = "tijeras";
var piedra = "piedra";
var papel = "papel";

function resultadoGanador(user, cpu) {
    switch (true) {
        case user === cpu :
            console.log("Empate")
        break;
        case user === "tijeras" && cpu === "papel" :
            console.log("Ganaste")
        break;
        case user === "piedra" && cpu === "tijeras" :
            console.log("Ganaste")
        break;
        case user === "papel" && cpu === "piedra" :
            console.log("Ganaste")
        break;
        default: 
            console.log("Perdiste")
    }
}>

Así quedó mi reto utilizando switch

function playGame (human, machine) {
    switch(human){
        case "rock":
            switch(machine){
                case "scissors":
                    console.log("You win!");
                    break;
                case "paper":
                    console.log("You lose!"); 
                    break;
                default:
                    console.log("Its a tie!"); 
                    break;
            }
            break;
        case "paper":
            switch(machine){
                case "rock":
                    console.log("You win!"); 
                    break;
                case "scissors":
                    console.log("You lose!"); 
                    break;
                default:
                    console.log("Its a tie!"); 
                    break;
            }
            break;
        case "scissors":
            switch(machine){
                case "paper":
                    console.log("You win!"); 
                    break;
                case "rock":
                    console.log("You lose!"); 
                    break;
                default:
                    console.log("Its a tie!"); 
                    break;
            }
            break;
    }
    console.log("H:" + human +" M:"+ machine);
}

var options = ["rock", "paper", "scissors"];
var machine = options[Math.floor(Math.random() * options.length)];
var choice = prompt("Enter your choice 1-rock, 2-paper or 3-scissors.");

playGame(options[choice-1], machine);

yo lo pude hacer pero con if alguien sabe como hacerlo con switch? 😦

var opciones = [0, 1, 2];
var eleccionMaquina;

function aleatorio(){
var numero = Math.floor(Math.random()*3);
return numero;
}

function usuario(eleccionUsuario){
eleccionUsuario = parseInt(eleccionUsuario);
eleccionMaquina = aleatorio(0,2);

if(eleccionUsuario == 0){//el usuario eligio piedra 
    if(opciones[eleccionMaquina] == 1){//si la maquina eligio papel 
        document.getElementById('efecto').innerHTML ='<h1>¡Perdiste :(!</h1> <h3>La Compu eligio papel y tu piedra.</h3>';
    }else{
        if(opciones[eleccionMaquina] == 2){
            document.getElementById('efecto').innerHTML ='<h1>¡Ganaste! :D </h1> <h3>La Compu eligio tijera y tu piedra.</h3>';
        }else{
            if(opciones[eleccionMaquina] == 0){
                document.getElementById('efecto').innerHTML ='<h1>¡Empate D:!</h1> <h3>Ambos eligieron piedra.</h3>';
            }
        }
    } 
}

if(eleccionUsuario == 1){//el usuario eligio papel 
    if(opciones[eleccionMaquina] == 2){
        document.getElementById('efecto').innerHTML ='<h1>¡Perdiste :(!</h1> <h3>La Compu eligio tijera y tu papel.</h3>';
    }else{
        if(opciones[eleccionMaquina] == 0){
            document.getElementById('efecto').innerHTML ='<h1>¡Ganaste :D!</h1> <h3>La compu eligio piedra y tu papel.</h3>';
            
        }else{
            if(opciones[eleccionMaquina] == 1){
                document.getElementById('efecto').innerHTML ='<h1>¡Empate D:!</h1> <h3>Ambos eligieron papel.</h3>'; 
            }
        }
    }
}

if(eleccionUsuario == 2) {//el usuario eligio tijera 
    if(opciones[eleccionMaquina] == 1){
        document.getElementById('efecto').innerHTML ='<h1>¡Ganaste :D!</h1> <h3>La maquina eligio papel y tu tijera.</h3>';
    
    }else{
        if(opciones[eleccionMaquina] == 0){
            document.getElementById('efecto').innerHTML ='<h1>¡Perdiste :(!</h1> <h3>La maquina eligio piedra y tu tijera.</h3>'; 
        }else{
            if(opciones[eleccionMaquina] == 2) {
                document.getElementById('efecto').innerHTML ='<h1>¡Empate D:!</h1> <h3>Ambos eligieron tijera.</h3>';
            }
        }
    }
}

document.getElementById('efecto').style.display = "";

}

function quitarEfecto() {
document.getElementById(‘efecto’).style.display = “none”;
}

– – – – – – – – – – – –
Puedes testear mi juego acá ^^!
https://piedra-papel-tijera.alvarohrv.repl.co

– – – – – – – – – – – –
Las imagenes duran en cargar la primera vez que son requeridas, no se muy bien como mejorar eso =/
– – – – – – – – – – – –
nota: si eres un principiante como yo, puedes hacer cosas interesantes tomando el curso de :
Programacion basica con Freddy,
de CSS con Leonidas,
y tutos complementarios para comprender:
getElementById
display: flex;
etc

– – – – – – – – – – – –

var player1 = "Ganaste";
var player2 = "Te ganaron"
var rock = "Piedra";
var paper = "Papel";
var scissors = "Tijera";

function game(player1, player2) {
	switch(true) {
		case player1 === player2:
			console.log("Que lindo empate");
			break;
		case player1 === paper && player2 === rock:
			console.log("Papel, gana jugador 1");
			break;
		case player1 === paper && player2 === scissors:
			console.log("Tijera, gana jugador 2");
			break;
		case player1 === rock && player2 === paper:
			console.log("Papel, gana jugador 2");
			break;
		case player1 === rock && player2 === scissors:
			console.log("Piedra, gana jugador 1");
			break;
		case player1 === scissors && player2 === paper:
			console.log("Tijera, gana jugador 1");
			break;
		case player1 === scissors && player2 === rock:
			console.log("Piedra, gana jugador 2");
			break;
		default:
			console.log("¿No juegan?")
	}
}

Les comparto también mis notas de esta clase, espero les sean de utilidad 😃

Dejo mi código del reto con switch.

Aquí dejo mi código, realista para todos los que comenzamos y no los desmotiven ver a gente que lleva más de 3 años en esto viendo comentando en cursos básicos con las excusa de nunca parar de aprender y esperando que les eleven el ego diciéndoles que su trabajo es bueno:

var tijera = "tijera";
var piedra = "piedra";
var papel = "papel";

var juego = function Game(Usuario,Maquina) {
    switch(true){
        //Usuario con tijera
        case (Usuario===tijera && Maquina===tijera):
            console.log("Empate");
            break;
        case (Usuario===tijera && Maquina===piedra):
            console.log("Perdiste");
            break;
        case (Usuario===tijera && Maquina===papel):
            console.log("Ganaste");
            break;

        //Usuario con piedra
        case (Usuario===piedra && Maquina===piedra):
            console.log("Empate");
            break;
        case (Usuario===piedra && Maquina===papel):
            console.log("Perdiste");
            break;
        case (Usuario===piedra && Maquina===tijera):
            console.log("Ganaste");
            break

        //Usuario con papel
        case (Usuario===papel && Maquina===papel):
            console.log("Empate");
            break;
        case (Usuario===papel && Maquina===tijera):
            console.log("Perdiste");
            break;
        default:
            console.log("Ganaste");
        
    }   
    
    
}



juego(piedra,tijera)
var piedra = "piedra";
  var papel = "papel";
  var tijeras = "tijeras";


  var resultado = function (usuario, cpu){

      switch (true)
        {
          case usuario === cpu:
            console.log("Empate");
            break;
          case usuario === piedra && cpu === tijeras:
               console.log("usuario gana con: " + piedra)
               break;
          case usuario === papel && cpu === piedra:
               console.log("usuario gana con: " + papel)
               break;
          case usuario === tijeras && cpu === papel:
               console.log("usuario gana con: " + tijeras)
               break;   
          default:
                console.log("cpu gana");
        }
  }

  resultado(papel, piedra);```

Reto cumplido!!

var ti = 'tijeras'
var pa = 'papel'
var pi = 'piedras'
var la = 'lagarto'
var sp = 'spock'

var result = function(user, computer){
    if (user == computer){
        console.log("empate");
    }
    else if (user != computer){
        switch(true){
            case ((user === ti && computer === pa)||(user === la && computer === pa)||(user === sp && computer === ti)||(user === pi && computer === ti)||(user === pa && computer === pi)||(user === sp && computer === pi)||(user === ti && computer === la)||(user === pi && computer === la)||(user === pa && computer === sp)||(user === la && computer === sp)):
                console.log("YOU WIN 🙌🎉🎊")
                break;
            case (user === pi && computer === pa):
                console.log("YOU LOSE 🤕🤕🤕 Papel cubre piedra");
                break;
            case (user === sp && computer === pa):
                console.log("YOU LOSE 🤕🤕🤕 Papel desaprueba a spock");
                break;
            case (user === la && computer === ti):
                console.log("YOU LOSE 🤕🤕🤕 tijera decapita largato");
                break;
            case (user === pa && computer === ti):
                console.log("YOU LOSE 🤕🤕🤕 tijera corta papel");
                break;
            case (user === ti && computer === pi):
                console.log("YOU LOSE 🤕🤕🤕 piedra aplasta tijera");
                break;
            case (user === la && computer === pi):
                console.log("YOU LOSE 🤕🤕🤕 piedra aplasta lagarto");
                break;
            case (user === sp && computer === la):
                console.log("YOU LOSE 🤕🤕🤕 lagarto envenena spock");
                break;
            case (user === pa && computer === la):
                console.log("YOU LOSE 🤕🤕🤕 lagarto devora papel");
                break;
            case (user === ti && computer === sp):
                console.log("YOU LOSE 🤕🤕🤕 spock rompe tijeras");
                break;
            case (user === pi && computer === sp):
                console.log("YOU LOSE 🤕🤕🤕 spock evaporiza piedra");
                break;
        }
    }
};
result(la,pa)

YOU WIN 🙌🎉🎊

Reto terminado
Repositorio

HTML

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="./css/styles.css">
    <link href="https://fonts.googleapis.com/css2?family=Lato&display=swap" rel="stylesheet">
    <title>Piedra, Papel o Tijera</title>
</head>
<body>

    <main class="main">
        <div class="title">
            <h1>Bienvenido<br>Juguemos Piedra, Papel o Tijera<br><br>Elije una opción !</h1>
        </div>
        <div class="options">
            <button id="piedra"><img src="./images/piedra.png"  alt=""></button>
            <button id="papel"><img src="./images/papel.png"    alt=""></button>
            <button id="tijera"><img src="./images/tijeras.png" alt=""></button>
        </div>
        <p id="resultado"></p>
        <a href="index.html" class="recharge">Jugar de Nuevo</a>
    </main>
    <footer class="footer">
        <p>Created by <a href="https://twitter.com/@Max23Esau" target="_blank">@Max23Esau</a></p>
    </footer>
    <script src="./game.js"></script>
</body>
</html>

JS

// piedra = 1
// papel = 2
// tijera = 3

var rock = document.getElementById("piedra");
rock.addEventListener("click", piedra);

var paper = document.getElementById("papel");
paper.addEventListener("click", papel);

var scissors = document.getElementById("tijera");
scissors.addEventListener("click", tijera);

var result = document.getElementById("resultado");
const Machine = Math.floor(Math.random() * (4 - 1) + 1);

function piedra(){
    switch(Machine){
        case 1: result.innerHTML = "La computadora eligio Piedra, Empataron !"; break;
        case 2: result.innerHTML = "La computadora eligio Papel, Perdiste !";   break;
        case 3: result.innerHTML = "La computadora eligio Tijera, Ganaste !";   break;
        default : result.innerHTML = "ERROR";
    }
}
function papel(){
    switch(Machine){
        case 1: result.innerHTML = "La computadora eligio Piedra, Ganaste !";  break;
        case 2: result.innerHTML = "La computadora eligio Papel, Empataron !"; break;
        case 3: result.innerHTML = "La computadora eligio Tijera, Perdiste !"; break;
        default : result.innerHTML = "ERROR";
    }
}
function tijera(){
    switch(Machine){
        case 1: result.innerHTML = "La computadora eligio Piedra, Perdiste !";  break;
        case 2: result.innerHTML = "La computadora eligio Papel, Ganaste !";    break;
        case 3: result.innerHTML = "La computadora eligio Tijera, Empataron !"; break;
        default : result.innerHTML = "ERROR";
    }
}

No quedó Todo exactamente como yo quería pero la verdad estoy satisfecho con el resultado, me base en el proyecto de Dulce Flores y en un video
.

.
Este es el link para que pruebes jugando 😃 → Game Rock, Paper or Scissors ←

Y este otro es el link del código, en donde también puedes encontrar todo lo visto en el curso
→ Repositorio de GitHub ←

Me gustaría si ven esto que me dieran algo de feedback por que creo que quedaron algunos bugs y estoy seguro de que es posible optimizar mi código

<h1>PIEDRA PAPEL O TIJERA USADO LA ESTRUCTURA DE CONTROL SWITCH.</h1>

Este es el link del GitHub: Piedra, papel o tijera

/*
PIEDRA PAPEL O TIJERA
  1. preguntar si quiere jugar (queda mejor si juega una vez y luego pregunta si quiere seguir jugando)
  2. Solicitar eleccion al jugador.
  3. Generar eleccion aleatoria a la cpu.
  4. Evaluar quien gano. ok
  5. Imprimir quien gano.
*/

//VARIABLES
let choicePlayer
let choiceCpu
let playAgain
let winner

// Solicitar eleccion del jugador
function getPlayerChoice() {
  let choicePlayer = prompt(`Escriba con cual quiere jugar PIEDRA, PAPEL o TIJERA ??`)
  return choicePlayer
}

// Generar eleccion CPU
function generateCpuChoice() {
  let randomNumber = Math.floor(Math.random()*100)

  if(randomNumber >= 0 && randomNumber < 34) {
    return `piedra`
  } else if(randomNumber > 33 && randomNumber < 67) {
    return `papel`
  } else {
    return `tijera`
  }
}

//Evaluar quien gano.
//Usando una estructura switch
function whoWinWithSwitch(choicePlayer, choiceCpu) {
  
  if(choicePlayer === choiceCpu) {
    return `Empate`
  }

  switch(choicePlayer) {
    case 'piedra': 
    return choiceCpu === 'papel' ? 'CPU won !!!' : 'You won !!!'
    break
    case 'papel': 
    return choiceCpu === 'tijera' ? 'CPU won !!!' : 'You won !!!'
    break
    case 'tijera': 
    return choiceCpu === 'piedra' ? 'CPU won !!!' : 'You won !!!'
    break
    default:
    return `${choicePlayer} no es una opcion valida.`
  }
}

//Programa secuencial del juego de piedra, papel o tijera.
do {
  choicePlayer = getPlayerChoice()
  choiceCpu = generateCpuChoice()
  winner = whoWinWithSwitch(choicePlayer, choiceCpu)
  console.log(winner)  
  playAgain = prompt(`Por favor digite 'y' si quiere seguir jugando o cualquier letra si desea terminar el juego.`)
} while(playAgain === 'y')```

Debemos tener en cuenta que se pueden poner en un solo caso todas las combinaciones donde el jugador 1 gana, eso reduce las líneas de código, pero si para empezar no te sientes cómodo no pasa nada, hazlo del modo largo.

Creo que este es el tema mas complejo del curso y debe de verse un par de veces y buscar info adicional

var opcion;

function juguemos(opcion){
    switch(opcion){
        case "piedra":
            console.log("ganaste");
            break;
        case "papel":
            console.log("perdiste");
            break;
        case "tijera":
            console.log("empate");
            break;
        default:
            console.log("La opcion ingresada no es valida");
    }
}

Este es mi código (No sé si sea trampa) 😄 Aunque estoy seguro que es un código correcto y posible para un juego 😃


var vs;
var tijera_papel = "mano1 con tijera";
var papel_tijera = "mano2 con tijera";
var papel_piedra = "mano1 con papel";
var piedra_papel = "mano2 con papel";
var piedra_tijera = "mano1 con piedra";
var tijera_piedra = "mano2 con piedra";
var tijera_tijera = "Empate";
var papel_papel = "Empate";
var piedra_piedra = "Empate";

vs = tijera_papel;

switch (vs) {

    case vs:
        console.log(vs);
        break;
    
}

var user = Number(
    prompt("Elije una opcion: 1-piedra 2-papel 3-tijera")
);

var machine = Math.floor(Math.random() * (4-1)) + 1;

switch (user, machine){
    
    case user === 1 && machine === 3:
        console.log("User win!")
        break;
    case user === 2 && machine === 1:
        console.log("User win!")
        break;
    case user === 3 && machine === 2:
        console.log("user win!")
        break;
    case user === machine:
        console.log("Draw")
        break;
    default:
        console.log("Machine win!")
}

El switch que quiero

Este es mi resultado 😄

var maquina = ["piedra","papel","tijera"];

function jugadas( jugador ){
    var i = Math.floor(Math.random() * 3);
    console.log(maquina[i])
    switch(jugador + "|" + maquina[i]){
        case maquina[i] + "|" + jugador:
            console.log("empate");
            break;
        case "piedra" + "|" + "papel":case "papel" + "|" + "tijera":case "tijera" + "|" + "piedra":
            console.log("perdiste contra la máquina "+maquina[i]);
            break;
        case "piedra" + "|" + "tijera":case "papel" + "|" + "piedra": case "tijera" + "|" + "papel":
            console.log("le ganaste a la máquina "+maquina[i]);
            break;
        default:
            console.log("jugada no válida");
    }
}

Ahí va:

rock_paper_scisors("Rock", "Paper");

function rock_paper_scisors(player1, player2){
   
    if(player1 !== "Rock" && player1 !== "Paper" && player1 !== "Scisors"){
        alert("Invalid movement by Player 1");
    } else if(player2 !== "Rock" && player2 !== "Paper" && player2 !== "Scisors"){
        alert("Invalid movement by Player 2");
    } else{

        switch(player1){
            case "Rock":
                switch(player2){
                    case "Rock":
                        result = "Tie!";
                        break;
                
                    case "Paper": 
                        result = "Player 2 wins!";
                        break;
                
                    case "Scisors":
                        result = "Player 1 wins!";
                        break;
                }
                break;
        
            case "Paper": 
                switch(player2){
                    case "Rock":
                        result = "Player 1 wins!";
                        break;
                        
                    case "Paper": 
                        result = "Tie!";
                        break;
                        
                    case "Scisors":
                        result = "Player 2 wins!";
                        break;
                }
                break;
        
            case "Scisors":
                switch(player2){
                    case "Rock":
                        result = "Player 2 wins!";
                        break;
                        
                    case "Paper": 
                        result = "Player 1 wins!";
                        break;
                    
                    case "Scisors":
                        result = "Tie!";
                        break;
                }
                break;
        }
        
    console.log(result);

    }
}```

Aquí mi tarea

var user;
var cpu;

const op1 = "piedra";
const op2 = "papel";
const op3 = "tijera";

var resultado = function(user, cpu){
    switch(true){
    case ( user == op1 && cpu == op3):
        console.log("El usuario GANO con " + user);
        break;
    case ( user == op2 && cpu == op1):
        console.log("El usuario GANO con " + user);
        break;
    case ( user == op3 && cpu == op2):
        console.log("El usuario GANO con " + user);
        break;
    case ( user === cpu):
        console.log("Hubo un empate con " + user)
        break;
    default:
        console.log("El Computador GANO con " + cpu)
}
};

var pregunta = prompt("Ingresa tu opción: piedra, papel o tijera ");
user = pregunta.toLowerCase();
var options = ["piedra", "papel", "tijera"];
cpu = options[Math.floor(Math.random() * 3)];

resultado(user, cpu);

para no hacer los proyectos en la compu los estoy haciendo en codepen.io

esta cool!

Alguien me podria dar una retroalimentacion del codigo por favor, es que no me corre

var user_choice = "piedra";
var machine_choice = "piedra";

switch (user_choice, machine_choice) {
    case (user_choice === "piedra" && machine_choice === "piedra"):
        console.log("Empate");
        break;
    case (user_choice === "tijera" && machine_choice === "piedra"):
        console.log("has perdido");
        break;
    case (user_choice === "papel" && machine_choice === "piedra"):
        console.log("has ganado");
        break;
    default:
        console.log("Debes escoger un valor vàlido");
        break;
}

Esta sería mi versión con switch 😁

const choices = ["Rock 👊", "Paper 🖐", "Scissors ✌"];
let player = Math.floor(Math.random() * choices.length);
let computer = Math.floor(Math.random() * choices.length);
console.log('Player: ' + choices[player] + ' | Computer: ' + choices[computer]);

function Game(playerChoice, computerChoice){
    switch(true) {
        case playerChoice === 0 && computerChoice === 1 || playerChoice === 1 && computerChoice === 2 || playerChoice === 2 && computerChoice === 0:
            return "You Lose! 😈";
        case playerChoice === 0 && computerChoice === 2 || playerChoice === 2 && computerChoice === 1 || playerChoice === 1 && computerChoice === 0: 
            return "You Win!!! 🎉";
        default:
            return "Is a Tie 😬";
    }
}

console.log('Result: ' + Game(player, computer));

Este fue mi reto, para experimentar un poco con el código hice las variables de dos formas diferentes, pero al final la estructura es la misma


//condicionales con switch array

var options = ["rock", "paper" , "scissors"];

function resultado (user, machine){
    switch (true) {

        case (user === machine):
            return "Esto fué un empate -.-";
            break;
        case (user == "rock" && machine == "scissors"):
            return "Ganaste :D";
            break;
        case (user == "paper" && machine == "rock"):
            return "Ganaste :D";
            break;    
        case (user == "scissors" && machine == "paper"):
            return "Ganaste :D";
            break; 
        default:
            return "Perdiste T.T";
    }
    
}

console.log (resultado ("rock", "scissors"))


//condicionales con switch numero

var rock = 1;
var paper = 2;
var scissors = 3;

function resultado (user, machine){
    switch (true) {

        case (user === machine):
            return "Esto fué un empate -.-";
            break;
        case (user == rock && machine == scissors):
            return "Ganaste :D";
            break;
        case (user == paper && machine == rock):
            return "Ganaste :D";
            break;    
        case (user == scissors && machine == paper):
            return "Ganaste :D";
            break; 
        default:
            return "Perdiste T.T";
    }
    
}

console.log (resultado (rock , scissors))

function juego(yo,robot){

switch(yo){

    case "Piedra": 
            if(robot="Papel"){
            console.log("PERDISTE");
            }else if(robot="Tijera") {
            console.log("Ganaste");
            }else if(robot="Piedra"){
             console.log("EMPATE");
            }else{console.log("INGRESA VALORES VALIDOS");}
    break;
    
    case "Papel": 
            if(robot="Papel"){
            console.log("EMPATE");
            }else if(robot="Tijera") {
            console.log("PERDISTE");
            }else if(robot="Piedra"){
             console.log("GANASTE");
            }else{console.log("INGRESA VALORES VALIDOS");}
    break;
    
    case "Tijera": 
            if(robot="Papel"){
            console.log("GANASTE");
            }else if(robot="Tijera") {
            console.log("EMPATE");
            }else if(robot="Piedra"){
             console.log("PERDISTE");
            }else{console.log("INGRESA VALORES VALIDOS");}
    break;

    default: "INGRESA VALORES VALIDOS";
    

}

}```

Aqui mi reto, se que es sencillo pero lo hice para que puedan jugar con alguien mas c:

var jugador1;
var jugador2;
var eleccion1;
var eleccion2;
const op1 = "pierda";
const op2 = "papel";
const op3 = "tijera";

jugador1 = prompt("Hola, por favor ingrese su nombre: ");
eleccion1 = prompt(
  "Por favor " + jugador1 + " elija una de las opciones (piedra, papel, tijera"
);
jugador2 = prompt("Hola, por favor ingrese su nombre: ");
eleccion2 = prompt(
  "Por favor " + jugador2 + " elija una de las opciones (piedra, papel, tijera"
);
switch (true) {
  case eleccion1 === eleccion2:
    alert(
      "Es un empate " + jugador1 + " y " + jugador2 + "Elijieron " + eleccion1
    );
    break;
  case eleccion1 === "piedra" && eleccion2 === "tijera":
    alert(jugador1 + " Gano!");
    break;
  case eleccion1 === "papel" && eleccion2 === "piedra":
    alert(jugador1 + " Gano!");
    break;
  case eleccion1 === "tijera" && eleccion2 === "papel":
    alert(jugador1 + " Gano!");
    break;
  default:
    alert(jugador2 + " Gano!");
}

Viendo el ejemplo de algunos compañeros lo hice así

var piedra = "Piedra";
var papel = "Papel";
var tijera = "Tijera";

function resultado(user,cpu){
switch (true) {
    case (user === piedra && cpu === tijera):
        console.log("El usuario Gano");
    break;
    case (user === papel && cpu === piedra):
        console.log("El usuario Gano");
    break;
    case (user === tijera && cpu === papel):
        console.log("El usuario Gano");
    break;
    case (user === tijera && cpu === papel):
        console.log("El usuario Gano");
    break;
    case (user === cpu ):
        console.log("Empate");
        break
    default:
        console.log("El CPU gano");
    
    }
}

// para hallar la respuesta escribimos: resultado(piedra,papel)```

Este es mi código acepto sugerencias para optimizarlo jsjsj

op1 = "Piedra";
op2 = "Papel";
op3 = "Tijera";

function ganador (player1,player2) {
    switch (true) {
        case (player1==op1 && player2==op1):
            return "Empate!";
            break;
        case (player1==op1 && player2==op2):
            return "Player 2 wins!";
            break;
        case (player1==op1 && player2==op3):
            return "Player 1 wins!";
            break;
        case (player1==op2 && player2==op2):
            return "Empate!";
            break;
        case (player1==op2 && player2==op3):
            return "Player 2 wins!";
            break;
        case (player1==op2 && player2==op1):
            return "Player 1 wins!";
            break;
        case (player1==op3 && player2==op3):
            return "Empate!";
            break;
        case (player1==op3 && player2!=op2):
            return "Player 1 wins!";
            break;
        case (player1==op3 && player2!=op1):
            return "Player 2 wins!";
            break;
        default:
            return "Elegí bien campeón, esa opción no es válida!";
    } 
}```

Hola, esta es mi propuesta utilizando el Switch:

var piedra = "PI";
var papel = "PA";
var tijera = "TI";

function play(opUser, opCPU){
    // Valida si los datos ingresados son validos
    if ( (opUser === piedra || opUser === papel || opUser === tijera) &&
            (opCPU === piedra || opCPU === papel || opCPU === tijera) ){
        // Valida si escogieron diferentes opciones
        if (opUser != opCPU){
            // Valida las diferentes jugadas posibles
            switch (opUser+opCPU){
                case piedra+papel:
                    console.log("Ganó la CPU!")
                    break;
                case piedra+tijera:
                    console.log("Ganó el Usuario!")
                    break;
                case papel+tijera:
                    console.log("Ganó la CPU!")
                    break;
                case papel+piedra:
                    console.log("Ganó el Usuario!")
                    break;
                case tijera+piedra:
                    console.log("Ganó la CPU!")
                    break;
                case tijera+papel:
                    console.log("Ganó el Usuario!")
                    break;                
                default:
                    console.log("No es posible esa jugada!")
            } 
        } else {
            console.log("¡Empate!");
        }
    } else {
        console.log("Datos de la jugada incorrectos.");
    }    
}

function juego(Usuario, Maquina){
	switch(Usuario){
		case Maquina:
			console.log("¡Empate! Ambos han escogido los mismo");
			break;
		case 'piedra':
			switch(Maquina){
				case 'tijera':
					console.log("¡Lo Lograste!, escoguiste piedra y derrotaste la tijera");
					break;
				case 'papel':
					console.log("Has sido derrotado por un mísero pedazo de papel");
					break;
			}
			break;
		case 'papel':
			switch(Maquina){
				case 'piedra':
					console.log("Le has ganado a una roca que era inamovible");
					break;
				case 'tijera':
					console.log("Como que te cortaron en 2");
					break;
			}
			break;
		case 'tijera':
			switch(Maquina){
				case 'papel':
					console.log("Como que lo cortaste en 2");
					break;
				case 'piedra':
					console.log("Te ganó la piedra");
					break;
			}
			break;
		default:
			console.log("Utiliza un valo rcorrecto!");
	}
}

juego ("tijera", "papel");```

codigo:

let max = 2;
let min=0;
let esa = ["piedra", "papel","tijera"];
let valor= prompt("ESCRIBE 'piedra', 'papel' o 'tijera'");
let entrada;
let diferente = false;

for (var x = 0; x<3; x++) {
    if (valor===esa[x]){
        entrada=x;
        diferente = true;       
    }
} 
if (!diferente) {
    alert("no es valido");
}

function aleato(max, min) {
    let a = Math.round(Math.random() * (max - min)+min);
    return a;
}
let a = aleato(max, min);


if (entrada==a){
    alert("tu: " + esa[entrada] + " pc: " + esa[a] + " empate, vuelve a intentarlo");
} else {
    switch (entrada) {
        case 0:
        switch (a) {
            case 1:
                alert("Tu: " + esa[entrada] + " El Pc: " + esa[a] + "; Tu Perdiste!");
                break;
            default:
                alert("Tu: " + esa[entrada] + " El Pc: " + esa[a] + "; Tu Ganaste!");                
            }break;
        
        case 1:
            switch (a) {
                case 0:
                    alert("Tu: " + esa[entrada] + " El Pc: " + esa[a] + "; Tu Ganaste!");
                    break;
                default:
                    alert("Tu: " + esa[entrada] + " El Pc: " + esa[a] + "; Tu perdiste!");                       
            }break
        
        case 2: 
            switch (a) {
                case 0:
                    alert("Tu: " + esa[entrada] + " El Pc: " + esa[a] + "; Tu perdiste!");
                    break;
                default:
                    alert("Tu: " + esa[entrada] + " El Pc: " + esa[a] + "; Tu Ganaste!");
            }    
    }
}

Muchachos, comparto mi codigo, les agradezco sus opiniones

var humano = Number(prompt('elige uno, piedra: 1, papel: 2, tijera: 3'))
var maquina = get_random_int(1,4);

function get_random_int(min, max) {
    return Math.floor(Math.random() * (max - min)) + min;
}
function que_es(numero){
    var esto_es =' ';
    switch (numero){
        case 1:  esto_es = 'Piedra';  break;
        default:
            numero == 2 ? esto_es = 'Papel':esto_es = 'tijera';
            break;
        }
    return esto_es;
}

alert('humano: '+ que_es(humano) +' vs maquina: ' + que_es(maquina));

switch(Math.abs(humano-maquina)){
    case 0:
        alert('empate');
        break;
    case 1:
        humano > maquina ? alert('Gano el humano'):alert('Gano la maquina');
        break;
    case 2:
        humano < maquina ? alert('Gano el humano'):alert('Gano la maquina');
        break;
}

Que tal campeones, excelente tarde, un reto mas que me llevo un cierto de tiempo de investigacion para terminarlo tal como me gusta… Porsupuesto que hizo falta agregarle del partida un reset instantaneo… Por ahora dejo el repositorio en Github para la visualizacion de la misma… Exito, hasta luego.

https://github.com/brunomaldonado/App

Con el switch tuve que considerar lo de hoisting ya que sino me votaba undefined en mi resultado. Ahi va mi aporte

//opciones del juego
var opcionesJuego = ["piedra", "papel", "tijera"];

//pedir al usuario que ingrese 1 de las 3 opciones
var inputUsuario = prompt("Para competir contra la computadora digita: 0 (para elegir piedra), 1 (para elegir papel) ó 2 (para elegir tijera)");

//variables que utilizará el juego
var eleccionHumano = parseInt(inputUsuario);
var eleccionMaquina = eleccionAleatorioJuego();

//var resultado = resultadoJuego(eleccionHumano,eleccionMaquina);
var resultado;

//resumen que mostraremos con el console.log
var resumenDelResultado;

//opteniendo un aleatorio de la lista opciones del juego
function eleccionAleatorioJuego() {
    var aleatorio = Math.floor(Math.random() * (2 - 0 + 1) + 0);
    return aleatorio;
}

//condicional con todas las conbinaciones de piedra, papale y tijera
switch (eleccionHumano - eleccionMaquina) {
    case 1 || -2:
        resultado = "Gana Humano";
        break;
    case -1 || 2:
        resultado = "Gana Máquina";
        break;
    case 0:
        resultado = "Empate";
        break;
    default:
        resultado = "Opción Invalida. No hay ganador"
}

resumenDelResultado = "Humano eligió: " + opcionesJuego[eleccionHumano] + "; Máquina eligio: " +  opcionesJuego[eleccionMaquina] + ". Resultado: " + resultado;
console.log(resumenDelResultado);

var piedra="piedra";
var papel = "papel";
var tijera = "tijera";

function gameSwitch(user, pc){
    switch (true){
        case (user == "piedra" && pc == "tijera")  || (user == "tijera" && pc == "papel") || (user == "papel" && pc == "piedra"):
            console.log("Ganaste");
            break;
        case (user === pc ):
            console.log("Empate!!!");
            break;
        default:
            console.log("Gano la PC!!!");
    }
}
gameSwitch(papel, papel);
var options = ["piedra", "papel", "tijera"];

var cpu = options[Math.floor(Math.random() * 3)]; // random del 0 al 2

var person = "piedra";

console.log("Persona: " + person + " Maquina: " + cpu);

switch(true){
  case (cpu === person):
    console.log("Empate");
    break;
  case (cpu == "piedra" && person == "tijera"):
    console.log("Computadora gana");
    break;
  case (cpu == "papel" && person == "piedra"):
    console.log("Computadora gana");
    break;
  case (cpu == "tijera" && person == "papel"):
    console.log("Computadora gana");
    break;
  default:
    console.log("Persona gana");
}

Reto logrado
Acá el codepen

Usando conocimientos del curso de programación básica 😃

//RETO DE LA CLASE;

var piedraPapelTijera = ['Piedra', 'Papel', 'Tijera'];
var aleatorioCPU = Math.floor(Math.random() * (2 - 0 + 1)) + 0;/* Generara un número entero aleatorio entre el 0 y 2 
incluyendolos.*/
var ganadasCPU = 0;
var ganadasUser = 0;

function validar(seleccionUsuario){

    if(piedraPapelTijera[aleatorioCPU] == 'Papel'){
        console.log('La computadora juega con: ' + piedraPapelTijera[aleatorioCPU]);
        console.log('Y el usuario con: ' + seleccionUsuario + '\n');

        switch(seleccionUsuario){
            case 'Piedra':
                console.log("\tPapel le gana a Piedra :). \n\tLa computadora ha ganado!!\n");
                ganadasCPU += 1;
                break;
            case 'Papel':
                console.log('\tEs un empate!!\n');
                break;
            case 'Tijera':
                console.log('\tPapel pierde contra Tijera :(. \n\tHa ganado el Usuario!!.\n');
                ganadasUser += 1;
        }
    }

    if(piedraPapelTijera[aleatorioCPU] == 'Piedra'){
        console.log('La computadora juega con: ' + piedraPapelTijera[aleatorioCPU]);
        console.log('Y el usuario con: ' + seleccionUsuario + '\n');

        switch(seleccionUsuario){
            case 'Piedra':
                console.log("\tEs un empate!!:)\n");
                break;
            case 'Papel':
                console.log('\tPiedra pierde contra papel :(. \n\tHa ganado el Usuario!!.\n');
                ganadasUser += 1;

                break;
            case 'Tijera':
                console.log('\tPiedra le gana a Tijera :(. \n\tLa computadora ha ganado!!\n');
                ganadasCPU += 1;
        }
    }

    if(piedraPapelTijera[aleatorioCPU] == 'Tijera'){
        console.log('La computadora juega con: ' + piedraPapelTijera[aleatorioCPU]);
        console.log('Y el usuario con: ' + seleccionUsuario + '\n');

        switch(seleccionUsuario){
            case 'Piedra':
                console.log("\tTijera pierde contra piedra:(. \n\tHa ganado el Usuario!!.\n");
                ganadasUser += 1;
                break;
            case 'Papel':
                console.log('\tTijera le gana a papel :(. \n\tLa computadora ha ganado!!\n');
                ganadasCPU += 1;
                break;
            case 'Tijera':
                console.log('\tEs un empate :)\n');
        }
    }
}


for(var i = 0; i <= 10; i++){
    if(ganadasCPU < 3 && ganadasUser < 3){
        var aleatorioCPU = Math.floor(Math.random() * (2 - 0 + 1)) + 0;
        var aleatorioUser = Math.floor(Math.random() * (2 - 0 + 1)) + 0;

        validar(piedraPapelTijera[aleatorioUser]);
    }  
}

console.log('\nMarcador CPU: ' + ganadasCPU);
console.log('Marcador User: ' + ganadasUser + "\n");

if(ganadasCPU == 3){
    console.log('\n\t\tEl ganador es....... LAAA COMPUUUUUU !!!!\n');
}
else if(ganadasUser == 3){
    console.log('\n\t\tEl ganador es..... ELLL USUARIOOOO!!!!\n');
}
ahora sí 🥲 function aleatorio(min, max) { return Math.floor(Math.random() * (max - min)) + min; } function imprimir(op,a){ if(op==="1"&&a===0){ console.log("Empate,pero de todas maneras gana la computadora "); } else if(op==="2"&&a===0){ console.log("ganaste usuario"); } else if(op==="3"&&a===0){ console.log("gana la computadora"); } else if(op==="1"&&a===1){ console.log("usuario ganaste"); } else if(op==="2"&&a===1){ console.log("Empate,pero de todas maneras gana la computadora"); } else if(op==="3"&&a===1){ console.log("ganaste usuario"); } else if(op==="1"&&a===2){ console.log("usuario ganaste"); } else if(op==="2"&&a===2){ console.log(" gana la computadora"); } else if(op==="3"&&a===2){ console.log("Empate, pero vomo me cae bien el creador GANA LA COMPUTADORA"); } } console.log("Hola Usuario ¿quieres jugar piedra papel tijera y ganarme?"); console.log("S/n"); var play="S"; if(play==="s"|| play==="S"){ console.log("Muy bien.. escoge una opción para empezar a jugar: "); console.log("1. piedra"); console.log("2. papel"); console.log("3. tijera"); var op="3"; console.log("opcion "+op); switch (op){ case "1": console.log("procesando tu opción"); console.log("seleccionando aleatorio para la computadora"); var cp=aleatorio(0,3); imprimir(op,cp); break; case "2": console.log("procesando tu opción"); console.log("seleccionando aleatorio para la computadora"); var cp=aleatorio(0,3); imprimir(op,cp); break; case "3": console.log("procesando tu opción"); console.log("seleccionando aleatorio para la computadora"); var cp=aleatorio(0,3); imprimir(op,cp); break; default: console.log("porfavor ingresa solo numeros, gracias"); } }else if(play==="n"||play==="N"){ console.log("FLOJO.."); }

Después de unos buenos intentos, logré hacer esto usando un archivo HTML conectándole un archivo JS.
HTML:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>PIPATI | SWITCH</title>
    <style>
        @import url('https://fonts.googleapis.com/css2?family=Akshar:[email protected]&family=Kite+One&family=Lexend+Mega:[email protected]&family=Montserrat:[email protected];400&display=swap');

        body {
            background-color: black;
            color: white;
            font-family: 'Akshar';
        }

        ul {
            font-size: 20px;
        }
    </style>
</head>
<body>
    <h1>PIEDRA, PAPEL O TIJERA EN UN SWITCH :D</h1>
    <h3>Por favor, seleccione alguna opción:</h3>
    <ul>
        <li>1. ¡PIEDRA!</li>
        <li>2. ¡PAPEL!</li>
        <li>3. ¡TIJERA!</li>
    </ul>
    <hr>
    <input type="number" id="valor">
    <input type="submit" value="¡VAMOS!" id="juega">

    <p id="resultado"></p>

    <script src="switch.js"></script>
</body>
</html>

JavaScript:

var piedra = 1;
var papel = 2;
var tijera = 3;
var player;

var resultado = document.getElementById("resultado");


function pipati(player, bot) {
    var v = document.getElementById("valor");
    player = parseInt(v.value);
    var bot = Math.floor(Math.random() * (4 - 1)) + 1;
    console.log(player);

    switch (true) {
        case player === bot:
            resultado.innerHTML += "Ha sido empate ( '. _ . )"
            resultado.innerHTML += "<hr>"
            break;
        case (player === 1 && bot !== 2) || (player === 2 && bot !== 3) || (player === 3 && bot !== 1):
            resultado.innerHTML += "Todo un Pro-Player 🥵🤙"
            resultado.innerHTML += "<hr>"
            break;
        default:
            resultado.innerHTML += "Manco, el bot ganó 😐"
            resultado.innerHTML += "<hr>"
            break;
    }

}

var boton = document.getElementById("juega");
boton.addEventListener("click", pipati);

Apenas estoy aprendiendo y me hizo muy feliz que funcionara :'3

Hola grupo en mi caso lo que use fue usar numero y la funcion random para que la computadora eligiera sola el producto espero que alguien pueda chekearlo

var piedra = 1;
var papel = 2;
var tijera = 3;
console.log("Hola usuario vas a jugar contra la maquina piedra papel o tijera\n por favor elige");
console.log("piedra = 1\n papel = 2\n tijera = 3\n");

// para que sea interesante cambiale el valor a user de 1 a 3 si eligen mas de tres no correra
// no se como validar eso aun 
let user = 1;

function random(min, max) {
    return Math.floor(Math.random() * (max - min + 1) + min);
  }

let machine = random(1,3);  


//se coloca en la condicion del switch un true para que valide 
// por todas las condiciones apenas encuentre una similitud saldra con el break

switch (true) {
    case (user === machine):
        console.log("es un empate");
        break;
    case (machine == 1 && user == 2):
        console.log("Ganaste");
        break;
    case (machine == 2  && user == 3):
        console.log("Ganaste");
        break;
    case (machine == 3 && user === 1):
        console.log("Ganaste");
        break;
    default:
        console.log('¡Perdiste!');       
}

Este seria mi reto muy muy apegado a todo lo que hemos visto solo en este curso. Pero leyendo las misma guías que deja el profesor, es muy recomendable tener un conocimiento o una base de HTML y CSS para que uno se sienta mas cómodo en lo que se aprende en el curso y además puedas entender los ejemplos de otros estudiantes. También se podría crear como paginas web y así sentirte mucho mejor. Pero si llegaste hasta como yo sin ningún curso visto antes de HTML y CSS… Toca leer mucho mas. 😃

var op1 = "Piedra";
var op2 = "Tijera";
var op3 = "Papel";

var resultado = function(usuario , cpu){

 switch (true){
    case( usuario == op1 && cpu == op2):
        console.log ("usuario win with " + op1);
        break;
    case(usuario == op2 && cpu == op3):
        console.log ("usuario win with " + op2);
        break;
    case(usuario == op3 && cpu ==op1):
        console.log("usuario win with "+ op3);
        break;
    case(usuario === cpu):
        console.log ("TENEMOS UN EMPATE");
        break;
    default:
        console.log("WIN CPU YOU ARE A LOSER");
	}
}
resultado (op1,op2)

Ahí les va la mía papús!

var opc = ["piedra", "papel", "tijeras"];
function play(usuario, maquina) {
  switch (true) {
    case usuario === maquina:
      return "Emapate!";
      break;
    case usuario === opc[0] && maquina === opc[2]:
      return "Ganaste con: " + opc[0];
      break;
    case usuario === opc[2] && maquina === opc[1]:
      return "Ganaste con: " + opc[2];
      break;
    case usuario === opc[1] && maquina === opc[0]:
      return "Ganaste con: " + opc[1];
      break;
    default:
      return "La maquina gana!";
      break;
  }
}
console.log(play("tijeras", "papel"));

Lo hice de la manera mas simple que encontre

var piedra = "piedra";
var papel = "papel";
var tijera = "tijera";
function jugar (fichaJugador, fichaPC) {
    switch(true){
        case fichaJugador === papel && fichaPC === piedra || 
        fichaJugador === tijera && fichaPC === papel || fichaJugador === piedra && fichaPC === tijera:
            console.log("El jugador gano");
        break;
        case fichaJugador === fichaPC:
            console.log("Empate");
        break;
        default:
            console.log("PC gano");
        break;
    }
}

jugar(papel, tijera);

Decidi asignarle valores numericos a las variables de nombre piedra, papel o tijera

var piedra = 1;
var papel = 2;
var tijera =3;

var resultado = function(user, cpu){
    switch(true){
        case (user===piedra && cpu===tijera):console.log("Gano la jugador");break;
        case (user===papel && cpu===piedra):console.log("Gano la jugador");break;
        case (user===tijera && cpu===papel):console.log("Gano la jugador");break;
        case (user === cpu):console.log("Empate!");break;
        default:console.log("Gano la computadora");break;
    }
};

resultado(piedra,papel)
// Juego piedra papel o tijera 🗿📄✂ con switch case //

var piedra = "piedra";
var papel = "papel";
var tijera = "tijera";
var player = "seleccion"
var cpu = "seleccion2"


switch (player !== cpu) {
    case player === piedra && cpu === tijera:
        console.log("¡¡You win!!🎉");
        break;
    case player === tijera && cpu === piedra:
        console.log("¡¡You win!!🎉");
        break;
    case player === papel && cpu === tijera:
        console.log("¡¡You win!!🎉");
        break;
    case player === tijera && cpu === papel:
        console.log("¡¡You win!!🎉");
        break;
    case player === papel && cpu === piedra:
        console.log("¡¡You win!!🎉");
        break;
    case player === piedra && cpu === papel:
        console.log("You lose, try again 😵‍💫");
        break;
    case player == cpu:
        console.log("empate! :I");
        break;
    default:
        console.log("no has hecho una seleccion valida, intente de nuevo");
}

/*  Biggyhands */

Así quedaron mis 2 versiones del game

var userChoice = "tijera";


// Game with "Common conditional"
function play(userChoice) {
    var pcChoice = "tijera";
    var result = `user ${userChoice} -- pc ${pcChoice}`

    if (userChoice === "piedra") {
        console.log(`You win: ${result}`)
    } else if (userChoice === "papel") {
        console.log(`Pc win: ${result}`)
    } else {
        console.log(`Tie: ${result}`)
    }
}


// Game with "switch"
function playTwo(userChoice) {
    var pcChoice = "tijera";
    var result = `user ${userChoice} -- pc ${pcChoice}`

    switch (userChoice) {
        case ("piedra"):
            console.log(`You win: ${result}`)
            break;
        case ("papel"):
            console.log(`Pc win: ${result}`)
            break;
        case ("tijera"):
            console.log(`Tie: ${result}`)
            break;
    }
}


play(userChoice)
playTwo(userChoice)

Este es el mío, intenté que fuese lo más sencillo posible, aunque me faltaría dar la opción de escoger y cambiar lo que escoges, y que el pc fuese random cada turno.
Pensé en poner un prompt y algunos similares como los comentarios, pero como no lo hemos visto en este curso, preferí no ponerlo jaja

var yo;
var pc;

function juego(){ 
    switch (yo, pc) {
        case (yo == "piedra" && pc =="tijeras"): 
            console.log("Ganaste");
            break;
        case (yo == "papel" && pc =="piedra"): 
            console.log("Ganaste");
            break;
        case (yo == "tijeras" && pc =="papel"): 
            console.log("Ganaste");
            break;
        case (yo === pc): 
            console.log("Empataste");
            break;
        default:
            console.log("Perdiste");
    }
}

Me costó mucho hacer que el switch funcionara hasta que vi un comentario con el (true) que por fin me ayudo a correr el código 👌🏽.

//Nombres de los jugadores
var jugadorA = "Arturo";
var jugadorB = "Andrea";

//Opciones a elegir en el juego
var piedra = "✊🏽 Piedra";
var papel = "✋🏽 Papel";
var tijera = "✌🏽 Tijera";

//Elección de cada jugador
var eleccionA = tijera;
var eleccionB = papel;

//Ejecución del código
juego();

//Arbitro 👶🏽
function juego() {
 

  //Elecciones mostradas en pantalla
  console.log(jugadorA + ": " + eleccionA);
  console.log(jugadorB + ": " + eleccionB);


  switch (true) {
    //Piedra vs Papel
    case (eleccionA == piedra && eleccionB == papel):
      console.log("Gana " + jugadorB);
      break;
      
    //Piedra vs Tijera
    case (eleccionA == piedra && eleccionB == tijera):
      console.log("Gana " + jugadorA);
      break;
        
    //Papel vs Piedra
    case (eleccionA == papel && eleccionB == piedra):
      console.log("Gana " + jugadorA);
      break;
          
    //Papel vs Tijera
    case (eleccionA == papel && eleccionB == tijera):
      console.log("Gana " + jugadorB);
      break;
            
    //Tijera vs Piedra
    case (eleccionA == tijera && eleccionB == piedra):
      console.log("Gana " + jugadorB);
      break;
              
    //Tijera vs Papel
    case (eleccionA == tijera && eleccionB == papel):
      console.log("Gana " + jugadorA);
      break;
        
    //Si sacan lo mismo o sacan una pistola 😀🙃
    default:
      console.log("Empate");
  }
}
var tijeras = "tijeras";
var piedra = "piedra";
var papel = "papel";

jugar("", "");

function jugar(jugador1, jugador2){
    
    switch(true){
        case(jugador1 === jugador2):
        console.log("empate");
        break;
        case(jugador1 === piedra && jugador2 === tijeras ):
        console.log("gana jugador 1")
        break;
        case(jugador1 === piedra && jugador2 === papel ):
        console.log("gana juador 2")
        break;
        case(jugador1 === papel  && jugador2 === piedra):
        console.log("gana jugador 1")
        break;
        case(jugador1 === papel && jugador2 === tijeras):
            console.log("gana jugador 2")
            break;
        case(jugador1 === tijeras && jugador2 === papel):
            console.log("gana jugador 1")
            break;
        case(jugador1 === tijeras && jugador2 === piedra):
            console.log("gana jugador 2")
            break;
            default:
                console.log("ingresa un valor correcto");
        }
     }
     

Aqui les dejo mi codigo, con todo lo aprendido hasta el momento 😩

 var piedra = "Piedra"
var papel = "Papel"
var tijera = "Tijera"

function jugar(usuario, computadora){
    switch(true){
        case(usuario === computadora):
        console.log("empate");
        break;
        case(usuario === piedra && computadora === papel ):
        console.log("gana la computadora")
        break;
        case(usuario === piedra && computadora === tijera ):
        console.log("gana el usuario")
        break;
        case(usuario === papel && computadora === piedra):
        console.log("gana el usuario")
        break;
        case(usuario === papel && computadora === tijera):
            console.log("gana la computadora")
            break;
        case(usuario === tijera && computadora === piedra):
            console.log("gana la computadora")
            break;
        case(usuario === tijera && computadora === papel):
            console.log("gana el usuario")
            break;

        }
     }
     
     jugar("Piedra", "Papel")

Adjunto el reto del juego de piedra papel o tijera usando la estructura de desción, switch.

var opc1="piedra";
var opc2="papel";
var opc3="tijeras";

function determinar (jugador, maquina){
    var resultado;
    switch (true){
        case jugador == maquina:
            resultado="empate";
            break;
        case jugador == opc1 && maquina == opc2:
            resultado="perdio";
            break;
        case jugador == opc2 && maquina == opc3:
            resultado="perdio";
            break;
        case jugador == opc3 && maquina == opc1:
            resultado="perdio";
            break;
        default:
            resultado="gano"
    }
    return resultado;
}

determinar(opc1, opc2);	 

Mi segundo aporte. Me costo más de lo que pense que tardaria. Saludos.

var scissors = 0;
var rock = 1;
var paper = 2;

function play(choice){
    var computer = Math.floor(Math.random() * 3);
    console.log(computer);
    switch(true){
        case computer == choice:
            console.log("Draw");
            break; 
        case choice == 2 && computer == 1 || choice == 1 && computer == 0 || choice == 0 && computer == 2:
            console.log("You win");
            break;   
        default:
            console.log("Computer Wins");
    }
}

play(rock); // Aqui escoges si será piedra papel o tijera, solo debes colocarla en inglés.
var op1 = "piedra";
var op2 = "papel";
var op3 = "tijera";

function resultado(user,cpu){
    switch(true){
        case (user === op1 && cpu ===op2):
            console.log("cpu gano con " + op2)
        break;
        case (user === op2 && cpu === op1):
            console.log("user gano con " + op2)
            break;
        case(user === op2 && cpu === op3):
            console.log("cpu gano con " + op3);
        break;
        case(user === op3 && cpu === op2):
        console.log("user gano con " + op3);
        break;
        case (user === op1 && cpu === op3):
            console.log("user gano con " + op1);
        break;
        case (user === op3 && cpu === op1):
            console.log("cpu gano con " + op1);
        break;
        case(user === cpu):
            console.log("eso fue un empate");
        default:
            console.log("las opciones no son validas :(")
    }
}

Recuerden usar && si no no les toma la doble condicion

var pierdra = "piedra";
var papel = "papel";
var tijera = "tijera";

function jugar(player1, player2){

    switch (true){
        case player1 === player2:
            console.log("draw");
            break;
        case player1 === "piedra" && player2 === "papel":
            console.log("Player 2 wins");
            break;
            case player1 === "papel" && player2 === "piedra":
                console.log("Player 1 wins");
                break;
            case player1 === "papel" && player2 === "tijera":
                console.log("Player 2 wins");
                break; 
            case player1 === "tijera" && player2 === "papel":
                console.log("Player 1 wins");
                break;
            case player1 === "piedra" && player2 === "tijera":
                console.log("Player 1 wins");
                break;
                case player1 === "tijera" && player2 === "piedra":
                console.log("Player 2 wins");
                break;

    }


}
var pregunta = prompt("juguemos piedra papel o tijera elije: "); 
var user = pregunta.toLowerCase();
var opción = ["piedra", "papel", "tijera"];
var machine = opción[Math.floor(Math.random() * 2)];




switch (true){
    case (user === machine):
        alert(user +" vs "+ machine + " "+  "empate") 
        break;
    // piedra 
    case (user === "piedra" && machine === "papel" ):
        alert(user +" vs " + machine + " "+ "perdiste")
        break;
    case (user === "piedra" && machine === "tijera" ):
        alert(user +" vs "+ machine + " "+ "ganaste")
        break;
    // tiejera
    case (user === "tijera" && machine === "piedra" ):
        alert(user +" vs "+ machine + " "+ "perdiste")
        break;
    case (user === "tijera" && machine === "papel" ):
        alert(user +" vs "+ machine + " "+  "ganaste")
        break;
    // papel 
    case (user === "papel" && machine === "tijera" ):
        alert(user +" vs "+ machine + " "+  "perdiste")
        break;
    case (user === "papel" && machine === "piedra" ):
        alert(user +" vs "+ machine + " "+ "ganaste")
        break;
    default: 
        alert("error de elección")
        break;
}

Mi reto es manual, porque aun no se poner un aleatorio de opciones a mi cpu… pero aqui esta…

var cpu = prompt("Opcion para el cpu, entre piedra, papel y tijera")
var user = prompt("Que opcion eliges tu? entre piedra, papel y tijera")
var options = ["piedra","papel","tijera"]

switch (true) {
    case (cpu === user):
    console.log("Empate");
    break;
    case (cpu === "piedra" && user === "tijera"):
        console.log("perdiste");
        break;
    case (cpu === "tijera" && user === "piedra"):
        console.log("Ganaste")
        break;
    case (cpu === "tijera" && user === "papel"):
        console.log("Perdistes")
        break;
    case (cpu === "papel" && user === "tijera"):
        console.log("Ganastes")
        break;
    case (cpu === "piedra" && user === "papel"):
        console.log("Ganastes");
        break;
    case (cpu === "papel" && user === "piedra"):
        console.log("Perdistes")
        break;
}

Un poco forzado, pero quedó

function piedraPapelTijera(){
    var piedra = "piedra";
    var papel = "papel";
    var tijera = "tijera";
    var opciones = [piedra, papel, tijera];
    var cpu, player;

    // pido los datos hasta que player ingrese un valor válido
    do{
        player = Number(window.prompt("Elige una opción:\n   1. piedra\n   2. papel\n   3. tijera"));
    }while(player<1 || player>3)
    player = opciones[player-1];

    // función con las condiciones de victoria
    function play(player) {
        cpuChooses();
        switch(true){
            case (player===cpu):
                alert("Draw");
                break;
            case (player===piedra && cpu===tijera):
            case (player===papel && cpu===piedra):
            case (player===tijera && cpu===papel):
                alert("Player Wins");
                break;
            default:
                alert("Game Over");
                break;
                
        }
    }
    
    // la máquina elige
    function cpuChooses() {
        var cpuIndex = Math.random();
        switch(true){
            case (cpuIndex<0.33):
                cpuIndex = 0;
                break;
            case (cpuIndex>= 0.33 && cpuIndex<0.66):
                cpuIndex = 1;
                break;
            default:
                cpuIndex = 2;
                break;
        }
        cpu = opciones[cpuIndex];
        console.log('cpu', cpu)
    }

    play(player);
}```
<code> 
//Juego de piedra, papel o tijera
var piedra = 1;
var tijeras = 2;
var papel = 3;
var resultado;

switch (piedra) {
    case 1:
        resultado = "empate";
        break;
    case 2:
        resultado = "ganaste";
        break;
    case 3:
        resultado = "perdiste";
        break;
    default:
        resultado = "ingrese solo piedra, papel o tijera";
}

function juego(usuario,pc) {

if (usuario==pc){
    console.log("Se presentó un empate");
} else if (usuario=="piedra" && pc=="papel"){
    console.log("Gano el pc");
} else if (usuario=="piedra" && pc=="tijera"){
    console.log("Gano el usuario");
} else if (usuario=="tijera" && pc=="papel"){
    console.log("Gano el usuario");
} else if (usuario=="tijera" && pc=="piedra"){
    console.log("Gano el pc");
} else if (usuario=="papel" && pc=="tijera"){
    console.log("Gano el pc");
} else if (usuario=="papel" && pc=="piedra"){
    console.log("Gano el usuario");
}

}

Le he asignado por defecto un valor a CPU y Player 1 para que se ejecute el código.

var cpu = piedra;
var player1 = tijera;
var piedra = "piedra";
var tijera = "tijera";
var papel = "papel";

switch(cpu != player1){
    case cpu === piedra && player1 === papel:
        console.log("Has ganado");
        break;
    case cpu === piedra && player1 === tijera:
        console.log("Has perdidio");
        break;
    case cpu === tijera && player1 === piedra:
        console.log("Has ganado");
        break;
    case cpu === tijera && player1 === papel:
        console.log("Has perdido");
        break;
    case cpu === papel && player1 === tijera:
        console.log("Has gano");
        break;
    case cpu === papel && player1 === piedra:
        console.log("Has perdido");
        break;
    default:
        console.log("Empate");
}

amigos este es mi codigo me pueden verificar si esta bien o que le hace falta, soy nuevo en el tema de la programación, se los agradesco.

var op1 = "piedra";
var op2 = "papel";
var op3 = "tijeras";

function play(jugador, ordenador){
switch(true){
    case  jugador == op1 && ordenador == op2:       
        console.log("gano el usuario")
        break;
    case jugador == op1 && ordenador == op3:         
        console.log("gano el usuario")
        break;
     case jugador == op3 && ordenador == op2:        
        console.log("gano el usuario")
        break;
    case  jugador === ordenador:
      console.log("empate entre los jugadores")
        break;
    default:        
        console.log("ganó el ordenador")        
}
}
play();

No lo voy a negar, este pequeño reto me costó más de lo que me gustaría admitir, creí que iba a hacer algo sencillo, que haciéndolo a las “Malas” podría serlo, pero intentando hacerlo mínimamente ‘bien’ es otro tema. al final tiré por un diseño basteante simpleque solo cumple, muy básico, pero es hasta donde mi creatividad llegaba.

​Si quieren probarlo hagan Click Acá, se agradece el feedback

Desktop:

Mobile:

Hola chicos, les comparto mi código, todos los que vieron la clase hasta acá lo comprenderán

var piedra = "piedra";
var papel = "papel";
var tijera = "tijera";

function juego (user,cpu){
    if (user != cpu){
        switch(true){
            case user==piedra && cpu ==papel:
                console.log("Gana la máquina con papel");
                break;
            
            case user==piedra && cpu ==tijera:
                console.log("Gana la máquina con piedra");
                break;
            case user ==papel && cpu ==piedra:
                console.log("gana el usuario con papel");
                break;
            case user ==papel && cpu ==tijera:
                console.log("gana el cpu con tijera");
                break;
            case user ==tijera && cpu ==piedra:
                console.log("gana el cpu con piedra");
                break;
            case user ==tijera && cpu ==papel:
                console.log("gana el usuario con tijera");
                break;
        }

    }
    else{
        console.log("empate con " + user + "s");
    }
}
juego(papel,tijera)
var p1 = "papel";
var p2 = "tijera";

switch (true){
    case (p1 === p2):
        console.log("EMPATE");
    break;
    case (p1 === "papel" && p2 === "piedra"):
        console.log("player 1 es el ganador");
    break;
    case (p1 === "piedra" && p2 === "papel"):
        console.log("player 2 es el ganador");
    break;
    case (p1 === "tijeras" && p2 === "papel"):
        console.log("player 1 es el ganador");
    break;
    case (p1 === "papel" && p2 === "tijeras"):
        console.log("player 2 es el ganador");
    break;
}

😃

por aqui jesus clemente otra vez, aqui mi humilde funcion donde colocas dos parametros tool1 y tool2 piedra, papel o tijera en cada uno y te arroja quien gana, con switch, apenas soy un novato tengan paciencia, gracias, SALUDOS A TODOS MIS AMIGOS LATINOS Y DE ESPAÑA #HappyCodding.

<code>
// AHORA CON SWITCH

var piedra = "piedra"; // definiendo variable piedra con un string "piedra"
var tijera = "tijera";
var papel = "papel";


function piedraPapelTijera(tool1, tool2) {
    switch (true) {
        case tool1 == tool2:
            console.log("empate");
            break;
        case tool1 == piedra && tool2 == tijera || tool1 == tijera && tool2 == piedra:
            console.log("gana piedra");
            break;
        case tool1 == tijera && tool2 == papel || tool1 == papel && tool2 == tijera: 
            console.log("gana tijera");
            break;
        case tool1 == papel && tool2 == piedra || tool1 == piedra && tool2 == papel:
            console.log("gana papel");
            break;    
    }
} 
var machine = ["piedra", "papel", "tijera"];
var rules = {"piedra": "papel","papel": "tijera","tijera": "piedra"};
function validacion(userSelected) {
    var message;
    var machineSelected = machine[Math.round(Math.random() * 2)];
    var opera = rules[userSelected] == machineSelected ? "machine" : rules[machineSelected] == userSelected ? "user" : "drow";
    switch (opera) {
        case "user":
            message = `¡Ganaste!\nYOU: ${userSelected}..........CPU: ${machineSelected}`;
            break;
        case "machine":
            message = `Perdiste :/\nYOU: ${userSelected}..........CPU: ${machineSelected}`;
            break;
        case "drow":
            message = `Empate ._.\nYOU: ${userSelected}..........CPU: ${machineSelected}`;
            break;
        default:
            message = "Error not found >:V";
            break;
    }
    return message; 
}
while (true) {
    alert(validacion(prompt("Escribe tu respuesta abajo:\n- piedra\n- papel\n- tijera")));
    if (prompt("¿Intentar de nuevo? escribe si o no\n(En minusculas porfavor:)") != "si")
        break;
}

acá va el mío , a ver si esta bien .

var ia = "piedra";
var user = "piedra"; 
switch (true) {
    case (ia==user):
        console.log("empate");
        break;
    case (ia=="piedra" && user=="tijera" || ia=="papel"&&user=="piedra"||ia=="tijera"&&user=="papel"):
        console.log("gana IA!");
        break;
    default: 
        console.log("Gana Humano!");
}
$(document).ready(function () {
    //let dato = document.getElementById("id1").onchange
    
    let btn_mostrar = $('#btn-mostrar')
    let Opciones = ['Piedra', 'Papel', 'Tijera']
let mensaje

    btn_mostrar.on('click', function() {
    
    let dato = $('#id1').val()
    
     if(!Opciones.includes(dato)) {

        mensaje = 'Datos errados' 
     } else{
        switch (Opciones[Math.floor(Math.random() * (3 - 0)) + 0] ){
            case 'Piedra':
                dato ==='Papel' ? mensaje = 'Ganaste a piedra': dato ==='Tijera' ? mensaje = 'Perdiste ante Piedra' : mensaje = 'Empate'
                break
            case 'Papel':
                dato ==='Piedra' ? mensaje = 'Perdiste ante Papel': dato ==='Tijera' ? mensaje = 'Ganaste a Papel' : mensaje = 'Empate'
                break
            case 'Tijera':
                dato ==='Papel' ? mensaje = 'Perdiste ante Tijera': dato ==='Piedra' ? mensaje = 'Ganaste a Tijera' : mensaje = 'Empate'
                break
            
        }
    }
    

    
    $('#id').text(mensaje) 
    
        
    })
    
    });
    

```
<cod
e>


var resultado= document.getElementById(“Resultado”);
var jugador= “tijeras”;
var maquina= “piedra”;
var estado;

function ppt (a,b)
{
switch (true)
{
case (a=b):
estado=“empatas”;
console.log(“empatas”);
break;
case (a
“piedra” && b== “tijeras”):
estado=“ganas”;
break;
case (a == “papel” && b== “piedra”):
estado=“ganas”;
break;
case (a== “tijeras” && b == “papel”):
estado=“ganas”;
break;

default:
estado=“pierdes”;

}
}

ppt(jugador,maquina);

resultado.innerHTML=estado;

Logré visualizarlo en la consola, así que me siento muy contenta!

var user ="tijeras";
var cpu ="piedra";

switch(true){
    case (cpu===user):
        console.log ("Empate");
        break;
    case (cpu==="tijeras" && user==="papel"|| cpu==="papel" && user==="piedra" || cpu==="piedra" && user==="tijeras"):
        console.log ("Gana la maquina");
        break;
    default:
        console.log ("¡Ganas tú!");
        break;
}

Esta es mi versión del juego piedra, papel o tijera version switch:

var op1 = 'Papel';
var op2 = 'Tijera';
var op3 = 'Piedra';

var juego = (player1, player2) => {
    var e = 'En este juego ';
    switch (false){ //Para validar sí los datos fueron invalidos
        case player1 === op1 || player1 === op2 || player1 === op3 || 
        player2 === op1 || player2 === op2 || player2 === op3 :
            console.log(`Datos invalidos. Vuelve a digitarlos.`)
        break;
        default: //Cuando los datos son validos, empezamos con la lógica
            switch (player1){
                case op1:
                    switch (player2){
                        case op2:
                            console.log(`${e}ganó el jugador 2`);
                            break;
                        case op3:
                            console.log(`${e}ganó el jugador 1`);
                        break;
                    }
                break;
                case op2:
                    switch (player2){
                        case op1:
                            console.log(`${e} ganó el jugador 1`);
                        break;
                        case op3: 
                            console.log(`${e} ganó el jugador 2`)
                    }
                break;
                case op3: 
                    switch(player2){
                        case op1:
                            console.log(`${e} ganó el jugador 2`)
                        break;
                        case op2: 
                            console.log(`${e} ganó el jugador 1`)
                        break;
                    }
                break;
            } //Cuando ocurre un empate
            switch (true){
                case player1 == player2:
                    console.log(`${e} hubó un empate`);
                break;
            }
    }
}

juego('Papel', 'Papel');

Mostrando en la consola un empate.

Por aquí el código :V, aunque también me surge la duda de cual de las dos en un contexto igual seria mejor usar, saludos!

var opRock = "rock";
var opPaper = "Paper";
var opScissors = "Scissors";

function Resultado(user,cpu){

    switch(true){
        case (user === cpu) :
            console.log(user + " and " + cpu + " are the same, it's tie");
            break;
        case ((user === opRock && cpu === opPaper)||(user === opPaper && cpu === opScissors)||(user === opScissors && cpu === opRock)) :
            console.log("The winner is  " + cpu + ", Won CPU");
            break;
        default : 
            console.log("The winner is  " + user + ", Won User");
    }

}

Resultado(opScissors,opPaper);
let piedra = "piedra";
let papel = "papel";
let tijera = "tijera";

function ganador(user, machine) {

    switch (true) {

        case user == machine:
            resultado = "empate";
            break

        case user == piedra && machine == tijera:
            resultado = "user";
            break

        case user == papel && machine == piedra:
            resultado = "user";
            break

        case user == tijera && machine == papel:
            resultado = "user";
            break

        default:
            resultado = "machine";
    }

    return(resultado)
}

/* Luego llamamos la funcion con los parametros que queremos. Ej. ganador(piedra, tijera);
*/
var a = "s";
var b = "sc";
var result;

switch(true){
  case (a==b):
    console.log("empate");
    break;
  case ((a=='s'&& b =="sc") || (a=="sc" && b =="p")||
        (a=="p" && b=="s")):
    console.log("a wins");
    break;
  case ((a == "sc"|| b == "s") || (a =="p" && b=="sc") || (b=="s" && b=="s")):
    console.log("b wins")
}

Respuesta con switch

miOpcion = parseInt(prompt('Escoje piedra(1), papel(2) o tijeras(3)'))

var opcionMaquina = Math.ceil(Math.random() * 3)

function piedraPapelOTijeras() {
    switch (true) {
        case (miOpcion === 1 && opcionMaquina === 1):
            console.log("Piedra vs Piedra: Empate!")
            break;
        case (miOpcion === 1 && opcionMaquina === 2):
            console.log("Piedra vs Papel: Perdiste!")
            break;
        case (miOpcion === 1 && opcionMaquina === 3):
            console.log("Piedra vs Tijeras: Ganaste!")
            break;
        case (miOpcion === 2 && opcionMaquina === 1):
            console.log("Papel vs Piedra: Ganaste!")
            break;
        case (miOpcion === 2 && opcionMaquina === 2):
            console.log("Papel vs Papel: Empate!")
            break;
        case (miOpcion === 2 && opcionMaquina === 3):
            console.log("Papel vs Tijeras: Perdiste!")
            break;
        case (miOpcion === 3 && opcionMaquina === 1):
            console.log("Tijeras vs Piedra: Ganaste!")
            break;
        case (miOpcion === 3 && opcionMaquina === 2):
            console.log("Tijeras vs Papel: Ganaste!")
            break;
        case (miOpcion === 3 && opcionMaquina === 3):
            console.log("Tijeras vs Tijeras: Empate!")
            break;
        default:
            console.log('No es valido')
    }
}
piedraPapelOTijeras()

Les comparto mi reto:

var jugador1,jugador2;
var piedra,papel,tijera;

function jugar(jugador1,jugador2){
switch(piedra,papel,tijera){
    case piedra:
        if(jugador1==piedra && jugador2==papel){
            console.log("Gana el jugador 2");
        }else if(jugador1==piedra && jugador2==tijera){
            console.log("Gana el jugador 1");
        }else if(jugador1==piedra && jugador2==piedra){
            console.log("Empate!");
        }break;
    case papel:
        if(jugador1==papel && jugador2==tijera){
            console.log("Gana el jugador 2");
        }else if(jugador1==papel && jugador2==piedra){
            console.log("Gana el jugador 1");
        }else if(jugador1==papel && jugador2==papel){
            console.log("Empate!");
        }break;
    case tijera:
        if(jugador1==tijera && jugador2==piedra){
            console.log("Gana el jugador 2");
        }else if(jugador1==tijera && jugador2==papel){
            console.log("Gana el jugado 1");
        }else if(jugador1==tijera && jugador2==tijera){
            console.log("Empate!");
        }break;
    } 
}```

Yo me regí por una regla matemática, dependiendo de la elección, generará cierta suma, entonces podremos saber qué elecciones hicieron, luego sólo preguntamos quién eligió qué.

var user = Number(prompt("Ingrese su opció: 0-Piedra, 1-Papel, 2-Tijera"));
var pc = Math.floor(Math.random()*3);

var eleccion = ["Piedra", "Papel" , "Tijera"];

console.log(`Tu elegiste: ${eleccion[user]} y la PC eligió ${eleccion[pc]} `)

var suma = pc + user;

switch (suma) {
    case 0:
        console.log("Empate");
        break;

    case 1:
        user==0? console.log("Perdiste!"): console.log("Ganaste!");
        break;
        
    case 2:
        if(user!=1){
            user==0? console.log("Ganaste!"): console.log("Perdiste!");
        }else{
            console.log("Empate!")
        }
        break;
            
    case 3:
        user==1? console.log("Perdiste!"): console.log("Ganaste!");
        break;

    case 4:
        console.log("Empate");
        break;

    default:
        console.log("Tu elección ha sido incorrecta");
        break;
}```

Les comparto mi reto:

Hola Platzicompas, estas son mis soluciones:
.
Ver 1.0, un poco rudimentaria:
.

.
Ver 2.0, creo que un poco más descente:
.

.
Cualquier feedback es bienvenido.
😎

var user_choice;
var cpu_choice;
user_choice = prompt("User: ");

function getRandomInt() {
    return Math.floor(Math.random() * 3);
}

function cpuChoice (cpu_choice) {
    switch (cpu_choice) {
        case 0:
            cpu_choice = "piedra";
            break;
        case 1:
            cpu_choice = "papel";
            break;
        case 2:
            cpu_choice = "tijera";
            break;
    }
    return cpu_choice;
}

function jugarPpt () {
    var winner;
    cpu_choice = getRandomInt();
    cpu_choice = cpuChoice(cpu_choice);

    switch (true){
        case (user_choice == cpu_choice):
            winner = "Tie";
            break;
        case (user_choice == "piedra" && cpu_choice == "papel"):
            winner = "CPU wins";
            break;
        case (user_choice == "papel" && cpu_choice == "tijeras"):
            winner = "CPU wins";
            break;
        case (user_choice == "tijeras" && cpu_choice == "piedra"):
            winner = "CPU wins";
            break;
        default:
            winner = "User wins";
            break;
    }

    console.log("CPU Choice: " + cpu_choice);
    console.log("User Choice: " + user_choice);
    console.log(winner);
}

jugarPpt();

// Switch: piedra, papel o tijera
// ingrese los valores para cada jugador
var usuario = 'papel';
var maquina = 'papel';

var resultado;

function juego() {

    switch(resultado) {
        case usuario === maquina:
            console.log('Empate');
            break;
        case (usuario === 'papel' && maquina === 'piedra') || (usuario === 'tijera' && maquina === 'papel') || (usuario === 'piedra' && maquina === 'tijera'):
            console.log('Ganaste');
            break;
        default:
            console.log('Perdiste');
    }

}

juego();

Para trabajar con switch, solo necesitamos el switch statement.

Dentro del switch, podemos escribir varios casos para los que puedan aplicar las variables. En caso de que no encaje en ninguno, hay una que los recibe, que es el default.

Dentro de JS, existe el switch, algo un poquito más casual.

funciona bien
agradezco las criticas

var op1 = "piedra";
var op2 = "papel";
var op3 = "tijera";
var maquina = op1;
var humano = op2;
var ganador = resultado

  function resultado (humano,maquina){
    switch(true) {
   case humano == maquina :

       console.log ("EMPATE");
       break;
    
   case   ((humano == op1 && maquina == op2 ) || 
              (humano == op2 && maquina == op3) ||
              (humano == op3 && maquina == op1)):

               console.log("EL HUMANO PIERDE");
               break;
                
 case ((humano == op2 && maquina == op1 ) || 
           (humano == op3 && maquina == op2) ||
           (humano == op1 && maquina == op3)) :
                
               console.log("EL HUMANO GANA") ;  
                 break;    
       default: 
            console.log("escribiste mal");  
    }         
};      
    resultado();

var varia =[" ",“piedra”,“tijera”, “papel”];
var opcion1 = prompt("Ingresa el numero de la primera opción: piedra = 1, papel = 2 o tijera = 3 ");
if(opcion1 <=3 && opcion1 >=1)
{
var opcion2 = prompt("Ingresa el numero de la segunda opción (puede ser igual a la primera): piedra = 1, papel = 2 o tijera = 3 ");
if(opcion2 <=3 && opcion2 >=1)
{ console.log ( "Resultado entre " + varia[opcion1] + " y " + varia[opcion2]);
if(opcion2 === opcion1) { console.log("Empate " ) }
if((opcion1 ==1 && opcion2 ==2) || (opcion1 ==2 && opcion2 ==1)) { console.log(“Piedra rompe tijera” ) }
if((opcion1 ==1 && opcion2 ==3) || (opcion1 ==3 && opcion2 ==1)) { console.log(“papel envuelve piedra” )}
if((opcion1 ==2 && opcion2 ==3) || (opcion1 ==3 && opcion2 ==2)) { console.log(“Tijera corta papel” )}
} else{ console.log ( "Error se suspende ");

APORTE

var tijera = "tijera";
var piedra = "piedra";
var papel = "papel";

// Otra forma
function playGame (resultado , computadora) {
    switch (resultado) {
        case tijera:
            if (computadora === tijera) console.log ("¡EMPATE! Sigue intentando");
            else if (computadora === piedra) console.log("¡PERDISTE! Lo siento :(")
            else console.log("¡GANASTE, FELICIDADES!");
            break;
        case piedra:
            if (computadora === "tijera") console.log("¡GANASTE, FELICIDADES!");
            else if (computadora === "piedra") console.log("¡EMPATE! Sigue intentando");
            else console.log ("¡PERDISTE! Lo siento :(");
            break;
        case papel:
            if (computadora === "tijera") console.log ("¡PERDISTE! Lo siento :(");
            else if (computadora === "piedra") console.log("¡GANASTE, FELICIDADES!");
            else console.log("¡EMPATE! Sigue intentando");
            break;
        default:
            console.loh("No existe ese valor en resultado")   
    }
}

playGame(piedra, tijera);