Freestyle Sparring

#include <vector>
#include <algorithm>
#include <utility>

bool Ordering(const std::vector<int> &num) {
  if (num.size()<=1) return true;
  return std::none_of(std::next(num.cbegin()),num.end(),
                      [prev=num[0]](int val) mutable {
                        return val<std::exchange(prev,val);
                      });
}

#include <string>
#include <string_view>
#include <vector>
#include <numeric>

std::string Jointup(const std::vector<std::string> &name , const std::string_view delim = " , "){
  if (name.empty()) return "";
  return std::accumulate(std::next(name.begin()),name.end(),
                         name.front(),
                         [&](auto &s, auto &n){return s.append(delim).append(n);});
}

local function find_squares_in_array(arr)
  local sum = 0
  for _, v in ipairs(arr) do
    sum = sum + v ^ 2
  end
  return sum
end

return find_squares_in_array

def Complicated_Greetings(name):
    h=["H","e","l","l","o"]
    c=","
    w=["W","o","r","l","d"]
    e="!"
    k=""
    for i in h:
        k+=i
    if name=="":
        k+=c
        k+=" "
        for i in w:
            k+=i
        k=k+e+e
    else:
        k+=" "
        k+=name
    return k

#include <ratio>
#include <utility>
#include <cstddef>
#include <tuple>
#include <type_traits>

template <typename... Coeffs>
struct Polynomial;

// Helpers to help "trim" Polynomials of leading zeroes.
template<typename...> struct trim_impl;
template<> struct trim_impl<> : std::common_type<Polynomial<>> {};
template<typename R1, typename... Rs> struct trim_impl<R1, Rs...> : std::conditional<sizeof...(Rs) and std::is_same_v<R1, std::ratio<0>>, typename trim_impl<Rs...>::type, Polynomial<R1, Rs...>> {};

template <typename... Coeffs>
struct Polynomial {
    // Degree of Polynomial.
    static constexpr auto degree = sizeof...(Coeffs) - 1;
    // Alias for type of i-th std::ratio in the parameter pack. Pre-C++26 workaround for pack indexing.
    template <std::size_t I> using at = std::tuple_element_t<I, std::tuple<Coeffs...>>;
    // Alias for Polynomial type with leading zeroes removed.
    using trim = typename trim_impl<Coeffs...>::type;
    // Pads by adding leading zeroes until the parameter pack becomes of size I.
    template <std::size_t... Is> static constexpr auto pad_impl(std::index_sequence<Is...> seq) -> Polynomial<std::ratio<Is & 0>..., Coeffs...>;
    template <std::size_t I>     static constexpr auto pad = decltype(pad_impl(std::make_index_sequence<std::max(I, degree) - degree>{})){};
    
    // Private (but not really) helpers:
    template <typename... R1, typename... Rs> static constexpr auto add_impl(Polynomial<R1...>, Polynomial<Rs...>)
        -> Polynomial<std::ratio_add<R1, Rs>...>;

    template <typename... Rs, std::size_t... Is> static constexpr auto diff_impl(std::index_sequence<Is...>)
        -> Polynomial<std::ratio_multiply<at<Is>, std::ratio<degree - Is>>...>;
    
    template <typename C, std::size_t... Is> static constexpr auto integrate_impl(std::index_sequence<Is...>)
        -> Polynomial<std::ratio_divide<Coeffs, std::ratio<degree + 1 - Is>>..., C>;
        
    // Public aliases.
    template <typename Other> using add = typename decltype(add_impl(pad<Other::degree>, Other::template pad<degree>))::trim;
    using differentiated = decltype(diff_impl(std::make_index_sequence<degree + not degree>{}));
    template<typename C> using integrated = typename decltype(integrate_impl<C>(std::make_index_sequence<degree + 1>{}))::trim;
};

def count_prime(n, prime, factors):
    count = 0
    while n % prime == 0: 
        count += 1
        n //= prime
    if count: 
        factors.append((prime, count))
    return n, factors

def is_prime(n):
    for i in range(7, int(n ** 0.5) + 1, 2):
        if n % i == 0:
            return False
    return True

def prime_factorization(n):
    factors = []
    n, factors = count_prime(n, 2, factors)
    prime = 3
    while prime * prime <= n:
        n, factors = count_prime(n, prime, factors)
        prime += 2
        while not is_prime(prime):
            prime += 2
    if n > 1: 
        factors.append((n, 1))
    return factors

