// Generator LCG
// Data: 8.04.2008
// (C)2020 mgr Jerzy Wałaszek
//----------------------------

var m, a, c, x, x0 : qword;

begin
  readln(m, a, c, x0);
  x := x0;
  repeat
    x := (a*x+c) mod m;
    write(x, ' ');
  until x = x0;
  writeln;
end.

// Generator LCG
// Data: 8.04.2008
// (C)2020 mgr Jerzy Wałaszek
//----------------------------

#include <iostream>

using namespace std;

int main()
{   
  unsigned long long m, a, c, x, x0;

  cin >> m >> a >> c >> x0;
  x = x0;
  do
  {
    x = (a*x+c) % m;
    cout << x << " ";
  } while(x != x0);
  cout << endl;
  return 0;
}

' Generator LCG
' Data: 8.04.2008
' (C)2020 mgr Jerzy Wałaszek
'----------------------------

Dim As Ulongint m, a, c, x, x0

Input m, a, c, x0
x = x0
Do
  x = (a*x+c) Mod m
  Print x;" ";
Loop Until x = x0
Print
End

# Generator LCG
# Data: 15.02.2024
# (C)2024 mgr Jerzy Wałaszek
#---------------------------

arr = input().split(" ")
m  = int(arr[0])
a  = int(arr[1])
c  = int(arr[2])
x0 = int(arr[3])
x  = x0
while True:
    x = (a*x+c) % m
    print(x, end=" ")
    if x == x0: break
print()

// Współczynniki generatora LCG
// Data: 10.04.2008
// (C)2020 mgr Jerzy Wałaszek
//-----------------------------

function NWD(a, b : qword) : qword;
var t : qword;
begin
  while b <> 0 do
  begin
    t := b;
    b := a mod b;
    a := t;
  end;
  NWD := a;
end;

var m, a, c, x, d, g : qword;

begin
  randomize;
  readln(x);
  m := x+1;
  repeat
    c  := random(m);
  until NWD(m, c) = 1;
  a := 1;
  x := m;
  d := 2;
  g := round(sqrt(m));
  while d <= g do
  begin
    if x mod d = 0 then
    begin
      a := a*d;
      repeat
        x := x div d;
      until x mod d <> 0;
    end;
    if d = 2 then
      inc(d)
    else
      inc(d, 2);
    if x < d then break;
  end;
  a := a*x;
  if m mod 4 = 0 then
    a := a*2;
  inc(a);
  writeln('m = ', m:12);
  writeln('a = ', a:12);
  writeln('c = ', c:12);
  writeln;
end.

// Współczynniki generatora LCG
// Data: 10.04.2008
// (C)2020 mgr Jerzy Wałaszek
//-----------------------------

#include <iostream>
#include <iomanip>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

typedef unsigned long long ulong;

ulong NWD(ulong a, ulong b)
{
  ulong t;

  while(b)
  {
    t = b;
    b = a % b;
    a = t;
  }
  return a;
}

int main()
{
  ulong m, a, c, x, d, g;

  srand(time(NULL));
  cin >> x;
  m = x+1;
  do
    c = rand() % m;
  while(NWD(m, c) != 1);
  a = 1;
  x = m;
  d = 2;
  g = (ulong)sqrt(m);
  while(d <= g)
  {
    if(x % d == 0)
    {
      a *= d;
      do
        x /= d;
      while(x % d == 0);
    }
    if(d == 2)
      d++;
    else
      d += 2;
    if(x < d) break;
  }
  a *= x;
  if(m % 4 == 0)
    a <<= 1;
  a++;
  cout << "m = " << setw(12) << m << endl
       << "a = " << setw(12) << a << endl
       << "c = " << setw(12) << c << endl
       << endl;
  return 0;
}

' Współczynniki generatora LCG
' Data: 10.04.2008
' (C)2020 mgr Jerzy Wałaszek
'-----------------------------

Function NWD (Byval a As Ulongint, _
              Byval b As Ulongint) _
              As Ulongint

  Dim t As Ulongint

  While b
    t = b
    b = a Mod b
    a = t
  Wend
  NWD = a
End Function

Dim As Ulongint m, a, c, x, d, g

Randomize Timer
Input x
m = x+1
Do
  c = Culngint(Rnd(1)*m)
