let player;
let cpu;

const rpsGame = function (player, cpu) {
  player = prompt(`Rock Paper Scissors Game, which shape you go with:`);
  cpu = Math.trunc(Math.random() * 3 + 1);
  switch (player) {
    case 'Rock':
      if (cpu === 2)
        return alert(`CPU's Paper covers your ${player}: YOU LOOSE!!!`);
      if (cpu === 3)
        return alert(`Your ${player} crushes CPU's Scissors: YOU WIN!!`);
      if (cpu === 1)
        return alert(`Both players choose ${player}: ITS A TIE...!`);
      break;
    case 'Paper':
      if (cpu === 1)
        return alert(`Your ${player} covers CPU's Rock: YOU WIN!!`);
      if (cpu === 2)
        return alert(`Both players choose ${player}: ITS A TIE...!`);
      if (cpu === 3)
        return alert(`CPU's Scissors cuts your ${player}: YOU LOOSE!!!`);
      break;
    case 'Scissors':
      if (cpu === 1)
        return alert(`CPU's Rock crushes your ${player}: YOU LOOSE!!!`);
      if (cpu === 2)
        return alert(`Your ${player} cuts CPU's Paper: YOU WIN...!!`);
      if (cpu === 3)
        return alert(`Both players choose ${player}: ITS A TIE...!`);
      break;
    default:
      return alert(`Wrong! Please choose from Rock, Paper or Scissors`);
      break;
  }
};

using System;
using System.Linq;

public class ArtihmeticParser
{
  public static int Evaluate(string input)
  {
    return input.Split("+").Select(EvaluateProduct).Aggregate(0,(a,b) => a+b);
  }
  
  private static int EvaluateProduct(string input)
  {
    return input.Split("*").Select(EvaluateInteger).Aggregate(1,(a,b) => a*b);
  }
  
  private static int EvaluateInteger(string input)
  {
    return int.Parse(input);
  }
}

#just woke up from a random dream where I had a student explained to me this very simple algorythm. 
#Seems pretty usless to me unless anybody can think of an actually use??
#crazy simple but the dream was so vivid I just had to put it down hahahaha
def power_rooter(num):
    total = 1
    while num > 1 and num//2 == num/2:
        num = num / 2
        total *= num
    return total

unit module Foo;
error-here

module ToupperFirst where
    import Data.Char
    
    toUpperFirst ""    = ""
    toUpperFirst xs    = [toUpper (x) | x <- xs, x == head (xs)] ++ tail (xs)

def hello_world():
    return "Hello World"

package com.codewars;

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.Optional;
import java.util.function.Predicate;

public class TimeSlotFinder {
  
  public boolean isSuitable(TimeSlot slot, String startTimeString, long durationInSecodns) {
		LocalDateTime startTime = LocalDateTime.parse(startTimeString);
		return Optional.of(slot)
				.filter(startsBefore(startTime))
				.filter(hasEnoughTimeLeftInSlot(startTime, durationInSecodns))
				.isPresent();
	}

	public Predicate<TimeSlot> startsBefore(LocalDateTime startTime) {
		return slot -> slot.startTime.isBefore(startTime) || slot.startTime.isEqual(startTime);
	}

	public Predicate<TimeSlot> hasEnoughTimeLeftInSlot(LocalDateTime startTime, long durationInSecodns) {
		return slot -> ChronoUnit.SECONDS.between(startTime, slot.endTime) >= durationInSecodns;
	}



  public static class TimeSlot {
		public final LocalDateTime startTime;
		public final LocalDateTime endTime;
		public final long durationInSeconds;

		public TimeSlot(String dateTimeString, long durationInSeconds) {
			this.startTime = LocalDateTime.parse(dateTimeString);
			this.endTime = startTime.plus(durationInSeconds, ChronoUnit.SECONDS);
			this.durationInSeconds = durationInSeconds;
		}
  }
}

function groupByWeek(days) {
  var dates = days.map(a => new Date(a)).sort((a, b) => b - a);
  
  console.log(dates.map(a => (a.getMonth()+1) + "/" + a.getDate() + "/" + a.getFullYear()))

  var currentMonday = new Date();
  currentMonday.setDate(dates[0].getDate() - dates[0].getDay())
  
  var currentSunday = new Date()
  currentSunday.setDate(currentMonday.getDate() + 6);
  
  //console.log(firstMonday.getDay())
  //console.log(firstSunday.getDay())
  
  var weeks = []
  var currentWeek = []
  for(var date of dates) {
    if(date >= currentMonday && date <= currentSunday) {
      currentWeek.push((date.getMonth()+1) + "/" + date.getDate() + "/" + date.getFullYear())
    } else {
      if(currentWeek.length > 0) {
        weeks.push(currentWeek)
      }
      currentWeek = [(date.getMonth()+1) + "/" + date.getDate() + "/" + date.getFullYear()]
      currentMonday.setDate(date.getDate() - date.getDay())
      currentSunday.setDate(currentMonday.getDate() + 6);
    }
    
  }
  if(currentWeek.length > 0) {
    weeks.push(currentWeek)
  }
  
  return weeks
  
}

