public class Ranking{
  public static Integer getPoints(String[] matches) {
   return null;
  }
}

odd_even=lambda n:int(__import__('requests').get(f'https://api.isevenapi.xyz/api/iseven/{n}/').json()['iseven'])

mylist = [("yellow", 1), ("blue", 2), ("yellow", 3), ("blue", 4), ("red", 1)]


def group(lst: list[tuple[str, int], ...], result: dict[str, int]={}) -> dict[str, list[int, ...]]:
    {result[c].append(n) if c in result else result.update({c: [n]}) for c, n in lst}
    return result


# print(group(mylist))

def average(t: tuple[tuple[int | float, ...], ...]) -> list[int | float]:
    return [sum(i) / len(i) for i in zip(*t)]

import random

class ArchitecturalGame:
    def __init__(self):
        self.score = 0
        self.level = 1
        self.max_level = 3
        self.choices = ["Design a skyscraper", "Renovate an old building", "Plan a city layout"]
        self.projects = ["Design a residential complex", "Renovate a historic landmark", "Create an eco-friendly city district"]
    
    def display_menu(self):
        print("Welcome to the Architectural Game!")
        if self.level <= self.max_level:
            print("Choose an option:")
            for i, choice in enumerate(self.choices):
                print(f"{i + 1}. {choice}")
        else:
            print("Your architectural firm is now established! Clients are approaching you with projects.")
            print("Choose a project:")
            for i, project in enumerate(self.projects):
                print(f"{i + 1}. {project}")
    
    def play(self):
        self.display_menu()
        if self.level <= self.max_level:
            choice = int(input("Enter your choice: "))
            if choice < 1 or choice > len(self.choices):
                print("Invalid choice. Please try again.")
                self.play()
            else:
                self.process_choice(choice)
        else:
            project_choice = int(input("Enter the project you want to work on: "))
            if project_choice < 1 or project_choice > len(self.projects):
                print("Invalid choice. Please try again.")
                self.play()
            else:
                self.process_project(project_choice)
    
    def process_choice(self, choice):
        if choice == 1:
            self.design_skyscraper()
        elif choice == 2:
            self.renovate_building()
        elif choice == 3:
            self.plan_city_layout()
    
    def process_project(self, project_choice):
        print(f"You chose to work on: {self.projects[project_choice - 1]}")
        self.score += random.randint(1, 10)
        self.display_score()
    
    def design_skyscraper(self):
        print("You chose to design a skyscraper.")
        # Implement logic for designing a skyscraper
        self.score += random.randint(1, 10) * self.level
        self.display_score()
    
    def renovate_building(self):
        print("You chose to renovate an old building.")
        # Implement logic for renovating a building
        self.score += random.randint(1, 10) * self.level
        self.display_score()
    
    def plan_city_layout(self):
        print("You chose to plan a city layout.")
        # Implement logic for planning a city layout
        self.score += random.randint(1, 10) * self.level
        self.display_score()
    
    def display_score(self):
        print(f"Your current score is: {self.score}")
        if self.level < self.max_level:
            print("Advancing to the next level...")
            self.level += 1
            self.play()
        else:
            print("Congratulations! You completed all levels.")
            self.level += 1
            self.play()

# Main function
def main():
    game = ArchitecturalGame()
    game.play()

if __name__ == "__main__":
    main()

    
   

const firstNonRepeatingCharacter = (str) => {
  let nonRepeatingCharacter = '';
  const repeatingCharacters = {};
  
  for(let char of str) {
    repeatingCharacters[char] === undefined ? repeatingCharacters[char] = 1 : repeatingCharacters[char] += 1
  }
  for(const [key, value] of Object.entries(repeatingCharacters)) {
    if (nonRepeatingCharacter !== '') break;
    if (value === 1) nonRepeatingCharacter = key;
  }
  return nonRepeatingCharacter !== '' ? nonRepeatingCharacter : null;
};

module ToUpperFirst where

    import Data.Char (toUpper, isSpace)
    
    toUpperFirst (x : xs) = if isSpace x then x : toUpperFirst xs else toUpper x : xs
    toUpperFirst _ = ""

dumbRockPaperScissors=lambda a,b:('Draw','Player 1 wins','Player 2 wins')['RPS'.find(a[0])-'RPS'.find(b[0])]
def rps (p1,p2):
    retval= {
        'R':{'R': 0, 'S':-1, "P": 1},
        'S':{'R': 1, 'S': 0, 'P':-1},
        'P':{'R':-1, 'S': 1, 'P':0}
    }
    return retval[p1][p2]