Freestyle Sparring

#include <random>

std::uniform_real_distribution<long double> dis(0.,1.); // Default is double
std::random_device rd;
std::mt19937 gen(rd());

long double pi_estimate(long long n, int seed=0) {
    gen.seed(seed);
    long long inside=0;
    for (auto i=0; i!=n; ++i) if (std::pow(dis(gen),2)+std::pow(dis(gen),2) < 1.) ++inside;
    return (4.*inside)/n; 
}

#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"