Wow hay quá

Đáp án tham khảo nhé mọi người

1.

#include <bits/stdc++.h>
using namespace std;

const long long __TESTLIB_LONGLONG_MAX = 9223372036854775807LL;
template<typename T>
static inline T __testlib_abs(const T& x)
{
    return x > 0 ? x : -x;
}
template<typename T>
static inline T __testlib_min(const T& a, const T& b)
{
    return a < b ? a : b;
}
template<typename T>
static inline T __testlib_max(const T& a, const T& b)
{
    return a > b ? a : b;
}
class random_t
{
private:
    unsigned long long seed;
    static const unsigned long long multiplier=0x5DEECE66DLL;
    static const unsigned long long addend=0xBLL;
    static const unsigned long long mask=(1LL << 48) - 1;
    static const int lim=25;
	static const int version=-1;
    long long nextBits(int bits) 
    {
        if (bits <= 48)
        {
            seed = (seed * multiplier + addend) & mask;
            return (long long)(seed >> (48 - bits));
        }
        else
        {
            int lowerBitCount = (random_t::version == 0 ? 31 : 32);
            return ((nextBits(31) << 32) ^ nextBits(lowerBitCount));
        }
    }
public:
    
    random_t()
        : seed(3905348978240129619LL)
    {
    	//srand(time(NULL));
		setSeed(/*rand()%10000+*/3905348978240120000LL);
    }
    void setSeed(int argc, char* argv[])
    {
        random_t p;

        seed = 3905348978240129619LL;
        for (int i = 1; i < argc; i++)
        {
            std::size_t le = std::strlen(argv[i]);
            for (std::size_t j = 0; j < le; j++)
                seed = seed * multiplier + (unsigned int)(argv[i][j]) + addend;
            seed += multiplier / addend;
        }

        seed = seed & mask;
    }
    void setSeed(long long _seed)
    {
        _seed = (_seed ^ multiplier) & mask;
        seed = _seed;
    }
    int next(int n)
    {
        if (n <= 0) n=0;
        if ((n & -n) == n)  // n is a power of 2
            return (int)((n * (long long)nextBits(31)) >> 31);
        const long long limit = INT_MAX / n * n;
        long long bits;
        do {
            bits = nextBits(31);
        } while (bits >= limit);
        return int(bits % n);
    }
    unsigned int next(unsigned int n)
    {
        if (n >= INT_MAX)
            n=INT_MAX;
        return (unsigned int)next(int(n));
    }
    long long next(long long n) 
    {
        if (n <= 0)	n=0;
        const long long limit = __TESTLIB_LONGLONG_MAX / n * n;
        long long bits;
        do {
            bits = nextBits(63);
        } while (bits >= limit);

        return bits % n;
    }
    unsigned long long next(unsigned long long n)
    {
    	
        if (n >= (unsigned long long)(__TESTLIB_LONGLONG_MAX))
            n=(unsigned long long)(__TESTLIB_LONGLONG_MAX);
        return (unsigned long long)next((long long)(n));
    }
    long next(long n)
    {
        return (long)next((long long)(n));
    }
    unsigned long next(unsigned long n)
    {
        if (n >= (unsigned long)(LONG_MAX))
            n=(unsigned long)(LONG_MAX);
        return (unsigned long)next((unsigned long long)(n));
    }
    int next(int from, int to)
    {
    	if(from == to) return from;
    	if(from > to) return 0;
        return int(next((long long)to - from + 1) + from);
    }
    unsigned int next(unsigned int from, unsigned int to)
    {
    	if(from > to) return 0;
    	if(from == to) return from;
        return (unsigned int)(next((long long)to - from + 1) + from);
    }
    long long next(long long from, long long to)
    {
    	if(from > to) return 0;
    	if(from == to) return from;
        return next(to - from + 1) + from;
    }
    unsigned long long next(unsigned long long from, unsigned long long to)
    {
    	if(from > to) return 0;
    	if(from == to) return from;
        if (from > to)
            from=to;
        return next(to - from + 1) + from;
    }
    long next(long from, long to)
    {
    	if(from > to) return 0;
    	if(from == to) return from;
        return next(to - from + 1) + from;
    }
    unsigned long next(unsigned long from, unsigned long to)
    {
    	if(from > to) return 0;
    	if(from == to) return from;
        if (from > to)
            from=to;
        return next(to - from + 1) + from;
    }
    double next() 
    {
        return (double)(((long long)(nextBits(26)) << 27) + nextBits(27)) / (double)(1LL << 53);
    }
    double next(double n)
    {
        return n * next();
    }
    double next(double from, double to)
    {
    	if(from > to) return 0;
    	if(from == to) return from;
        return next(to - from) + from;
    }
    template <typename Container>
    typename Container::value_type any(const Container& c)
    {
        size_t size = c.size();
        if (size <= 0)
            size=1;
        return *(c.begin() + next(size));
    }
    template <typename Iter>
    typename Iter::value_type any(const Iter& begin, const Iter& end)
    {
        int size = int(end - begin);
        if (size <= 0)
            size=1;
        return *(begin + next(size));
    }
};
template<typename _RandomAccessIter>
void shuffle(_RandomAccessIter __first, _RandomAccessIter __last){
    if (__first == __last) return;
    random_t rnd;
    for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
        std::iter_swap(__i, __first + rnd.next(int(__i - __first) + 1));
}

