F# To Clojure Converter

let generatePassword length =
let rand = Random()
let upperChars = “ABCDEFGHIJKLMNOPQRSTUVWXYZ”
let lowerChars = “abcdefghijklmnopqrstuvwxyz”
let numbers = “0123456789”
let specialChars = “!@#$%^&*()-_=+[]{};:,.<>?/`~”

let allChars = upperChars + lowerChars + numbers + specialChars
let password = StringBuilder()

for i in 1 .. length do
let index = rand.Next(allChars.Length)
password.Append(allChars.[index]) |> ignore

password.ToString()

[]
let main argv =
printf “Enter the desired length of the password: ”
let input = Console.ReadLine()

match Int32.TryParse(input) with
| (true, length) when length > 0 ->
let password = generatePassword length
printfn “Generated Password: %s” password
| _ ->
printfn “Please enter a valid positive integer.”

0

(defn generate-password [length]
(let [rand (Random.)
upper-chars “ABCDEFGHIJKLMNOPQRSTUVWXYZ”
lower-chars “abcdefghijklmnopqrstuvwxyz”
numbers “0123456789”
special-chars “!@#$%^&*()-_=+[]{};:,.<>?/`~”
all-chars (str upper-chars lower-chars numbers special-chars)
password (StringBuilder.)]
(dotimes [_ length]
(let [index (.nextInt rand (count all-chars))]
(.append password (.charAt all-chars index))))
(.toString password)))

(defn -main []
(print “Enter the desired length of the password: “)
(let [input (read-line)
length (try (Integer. input) (catch Exception _ nil))]
(if (and length (> length 0))
(let [password (generate-password length)]
(println (str “Generated Password: ” password)))
(println “Please enter a valid positive integer.”))))

let isPrime n =
if n < 2 then false else let upperLimit = int (sqrt (float n)) seq { 2 .. upperLimit } |> Seq.forall (fun i -> n % i <> 0)

let generatePrimes limit =
seq { 2 .. limit }
|> Seq.filter isPrime
|> Seq.toList

let main () =
Console.WriteLine(“Enter a limit for generating prime numbers:”)
let limitInput = Console.ReadLine()

match Int32.TryParse(limitInput) with
| (true, limit) when limit >= 2 ->
let primes = generatePrimes limit
Console.WriteLine($”Prime numbers up to {limit}: {String.Join(“, “, primes)}”)

Console.WriteLine(“Enter a number to check if it’s prime:”)
let numberInput = Console.ReadLine()

match Int32.TryParse(numberInput) with
| (true, number) ->
if isPrime number then
Console.WriteLine($”{number} is a prime number.”)
else
Console.WriteLine($”{number} is not a prime number.”)
| _ ->
Console.WriteLine(“Invalid number input.”)
| _ ->
Console.WriteLine(“Invalid limit input. Please enter a number greater than or equal to 2.”)

[]
let mainEntry _ =
main()
0

(defn is-prime [n]
(if (< n 2) false (let [upper-limit (Math/floor (Math/sqrt (double n)))] (every? (fn [i] (not (= (mod n i) 0))) (range 2 (inc (int upper-limit))))))) (defn generate-primes [limit] (filter is-prime (range 2 (inc limit)))) (defn main [] (println "Enter a limit for generating prime numbers:") (let [limit-input (read-line) limit (try (Integer/parseInt limit-input) (catch Exception _ nil))] (if (and limit (>= limit 2))
(let [primes (generate-primes limit)]
(println (str “Prime numbers up to ” limit “: ” (str/join “, ” primes)))

(println “Enter a number to check if it’s prime:”)
(let [number-input (read-line)
number (try
(Integer/parseInt number-input)
(catch Exception _
nil))]
(if number
(if (is-prime number)
(println (str number ” is a prime number.”))
(println (str number ” is not a prime number.”)))
(println “Invalid number input.”)))
(println “Invalid limit input. Please enter a number greater than or equal to 2.”))))

(defn -main []
(main))