import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.Collectors;
import java.math.BigInteger;

public class MaxNumber {
    public static BigInteger print(long number) {
      String numeroMaximo = Long.toString(number)                      
                    .chars()                              
                    .mapToObj(Character::toString)
                    .sorted((a, b) -> b.compareTo(a))
                    .collect(Collectors.joining());
      return new BigInteger(numeroMaximo);
    }
}

def m(a, b):
    # Did you know? This is an implementation of Long Multiplacation
    negative_result = (a < 0) ^ (b < 0)
    a, b = abs(a), abs(b)
    a_str = str(a)[::-1]
    b_str = str(b)[::-1]
    result_length = len(a_str) + len(b_str)
    result = [0] * result_length
    for i in range(len(a_str)):
        for j in range(len(b_str)):
            digit_a = int(a_str[i])
            digit_b = int(b_str[j])
            product = digit_a * digit_b
            result[i + j] += product
            carry = result[i + j] // 10
            result[i + j] %= 10
            result[i + j + 1] += carry
    while len(result) > 1 and result[-1] == 0:
        result.pop()
    result_str = ''.join(map(str, result[::-1]))
    final_result = int(result_str)
    return -final_result if negative_result else final_result

# test me pls

"numbers from 0,1,2,3,4,5,6,7,8,9"
"pick four digit number"
"scatter the numbers randomly"
"select number"

#include <fmt/format.h>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <bitset>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <random>
using namespace std;


static const string msgs[]={
  "Enter your guess (a 4-digit number with non-repeating digits): ",
  "Correct numbers: {} Correct position: {}",
  "Congratulations! You guessed the number {} correctly in {} attempts!",
  "Oups.. You could not guess the number in {} attempts!",
  "Invalid input. Please enter a 4-digit number with non-repeating digits."
};

// Initialize random number generator outside functions
static random_device rd;  // Obtain a random number from hardware
static mt19937 g(rd());   // Seed the generator

string generateRandomNumber() {
    static string base{"0123456789"}; 

    // Shuffle digits
    shuffle(base.begin(), base.end(), g);

    // Return the first 4 digits as a string
    return base.substr(0,4);
}

bool hasDuplicateDigits(const string &number) {
    return accumulate(number.cbegin(),number.cend(), bitset<10>{0},
                         [](auto &bs,auto c) {return bs.set(c-'0');}
                         ).count()!=number.size();
}

bool isNumeric(const string &s) {
    return all_of(s.begin(), s.end(), ::isdigit);
}

string getUserGuess(istream &in = cin, ostream &out = cout) {
    string guess;
    out << msgs[0];
    in >> guess;
    return guess;
}

pair<int, int> checkGuess(const string &randomNumber, const string &userGuess) {
    pair<int, int> ret {0,0};
  
    for (int i = 0; i < 4; ++i) {
        if (randomNumber[i] == userGuess[i]) {
            ++get<0>(ret), ++get<1>(ret);
        } else if (count(randomNumber.begin(), randomNumber.end(), userGuess[i])) {
            ++get<0>(ret);
        }
    }

    return ret;
}

int acceptGuess(const string &expected, istream &in = cin, std::ostream &out = std::cout, int maxattempts=20) {
    int attempts = 0;
    std::pair status{0,0};
    do {
        std::string userGuess = getUserGuess(in, out);
        if (userGuess.length() != 4 || hasDuplicateDigits(userGuess) || !isNumeric(userGuess)) {
            out << msgs[4] << std::endl;
        } else {
          status = checkGuess(expected, userGuess);
          out << fmt::format(msgs[1],status.first,status.second) << std::endl;
        }
        attempts++;
    } while (status.second!=4 && attempts<maxattempts);
    
    if (attempts==maxattempts)
       out << fmt::format(msgs[3],attempts)<< std::endl;
    else 
       out << fmt::format(msgs[2],expected,attempts)<< std::endl;
    return attempts;
}

int _main(std::istream &in = std::cin, std::ostream &out = std::cout) {
    // Seed rand since random_shuffle _probably_ uses it.
    srand(static_cast<unsigned>(time(0)));
    std::string randomNumber = generateRandomNumber();
    acceptGuess(randomNumber, in, out);
    return 0;
}