Kumite

def convert_decimal_roman(number: int) -> str:
    try:
        number = int(number)
    except ValueError:
        print("Invalid Input, Value Error")
        return("Invalid Input")
    str = ''
    numDct = {1000: "M",
              900: "CM",
              500: "D",
              400: "CD",
              100: "C",
              90: "XC",
              50: "L",
              40: "XL",
              10: "X",
              9: "IX",
              5: "V",
              4: "IV",
              1: "I"}
    
    decimals = []
    for key, value in numDct.items():
        decimals.append(value * (number // key))
        number %= key
        
    return "".join(decimals)

from gmpy2 import is_prime as prime_checker

def removeEverySecond(string):
    return string[::2]

public class FizzBuzz
{
    public string GetOutput(int number) {
      if (number % 15 == 0) return "FizzBuzz";
      else if (number % 3 == 0) return "Fizz";
      else if (number % 5 == 0) return "Buzz";
      else return number.ToString();
      // Fizz buzz is a popular computer science interview question.  
      // The function above is given a number - if the number is
      // divisible by 3, return "fizz", if it's divisible by 5, 
      // return "buzz", if not divisble by 3 or 5 - return the
      // number itself.
    }
}

4

/*13.Dec.2021. Draw of the UEFA Champions League quarter-finals. 
This was a joke with a bad software. They had to redraw it. Decided to code a better one.

Rules: there are 16 teams, 8 group-winners in one pot and 8 runners-up in another pot.
A runner-up team is drawed first. Then it is paired with a group-winner. 
There are 2 criteria for the opponent:
it can not go from the same group
it can not have the same nationality.
After the pairing, the drawed teams are taken out from their pots before the next pairing.

During development turned out that the draw can end in a way that 
a team drawed from the runners-up pot DO NOT have 
an eligible opponent in the other pot.
This case is handled and log functions are added to shorten the code.*/


/*database: 2 arrays of objects*/
const groupWinners = [
    {
        name: "Manchester City",
        group: "A",
        nationality: "English"
    },
    {
        name: "Liverpool",
        group: "B",
        nationality: "English"
    },
    {
        name: "Ajax Amsterdam",
        group: "C",
        nationality: "Dutch"
    },
    {
        name: "Real Madrid",
        group: "D",
        nationality: "Spanish"
    },
    {
        name: "Bayern Munich",
        group: "E",
        nationality: "German"
    },
    {
        name: "Manchester United",
        group: "F",
        nationality: "English"
    },
    {
        name: "Lille",
        group: "G",
        nationality: "French"
    },
    {
        name: "Juventus",
        group: "H",
        nationality: "Italian"
    }
];

const runnersUp = [
    {
        name: "Paris Saint-Germain",
        group: "A",
        nationality: "French"
    },
    {
        name: "Atletico Madrid",
        group: "B",
        nationality: "Spanish"
    },
    {
        name: "Sporting CP",
        group: "C",
        nationality: "Portuguese"
    },
    {
        name: "Internazionale",
        group: "D",
        nationality: "Italian"
    },
    {
        name: "Benfica",
        group: "E",
        nationality: "Portuguese"
    },
    {
        name: "Villarreal",
        group: "F",
        nationality: "Spanish"
    },
    {
        name: "FC Salzburg",
        group: "G",
        nationality: "Austrian"
    },
    {
        name: "Chelsea",
        group: "H",
        nationality: "English"
    }
];

/*log function */
function log(textStr, groupStr, nationalityStr, endStr, teamObj) {
    console.log(
        textStr,
        teamObj.name,
        groupStr,
        teamObj.group,
        nationalityStr,
        teamObj.nationality,
        endStr
    );
}

/*log the teams */
console.log("\nWELCOME TO THE DRAW OF THE UEFA CHAMPIONS LEAGUE QUARTER-FINALS!\n");
console.log("Let's see the teams!\n");
console.log("Group winners:\n");
groupWinners.forEach(
    team => {
        log("", " (Group: ", " Nationality: ", ")", team);
    }
);
console.log("\nRunners-up:\n");
runnersUp.forEach(
    team => {
        log("", " (Group: ", " Nationality: ", ")", team);
    }
);

console.log("\n\nLet's start the draw!\n");
draw();

function draw() {
    /*arrays containing teams which can be still drawed and an array for the pairings*/
    let groupWinnersToDraw = [...groupWinners];
    let runnersUpToDraw = [...runnersUp];
    let pairings = [];

    /*while there are teams to draw */
    while (runnersUpToDraw.length > 0) {
        /*choose a random team from runnersUpToDraw */
        let index = Math.floor(Math.random() * (runnersUpToDraw.length));
        let teamToFace = runnersUpToDraw[index];
        /*updating the runnersUpToDraw array*/
        runnersUpToDraw = runnersUpToDraw
            .slice(0, index)
            .concat(
                runnersUpToDraw.slice(index + 1, runnersUpToDraw.length)
            );

        log("\n\nTeam to face:", " (Group: ", " Nationality: ", ")", teamToFace);
        console.log("\n");

        /*selecting the potential opponents */
        let potentialOpponents = groupWinnersToDraw.filter(
            team =>
                (team.group != teamToFace.group && 
                team.nationality != teamToFace.nationality)
        );
        if (potentialOpponents.length == 0) {
            potentialOpponents.push(
                `No eligible opponent for ${teamToFace.name}! We have to re-draw!`
            );
        }

        if (typeof potentialOpponents[0] == "string") {
            console.log(potentialOpponents[0]);
            return;
        }

        console.log("Potential opponents:\n");
        potentialOpponents.forEach(
            team => 
                log("", " (Group: ", " Nationality: ", ")", team)
        );

        /*choose a random team from potentialOpponents */
        let anotherIndex = Math.floor(Math.random() * (potentialOpponents.length));
        let opponent = potentialOpponents[anotherIndex];
        log("\n\nThe opponent is:", " (Group: ", " Nationality: ", ")", opponent);
        /*updating the groupWinnersToDraw array*/
        let yetAnotherIndex = 0;
        for (let i = 0; i < groupWinnersToDraw.length; i++) {
            if (groupWinnersToDraw[i].name == opponent.name) {
                yetAnotherIndex = i;
            }
        }
        groupWinnersToDraw = groupWinnersToDraw
            .slice(0, yetAnotherIndex)
            .concat(
                groupWinnersToDraw.slice(yetAnotherIndex + 1, groupWinnersToDraw.length)
            );

        if (runnersUpToDraw.length > 0) {    
            console.log("\n\nRemaining group-winners:\n")
            groupWinnersToDraw.forEach(
                team => {
                    log("", " (Group: ", " Nationality: ", ")", team);
                }
            );

            console.log("\nRemaining runners-up:\n");
            runnersUpToDraw.forEach(
                team => {
                    log("", " (Group: ", " Nationality: ", ")", team);
                }
            );
        }

        /*save the pairings */
        let drawing = [];
        drawing.push(teamToFace, opponent);
        pairings.push(drawing);
    }

    /*log the draw */
    console.log("\nTHE QUARTER-FINALS: \n");
    pairings.forEach(
        pair => {
            console.log(
                pair[0].name,
                " (Group: ",
                pair[0].group, 
                " Nationality: ",
                pair[0].nationality, 
                ")",
                "   vs   ",
                pair[1].name, 
                " (Group: ",
                pair[1].group, 
                " Nationality: ",
                pair[1].nationality,
                ")"
            );
        }
    );
}