Programa en C para generar tablas de multiplicar

Aquí, construiremos un programa C para generar una tabla de multiplicar usando 2 enfoques, es decir

1. Uso de bucles y una array 2-D
2. Usando bucles y sin almacenarlos en una array

Dado el valor de un número, necesitamos encontrar la tabla de multiplicar del número hasta un rango dado. Usaremos los conceptos de bucle y el uso de una array 2-D para imprimir una tabla de multiplicación .

Aporte: 

num = 5 
range = 10

Producción:

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

1. Uso de bucles y una array 2-D

Algoritmo:

• Tome la entrada del número y el rango de la tabla de multiplicar.
• Ahora use un bucle for (la variable «k») se usa para atravesar la array 2-D, itera a través de 0 hasta el rango.
• La primera columna almacena el número (es decir, arr[k][0] = num) .
• La segunda columna almacena el valor que se multiplicará (es decir, arr[k][1] = k+1) .
• La tercera columna almacena el producto (es decir, arr[k][2] = arr[k][1] * arr[k][0] ) .
• Luego usa otro bucle para imprimir la tabla de multiplicar.

// C program to demonstrate the
// Multiplication table of a number
#include <stdio.h>
void print_table(int range, int num)
{
    // Taking two integer variables row and column
    int row, col;
 
    // Initializing row with range of the multiplication
    // table.
    row = range;
 
    // Initializing column with 3.
    col = 3;
 
    // Creating a 2-D array to calculate and store the
    // Multiplication Table .
    int arr[row][col];
 
    // For loop to calculate the table
    for (int k = 0; k < row; k++) {
        // Storing the number in the first column.
        arr[k][0] = num;
 
        // Storing the value to be multiplied in the second
        // column.
        arr[k][1] = k + 1;
 
        // Calculating and Storing the product in the third
        // column.
        arr[k][2] = arr[k][1] * arr[k][0];
    }
 
    // For loop to print the Multiplication table
    for (int i = 0; i < row; i++) {
        printf("%d * %d = %d", arr[i][0], arr[i][1],
               arr[i][2]);
        printf("\n");
    }
}
// Driver code
int main()
{
    // The range of the
    // Multiplication table.
    int range = 10;
 
    // The number to calculate the
    // Multiplication table.
    int num = 5;
 
    // Callig the Function.
    print_table(range, num);
    return 0;
}

Producción:

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

• Complejidad temporal: O(n).
• Espacio auxiliar: O (fila * columna), ya que se usa una array 2-D.

2. Usando bucles y sin almacenarlos en una array 

La idea es utilizar el concepto de bucle e imprimir directamente la tabla de multiplicar sin almacenarlas en una array.

Algoritmo:

• Tome la entrada del número y el rango de la tabla de multiplicar.
• Declare una variable para almacenar el producto.
• Use un bucle for para multiplicar e imprimir directamente la tabla de multiplicación.

// C program to Demonstrate the
// Multiplication table of a number
#include <stdio.h>
void print_table(int range, int num)
{
    // Declaring a variable mul to store the  product.
    int mul;
 
    // For loop to calculate the Multiplication table.
    for (int i = 1; i <= range; i++) {
        // To store the product.
        mul = num * i;
 
        // Printing the Multiplication Table.
        printf("%d * %d = %d", num, i, mul);
 
        // Proceeding to the next line.
        printf("\n");
    }
}
// Driver code
int main()
{
 
    // The range of the
    // Multiplication table
    int range = 10;
 
    // The number to calculate the
    // Multiplication table
    int num = 5;
 
    // Callig the Function.
    print_table(range, num);
 
    return 0;
}

Producción:

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

• Complejidad de tiempo: O (n), ya que solo se requiere un ciclo for.
• Espacio auxiliar: O(1), no se requiere espacio adicional, por lo que es una constante.