Freestyle Sparring

def subtracti(a, b):
    return a-b

def m(a,b):
    return a*b

def twin_sum_solutions(array)
  array.each_with_object([]) do |element, memo|
    next if memo.include? element * 2
    memo << element * 2 if array.count(element) > 1
  end
end

def split(string, separator):
    split_list = []
    current_slice = ''
    for char in string:
        if char == separator:
            split_list.append(current_slice)
            current_slice = ''
        else:
            current_slice += char
    
    split_list.append(current_slice)
    return split_list

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


static const std::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 std::random_device rd;  // Obtain a random number from hardware
static std::mt19937 g(rd());   // Seed the generator

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

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

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

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

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

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

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

    return ret;
}

int acceptGuess(const std::string &expected, std::istream &in = std::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;
}

#include <vector>
#include <numeric>

template <typename T> using add_t=decltype(T() + T());

template <typename T = double>
add_t<T> sum(const std::vector<T>& v) {
  return std::accumulate(v.cbegin(),v.cend(),add_t<T>{0});
}