Prymitywny totolotek

#include <iostream>
#include <ctime>
using namespace std;

int main() {
	unsigned times = 6, min = 1, max = 49, good = 0;
	
	srand(6);
	
	for(unsigned i = 0; i < times; ++i){
		cout << "[Draw nr: " << i+1 << "]" << endl;
		int num, drawn = rand()%max+min;
		cin >> num;
		cout << "drawn: " << drawn << endl;
		if(num == drawn)
			good += 1;
	}
	
	cout << good << "/" << times;
	return 0;
}

8 34 3 4 5 6

[Draw nr: 1]
drawn: 8
[Draw nr: 2]
drawn: 34
[Draw nr: 3]
drawn: 15
[Draw nr: 4]
drawn: 26
[Draw nr: 5]
drawn: 2
[Draw nr: 6]
drawn: 39
2/6

#include <iostream>
#include <type_traits>
#include <random>
#include <algorithm>
using namespace std;

template<typename T>
struct PrimitiveWrapper{
    static_assert(is_fundamental<T>::value, "T is not fundamental");
    using value_type = char;
    T &ref;
    const size_t max = sizeof(T);
    size_t used_size;
    
    PrimitiveWrapper(T &ref, size_t used): ref(ref), used_size(used){}
    size_t max_size() const
    { return max; }
    size_t size() const
    { return used_size; }
    void push_back(value_type val)
    { if(used_size<max) at(used_size++) = val; else throw std::out_of_range("PrimitiveWrapper kaput"); }
    value_type &at(size_t idx)
    { return *(begin()+idx); }
    value_type *begin()
    { return reinterpret_cast<value_type*>(&ref); }
    value_type *end()
    { return begin() + sizeof(ref); }
};

template<typename T>
auto wrap(T &ref, size_t size_already_used = 0)
{ return PrimitiveWrapper<T>(ref, size_already_used); }

//divine-version; Not recommended for mortals
template<typename T>
void unique_random_for_wrappers(T cont, typename T::value_type min, typename T::value_type max){
    default_random_engine gen;
    uniform_int_distribution<typename T::value_type> dist(min, max);
    for(size_t i = 0; i < cont.max_size();){
        auto drawn = dist(gen);
        if(find(begin(cont), end(cont), drawn) == end(cont)){
            cont.push_back(drawn);
            i += 1;
        }
    }
}



int main() {
    unsigned times = 6, min = 1, max = 49, good = 0;
    uint64_t cont;
    auto drawn_numbers = wrap(cont);
    unique_random_for_wrappers(drawn_numbers, min, max);
    sort(begin(drawn_numbers), end(drawn_numbers));
 
    for(unsigned i = 0; i < times; ++i){
        cout << "{Draw[" << i << "] = " << (int)drawn_numbers.at(i) << "}\n";
        int num;
        cin >> num;
        if(num == drawn_numbers.at(i))
            good += 1;
    }
 
    cout << good << "/" << times;
    return 0;
}

namespace Totolotek
{

    public class Lotto{

        private List<int> _numbers;
        private int _numbersAmount;
        private int _numbersValueMax;

        public void Draw()
        {
            Random rnd = new Random();
            for (int i = 0; i < _numbersAmount; i++)
            {
                int value = -1;
                while (_numbers.Contains(value) || value==-1){
                    value = rnd.Next(1, _numbersValueMax);
                }
                _numbers.Add(value);
            }
            _numbers.Sort();
        }

        public List<int> getNumbers()
        {
            return _numbers;
        }

        public Lotto(int numbersAmount, int numbersValueMax)
        {
            _numbers = new List<int>();
            _numbersAmount = numbersAmount;
            _numbersValueMax = numbersValueMax;
        }


    }
    class Program
    {
        static void Main(string[] args)
        {
            const int NUMBERS_AMOUNT = 6;
            const int NUMBERS_VALUE_MAX = 49;

            Lotto lotek = new Lotto(NUMBERS_AMOUNT, NUMBERS_VALUE_MAX);
            lotek.Draw();

            foreach (int number in lotek.getNumbers())
            {
                Console.Write(number + " ");
            }
            Console.WriteLine();
        }
    }
}

namespace Totolotek
{