int main(){
	random_t rnd;
	for(int i=0;i<100;i++) cout<<rnd.next(-5000, 1)<<" ";
	cout<<endl;
	return 0;	
}

2 và 3

#include <bits/stdc++.h>
#include <sys/time.h>
 
using namespace std;
 
typedef unsigned long long ull;
 
 
timeval tv;
 
ull getSeed(){
    gettimeofday(&tv, NULL);
    return (tv.tv_sec+tv.tv_usec-tv.tv_sec/tv.tv_usec+tv.tv_sec*clock()*ULLONG_MAX+tv.tv_usec*clock()*ULLONG_MAX)%ULLONG_MAX;
}
 
//Hàm random có xử lý seed ngẫu nhiên, tùy chỉnh độ phân bổ => tốc độ chạy chậm
ull random(ull a, ull b)
{
	ull x;
	int doGiam=100; // >1 Độ giảm càng cao thì mật độ càng giảm, 1 là cân bằng. 1->100
	if(b < a) swap(a,b);
	x = b - a;
	long double d[doGiam];
	ull i=0;
	d[i]=1.0*x/doGiam;
	for(i=1;i<doGiam;i++)	d[i]=d[i-1]+x/doGiam;
	int rd=getSeed()%doGiam;
	return getSeed()%((ull)d[rd]+1)+a;
}
 
//Hàm random không xử lý seed ngẫu nhiên, tốc độ nhanh, mật độ cân bằng.
ull random2(ull a, ull b)
{
	return min(a,b)+getSeed()%(max(a,b)-min(a,b));
}
 
 
int main()
{
	ull test =500;
	ull A[test]={0};
	ull B[test]={0};
 
	//Ví dụ
 
	for(int i=0;i<100000;i++)
	{
		A[random2(0, test)]++;
		B[random(0,test)]++;
	}
 
	for(int i=0;i<test;i++)
	{
		cout << i << " - " << A[i]<<" - "<<B[i]<< endl;
	}
	return 0;
}

Kết quả không có ai có đáp án thỏa các bộ test nhé mọi người. Cùng qua event sau để rinh giải nè

https://codepaste.net/spxbwa

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace randomab
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 6;
            int b = 20;
            
            HamRandom rand = new HamRandom();
            for (int i = 0; i < 10; i++)
              {
			 Console.WriteLine("dung times: " +rand.Rand1(a,b));
             Console.WriteLine("dung thread: " +rand.Rand2(a,b));
              }

            Console.ReadKey();
        }
    }
    class HamRandom
    {
        //dung times
        public int Rand1(int a, int b)
        {
            int y = Math.Max(a, b);
            int x = Math.Min(a, b);
            int t  = DateTime.Now.Millisecond + y;
                Thread.Sleep(DateTime.Now.Millisecond / 5);
               return t % (y - x) + x;
            
        }
       
        //dung thread
        int value = 0; int khoichay = 0;
        public int Rand2(int a, int b)
        {
            int y = Math.Max(a, b);
            int x = Math.Min(a, b);

            object input = new Tuple<int>(y - x);
            Thread t = new Thread(run);
    
            t.Start(input);
            t.IsBackground = true;
            if (khoichay ==0)
            {
                Rand2(a, b);
            }
            return value+x; 
           
        }
        public void run(object input)
        {
            Tuple<int> a = input as Tuple<int>;
            int x = a.Item1;

            for (int i = 0; i < x; i++)
            {
                value = i; khoichay = 1;
                if (i == x-1)
                {
                    i = 0;
                }
            }
           
        }
     
    }
}