Loop Until NWD(m, c) = 1
a = 1
x = m
d = 2
g = Culngint(Sqr(m))
While d <= g
  If x Mod d = 0 Then
    a *= d
    Do
      x \= d
    Loop Until x Mod d <> 0
  End If
  If d = 2 Then
    d += 1
  Else
    d += 2
  End If
  If x < d Then Exit While
Wend
a *= x
If m Mod 4 = 0 Then a *= 2
a += 1
Print Using "m = ############";m
Print Using "a = ############";a
Print Using "c = ############";c
Print
End

# Współczynniki generatora LCG
# Data: 15.02.2024
# (C)2024 mgr Jerzy Wałaszek
# ----------------------------

import math
import random


def nwd(a, b):
    while b:
        t = b
        b = a % b
        a = t
    return a


x = int(input())
m = x+1
while True:
    c = random.randrange(0, m)
    if nwd(m, c) == 1: break
a, x, d = 1, m, 2
g = int(math.sqrt(m))
while d <= g:
    if not (x % d):
        a *= d
        while True:
            x //= d
            if x % d: break
    if d == 2:
        d += 1
    else:
        d += 2
    if x < d: break
a *= x
if not (m % 4): a <<= 1
a += 1
print("m = %12d" % m)
print("a = %12d" % a)
print("c = %12d" % c)

// Test generatora LCG
// Data: 13.04.2014
// (C)2014 mgr Jerzy Wałaszek
//---------------------------

program LCGTest;

var
  m, a, c, x, i, count : cardinal;
  T : array of boolean;

begin
  while true do
  begin
     write('m = '); readln(m); // Czytamy moduł
     if m = 0 then break;  // Jeśli zero, to kończymy
     write('a = '); readln(a); // Czytamy mnożnik
     write('c = '); readln(c); // Czytamy przyrost
     SetLength(T, m); // Tworzymy tablicę dynamiczną
     for i := 0 to m-1 do // Wypełniamy ją zerami
        T[i] := false;
     x := 0; // Określamy ziarno generatora
     for i := 0 to m-1 do // Generujemy m liczb pseudolosowych
     begin
       x := (a*x+c) Mod m; // Wyznaczamy kolejną liczbę pseudolosową
       T[x] := true; // i umieszczamy ją na
                     // swoim miejscu w tablicy
     end;
     count := 0;
     for i := 0 to m-1 do
       if T[i] then inc(count); // Zliczamy wygenerowane liczby
     writeln(count); // Wyświetlamy ilość wygenerowanych liczb
     if count = m then
       writeln('OK') // Oceniamy generator
     else
       writeln('---');
     writeln;
     SetLength(T, 0); // Usuwamy tablicę dynamiczną
  end;
end.

// Test generatora LCG
// Data: 13.04.2014
// (C)2014 mgr Jerzy Wałaszek
//---------------------------

#include <iostream>

using namespace std;

int main()
{
  unsigned int m, a, c, x, i, count;
  bool * T;
  while(true)
  {
     cout << "m = "; cin >> m; // Czytamy moduł
     if(!m) break; // Jeśli zero, to kończymy
     cout << "a = "; cin >> a; // Czytamy mnożnik
     cout << "c = "; cin >> c; // Czytamy przyrost
     T = new bool[m]; // Tworzymy tablicę dynamiczną
     for(i = 0; i < m; i++) // Wypełniamy ją zerami
        T[i] = false;
     x = 0; // Określamy ziarno generatora
     for(i = 0; i < m; i++) // Generujemy m liczb pseudolosowych
     {
        x = (a*x+c) % m; // Wyznaczamy kolejną liczbę pseudolosową
        T[x] = true; // i umieszczamy ją na
                     // swoim miejscu w tablicy
     }
     count = 0;
     for(i = 0; i < m; i++)
        if(T[i]) count++; // Zliczamy wygenerowane liczby
     cout << count << endl; // Wyświetlamy ilość wygenerowanych liczb
     if(count == m) cout << "OK"; // Oceniamy generator
     else cout << "---";
     delete [] T; // Usuwamy tablicę dynamiczną
     cout << endl << endl;
  }
  return 0;
}

' Test generatora LCG
' Data: 13.04.2014
' (C)2014 mgr Jerzy Wałaszek
'---------------------------

Dim As UInteger m, a, c, x, i, count
Dim As Byte Ptr T

