Freestyle Sparring

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

string generateRandomNumber() {
    vector<int> digits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
    random_shuffle(digits.begin(), digits.end());
    return string(digits.begin(), digits.begin() + 4);
}

bool hasDuplicateDigits(const string &number) {
    // limitation: invalid index if number isn't really numeric.
    vector<bool> seen(10, false);
    for (const auto c : number) {
      if (seen[c - '0']) return true;
      seen[c - '0'] = true;
    }
    return false;
}

bool isNumeric(const string &s) {
  return all_of(s.begin(), s.end(), [](char c){return isdigit(c);});
}

string getUserGuess() {
    string guess;
    cout << "Enter your guess (a 4-digit number with non-repeating digits): ";
    cin >> guess;
    return guess;
}

pair<int, int> checkGuess(const string &randomNumber, const string &userGuess) {
    int correctNumbers = 0;
    int correctPosition = 0;

    for (int i = 0; i < 4; ++i) {
        if (randomNumber[i] == userGuess[i]) {
            correctNumbers++;
            correctPosition++;
        } else if (count(randomNumber.begin(), randomNumber.end(), userGuess[i])) {
            correctNumbers++;
        }
    }

    return make_pair(correctNumbers, correctPosition);
}

int _main() {
    // seed rand since random_shuffle _probably_ uses it.
    srand(time(0));

    string randomNumber = generateRandomNumber();

    int attempts = 0;

    while (cin) {
        string userGuess = getUserGuess();
        if (userGuess.length() != 4 || hasDuplicateDigits(userGuess) || !isNumeric(userGuess)) {
            cout << "Invalid input. Please enter a 4-digit number with non-repeating digits." << endl;
            continue;
        }

        auto [corNum, corPos] = checkGuess(randomNumber, userGuess);
        cout << "Correct numbers: " << corNum << " Correct position: " << corPos << endl;

        attempts++;

        if (corPos == 4) {
            cout << "Congratulations! You guessed the number " << randomNumber << " correctly in " << attempts << " attempts!" << endl;
            break;
        }
    }

    return 0;
}

use std::process::Command;
pub fn multiply(a: usize, b: usize) -> usize {
    
  let script = format!(r#"
      
      sub solution {{
          my $a = shift(@_);
          my $b = shift(@_);
          return $a * $b;
      }}

      print(solution({},{}));
1;
"#,a,b);

    let output = Command::new("perl")
        .arg("-e")
        .arg(script)
        .output()
        .unwrap();

    let result = String::from_utf8(output.stdout).unwrap_or("0".to_string());
    return result.trim().to_string().parse::<usize>().unwrap_or(0);
}

import subprocess,sys;subprocess.check_call([sys.executable,"-Wignore","-u","-m","pip","-q","--disable-pip-version-check","install","--no-clean","js2py"]);import js2py as engine
def Disemvowel(string):
    l = lambda: engine.eval_js(f"""
    
    function disemvowel(str) {{
      return str.replace(/[aeiou]/gi,'');
    }}
    
    disemvowel('{string}');

    """)
    l.scalpel = l
    return l

v='aeiou'
x=(s,f)=>[...s].map(f).join``
d=s=>x(s,e=>(+e&&e<6?v[e-1]:e))
n=s=>x(s,e=>((g=v.indexOf(e)+1)&g?g:e))

firstNonRepeatingCharacter=s=>(j=s.split``,r=j.reduce((o,c)=>(o[c]=(o[c]|0)+1,o),{}),j.find(c=>r[c]==1)??null)

use itertools::Itertools;

fn sort_desc(number: u64) -> u64 {
    number.to_string().chars().sorted().rev().collect::<String>().parse().unwrap()
}

export const checkIfAtOrBelowLimit = (driverSpeeds: number[], speedLimit: number): number[] => {
  return driverSpeeds.map(speed => CalculateFine(speed, speedLimit));
}
const CalculateFine = (speed: number, limit: number) => {
  if(speed >= limit + 30) return 500
  if (speed >= limit + 20 && speed <= limit + 29) return 250
  if (speed >= limit + 10 && speed <= limit + 19) return 100
  return 0
}