aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Pseudo-random-numbers-Middle-square-method/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Pseudo-random_numbers/Middle-square_method

30
Task/Pseudo-random-numbers-Middle-square-method/00-TASK.txt Normal file
View file

@ -0,0 +1,30 @@
; The Method:
To generate a sequence of n-digit pseudorandom numbers, an n-digit starting value is created and squared, producing a 2n-digit number. If the result has fewer than 2n digits, leading zeroes are added to compensate. The middle n digits of the result would be the next number in the sequence and returned as the result. This process is then repeated to generate more numbers.
; Pseudo code:
<pre>var seed = 675248
function random()
var s = str(seed * seed) 'str: turn a number into string
do while not len(s) = 12
s = "0" + s 'add zeroes before the string
end do
seed = val(mid(s, 4, 6)) 'mid: string variable, start, length
'val: turn a string into number
return seed
end function
</pre>
; Middle-square method use:
<pre>
for i = 1 to 5
print random()
end for
</pre>
;Task:
* Generate a class/set of functions that generates pseudo-random
numbers (6 digits) as shown above.
* Show the first five integers generated with the seed 675248 as shown above.
* Show your output here, on this page.

7
Task/Pseudo-random-numbers-Middle-square-method/11l/pseudo-random-numbers-middle-square-method.11l Normal file
View file

@ -0,0 +1,7 @@
F random()
V :seed = 675248
:seed = Int(String(Int64(:seed) ^ 2).zfill(12)[3 .+ 6])
R :seed
L 5
print(random())

79
Task/Pseudo-random-numbers-Middle-square-method/AArch64-Assembly/pseudo-random-numbers-middle-square-method.aarch64 Normal file
View file

@ -0,0 +1,79 @@
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program pRandom64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResult: .asciz " @ \n"
szCarriageReturn: .asciz "\n"
qSeed: .quad 675248
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
ldr x0,qAdrqSeed
ldr x3,[x0]
mov x2,#5
1:
mov x0,x3
bl computePseudo
mov x3,x0
ldr x1,qAdrsZoneConv
bl conversion10 // call décimal conversion
ldr x0,qAdrsMessResult
ldr x1,qAdrsZoneConv // insert conversion in message
bl strInsertAtCharInc
bl affichageMess // display message
subs x2,x2,#1
bgt 1b
100: // standard end of the program
mov x0, #0 // return code
mov x8, #EXIT // request to exit program
svc #0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrsMessResult: .quad sMessResult
qAdrsZoneConv: .quad sZoneConv
qAdrqSeed: .quad qSeed
/***************************************************/
/* compute pseudo random number */
/***************************************************/
/* x0 contains the number */
computePseudo:
stp x1,lr,[sp,-16]! // save registers
stp x2,x3,[sp,-16]! // save registers
mov x2,x0
mul x0,x2,x2
ldr x2,qdiv
udiv x1,x0,x2
ldr x2,qdiv2
udiv x0,x1,x2
msub x0,x2,x0,x1
ldp x2,x3,[sp],16 // restaur 2 registers
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qdiv: .quad 1000
qdiv2: .quad 1000000
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"

9
Task/Pseudo-random-numbers-Middle-square-method/ALGOL-68/pseudo-random-numbers-middle-square-method.alg Normal file
View file

@ -0,0 +1,9 @@
BEGIN # generate random numbers by the middle-square method #
INT seed := 675248;
# returns the next middle-square random number #
PROC ms random = INT: seed := SHORTEN( ( ( LONG INT( seed ) * LONG INT( seed ) ) OVER 1000 ) MOD 1 000 000 );
# test the ms random procedure #
FOR i TO 5 DO
print( ( " ", whole( ms random, 0 ) ) )
OD
END

124
Task/Pseudo-random-numbers-Middle-square-method/ARM-Assembly/pseudo-random-numbers-middle-square-method.arm Normal file
View file

