Write a program that receives a number as input and prints it in the following format as shown below.
Examples :
Input : n = 3 Output : 1*2*3*10*11*12 --4*5*8*9 ----6*7 Input : n = 4 Output : 1*2*3*4*17*18*19*20 --5*6*7*14*15*16 ----8*9*12*13 ------10*11
Asked in CGI coding round
Approach: The approach is to see the problem, not as a single task but three tasks which, on combining, complete the main task. The three tasks are printing the left-half of the pattern, printing dashes(-), and printing the right-half of the pattern. Combining all three tasks, we would be able to print the pattern.
left-half of pattern 1*2*3* --4*5* ----6* A function printdashes() to print the "-". right-half of pattern 10*11*12 *8*9 7
Below is the implementation.
1*2*3*10*11*12 --4*5*8*9 ----6*7
Time Complexity: O(n2)
Auxiliary Space: O(1), As constant extra space is used.
Another approach :
# Python3 program to print the given pattern # Function to print the pattern def printPattern(row):
x = 1
z = (row * row) + 1
if row = = 1 :
col = 1 else :
col = (row * 4 ) - 1
for i in range ( 1 , row + 1 ):
t = z
for j in range ( 1 , col - ((i - 1 ) * 2 ) + 1 ):
if ((i * 2 ) - 2 > = j):
print (" ", end = " - ")
else :
if (col = = 1 ):
print (x, end = "")
elif (j < = col / 2 and j % 2 = = 1 ):
print (x, end = "")
x + = 1
elif (j > col / 2 and j % 2 = = 1 ):
print (t, end = "")
t + = 1
else :
print ( "*" , end = "")
z = (z - row) + i
print ()
# Driver code row = 3
printPattern(row) # This code is contributed by shivani |
// C# program to print the given pattern using System;
class GFG
{ // function to print the pattern static void printPattern( int row)
{ int x = 1;
int z = (row * row) + 1;
int col = row == 1 ? 1 : (row * 4) - 1;
for ( int i = 1; i <= row; i++)
{
int t = z;
for ( int j = 1; j <= col -((i - 1) * 2); j++)
{
if ((i * 2) - 2 >= j)
{
Console.Write( "-" );
}
else
{
if (col == 1)
{
Console.Write(x);
}
else if (j <= col/2 && j % 2 == 1)
{
Console.Write(x);
x++;
}
else if (j > col/2 && j % 2 == 1)
{
Console.Write(t);
t++;
}
else
{
Console.Write( "*" );
}
}
}
z = (z - row) + i;
Console.Write( "\n" );
}
} // Driver code public static void Main(String[] args)
{ int row = 3;
printPattern(row);
} } // This code is contributed by 29AjayKumar |
<script> // javascript program to print the given pattern // function to print the pattern function printPattern(row)
{ var x = 1;
var z = (row * row) + 1;
var col = row == 1 ? 1 : (row * 4) - 1;
for ( var i = 1; i <= row; i++)
{
var t = z;
for ( var j = 1; j <= col -((i - 1) * 2); j++)
{
if ((i * 2) - 2 >= j)
{
document.write( "-" );
}
else
{
if (col == 1)
{
document.write(x);
}
else if (j <= col/2 && j % 2 == 1)
{
document.write(x);
x++;
}
else if (j > col/2 && j % 2 == 1)
{
document.write(t);
t++;
}
else
{
document.write( "*" );
}
}
}
z = (z - row) + i;
document.write( "<br>" );
}
} // Driver code var row = 3;
printPattern(row); // This code is contributed by 29AjayKumar </script> |
1*2*3*10*11*12 --4*5*8*9 ----6*7
Time Complexity: O(n2)
Auxiliary Space: O(1), As constant extra space is used.
Another approach :
#include <bits/stdc++.h> using namespace std;
void pattern( int n) {
int size = n * (n + 1);
// prev1 will be used to keep track of last number
// printed in left half of pattern
int prev1 = 0;
// prev2 will be used to keep track of last number
// printed in right half of pattern
int prev2 = size;
for ( int i = 0; i < n; i++) {
// print the '-'
for ( int j = 0; j < 2 * i; j++) cout << "-" ;
// l1 to store numbers of left half to be printed
vector< int > l1;
for ( int j = prev1 + 1; j <= prev1 + n - i; j++) l1.push_back(j);
// l2 to store numbers of right half to be printed
vector< int > l2;
for ( int j = prev2 - (n - i) + 1; j <= prev2; j++) l2.push_back(j);
// combine l1 and l2 and print the list separated by *
for ( int j = 0; j < l1.size(); j++) cout << l1[j] << "*" ;
for ( int j = 0; j < l2.size(); j++) cout << l2[j] << "*" ;
cout << endl;
// decrease prev2 and increase prev1
prev2 -= (n - i);
prev1 += (n - i);
}
} // driver program int main() {
int n = 3;
pattern(n);
return 0;
} // This code is contributed by poojaagarwal2. |
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void pattern( int n)
{
int size = n * (n + 1 );
// prev1 will be used to keep track of last number
// printed in left half of pattern
int prev1 = 0 ;
// prev2 will be used to keep track of last number
// printed in right half of pattern
int prev2 = size;
for ( int i = 0 ; i < n; i++) {
// print the '-'
for ( int j = 0 ; j < 2 * i; j++)
System.out.print( "-" );
// l1 to store numbers of left half to be
// printed
List<Integer> l1 = new ArrayList<>();
for ( int j = prev1 + 1 ; j <= prev1 + n - i; j++)
l1.add(j);
// l2 to store numbers of right half to be
// printed
List<Integer> l2 = new ArrayList<>();
for ( int j = prev2 - (n - i) + 1 ; j <= prev2;
j++)
l2.add(j);
// combine l1 and l2 and print the list
// separated by *
for ( int j = 0 ; j < l1.size(); j++)
System.out.print(l1.get(j) + "*" );
for ( int j = 0 ; j < l2.size(); j++)
System.out.print(l2.get(j) + "*" );
System.out.println();
// decrease prev2 and increase prev1
prev2 -= (n - i);
prev1 += (n - i);
}
}
public static void main(String[] args)
{
int n = 3 ;
pattern(n);
}
} |
def pattern(n):
size = n * (n + 1 )
# prev1 will be used to keep track of last number
# printed in left half of pattern
prev1 = 0
# prev2 will be used to keep track of last number
# printed in right half of pattern
prev2 = size
for i in range (n):
# print the '-'
print ( '-' * ( 2 * i), end = '')
# l1 to store numbers of left half to be printed
l1 = [j for j in range (prev1 + 1 , prev1 + n - i + 1 )]
# l2 to store numbers of right half to be printed
l2 = [j for j in range (prev2 - (n - i) + 1 ,prev2 + 1 )]
# combine l1 and l2 and print the list separated by *
print ( * l1 + l2, sep = '*' )
# decrease prev2 and increase prev1
prev2 - = (n - i)
prev1 + = (n - i)
# driver program n = 3
pattern(n) # This code is contributed # by Akash Jain (ultrainstinct). |
//C# code for the above approach using System;
using System.Collections.Generic;
class GFG
{ public static void pattern( int n)
{
int size = n * (n + 1);
// prev1 will be used to keep track of last number
// printed in left half of pattern
int prev1 = 0;
// prev2 will be used to keep track of last number
// printed in right half of pattern
int prev2 = size;
for ( int i = 0; i < n; i++)
{
// print the '-'
for ( int j = 0; j < 2 * i; j++)
Console.Write( "-" );
// l1 to store numbers of left half to be
// printed
List< int > l1 = new List< int >();
for ( int j = prev1 + 1; j <= prev1 + n - i; j++)
l1.Add(j);
// l2 to store numbers of right half to be
// printed
List< int > l2 = new List< int >();
for ( int j = prev2 - (n - i) + 1; j <= prev2; j++)
l2.Add(j);
// combine l1 and l2 and print the list
// separated by *
for ( int j = 0; j < l1.Count; j++)
Console.Write(l1[j] + "*" );
for ( int j = 0; j < l2.Count; j++)
Console.Write(l2[j] + "*" );
Console.WriteLine();
// decrease prev2 and increase prev1
prev2 -= (n - i);
prev1 += (n - i);
}
}
public static void Main( string [] args)
{
int n = 3;
pattern(n);
}
} |
function pattern( n) {
let size = n * (n + 1);
// prev1 will be used to keep track of last number
// printed in left half of pattern
let prev1 = 0;
// prev2 will be used to keep track of last number
// printed in right half of pattern
let prev2 = size;
for (let i = 0; i < n; i++) {
// print the '-'
for (let j = 0; j < 2 * i; j++)
console.log( "-" );
// l1 to store numbers of left half to be printed
let l1=[];
for (let j = prev1 + 1; j <= prev1 + n - i; j++)
l1.push(j);
// l2 to store numbers of right half to be printed
let l2=[];
for (let j = prev2 - (n - i) + 1; j <= prev2; j++)
l2.push(j);
// combine l1 and l2 and print the list separated by *
for (let j = 0; j < l1.length; j++)
console.log( l1[j] + "*" );
for (let j = 0; j < l2.length; j++)
console.log( l2[j] + "*" );
console.log( "<br>" );
// decrease prev2 and increase prev1
prev2 -= (n - i);
prev1 += (n - i);
}
} // driver program let n = 3; pattern(n); // This code is contributed by ratiagrawal. |
1*2*3*10*11*12* --4*5*8*9* ----6*7*
Time Complexity: O(n2)
Auxiliary Space: O(1)
As constant extra space is used.
Another approach :
#include <algorithm> #include <iostream> #include <string> #include <vector> using namespace std;
int main()
{ int n = 4;
int temp_number = (n * n) + n;
int counter = 1;
// loop through each row of the pattern
for ( int i = 0; i < n; i++) {
vector< int > temp_list;
// loop through each column in the current row
for ( int j = 0; j < n - i; j++) {
// generate two numbers and add them to the
// temp_list
temp_list.push_back(counter);
temp_list.push_back(temp_number - counter + 1);
counter += 1;
}
// sort the numbers in the current row in ascending
// order
sort(temp_list.begin(), temp_list.end());
// print the appropriate number of dashes before the
// row
for ( int k = 0; k < i; k++) {
cout << "--" ;
}
// print the numbers in the current row, separated
// by asterisks
for ( int num : temp_list) {
cout << num;
if (num != temp_list.back()) {
cout << "*" ;
}
}
cout << endl;
}
return 0;
} // This code is contributed by divyansh2212 |
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args)
{
int n = 4 ;
int temp_number = (n * n) + n;
int counter = 1 ;
// loop through each row of the pattern
for ( int i = 0 ; i < n; i++) {
ArrayList<Integer> temp_list
= new ArrayList<Integer>();
// loop through each column in the current row
for ( int j = 0 ; j < n - i; j++) {
// generate two numbers and add them to the
// temp_list
temp_list.add(counter);
temp_list.add(temp_number - counter + 1 );
counter += 1 ;
}
// sort the numbers in the current row in
// ascending order
Collections.sort(temp_list);
// print the appropriate number of dashes before
// the row
for ( int k = 0 ; k < i; k++) {
System.out.print( "--" );
}
// print the numbers in the current row,
// separated by asterisks
for ( int num : temp_list) {
System.out.print(num);
if (num
!= temp_list.get(temp_list.size()
- 1 )) {
System.out.print( "*" );
}
}
System.out.println();
}
}
} |
n = 4
temp_number = (n * n) + n
counter = 1
for i in range (n):
temp_list = []
for j in range (n - i):
temp_list.append(counter)
temp_list.append(temp_number - counter + 1 )
counter + = 1
temp_list.sort()
temp_list = [ str (each) for each in temp_list]
[ print ( "--" , end = "") for k in range (i)]
print ( "*" .join(temp_list))
|
let n = 4; let temp_number = n * n + n; let counter = 1; // loop through each row of the pattern for (let i = 0; i < n; i++) {
let temp_list = [];
// loop through each column in the current row
for (let j = 0; j < n - i; j++) {
// generate two numbers and add them to the temp_list
temp_list.push(counter);
temp_list.push(temp_number - counter + 1);
counter += 1;
}
// sort the numbers in the current row in ascending order
temp_list.sort( function (a, b) { return a - b; });
// print the appropriate number of dashes before the row
let temp = "" ; for (let k = 0; k < i; k++) {
temp = temp+ "--" ;
}
// print the numbers in the current row, separated by asterisks for (let num of temp_list) {
temp= temp+ num.toString();
if (num != temp_list[temp_list.length - 1]) {
temp = temp + "*" ;
}
} console.log(temp);
} |
1*2*3*4*17*18*19*20 --5*6*7*14*15*16 ----8*9*12*13 ------10*11
Time Complexity: O(n2)
Auxiliary Space: O(1)
As constant extra space is used.