#include <map>
#include <sstream>
#include <cstdint>
#include <string>

                          // ( 1_x2 4_x1 4_x0 )
#define ALTERNATE_DISPLAY // ( 1x^2 4x^1 4x^0 )

class polynomial;
std::ostream &operator <<(std::ostream &lhs, polynomial rhs);

class polynomial
{
public:
    std::map<unsigned long long, double> coefficients;
    polynomial operator +(int rhs)
    {
        polynomial result(*this);
        int result_x0 = result.coefficients[0] += rhs;
        if (!result_x0)
        {
            result.coefficients.erase(0);
        }
        return result;
    }
    polynomial operator -(int rhs)
    {
        polynomial result(*this);
        int result_x0 = result.coefficients[0] -= rhs;
        if (!result_x0)
        {
            result.coefficients.erase(0);
        }
        return result;
    }
    polynomial operator *(int rhs)
    {
        polynomial result;
        for (std::pair<unsigned long long, double> const &term : this->coefficients)
        {
            result.coefficients[term.first] = rhs * term.second;
        }
        return result;
    }
    polynomial operator +(polynomial rhs)
    {
        polynomial result;
        for (std::pair<unsigned long long, double> const &term : this->coefficients)
        {
            result.coefficients[term.first] = term.second;
        }
        for (std::pair<unsigned long long, double> const &term : rhs.coefficients)
        {
            double &lhsx = this->coefficients[term.first];
            if (lhsx != -term.second)
            {
                result.coefficients[term.first] += term.second;
            }
            else
            {
                result.coefficients.erase(term.first);
            }
        }
        return result;
    }
    polynomial operator -(polynomial rhs)
    {
        polynomial result;
        for (std::pair<unsigned long long, double> const &term : this->coefficients)
        {
            result.coefficients[term.first] = term.second;
        }
        for (std::pair<unsigned long long, double> const &term : rhs.coefficients)
        {
            double &lhsx = this->coefficients[term.first];
            if (lhsx != term.second)
            {
                result.coefficients[term.first] -= term.second;
            }
            else
            {
                result.coefficients.erase(term.first);
            }
        }
        return result;
    }
    polynomial operator *(polynomial rhs)
    {
        polynomial result;
        for (std::pair<unsigned long long, double> const &term_i0 : this->coefficients)
        {
            for (std::pair<unsigned long long, double> const &term_i1 : rhs.coefficients)
            {
                result.coefficients[term_i0.first + term_i1.first] 
                    += term_i0.second * term_i1.second;
                std::cout << "    " << result << '\n';
            }
        }
        return result;
    }
};

polynomial operator ""_x(unsigned long long coefficient)
{
    polynomial result;
    if (coefficient)
    {
        result.coefficients[1] = coefficient;    
    }
    return result;
}

// I don't know how to make a user-defined literal that takes two arguments (like 1e9)
polynomial operator""_x0(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[0]=coefficient;return result;}
polynomial operator""_x1(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[1]=coefficient;return result;}
polynomial operator""_x2(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[2]=coefficient;return result;}
polynomial operator""_x3(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[3]=coefficient;return result;}
polynomial operator""_x4(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[4]=coefficient;return result;}
polynomial operator""_x5(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[5]=coefficient;return result;}
polynomial operator""_x6(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[6]=coefficient;return result;}
polynomial operator""_x7(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[7]=coefficient;return result;}
polynomial operator""_x8(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[8]=coefficient;return result;}
polynomial operator""_x9(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[9]=coefficient;return result;}
polynomial operator""_x10(unsigned long long coefficient){polynomial result;if(coefficient)result.coefficients[10]=coefficient;return result;}

polynomial pow(polynomial lhs, unsigned long long rhs)
{
    polynomial result = 1_x0;
    for (unsigned long long _0 = 0; _0 < rhs; ++_0)
    {
        result = result * lhs;
    }
    return result;
}

std::ostream &operator <<(std::ostream &lhs, polynomial rhs)
{
    lhs << "( ";
    for (auto x_it = rhs.coefficients.rbegin(); x_it != rhs.coefficients.rend(); ++x_it)
    {
        lhs << x_it->second 
#ifndef ALTERNATE_DISPLAY
            << "_x" << x_it->first << ' ';
#else
            << (x_it->first ? "x" : "") << (x_it->first > 1 ? "^" + std::to_string(x_it->first) : "") << ' ';
#endif
    }
    lhs << ')'; 
    return lhs;
}

add(X, Y, R) :- R is X + Y.
add0(_, _, _).
add_or_sub(X, Y, R) :- R is X + Y; R is X - Y.