Imprime N líneas de 4 números de modo que cada par entre 4 números tenga un GCD K

Dados N y K, la tarea es imprimir N líneas donde cada línea contiene 4 números, de modo que cada uno de esos 4 números tenga un GCD K y el número máximo utilizado en N*4 debe minimizarse.
Nota: En caso de salidas múltiples, imprima cualquiera. 
Ejemplos: 

Entrada: N = 1, K = 1 
Salida : 1 2 3 5 
Cada par entre 1, 2, 3 y 5 da un MCD K y el número más grande entre estos es 5 que es el mínimo posible. 

Entrada : 2 2 
Salida : 
2 4 6 22 
14 18 10 16
En la entrada anterior, el número máximo es 22, que es el mínimo posible para hacer 2 líneas de 4 números. 

Enfoque: La primera observación es que si podemos resolver el problema dado para K=1, podemos resolver el problema con MCD K simplemente multiplicando las respuestas con K. Sabemos que tres números impares consecutivos siempre tienen un MCD 1 cuando están emparejados , por lo que se pueden obtener fácilmente tres números de cada línea. Por lo tanto, las líneas se verán así: 

1 3 5 _ 
7 9 11 _ 
13 15 17 _  
.
.
.

Un número par no se puede insertar siempre, porque insertar 6 en la tercera línea dará MCD(6, 9) como 3. Entonces, el mejor número que se puede insertar es un número entre los dos primeros números de cada línea. Por lo tanto, el patrón se ve así:  

1 2 3 5  
7 8 9 11  
13 14 15 17  
.
.
.

Para obtener el GCD K dado, uno puede multiplicar fácilmente K a los números obtenidos. Por lo tanto para la i-ésima línea:  

1. el primer número será k * (6*i+1)
2. el segundo número será k * (6*i+1)
3. el tercer número será k * (6*i+3)
4. el cuarto número será k * (6*i+5)

El número máximo entre N*4 números será k * (6*i – 1) 
A continuación se muestra la implementación del enfoque anterior.  

// C++ implementation of the
// above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to print N lines
void printLines(int n, int k)
{
    // Iterate N times to print N lines
    for (int i = 0; i < n; i++) {
        cout << k * (6 * i + 1) << " "
             << k * (6 * i + 2) << " "
             << k * (6 * i + 3) << " "
             << k * (6 * i + 5) << endl;
    }
}
// Driver Code
int main()
{
    int n = 2, k = 2;
    printLines(n, k);
    return 0;
}

// Java implementation of the
// above approach
 
import java.util.*;
import java.lang.*;
import java.io.*;
 
class GFG
{
// Function to print N lines
static void printLines(int n, int k)
{
    // Iterate N times to print N lines
    for (int i = 0; i < n; i++) {
        System.out.println ( k * (6 * i + 1) + " "
            + k * (6 * i + 2) + " "
            + k * (6 * i + 3) + " "
            + k * (6 * i + 5) );
    }
}
// Driver Code
public static void main(String args[])
{
    int n = 2, k = 2;
    printLines(n, k);
}
}

# Python implementation of the
# above approach.
 
# Function to print N lines
def printLines(n, k) :
 
    # Iterate N times to print N lines
    for i in range(n) :
        print( k * (6 * i + 1),
                k * (6 * i + 2),
               k * (6 * i + 3),
               k * (6 * i + 5))
         
# Driver code    
if __name__ == "__main__" :
 
    n, k = 2, 2
    printLines(n, k)
 
# This code is contributed by ANKITRAI1

<?php
// Function to print N lines
function printLines($n, $k)
{
    // Iterate N times to print N lines
    for ($i = 0; $i < $n; $i++)
    {
        echo ($k * (6 * $i + 1));
        echo (" ");
        echo ($k * (6 * $i + 2));
        echo (" ");
        echo ($k * (6 * $i + 3));
        echo (" ");
        echo ($k * (6 * $i + 5));
        echo ("\n");
    }
}
 
// Driver Code
$n = 2;
$k = 2;
printLines($n, $k);
     
// This code is contributed
// by Shivi_Aggarwal
?>

// C# implementation of the
// above approach
using System;
 
class GFG
{
// Function to print N lines
static void printLines(int n, int k)
{
    // Iterate N times to print N lines
    for (int i = 0; i < n; i++)
    {
        Console.WriteLine ( k * (6 * i + 1) + " " +
                            k * (6 * i + 2) + " " +
                            k * (6 * i + 3) + " " +
                            k * (6 * i + 5) );
    }
}
 
// Driver Code
public static void Main()
{
    int n = 2, k = 2;
    printLines(n, k);
}
}
 
// This code is contributed
// by Akanksha Rai(Abby_akku)

<script>
// javascript implementation of the
// above approach
 
    // Function to print N lines
    function printLines(n , k)
    {
     
        // Iterate N times to print N lines
        for (i = 0; i < n; i++)
        {
            document.write(k * (6 * i + 1)
            + " " + k * (6 * i + 2) + " "
            + k * (6 * i + 3) + " "
            + k * (6 * i + 5)+"<br/>");
        }
    }
 
    // Driver Code
        var n = 2, k = 2;
        printLines(n, k);
 
// This code is contributed by umadevi9616
</script>

2 4 6 10
14 16 18 22

Complejidad de tiempo : O (N * 4), ya que estamos usando un ciclo para atravesar N veces y hacer 4 operaciones en cada recorrido.

Espacio auxiliar : O(1), ya que no estamos utilizando ningún espacio adicional.