Freestyle Sparring

import random
import time
def not_even(n):
    pizza_time = time.ctime()
    if n % 2 == 0:
        return 'its not even', pizza_time
    else:
        return 'its still not even', pizza_time
    return pizza_time
n = random.randint(0, 10000)
 
print(not_even(n))

fn mean(x: &[f64]) -> f64 {
    let x_len_float = x.len() as f64;
    return x.iter().sum::<f64>() / x_len_float;
}

v='aeiou'
x=(s,f)=>[...s].map(f).join``
d=s=>x(s,e=>v[Math.min(6,e)-1]||e)
n=s=>x(s,e=>v.indexOf(e)+1||e)

#include <string>
#include <vector>

auto split(const std::string& str, char sep) {
  auto result = std::vector<std::string>{};
  std::string::size_type pos = 0, pos2 = 0;
  
  while ((pos2 = str.find(sep, pos)) != std::string::npos) {
    result.push_back(str.substr(pos, pos2 - pos));
    pos = pos2 + 1;
  }
  result.push_back(str.substr(pos));
  return result;
}

#include <vector>
#include <numeric>
using namespace std;
int missingNumber(vector<int> nums) {
  return (nums.size() * (nums.size() + 1))/2 - accumulate(nums.begin(), nums.end(), 0);
}

#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