@ -0,0 +1,124 @@
/* ARM assembly Raspberry PI or android with termux */
/* program pRandom.s */
/* REMARK 1 : this program use routines in a include file
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes */
/************************************/
.include "../constantes.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResult: .asciz " @ \n"
szCarriageReturn: .asciz "\n"
iSeed: .int 675248
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
ldr r0,iAdriSeed
ldr r3,[r0]
mov r2,#5
1:
mov r0,r3
bl computePseudo
mov r3,r0
ldr r1,iAdrsZoneConv
bl conversion10 @ call décimal conversion
ldr r0,iAdrsMessResult
ldr r1,iAdrsZoneConv @ insert conversion in message
bl strInsertAtCharInc
bl affichageMess @ display message
subs r2,r2,#1
bgt 1b
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsMessResult: .int sMessResult
iAdrsZoneConv: .int sZoneConv
iAdriSeed: .int iSeed
/***************************************************/
/* compute pseudo random number */
/***************************************************/
/* r0 contains the number */
computePseudo:
push {r1-r2,lr} @ save registers
mov r2,r0
umull r0,r1,r2,r2
ldr r2,idiv
bl division32R
ldr r2,idiv2
bl division32R
mov r0,r2
pop {r1-r2,pc} @ restaur registers
idiv: .int 1000
idiv2: .int 1000000
/***************************************************/
/* division number 64 bits in 2 registers by number 32 bits */
/***************************************************/
/* r0 contains lower part dividende */
/* r1 contains upper part dividende */
/* r2 contains divisor */
/* r0 return lower part quotient */
/* r1 return upper part quotient */
/* r2 return remainder */
division32R:
push {r3-r9,lr} @ save registers
mov r6,#0 @ init upper upper part remainder !!
mov r7,r1 @ init upper part remainder with upper part dividende
mov r8,r0 @ init lower part remainder with lower part dividende
mov r9,#0 @ upper part quotient
mov r4,#0 @ lower part quotient
mov r5,#32 @ bits number
1: @ begin loop
lsl r6,#1 @ shift upper upper part remainder
lsls r7,#1 @ shift upper part remainder
orrcs r6,#1
lsls r8,#1 @ shift lower part remainder
orrcs r7,#1
lsls r4,#1 @ shift lower part quotient
lsl r9,#1 @ shift upper part quotient
orrcs r9,#1
@ divisor sustract upper part remainder
subs r7,r2
sbcs r6,#0 @ and substract carry
bmi 2f @ négative ?
@ positive or equal
orr r4,#1 @ 1 -> right bit quotient
b 3f
2: @ negative
orr r4,#0 @ 0 -> right bit quotient
adds r7,r2 @ and restaur remainder
adc r6,#0
3:
subs r5,#1 @ decrement bit size
bgt 1b @ end ?
mov r0,r4 @ lower part quotient
mov r1,r9 @ upper part quotient
mov r2,r7 @ remainder
100: @ function end
pop {r3-r9,lr} @ restaur registers
bx lr
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"

17
Task/Pseudo-random-numbers-Middle-square-method/AWK/pseudo-random-numbers-middle-square-method.awk Normal file
View file

@ -0,0 +1,17 @@
# syntax: GAWK -f PSEUDO-RANDOM_NUMBERS_MIDDLE-SQUARE_METHOD.AWK
BEGIN {
seed = 675248
srand(seed)
for (i=1; i<=5; i++) {
printf("%2d: %s\n",i,main())
}
exit(0)
}
function main( s) {
s = seed ^ 2
while (length(s) < 12) {
s = "0" s
}
seed = substr(s,4,6)
return(seed)
}

16
Task/Pseudo-random-numbers-Middle-square-method/Ada/pseudo-random-numbers-middle-square-method.ada Normal file
View file

