defmodule SimpleCalculator do
def start do
IO.puts(“Welcome to the Simple Calculator!”)
calculate()
end

defp calculate do
number1 = get_number(“Enter the first number:”)
operator = get_operator(“Enter an operator (+, -, *, /):”)
number2 = get_number(“Enter the second number:”)

result = perform_operation(number1, operator, number2)

IO.puts(“The result of #{number1} #{operator} #{number2} is #{result}”)
end

defp get_number(prompt) do
IO.write(“#{prompt} “)
case Integer.parse(IO.gets(“”)) do
{number, _} -> number
:error ->
IO.puts(“Invalid number. Please try again.”)
get_number(prompt)
end
end

defp get_operator(prompt) do
IO.write(“#{prompt} “)
operator = String.trim(IO.gets(“”))
if operator in [“+”, “-“, “*”, “/”], do: operator, else:
IO.puts(“Invalid operator. Please try again.”)
get_operator(prompt)
end

defp perform_operation(number1, “+”, number2), do: number1 + number2
defp perform_operation(number1, “-“, number2), do: number1 – number2
defp perform_operation(number1, “*”, number2), do: number1 * number2
defp perform_operation(number1, “/”, number2) when number2 != 0, do: number1 / number2
defp perform_operation(_, “/”, 0), do: “undefined (division by zero)”

end

SimpleCalculator.start()

class SimpleCalculator {
static start() {
console.log(“Welcome to the Simple Calculator!”);
this.calculate();
}

static async calculate() {
const number1 = await this.getNumber(“Enter the first number:”);
const operator = await this.getOperator(“Enter an operator (+, -, *, /):”);
const number2 = await this.getNumber(“Enter the second number:”);

const result = this.performOperation(number1, operator, number2);

console.log(`The result of ${number1} ${operator} ${number2} is ${result}`);
}

static getNumber(prompt) {
return new Promise((resolve) => {
process.stdout.write(`${prompt} `);
process.stdin.once(“data”, (input) => {
const number = parseInt(input.toString().trim());
if (!isNaN(number)) {
resolve(number);
} else {
console.log(“Invalid number. Please try again.”);
resolve(this.getNumber(prompt));
}
});
});
}

static getOperator(prompt) {
return new Promise((resolve) => {
process.stdout.write(`${prompt} `);
process.stdin.once(“data”, (input) => {
const operator = input.toString().trim();
if ([“+”, “-“, “*”, “/”].includes(operator)) {
resolve(operator);
} else {
console.log(“Invalid operator. Please try again.”);
resolve(this.getOperator(prompt));
}
});
});
}

static performOperation(number1, operator, number2) {
switch (operator) {
case “+”:
return number1 + number2;
case “-“:
return number1 – number2;
case “*”:
return number1 * number2;
case “/”:
return number2 !== 0 ? number1 / number2 : “undefined (division by zero)”;
}
}
}

SimpleCalculator.start();

defmodule PasswordGenerator do
@lowercase “abcdefghijklmnopqrstuvwxyz”
@uppercase “ABCDEFGHIJKLMNOPQRSTUVWXYZ”
@digits “0123456789”
@special_characters “!@#$%^&*()-_=+[]{}|;:,.<>?/~”

def generate_password(length) when length < 4 do {:error, "Password length must be at least 4"} end def generate_password(length) do password = 1..(length - 4) |> Enum.map(fn _ -> random_char() end)
|> List.to_string()
|> add_required_characters()

password |> shuffle()
end

defp random_char() do
Enum.random(@lowercase <> @uppercase <> @digits <> @special_characters)
end

defp add_required_characters(password) do
required_chars = [
Enum.random(@lowercase),
Enum.random(@uppercase),
Enum.random(@digits),
Enum.random(@special_characters)
]

required_chars ++ String.graphemes(password)
end

defp shuffle(password_chars) do
password_chars
|> Enum.shuffle()
|> List.to_string()
end
end

# Example usage:
# PasswordGenerator.generate_password(12)

class PasswordGenerator {
private static lowercase = “abcdefghijklmnopqrstuvwxyz”;
private static uppercase = “ABCDEFGHIJKLMNOPQRSTUVWXYZ”;
private static digits = “0123456789”;
private static specialCharacters = “!@#$%^&*()-_=+[]{}|;:,.<>?/~”;

public static generatePassword(length: number): string | { error: string } {
if (length < 4) { return { error: "Password length must be at least 4" }; } const password = Array.from({ length: length - 4 }, () => this.randomChar()).join(”);
const finalPassword = this.addRequiredCharacters(password);

return this.shuffle(finalPassword);
}

private static randomChar(): string {
const allChars = this.lowercase + this.uppercase + this.digits + this.specialCharacters;
const randomIndex = Math.floor(Math.random() * allChars.length);
return allChars[randomIndex];
}

private static addRequiredCharacters(password: string): string {
const requiredChars = [
this.randomCharFrom(this.lowercase),
this.randomCharFrom(this.uppercase),
this.randomCharFrom(this.digits),
this.randomCharFrom(this.specialCharacters)
];

return […requiredChars, …Array.from(password)].join(”);
}

private static randomCharFrom(chars: string): string {
const randomIndex = Math.floor(Math.random() * chars.length);
return chars[randomIndex];
}

private static shuffle(password: string): string {
const shuffled = password.split(”).sort(() => Math.random() – 0.5);
return shuffled.join(”);
}
}

// Example usage:
// console.log(PasswordGenerator.generatePassword(12));