While 1
  Input "m = ";m ' Czytamy moduł
  If m = 0 Then _
    Exit While ' Jeśli zero, to kończymy
  Input "a = ";a ' Czytamy mnożnik
  Input "c = ";c ' Czytamy przyrost
  T = New Byte[m] ' Tworzymy tablicę dynamiczną
  For i = 0 To m-1 ' Wypełniamy ją zerami
    T[i] = 0
  Next
  x = 0 ' Określamy ziarno generatora
  For i = 0 To m-1 ' Generujemy m liczb pseudolosowych
    x = (a*x+c) Mod m ' Wyznaczamy kolejną liczbę pseudolosową
    T[x] = 1 ' i umieszczamy ją na swoim miejscu w tablicy
  Next
  count = 0
  For i = 0 To m-1
    If T[i] = 1 Then _
      count += 1 ' Zliczamy wygenerowane liczby
  Next
  Print Using "&";count ' Wyświetlamy ilość wygenerowanych liczb
  If count = m Then ' Oceniamy generator
    Print "OK"
  Else
    Print "---"
  End If
  Print 
  Delete [] T ' Usuwamy tablicę dynamiczną
Wend
End

# Test generatora LCG
# Data: 15.02.2024
# (C)2024 mgr Jerzy Wałaszek
# ---------------------------

while True:
    # Czytamy moduł
    m = int(input("m = "))
    # Jeśli zero, to kończymy
    if not m: break
    # Czytamy mnożnik
    a = int(input("a = "))
    # Czytamy przyrost
    c = int(input("c = "))
    # Tworzymy tablicę dynamiczną
    t = [False] * m
    # Określamy ziarno generatora
    x = 0
    # Generujemy m liczb pseudolosowych
    for i in range(m):
        # Wyznaczamy kolejną
        # liczbę pseudolosową
        x = (a*x+c) % m
        # i umieszczamy ją na swoim
        # miejscu w tablicy
        t[x] = True
    count = 0
    for i in range(m):
        if t[i]:
            # Zliczamy wygenerowane liczby
            count += 1
    # Wyświetlamy ilość wygenerowanych liczb
    print(count)
    # Oceniamy generator
    if count == m:
        print("OK")
    else:
        print("---")
        print()
    # Usuwamy tablicę dynamiczną

    t = None

LCG(34359738368, 3141592653, 2718281829, X_o)

Do wykonywania mnożenia i dodawania stosujemy procedury mnożenia i dodawania modulo, które opisaliśmy w rozdziale o chińskim teście pierwszości. Dzięki nim rachunki nie przekroczą zakresu liczb 64-bitowych.

// Liczby pseudolosowe w <x, y>
// Data: 12.04.2008
// (C)2020 mgr Jerzy Wałaszek
//---------------------------

program prg;

uses SysUtils, DateUtils;

// Zmienne globalne dla LCG
//-------------------------

const a = 3141592653;
      c = 2718281829;
      m = 34359738368;

var X0 : qword;

// Procedura inicjuje ziarno X
//----------------------------
procedure Uprzypadkowij;
var
  t : TDateTime;
begin
  t  := Now;
  X0 := HourOf(t);
  X0 := X0*  60+MinuteOf(t);
  X0 := X0*  60+SecondOf(t);
  X0 := X0*1000+MillisecondOf(t);
end;

// Funkcja oblicza a*b mod n
//----------------------------
function Mnoz(a, b, n : qword) : qword;
var
  m, w : qword;
begin
  w := 0;
  m := 1;
  while m <> 0 do
  begin
    if b and m <> 0 then
      w := (w+a) mod n;
    a := (a shl 1) mod n;
    m := m shl 1;
  end;
  Mnoz := w;
end;

// Funkcja generatora LCG
//-----------------------
function LCG() : qword;
begin
  X0  := Mnoz(X0, a, m);
  X0  := (X0+c) mod m;
  LCG := X0;
end;

var
  Wxy, Lxy, x, y : qword;
  i, n : integer;
  XR  : double;
begin
  Uprzypadkowij;
  readln(x, y, n);
  Lxy := y-x+1;
  for i := 1 to n do
  begin
    XR  := LCG/m;
    Wxy := trunc(XR*Lxy)+x;
    write(Wxy, ' ');
  end;
  writeln;
end.

// Liczby pseudolosowe w <x, y>
// Data: 12.04.2008
// (C)2020 mgr Jerzy Wałaszek
//---------------------------

#include <iostream>
#include <cmath>

using namespace std;

typedef unsigned long long ulong;