    public class Lotto{

        public List<int> Numbers {get;set;}
        private int NumbersAmount { get; set; }
        private int NumbersValueMax { get; set; }

        public Lotto(int numbersAmount, int numbersValueMax)
        {
            Numbers = new List<int>();
            NumbersAmount = numbersAmount;
            NumbersValueMax = numbersValueMax;
        }

        public void Draw()
        {
            Numbers.Clear();
            Random rnd = new Random();
            for (int i = 0; i < NumbersAmount; i++)
            {
                int value = -1;
                while (Numbers.Contains(value) || value == -1)
                {
                    value = rnd.Next(1, NumbersValueMax);
                }
                Numbers.Add(value);
            }
            Numbers.Sort();
        }
    }
    class Program
    {

        static void Main(string[] args)
        {
            const int NUMBERS_AMOUNT = 6;
            const int NUMBERS_VALUE_MAX = 49;

            Lotto lotek = new Lotto(NUMBERS_AMOUNT, NUMBERS_VALUE_MAX);

            long times = 1;
            List<int> myNumbers = new List<int>( new int[] {1, 2, 3, 4, 5, 6});
            
            lotek.Draw();

            while (!myNumbers.SequenceEqual(lotek.Numbers) && times < long.MaxValue)
            {
                lotek.Draw();
                times++;  
            }
            Console.WriteLine("Udaloby ci się wygrac w totka dopiero za " + times + " razem :)");



        }
    }
}

#include <iostream>
#define num(i) (1ULL << i)
using namespace std;

inline short numOfBits(uint64_t i)
{
    i = i - ((i >> 1) & 0x5555555555555555);
    i = (i & 0x3333333333333333) + ((i >> 2) & 0x3333333333333333);
    return (((i + (i >> 4)) & 0xF0F0F0F0F0F0F0F) * 0x101010101010101) >> 56;
}

inline uint64_t draw()
{
	return ((uint64_t)rand() << 32) & 0x1FFFF00000000 | rand();
}

void printBits(uint64_t input)
{
	bool first = true;
	for (short i = 1; i < 64; i ++)
		if (input & num(i))
		{
			cout << (first ? "" : ", ") << i;
			first = false;
		}
}

int main() {
	auto myNumbers = num(5) | num(10) | num(15) | num(32) | num(46) | num(3);
	srand(time(NULL));
	
	uint64_t result;
	do { result ^= draw(); }
	while (numOfBits(result) != 6);
		
	cout << "Twoje typy: ";
	printBits(myNumbers);
	cout << endl;

	cout << "Wylosowano: ";
	printBits(result);
	cout << endl;
	
	cout << "Trafiłeś " << numOfBits(result & myNumbers) << " liczb";
	
	return 0;
}

import java.util.*;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Set<Integer> wylosowane = new Random().ints(1, 50).distinct().limit(6).boxed().collect(Collectors.toSet());
        Set<Integer> typowanePrzezTypa = new HashSet<>();
        Scanner sc = new Scanner(System.in);
        do {
            typowanePrzezTypa.add(sc.nextInt());
        } while (typowanePrzezTypa.size() < 6);
        System.out.println("wylosowane " + wylosowane);
        System.out.println("typowane " + typowanePrzezTypa);
        wylosowane.retainAll(typowanePrzezTypa);
        System.out.println("trafiono " + wylosowane);
    }
}

using System;
using System.Text.RegularExpressions;
using System.Linq;

class Program {
    static void Main(string[] args) {
        var wylosowane = Enumerable.Range(1, int.MaxValue).Select(x => new Random().Next(1, 49)).Distinct().Take(6).ToList();
        var typowanePrzezTypa = Enumerable.Range(1, int.MaxValue).Select(x => Console.ReadLine()).Where(x => Regex.IsMatch(x, @"^\d+$")).Distinct().Take(6).Select(int.Parse).ToList();
        Console.WriteLine("wylosowane " + string.Join(", ", wylosowane));
        Console.WriteLine("typowane " + string.Join(", ", typowanePrzezTypa));
        Console.WriteLine("trafiono " + string.Join(", ", wylosowane.Intersect(typowanePrzezTypa)));
    }
}