Random Number Code Examples

<?php
// Generate a single random number between 1 and 100
$randomNumber = random_int(1, 100);
echo $randomNumber;  // Example output: 42

// Generate multiple random numbers
$numbers = [];
for ($i = 0; $i < 10; $i++) {
    $numbers[] = random_int(1, 100);
}
print_r($numbers);
// Example output: [23, 7, 91, 45, 12, 68, 3, 89, 54, 31]

// Generate random float/decimal
$randomFloat = random_int(0, 10000) / 100;  // 0.00 to 100.00
echo number_format($randomFloat, 2);  // Example: 42.17

// Generate a random number between 1 and 100
const randomNumber = Math.floor(Math.random() * 100) + 1;
console.log(randomNumber);  // Example output: 42

// Generate multiple random numbers
const numbers = Array.from({ length: 10 }, () =>
    Math.floor(Math.random() * 100) + 1
);
console.log(numbers);
// Example output: [23, 7, 91, 45, 12, 68, 3, 89, 54, 31]

// Generate cryptographically secure random number
const secureRandom = () => {
    const array = new Uint32Array(1);
    crypto.getRandomValues(array);
    return array[0] / (0xFFFFFFFF + 1);  // Normalize to 0-1
};
const secureNumber = Math.floor(secureRandom() * 100) + 1;
console.log(secureNumber);  // Example: 67

// Random decimal between 0 and 100
const randomFloat = (Math.random() * 100).toFixed(2);
console.log(randomFloat);  // Example: 42.17

import random
import secrets

# Generate a single random number between 1 and 100
random_number = random.randint(1, 100)
print(random_number)  # Example output: 42

# Generate multiple random numbers
numbers = [random.randint(1, 100) for _ in range(10)]
print(numbers)
# Example output: [23, 7, 91, 45, 12, 68, 3, 89, 54, 31]

# Generate cryptographically secure random number
secure_number = secrets.randbelow(100) + 1  # 1 to 100
print(secure_number)  # Example: 67

# Random float between 0 and 100
random_float = random.uniform(0, 100)
print(f"{random_float:.2f}")  # Example: 42.17

# Using NumPy for array generation
import numpy as np
numpy_numbers = np.random.randint(1, 101, size=10)
print(numpy_numbers)
# Example output: [23  7 91 45 12 68  3 89 54 31]

import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import java.security.SecureRandom;
import java.util.stream.IntStream;

public class RandomNumberExample {
    public static void main(String[] args) {
        // Generate a single random number between 1 and 100
        Random random = new Random();
        int randomNumber = random.nextInt(100) + 1;
        System.out.println(randomNumber);  // Example output: 42

        // Generate multiple random numbers (Java 8+)
        int[] numbers = IntStream.generate(() ->
            ThreadLocalRandom.current().nextInt(1, 101)
        ).limit(10).toArray();

        System.out.println(java.util.Arrays.toString(numbers));
        // Example output: [23, 7, 91, 45, 12, 68, 3, 89, 54, 31]

        // Generate cryptographically secure random number
        SecureRandom secureRandom = new SecureRandom();
        int secureNumber = secureRandom.nextInt(100) + 1;
        System.out.println(secureNumber);  // Example: 67

        // Random double between 0 and 100
        double randomDouble = random.nextDouble() * 100;
        System.out.printf("%.2f%n", randomDouble);  // Example: 42.17
    }
}

using System;
using System.Security.Cryptography;
using System.Linq;

class RandomNumberExample
{
    static void Main()
    {
        // Generate a single random number between 1 and 100
        Random random = new Random();
        int randomNumber = random.Next(1, 101);
        Console.WriteLine(randomNumber);  // Example output: 42

        // Generate multiple random numbers
        int[] numbers = Enumerable.Range(0, 10)
            .Select(_ => random.Next(1, 101))
            .ToArray();
        Console.WriteLine($"[{string.Join(", ", numbers)}]");
        // Example output: [23, 7, 91, 45, 12, 68, 3, 89, 54, 31]

        // Generate cryptographically secure random number
        int secureNumber = RandomNumberGenerator.GetInt32(1, 101);  // 1 to 100, .NET Core 3.0+
        Console.WriteLine(secureNumber);  // Example: 67

        // Random double between 0 and 100
        double randomDouble = random.NextDouble() * 100;
        Console.WriteLine($"{randomDouble:F2}");  // Example: 42.17
    }
}

#include <iostream>
#include <random>
#include <iomanip>
#include <vector>

int main() {
    // Initialize random number generator
    std::random_device rd;  // Seed
    std::mt19937 gen(rd()); // Mersenne Twister engine
    std::uniform_int_distribution<> distrib(1, 100);

    // Generate a single random number between 1 and 100
    int randomNumber = distrib(gen);
    std::cout << randomNumber << std::endl;  // Example output: 42

    // Generate multiple random numbers
    std::vector<int> numbers;
    for (int i = 0; i < 10; ++i) {
        numbers.push_back(distrib(gen));
    }

    std::cout << "[";
    for (size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i];
        if (i < numbers.size() - 1) std::cout << ", ";
    }
    std::cout << "]" << std::endl;
    // Example output: [23, 7, 91, 45, 12, 68, 3, 89, 54, 31]

    // Random double between 0 and 100
    std::uniform_real_distribution<> realDistrib(0.0, 100.0);
    double randomDouble = realDistrib(gen);
    std::cout << std::fixed << std::setprecision(2) << randomDouble << std::endl;
    // Example: 42.17

    return 0;
}

require 'securerandom'

# Generate a single random number between 1 and 100
random_number = rand(1..100)
puts random_number  # Example output: 42

# Generate multiple random numbers
numbers = Array.new(10) { rand(1..100) }
puts numbers.inspect
# Example output: [23, 7, 91, 45, 12, 68, 3, 89, 54, 31]

# Generate cryptographically secure random number
secure_number = SecureRandom.random_number(1..100)
puts secure_number  # Example: 67

# Random float between 0 and 100
random_float = rand(0.0..100.0)
puts format('%.2f', random_float)  # Example: 42.17

# Using Random class for reproducible results
prng = Random.new(42)  # Seeded for reproducibility
seeded_number = prng.rand(1..100)
puts seeded_number

package main

import (
    cryptorand "crypto/rand"
    "fmt"
    "math/big"
    "math/rand/v2"
)

func main() {
    // Generate a single random number between 1 and 100
    randomNumber := rand.IntN(100) + 1
    fmt.Println(randomNumber)  // Example output: 42

    // Generate multiple random numbers
    numbers := make([]int, 10)
    for i := range numbers {
        numbers[i] = rand.IntN(100) + 1
    }
    fmt.Println(numbers)
    // Example output: [23 7 91 45 12 68 3 89 54 31]

    // Generate cryptographically secure random number
    nBig, _ := cryptorand.Int(cryptorand.Reader, big.NewInt(100))
    secureNumber := nBig.Int64() + 1
    fmt.Println(secureNumber)  // Example: 67

    // Random float between 0 and 100
    randomFloat := rand.Float64() * 100
    fmt.Printf("%.2f\n", randomFloat)  // Example: 42.17
}