WAP to generate 10 random numbers using top programming languages

Short snippets to generate 10 random numbers.

Python

import random
for i in range(10):
    print(random.randint(1, 100))

C

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
    srand(time(NULL));
    for (int i = 0; i < 10; i++) {
        printf("%d\n", rand() % 100 + 1);
    }
    return 0;
}

JavaScript

for (let i = 0; i < 10; i++) {
    console.log(Math.floor(Math.random() * 100) + 1);
}

Ruby

for i in 1..10 do
  puts rand(1..100)
end

Java

import java.util.Random;

public class RandomNumbers {
    public static void main(String[] args) {
        Random rand = new Random();
        for (int i = 0; i < 10; i++) {
            System.out.println(rand.nextInt(100) + 1);
        }
    }
}

PHP

for ($i = 0; $i < 10; $i++) {
    echo rand(1, 100) . "\n";
}

Swift

for _ in 1...10 {
    print(Int.random(in: 1...100))
}

Kotlin

fun main() {
    repeat(10) {
        println((1..100).random())
    }
}

Go

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 10; i++ {
        fmt.Println(rand.Intn(100) + 1)
    }
}

Rust

use rand::Rng;

fn main() {
    let mut rng = rand::thread_rng();
    for _ in 0..10 {
        println!("{}", rng.gen_range(1..=100));
    }
}

Ada

with Ada.Numerics.Discrete_Random;

procedure Main is
   package Random_Numbers is new Ada.Numerics.Discrete_Random (Integer);
   G : Random_Numbers.Generator;
   R : Random_Numbers.Uniform;
begin
   for I in 1..10 loop
      Random_Numbers.Reset(G);
      Random_Numbers.Random(R, G);
      Ada.Text_IO.Put(R'Image);
      Ada.Text_IO.New_Line;
   end loop

Haskell

import System.Random

main :: IO ()
main = do
    gen <- newStdGen
    let randomNumbers = take 10 (randomRs (1,100) gen)
    mapM_ print randomNumbers

CPP

#include <iostream>
#include <random>

int main() {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1, 100);

    for (int i = 0; i < 10; i++) {
        std::cout << dis(gen) << std::endl;
    }

    return 0;
}

Assembly

section .data
    seed    dd  0

section .text
    global _start

_start:
    mov eax, 0
    call time
    mov [seed], eax
    call srand
    mov ecx, 10
loop:
    call rand
    mov ebx, 100
    div ebx
    add eax, 1
    push eax
    call print_int
    add esp, 4
    call print_nl
    loop loop
    mov eax, 1
    xor ebx, ebx
    int 0x80

srand:
    push ebp
    mov ebp, esp
    push dword [ebp+8]
    call rand
    mov esp, ebp
    pop ebp
    ret

rand:
    push ebp
    mov ebp, esp
    call dword [rand_ptr]
    mov esp, ebp
    pop ebp
    ret


print_int:
    push ebp
    mov ebp, esp
    push ebx
    push eax
    mov eax, 4
    mov ebx, 1
    mov ecx, esp
    mov edx, 4
    int 0x80
    pop eax
    pop ebx
    mov esp, ebp
    pop ebp
    ret

print_nl:
    push ebp
    mov ebp, esp
    mov eax, 4
    mov ebx, 1
    mov ecx, nl
    mov edx, 1
    int 0x80
    mov esp, ebp
    pop ebp
    ret

section .data
    nl      db  0x0a
    rand_ptr dd  0x0804a030

R

set.seed(Sys.time())
random_numbers <- sample(1:100, 10, replace=TRUE)
print(random_numbers)

PL/S

MAIN: PROCEDURE OPTIONS(MAIN);
    DCL I FIXED BIN(31);
    DCL R FIXED DECIMAL(5,2);
    DO I = 1 TO 10;
        R = RANDOM(100);
        PUT SKIP EDIT('Random number:', R(5,2));
    END;
END MAIN;

BLISS

main: procedure options(main);
    declare i: integer;
    declare r: real;
    for i = 1 to 10 do
        r = random();
        write("Random number: ", r, $);
    endfor
end;

BCPL

GETRAN := PROC() BEGINTIME;
    INT R;
    FOR I := 0 TO 9 DO
        R := RANDOM() MOD 100 + 1;
        PRINTF("Random number: %d\n", R);
    OD;
END;

Extended ALGOL

BEGIN
    FOR I := 1 STEP 1 UNTIL 10 DO
        R := RANDOM(100);
        OUTFILE(OUTPUT, "Random number: ", R);
    END;
END.

Matlab

rng('shuffle');
random_numbers = randi([1, 100], [1, 10]);
disp(random_numbers);

Scala

import scala.util.Random

val random = new Random(System.currentTimeMillis()
val random_numbers = Seq.fill(10)(random.nextInt(100) + 1)
println(random_numbers)

Perl

use Time::HiRes qw(time);
srand(time());
@random_numbers = map { int(rand(100)) + 1 } (1..10);
print join(", ", @random_numbers), "\n";