// Zmienne globalne dla LCG
//-------------------------

const ulong a = 3141592653ull;
const ulong c = 2718281829ull;
const ulong m = 34359738368ull;

ulong X0;

// Procedura inicjuje ziarno X
//----------------------------
void Uprzypadkowij()
{
  X0 = (ulong)time(NULL);
}

// Funkcja oblicza a*b mod n
//--------------------------
ulong Mnoz(ulong a, 
           ulong b, 
           ulong n)
{
  ulong m, w;

  w = 0; m = 1;
  while(m)
  {
    if(b & m) w = (w+a) % n;
    a = (a << 1) % n;
    m <<= 1;
  }
  return w;
}

// Funkcja generatora LCG
//-----------------------
ulong LCG()
{
  X0 = Mnoz(X0, a, m);
  X0 = (X0+c) % m;
  return X0;
}

int main( )
{
  ulong Wxy, Lxy, x, y;
  int n;
  double XR;

  Uprzypadkowij();
  cin >> x >> y >> n;
  Lxy = y-x+1;
  for(int i = 1;i <= n;i++)
  {
    XR = LCG()/(double)m; 
    Wxy = (ulong)floor(XR*Lxy)+x;
    cout << Wxy << " ";
  }
  cout << endl << endl;
  return 0;
}

' Liczby pseudolosowe w <x, y>
' Data: 12.04.2008
' (C)2020 mgr Jerzy Wałaszek
'----------------------------

' Zmienne globalne dla LCG
'-------------------------
Dim Shared a As ULongInt = 3141592653
Dim shared c As ULongInt = 2718281829
Dim Shared m As ULongInt = 34359738368

Dim Shared X0 As Ulongint

' Procedura inicjuje ziarno X
'----------------------------
Sub Uprzypadkowij()
  X0 = Culngint(Timer*1000) Mod m
End Sub

' Funkcja oblicza a*b mod n
'--------------------------
Function Mnoz(Byval ax As Ulongint, _
              Byval bx As Ulongint, _
              Byval n As Ulongint) _
              As Ulongint

  Dim As Ulongint mx, w

  w = 0: mx = 1
  While mx
    If bx And mx Then w = (w+ax) Mod n
    ax = (ax Shl 1) Mod n
    mx = mx Shl 1
  Wend
  Mnoz = w
End Function

' Funkcja generatora LCG
'-----------------------
Function LCG() As Ulongint
  X0  = Mnoz(X0, a, m)
  X0  = (X0+c) Mod m
  LCG = X0
End Function

' Zaokrągla w dół
'----------------
Function Floor(Byval x As Double) _
               As Ulongint
  Dim result As Ulongint
  result = Culngint(x)
  If result > x Then result -= 1
  Floor = result
End Function

Dim As Ulongint Wxy, Lxy, x, y
Dim As Integer i, n
Dim As Double XR

Uprzypadkowij()
Input x, y, n
Lxy = y-x+1
For i = 1 To n
  LCG()
  XR  = X0/m
  Wxy = Floor(XR*Lxy)+x
  Print Wxy;" ";
Next
Print
End

# Liczby pseudolosowe w <x, y>
# Data: 15.03.2024
# (C)2024 mgr Jerzy Wałaszek
# ---------------------------

import time

# Zmienne globalne dla LCG
# -------------------------
A = 3141592653
C = 2718281829
M = 34359738368
G = 2**64
x0 = 0


# Procedura inicjuje ziarno X
# ----------------------------
def uprzypadkowij():
    global x0
    x0 = int(time.time()) % M
    return


# Funkcja oblicza a*b mod n
# -------------------------
def mnoz(ax, bx, n):
    w, mx = 0, 1
    while mx < G:
        if bx & mx:
            w = (w+ax) % n
        ax = (ax << 1) % n
        mx <<= 1
    return w


# Funkcja generatora LCG
# -----------------------
def lcg():
    global x0
    x0 = mnoz(x0, A, M)
    x0 = (x0+C) % M
    return x0


# Zaokrągla w dół
# ----------------
def floor(x):
    r = int(x)
    if r > x: r -= 1
    return r


uprzypadkowij()
arr = input().split()
x = int(arr[0])
y = int(arr[1])
n = int(arr[2])
lxy = y-x+1
for i in range(n):
    lcg()
    xr = x0/M
    wxy = floor(xr*lxy)+x
    print(wxy, end=" ")
print()