Generar todos los puntos integrales que se encuentran dentro de un rectángulo

Dado un rectángulo de largo L y ancho W , la tarea es generar todas las coordenadas integrales (X, Y) que se encuentran dentro de un rectángulo de dimensiones L * W que tiene uno de sus vértices en el origen (0, 0) .

Ejemplos:

Entrada: L = 3, W = 2
Salida: (0, 0) (0, 1) (1, 0) (1, 1) (2, 0) (2, 1)
Explicación: Número total de coordenadas integrales existentes dentro el rectángulo son L × W = 6. Por lo tanto, la salida es (0, 0) (0, 1) (1, 0) (1, 1) (2, 0) (2, 1).

Entrada: L = 5, W = 3
Salida: (0, 0) (0, 1) (0, 2) (1, 0) (1, 1) (1, 2) (2, 0) (2, 1 ) (2, 2) (3, 0) (3, 1) (3, 2) (4, 0) (4, 1) (4, 2)

Enfoque: el problema se puede resolver generando todos los números enteros del rango 0 a L para las coordenadas X y de 0 a W para las coordenadas Y usando la función rand() . Siga los pasos a continuación para resolver el problema:

1. Cree un conjunto de pares para almacenar todas las coordenadas (X, Y) que se encuentran dentro del rectángulo.
2. Utilice la ecuación rand() % L para generar todos los enteros que se encuentran entre 0 y L y rand() % W para generar todos los enteros que se encuentran entre 0 y W .
3. Imprima todas las coordenadas L × W posibles (X, Y) que se encuentran dentro del rectángulo.

A continuación se muestra la implementación del enfoque anterior: 

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to generate coordinates
// lying within the rectangle
void generatePoints(int L, int W)
{
    // Store all possible coordinates
    // that lie within the rectangle
    set<pair<int, int> > hash;
 
    // Stores the number of possible
    // coordinates that lie within
    // the rectangle
    int total = (L * W);
 
    // Use current time as seed
    // for random generator
    srand(time(0));
 
    // Generate all possible
    // coordinates
    while (total--) {
        // Generate all possible
        // X-coordinates
        int X = rand() % L;
 
        // Generate all possible
        // Y-coordinates
        int Y = rand() % W;
 
        // If coordinates(X, Y) has
        // not been generated already
        while (hash.count({ X, Y })) {
            X = rand() % L;
            Y = rand() % W;
        }
 
        // Insert the coordinates(X, Y)
        hash.insert({ X, Y });
    }
 
    // Print the coordinates
    for (auto points : hash) {
        cout << "(" << points.first << ", "
             << points.second << ") ";
    }
}
 
// Driver Code
int main()
{
    // Rectangle dimensions
    int L = 3, W = 2;
 
    generatePoints(L, W);
}

# Python3 program to implement
# the above approach
import time
import random
 
random.seed(time.time())
 
# Function to generate coordinates
# lying within the rectangle
def generatePoints(L, W):
     
    # Store all possible coordinates
    # that lie within the rectangle
    hash = {}
 
    # Stores the number of possible
    # coordinates that lie within
    # the rectangle
    total = (L * W)
 
    # Generate all possible
    # coordinates
    for i in range(total):
         
        # Generate all possible
        # X-coordinates
        X = random.randint(0, L) % L
 
        # Generate all possible
        # Y-coordinates
        Y = random.randint(0, W) % W
 
        # If coordinates(X, Y) has
        # not been generated already
        while ((X, Y) in hash):
            X = random.randint(0, L) % L
            Y = random.randint(0, W) % W
 
        # Insert the coordinates(X, Y)
        hash[(X, Y)] = 1
 
    # Print the coordinates
    for points in sorted(hash):
        print("(", points[0],
             ", ", points[1],
             ") ", end = "")
 
# Driver code
if __name__ == '__main__':
     
    # Rectangle dimensions
    L, W = 3, 2
 
    generatePoints(L, W)
 
# This code is contributed by mohit kumar 29

// C# program to implement
// the above approach
using System;
using System.Collections;
using System.Collections.Generic;
 
class GFG{
 
public class store : IComparer<KeyValuePair<int, int>>
{
    public int Compare(KeyValuePair<int, int> x,
                       KeyValuePair<int, int> y)
    {
        if (x.Key != y.Key)
        {
            return x.Key.CompareTo(y.Key);   
        }
        else
        {
            return x.Value.CompareTo(y.Value);   
        }
    }
}
      
// Function to generate coordinates
// lying within the rectangle
static void generatePoints(int L, int W)
{
     
    // Store all possible coordinates
    // that lie within the rectangle
    SortedSet<KeyValuePair<int,
                           int>> hash = new SortedSet<KeyValuePair<int,
                                                                   int>>(new store());
  
    // Stores the number of possible
    // coordinates that lie within
    // the rectangle
    int total = (L * W);
  
    // For random generator
    Random rand = new Random();
  
    // Generate all possible
    // coordinates
    while ((total--) != 0)
    {
         
        // Generate all possible
        // X-coordinates
        int X = rand.Next() % L;
  
        // Generate all possible
        // Y-coordinates
        int Y = rand.Next() % W;
  
        // If coordinates(X, Y) has
        // not been generated already
        while (hash.Contains(
            new KeyValuePair<int, int>(X, Y)))
        {
            X = rand.Next() % L;
            Y = rand.Next() % W;
        }
  
        // Insert the coordinates(X, Y)
        hash.Add(new KeyValuePair<int, int>(X, Y));
    }
  
    // Print the coordinates
    foreach(KeyValuePair<int, int> x in hash)
    {
        Console.Write("(" + x.Key + ", " +
                          x.Value + ") ");
    }
}
 
// Driver Code
public static void Main(string[] args)
{
     
    // Rectangle dimensions
    int L = 3, W = 2;
  
    generatePoints(L, W);
}
}
 
// This code is contributed by rutvik_56

// JavaScript program to implement
// the above approach
 
// Function to generate coordinates
// lying within the rectangle
function generatePoints(L, W)
{
    // Store all possible coordinates
    // that lie within the rectangle
    let hash = new Set();
 
    // Stores the number of possible
    // coordinates that lie within
    // the rectangle
    let total = (L * W);
 
    // Generate all possible
    // coordinates
    while (total--) {
        // Generate all possible
        // X-coordinates
        let X = Math.floor((Math.random()*(L+1))) % L;
 
        // Generate all possible
        // Y-coordinates
        let Y = Math.floor((Math.random()*(W+1))) % W;
 
        // If coordinates(X, Y) has
        // not been generated already
        while (hash.has([X, Y].join())) {
            X = Math.floor((Math.random()*(L+1))) % L;
            Y = Math.floor((Math.random()*(W+1))) % W;
        }
 
        // Insert the coordinates(X, Y)
        // console.log(X, Y);
        hash.add([X, Y].join());
    }
 
    // Print the coordinates
    hash.forEach(element=>{
        document.write("(", element, ") ");
    })
 
}
 
// Driver Code
 
// Rectangle dimensions
let L = 3, W = 2;
 
generatePoints(L, W);
 
// The code is contributed by Gautam goel (gautamgoel962)

(0, 0) (0, 1) (1, 0) (1, 1) (2, 0) (2, 1)

Complejidad de Tiempo: O(L * W) 
Espacio Auxiliar: O(L * W)