@ -0,0 +1,16 @@
with Ada.Text_IO; use Ada.Text_IO;
procedure Main is
type long is range 0 .. 2**64;
Seed : long := 675_248;
function random return long is
begin
Seed := Seed * Seed / 1_000 rem 1_000_000;
return Seed;
end random;
begin
for I in 1 .. 5 loop
Put (long'Image (random));
end loop;
New_Line;
end Main;

23
Task/Pseudo-random-numbers-Middle-square-method/AppleScript/pseudo-random-numbers-middle-square-method-1.applescript Normal file
View file

@ -0,0 +1,23 @@
on newGenerator(n, seed)
script generator
property seed : missing value
property p1 : 10 ^ (n div 2)
property p2 : 10 ^ n
on getRandom()
set seed to seed * seed div p1 mod p2
return seed div 1
end getRandom
end script
set generator's seed to seed mod (10 ^ n)
return generator
end newGenerator
local generator, output
set generator to newGenerator(6, 675248)
set output to {}
repeat 5 times
set end of output to generator's getRandom()
end repeat
return output

1
Task/Pseudo-random-numbers-Middle-square-method/AppleScript/pseudo-random-numbers-middle-square-method-2.applescript Normal file
View file

@ -0,0 +1 @@
{959861, 333139, 981593, 524817, 432883}

7
Task/Pseudo-random-numbers-Middle-square-method/Arturo/pseudo-random-numbers-middle-square-method.arturo Normal file
View file

@ -0,0 +1,7 @@
seed: 675248
rand: function => [
let 'seed <= ((seed^2) / 1000) % 1000000
]
do.times: 5 -> print rand

11
Task/Pseudo-random-numbers-Middle-square-method/BASIC256/pseudo-random-numbers-middle-square-method.basic Normal file
View file

@ -0,0 +1,11 @@
global semilla
semilla = 675248
for i = 1 to 5
print i; ": "; Random()
next i
end
function Random()
semilla = floor((semilla*semilla/1e3) mod 1e6)
return int(semilla)
end function

7
Task/Pseudo-random-numbers-Middle-square-method/Bc/pseudo-random-numbers-middle-square-method.bc Normal file
View file

@ -0,0 +1,7 @@
s = 675248
define r() {
s = s * s / 1000 % 1000000
return(s)
}
for (i = 0; i != 5; ++i) r()

30
Task/Pseudo-random-numbers-Middle-square-method/C++/pseudo-random-numbers-middle-square-method.cpp Normal file
View file

@ -0,0 +1,30 @@
#include <exception>
#include <iostream>
using ulong = unsigned long;
class MiddleSquare {
private:
ulong state;
ulong div, mod;
public:
MiddleSquare() = delete;
MiddleSquare(ulong start, ulong length) {
if (length % 2) throw std::invalid_argument("length must be even");
div = mod = 1;
for (ulong i=0; i<length/2; i++) div *= 10;
for (ulong i=0; i<length; i++) mod *= 10;
state = start % mod;
}
ulong next() {
return state = state * state / div % mod;
}
};
int main() {
MiddleSquare msq(675248, 6);
for (int i=0; i<5; i++)
std::cout << msq.next() << std::endl;
return 0;
}

12
Task/Pseudo-random-numbers-Middle-square-method/C/pseudo-random-numbers-middle-square-method.c Normal file
View file

@ -0,0 +1,12 @@
#include<stdio.h>
long long seed;
long long random(){
seed = seed * seed / 1000 % 1000000;
return seed;
}
int main(){
seed = 675248;
for(int i=1;i<=5;i++)
printf("%lld\n",random());
return 0;
}

21
Task/Pseudo-random-numbers-Middle-square-method/CLU/pseudo-random-numbers-middle-square-method.clu Normal file
View file

@ -0,0 +1,21 @@
middle_square = cluster is seed, next
rep = null
own state: int
seed = proc (s: int)
state := s
end seed
next = proc () returns (int)
state := (state ** 2) / 1000 // 1000000
return(state)
end next
end middle_square
start_up = proc ()
po: stream := stream$primary_output()
middle_square$seed(675248)
for i: int in int$from_to(1, 5) do
stream$putl(po, int$unparse(middle_square$next()))
end
end start_up

25
Task/Pseudo-random-numbers-Middle-square-method/COBOL/pseudo-random-numbers-middle-square-method.cobol Normal file
View file

@ -0,0 +1,25 @@
IDENTIFICATION DIVISION.
PROGRAM-ID. MIDDLE-SQUARE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 STATE.
03 SEED PIC 9(6) VALUE 675248.
03 SQUARE PIC 9(12).
03 FILLER REDEFINES SQUARE.
05 FILLER PIC 9(3).
05 NEXT-SEED PIC 9(6).
05 FILLER PIC 9(3).
PROCEDURE DIVISION.
BEGIN.
PERFORM SHOW-NUM 5 TIMES.
STOP RUN.
SHOW-NUM.
PERFORM MAKE-RANDOM.
DISPLAY SEED.
MAKE-RANDOM.
MULTIPLY SEED BY SEED GIVING SQUARE.
MOVE NEXT-SEED TO SEED.

3
Task/Pseudo-random-numbers-Middle-square-method/Dc/pseudo-random-numbers-middle-square-method.dc Normal file
View file

@ -0,0 +1,3 @@
675248 5 sn
[d * 1000 / 1000000 %] sr
[lr x p ln 1 - d sn 0 <l] d sl x

18
Task/Pseudo-random-numbers-Middle-square-method/Delphi/pseudo-random-numbers-middle-square-method.delphi Normal file
View file

@ -0,0 +1,18 @@
var Seed: int64 = 675248;
function MiddleSquareRandom: int64;
var S: string;
begin
S:=IntToStr(Seed * Seed);
while Length(S)<12 do S:='0'+S;
Seed:=StrToInt(MidStr(S, 4, 6));
Result:=Seed;
end;
procedure ShowMiddleSqrRandom(Memo: TMemo);
var I: integer;
begin
for I:=1 to 5 do
Memo.Lines.Add(IntToStr(MiddleSquareRandom));
end;

15
Task/Pseudo-random-numbers-Middle-square-method/EasyLang/pseudo-random-numbers-middle-square-method.easy Normal file
View file

@ -0,0 +1,15 @@
global seed .
seed = 675248
proc rand . randNum .
strSeed$ = seed
s$ = seed * seed
while not len s$ = len strSeed$ * 2
s$ = "0" & s$
.
seed = number substr s$ (len strSeed$ / 2 + 1) len strSeed$
randNum = seed
.
for i = 1 to 5
call rand randNum
print randNum
.

2
Task/Pseudo-random-numbers-Middle-square-method/F-Sharp/pseudo-random-numbers-middle-square-method.fs Normal file
View file

@ -0,0 +1,2 @@
// Pseudo-random numbers/Middle-square method. Nigel Galloway: January 5th., 2022
Seq.unfold(fun n->let n=n*n%1000000000L/1000L in Some(n,n)) 675248L|>Seq.take 5|>Seq.iter(printfn "%d")

8
Task/Pseudo-random-numbers-Middle-square-method/Factor/pseudo-random-numbers-middle-square-method.factor Normal file
View file

@ -0,0 +1,8 @@
USING: kernel math namespaces prettyprint ;
SYMBOL: seed
675248 seed set-global
: rand ( -- n ) seed get sq 1000 /i 1000000 mod dup seed set ;
5 [ rand . ] times

3
Task/Pseudo-random-numbers-Middle-square-method/Forth/pseudo-random-numbers-middle-square-method.fth Normal file
View file

@ -0,0 +1,3 @@
: next-random dup * 1000 / 1000000 mod ;
: 5-random-num 5 0 do next-random dup . loop ;
675248 5-random-num

17
Task/Pseudo-random-numbers-Middle-square-method/FreeBASIC/pseudo-random-numbers-middle-square-method.basic Normal file
View file

@ -0,0 +1,17 @@
Dim Shared seed As Integer = 675248
Dim i As Integer
Declare Function Rand As Integer
For i = 1 To 5
Print Rand
Next i
Sleep
Function Rand As Integer
Dim s As String
s = Str(seed ^ 2)
Do While Len(s) <> 12
s = "0" + s
Loop
seed = Val(Mid(s, 4, 6))
Rand = seed
End Function

15
Task/Pseudo-random-numbers-Middle-square-method/Go/pseudo-random-numbers-middle-square-method.go Normal file
View file

@ -0,0 +1,15 @@
package main
import "fmt"
func random(seed int) int {
return seed * seed / 1e3 % 1e6
}
func main() {
seed := 675248
for i := 1; i <= 5; i++ {
seed = random(seed)
fmt.Println(seed)
}
}

9
Task/Pseudo-random-numbers-Middle-square-method/Haskell/pseudo-random-numbers-middle-square-method.hs Normal file
View file

@ -0,0 +1,9 @@
findPseudoRandom :: Int -> Int
findPseudoRandom seed =
let square = seed * seed
squarestr = show square
enlarged = replicate ( 12 - length squarestr ) '0' ++ squarestr
in read $ take 6 $ drop 3 enlarged
solution :: [Int]
solution = tail $ take 6 $ iterate findPseudoRandom 675248

1
Task/Pseudo-random-numbers-Middle-square-method/J/pseudo-random-numbers-middle-square-method.j Normal file
View file

@ -0,0 +1 @@
(_6{._3}.])&.:(10&#.^:_1)@(*~) ^: (>:i.6) 675248

35
Task/Pseudo-random-numbers-Middle-square-method/Java/pseudo-random-numbers-middle-square-method.java Normal file
View file

@ -0,0 +1,35 @@
public final class MiddleSquareTask {
public static void main(String[] aArgs) {
MiddleSquare random = new MiddleSquare(675248);
for ( int i = 0; i < 5; i++ ) {
System.out.println(random.nextInt());
}
}
}
final class MiddleSquare {
public MiddleSquare(int aSeed) {
final int length = String.valueOf(aSeed).length();
if ( length % 2 == 1 ) {
throw new IllegalArgumentException("Seed must have an even number of digits");
}
state = aSeed;
divisor = (int) Math.pow(10, length / 2);
modulus = (int) Math.pow(10, length);
}
public int nextInt() {
state = ( ( state * state ) / divisor ) % modulus;
return (int) state;
}
private long state;
private final int divisor, modulus;
}

16
Task/Pseudo-random-numbers-Middle-square-method/Jq/pseudo-random-numbers-middle-square-method.jq Normal file
View file

@ -0,0 +1,16 @@
# Input: a positive integer
# Output: the "middle-square"
def middle_square:
(tostring|length) as $len
| (. * .)
| tostring
| (3*length/4|ceil) as $n
| .[ -$n : $len-$n]
| if length == 0 then 0 else tonumber end;
# Input: a positive integer
# Output: middle_square, applied recursively
def middle_squares:
middle_square | ., middle_squares;
limit(5; 675248 | middle_squares)

13
Task/Pseudo-random-numbers-Middle-square-method/Julia/pseudo-random-numbers-middle-square-method.julia Normal file
View file

@ -0,0 +1,13 @@
const seed = [675248]
function random()
s = string(seed[] * seed[], pad=12) # turn a number into string, pad to 12 digits
seed[] = parse(Int, s[begin+3:end-3]) # take middle of number string, parse to Int
return seed[]
end
# Middle-square method use
for i = 1:5
println(random())
end

25
Task/Pseudo-random-numbers-Middle-square-method/Lambdatalk/pseudo-random-numbers-middle-square-method.lambdatalk Normal file
View file

@ -0,0 +1,25 @@
{def W.fill
{lambda {:v :n}
{if {<= :n 0}
then
else :v{W.fill :v {- :n 1}}}}}
-> W.fill
{def W.pad
{lambda {:n :size}
{if {<= {W.length :n} :size}
then :n{W.fill :size {- :size {W.length :n}}}
else {W.slice 0 {- :size {W.length :n}} :n}}}}
-> W.pad
{def randoms
{lambda {:s :n}
{if {>= :n 0}
then :s
{randoms {W.pad {% {floor {/ {* :s :s} 1.e3}} 1.e6} 6}
{- :n 1}}
else}}}
-> randoms
{randoms 959861 4}
-> 959861 333139 981593 524817 432883

14
Task/Pseudo-random-numbers-Middle-square-method/Lua/pseudo-random-numbers-middle-square-method.lua Normal file
View file

@ -0,0 +1,14 @@
seed = 675248
function rnd ()
local s = tostring(seed * seed)
while #s ~= 12 do
s = "0" .. s
end
seed = tonumber(s:sub(4, 9))
return seed
end
for i = 1, 5 do
print(rnd())
end

11
Task/Pseudo-random-numbers-Middle-square-method/Miranda/pseudo-random-numbers-middle-square-method.miranda Normal file
View file

@ -0,0 +1,11 @@
main :: [sys_message]
main = [Stdout (lay (map show numbers))]
where numbers = take 5 (randoms 6 seed)
seed = 675248
randoms :: num->num->[num]
randoms sz = tl . iterate (msq sz)
msq :: num->num->num
msq sz seed = sq div (10^(sz div 2)) mod 10^sz
where sq = seed^2

6
Task/Pseudo-random-numbers-Middle-square-method/Nim/pseudo-random-numbers-middle-square-method.nim Normal file
View file

@ -0,0 +1,6 @@
proc rand:int =
var seed {.global.} = 675248
seed = int(seed*seed) div 1000 mod 1000000
return seed
for _ in 1..5: echo rand()

7
Task/Pseudo-random-numbers-Middle-square-method/OCaml/pseudo-random-numbers-middle-square-method.ocaml Normal file
View file

@ -0,0 +1,7 @@
let random_seq seed =
let next x = x * x / 1000 mod 1000_000 in
Seq.iterate next (next seed)
(* test *)
let () =
random_seq 675248 |> Seq.take 5 |> Seq.iter (Printf.printf " %u")

13
Task/Pseudo-random-numbers-Middle-square-method/Perl/pseudo-random-numbers-middle-square-method.pl Normal file
View file

@ -0,0 +1,13 @@
#!/usr/bin/perl
use strict; # https://rosettacode.org/wiki/Pseudo-random_numbers/Middle-square_method
use warnings;
sub msq
{
use feature qw( state );
state $seed = 675248;
$seed = sprintf "%06d", $seed ** 2 / 1000 % 1e6;
}
print msq, "\n" for 1 .. 5;

12
Task/Pseudo-random-numbers-Middle-square-method/Phix/pseudo-random-numbers-middle-square-method.phix Normal file
View file

@ -0,0 +1,12 @@
(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">seed</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">675248</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">random</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">seed</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">seed</span><span style="color: #0000FF;">*</span><span style="color: #000000;">seed</span><span style="color: #0000FF;">/</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1e6</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">-- seed = to_integer(sprintf("%012d",seed*seed)[4..9])</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">seed</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">5</span> <span style="color: #008080;">do</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">random</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--

10
Task/Pseudo-random-numbers-Middle-square-method/PureBasic/pseudo-random-numbers-middle-square-method.basic Normal file
View file

@ -0,0 +1,10 @@
Procedure.i MSRandom()
Static.i seed=675248
seed = (seed*seed/1000)%1000000
ProcedureReturn seed
EndProcedure
If OpenConsole()
For i=1 To 5 : PrintN(Str(i)+": "+Str(MSRandom())) : Next
Input()
EndIf

7
Task/Pseudo-random-numbers-Middle-square-method/Python/pseudo-random-numbers-middle-square-method.py Normal file
View file

@ -0,0 +1,7 @@
seed = 675248
def random():
global seed
seed = int(str(seed ** 2).zfill(12)[3:9])
return seed
for _ in range(5):
print(random())

14
Task/Pseudo-random-numbers-Middle-square-method/Quackery/pseudo-random-numbers-middle-square-method-1.quackery Normal file
View file

@ -0,0 +1,14 @@
[ dip [ split nip ]
split drop ] is mid ( [ n n --> [ )
[ stack 675248 ] is seed ( --> n )
[ seed take
dup * number$
[ dup size 12 != while
char 0 join
again ]
3 6 mid $->n drop
dup seed put ] is rand ( --> n )
5 times [ rand echo sp ]

8
Task/Pseudo-random-numbers-Middle-square-method/Quackery/pseudo-random-numbers-middle-square-method-2.quackery Normal file
View file

@ -0,0 +1,8 @@
[ stack 675248 ] is seed ( --> s )
[ seed take
dup * 1000 /
1000000 mod
dup seed put ] is rand ( --> n )
5 times [ rand echo sp ]

6
Task/Pseudo-random-numbers-Middle-square-method/Raku/pseudo-random-numbers-middle-square-method.raku Normal file
View file

@ -0,0 +1,6 @@
sub msq {
state $seed = 675248;
$seed = $seed² div 1000 mod 1000000;
}
say msq() xx 5;

4
Task/Pseudo-random-numbers-Middle-square-method/Red/pseudo-random-numbers-middle-square-method.red Normal file
View file

@ -0,0 +1,4 @@
Red[]
seed: 675248
rand: does [seed: to-integer (seed * 1.0 * seed / 1000) % 1000000] ; multiply by 1.0 to avoid integer overflow (32-bit)
loop 5 [print rand]

7
Task/Pseudo-random-numbers-Middle-square-method/Ruby/pseudo-random-numbers-middle-square-method.rb Normal file
View file

@ -0,0 +1,7 @@
def middle_square (seed)
return to_enum(__method__, seed) unless block_given?
s = seed.digits.size
loop { yield seed = (seed*seed).to_s.rjust(s*2, "0")[s/2, s].to_i }
end
puts middle_square(675248).take(5)

8
Task/Pseudo-random-numbers-Middle-square-method/Sidef/pseudo-random-numbers-middle-square-method.sidef Normal file
View file

@ -0,0 +1,8 @@
class MiddleSquareMethod(seed, k = 1000) {
method next {
seed = (seed**2 // k % k**2)
}
}
var obj = MiddleSquareMethod(675248)
say 5.of { obj.next }

10
Task/Pseudo-random-numbers-Middle-square-method/UNIX-Shell/pseudo-random-numbers-middle-square-method.sh Normal file
View file

@ -0,0 +1,10 @@
seed=675248
random(){
seed=`expr $seed \* $seed / 1000 % 1000000`
return seed
}
for ((i=1;i<=5;i++));
do
random
echo $?
done

18
Task/Pseudo-random-numbers-Middle-square-method/Visual-Basic/pseudo-random-numbers-middle-square-method.vb Normal file
View file

@ -0,0 +1,18 @@
Option Explicit
Dim seed As Long
Sub Main()
Dim i As Integer
seed = 675248
For i = 1 To 5
Debug.Print Rand
Next i
End Sub
Function Rand() As Variant
Dim s As String
s = CStr(seed ^ 2)
Do While Len(s) <> 12
s = "0" + s
Loop
seed = Val(Mid(s, 4, 6))
Rand = seed
End Function

4
Task/Pseudo-random-numbers-Middle-square-method/Wren/pseudo-random-numbers-middle-square-method.wren Normal file
View file

@ -0,0 +1,4 @@
var random = Fn.new { |seed| ((seed * seed)/1e3).floor % 1e6 }
var seed = 675248
for (i in 1..5) System.print(seed = random.call(seed))

11
Task/Pseudo-random-numbers-Middle-square-method/XPL0/pseudo-random-numbers-middle-square-method.xpl0 Normal file
View file

@ -0,0 +1,11 @@
real Seed;
func Random;
[Seed:= Floor(Mod(Seed*Seed/1e3, 1e6));
return fix(Seed);
];
int N;
[Seed:= 675248.;
for N:= 1 to 5 do
[IntOut(0, Random); ChOut(0, ^ )];
]

10
Task/Pseudo-random-numbers-Middle-square-method/Yabasic/pseudo-random-numbers-middle-square-method.basic Normal file
View file

@ -0,0 +1,10 @@
semilla = 675248
for i = 1 to 5
print i, ": ", Random()
next i
end
sub Random()
semilla = floor(mod(((semilla*semilla)/1e3), 1e6))
return int(semilla)
end sub