疑似乱数(Python3) #

# 配列A, 乱数初期値A0～A3を入れておく
A = [1, 2, 3, 4]

# 乱数出力用配列　初期はカラ
arrayRandom = []

# 初期値n = 0から99まで、
# 100個ぶんの乱数xを計算して
# 配列Aに足していくwhileループ処理
n = 0
while n < 100:
    # 乱数計算 a//bで小数点以下切り捨て除算
    x = ((A[n+1] * 256 + A[n]) // 13) % 256
    # 作った乱数を配列AとarrayRandomの末尾に追加
    A.append(x) 
    arrayRandom.append(x)
    # 初期値nを+1してループの最初に戻る
    n += 1
    
# nが100越えたらループ終了、出力
print(f"初期値：\n{A[0:4]}")
print(f"出力された乱数：\n{arrayRandom}")

疑似乱数(JavaScript) #

// 配列A, 乱数初期値A0～A3を入れておく
let A = [1, 2, 3, 4];

//乱数出力用配列　初期はカラ
let arrayRandom = [];

// 初期値n = 0から99まで、
// 100個ぶんの乱数を計算して
// 配列Aに足していくwhileループ処理
let n = 0;
while (n < 100) {
    // 乱数計算
    A[n+4] = Math.trunc((A[n+1] * 256 + A[n]) / 13) % 256;
    // 作った乱数を配列arrayRandomにも入れる
    arrayRandom[n] = A[n+4];
    // 初期値nを+1してループの最初に戻る
    n++;
}

// nが100越えたらループ終了、出力
console.log("初期値：\n" + A.slice(0, 4));
console.log("出力された乱数：\n" + arrayRandom);

疑似乱数(Go) #

package main

import ("fmt")

func main(){
    // 配列（スライス）A, 乱数初期値A0～A3を入れておく
    A := []int{1, 2, 3, 4}
     
    // 初期値n = 0から99まで、
    // 100個ぶんの乱数xを計算して
    // 配列Aに足していくforループ処理
    for n := 0; n < 100; n++ {
        // 乱数計算(Goでは整数同士の除算は切り捨て処理）
        x := ((A[n+1] * 256 + A[n]) / 13) % 256
        // 作った乱数をappendで配列Aの末尾に追加
        A = append(A, x)
    }
    
    // nが100越えたらループ終了、出力
    fmt.Println("初期値：\n", A[0:4])
    fmt.Println("出力された乱数：\n", A[4:len(A)])
}

疑似乱数(Rust) #

fn main(){
    // 配列（ベクタ）a
    // ※Rustでの命名規則の都合で小文字にします
    // 乱数初期値A0～A3を入れておく
    let mut a = vec![1, 2, 3, 4];

    // 初期値n = 0から99まで、
    // 100個ぶんの乱数xを計算して
    // 配列（ベクタ）aに足していくwhileループ処理
    let mut n = 0;
    while n < 100 {
        // 乱数計算(Rustでは整数同士の除算は切り捨て処理）
        let x = ((a[n+1] * 256 + a[n]) / 13) % 256;
       // 作った乱数をpushで配列aの末尾に追加
        a.push(x);
        // 初期値nを+1してループの最初に戻る
        n += 1;
    }

    // 配列（ベクタ）aを初期値までと後とで分割
    let random = a.split_off(4);

    // 出力
    println!("初期値：\n{:?}", a);
    println!("出力された乱数：\n{:?}", random);
}

疑似乱数(C#) #

public class Program {
    public static void Main(){

        // 配列a
        // 乱数初期値A0～A3を入れておく
        int[] a = new int[104];
        a[0] = 1;
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;

        // 初期値n = 0から99まで、
        // 100個ぶんの乱数を計算して
        // 配列aに足していくwhileループ処理
        int n = 0;
        while (n < 100) {
            // 乱数計算(C#では整数同士の除算は切り捨て処理）
            a[n+4] = ((a[n+1] * 256 + a[n]) / 13) % 256;
            // 初期値nを+1してループの最初に戻る
            n += 1;
        }

        // 配列aを初期値までと後とで分割
        int[] firstArray = new int[4];
        int m = 0;
        while (m < 4) {
            firstArray[m] = a[m];
            m += 1;
        }

        int[] secondArray = new int[100];
        int i = 0;
        while (i < 100) {
            secondArray[i] = a[i+4];
            i += 1;
        }

        // 出力
        System.Console.WriteLine($"初期値：\n{string.Join(", ", firstArray)}");
        System.Console.WriteLine($"出力された乱数：\n{string.Join(", ", secondArray)}");
    }
}

疑似乱数(Java) #

import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        // 配列a
        // 乱数初期値A0～A3を入れておく
        int[] a = new int[104];
        a[0] = 1;
        a[1] = 2;
        a[2] = 3;
        a[3] = 4;

        // 初期値n = 0から99まで、
        // 100個ぶんの乱数を計算して
        // 配列aに足していくwhileループ処理
        int n = 0;
        while (n < 100) {
            // 乱数計算(Javaでは整数同士の除算は切り捨て処理）
            a[n+4] = ((a[n+1] * 256 + a[n]) / 13) % 256;
            // 初期値nを+1してループの最初に戻る
            n++;
        }

        // 配列aを初期値までと後とで分割
        int[] firstArray = Arrays.copyOfRange(a, 0, 4);
        int[] secondArray = Arrays.copyOfRange(a, 4, 104);

        // 出力
        System.out.println("初期値：\n" + Arrays.toString(firstArray));
        System.out.println("出力された乱数：\n" + Arrays.toString(secondArray));
    }
}

疑似乱数(Ruby) #

# 配列A, 乱数初期値A0～A3を入れておく
A = [1, 2, 3, 4]

# 乱数出力用配列　初期はカラ
arrayRandom = []

# 初期値n = 0から99まで、
# 100個ぶんの乱数を計算して
# 配列Aに足していくwhileループ処理
n = 0
while n < 100
    # 乱数計算(Rubyでは整数同士の除算は切り捨て処理）
    x = ((A[n+1] * 256 + A[n]) / 13) % 256
    # 作った乱数を配列arrayRandomにも入れる
    A.push(x)
    arrayRandom.push(x)
    # 初期値nを+1してループの最初に戻る
    n += 1
end

# nが100越えたらループ終了、出力
puts "初期値：\n#{A.slice(0, 4)}"
puts "出力された乱数：\n#{arrayRandom}"

疑似乱数(なでしこ3) #

# 配列A, 乱数初期値A0～A3を入れておく
A = [1, 2, 3, 4]

# 乱数出力用配列　初期はカラ
乱数出力用配列 = []

# 初期値n = 0から
# 100個ぶんの乱数を計算して
# 配列Aに足していくループ処理
n = 0
100回
    # 乱数計算 truncは「切捨」で処理
    y = (A[n+1] * 256 + A[n]) / 13を切捨。
    x = y % 256
    # 作った乱数を配列乱数出力用配列にも入れる
    Aにxを配列プッシュ。
    乱数出力用配列にxを配列プッシュ。
    # 初期値nを+1してループの最初に戻る
    n = n + 1
ここまで。

初期配列=Aの0…3を配列範囲コピー。

# 出力
「初期値：」と表示。
初期配列と表示。
「出力された乱数：」と表示。
乱数出力用配列と表示。

実行結果 #