Challenge #48 explanation

CHALLENGE SOLVA

Coding made simple

Challenge No. 48

ROHIT KANOJIYA🇮🇳
TODAY'S Challenge : 48 COMMENT Your Code 👇 Date : 01/05/2020
link to the challenge

Hello everyone, its me again, here is an explanation to my code made to answer the challenge above. The code is written in Java language. I really hope this peace of work will help someone somewhere. If you like the work give it a thumbs up like, comment in the comments section and follow. Let's start.

Explanation

To begin with, let's analyse the pattern given in the challenge. The input is an integer 4 and the pattern is:

                            
    14                 7    
    14 10           5  7    
    14 10  6     3  5  7    
    14 10  6  2  3  5  7    
    14 10  6     3  5  7    
    14 10           5  7    
    14                 7

a) Pattern width: Unlike yesterday where we said the pattern width is the length of the string input, today we are dealing with an integer input and we are required to calculate the width that the pattern will have. Therefore, from the pattern above, the width is 7. If we try to derive that width, you will notice it is actually double the integer input but less than 1. That is;
4 * 2 - 1 = 7
b) Pattern height: Similar to yesterday's challenge, will apply the same formula to get the pattern height. In short it is just the application of the formula we've used above to calculate the pattern width. That is;
4 * 2 - 1 = 7
Note: rarely does the pattern height formula change.
c) Pattern: The pattern is quite confusing but let's break it down. Split the pattern vertically into two halves as illustrated in the figure below. You will realise the left pattern is decreasing by 4
while the right pattern, is decreasing by 2 . from the far right.

Now we've only identify the flow of the pattern, the real question is, Where do we start subtracting both from left and right? . Don't panic, this is quite simple.
Realise, the left pattern starts from
n * 4 - 2
Note: we are subtracting "2" because the left pattern ends with "2"

For the right pattern, the starting point is quite dynamic. Let's see!. for every line the starting point is width of the pattern less line multiply by 2. for example, suppose we are in line 2, the starting point for the next line will be;
4 * 2 - 1 - (2 * 2)
Note: we are multiplying by "2" because the iteration of the pattern is "2" .

First half(left)

    ( 4*4 - 2 = 14 ) 14          
                     14 10      
                     14 10  6   
                     14 10  6  2
                     14 10  6   
                     14 10      
                     14

Second half(right)

              7 
           5  7 ( (4*2-1) - (2 * 2) = 3 )
        3  5  7
     1  3  5  7
        3  5  7
           5  7
              7

1 is the virtual starting point, just to complete the pattern(illustration purposes)

Let's now actualize the what we've analysed above. Remember you must be familiar with Java language for easy understanding.

Firstly, you have to declare your class and the main method. and import the Scanner class to get the user input

    
    import java.util.Scanner;
    
    public class Program {
    
        public static void main (String[] args) {
        
            
        }
    }

Secondly, let's declare some variables and take user input using the Scanner and System.in objects.

Variable n will hold the user integer input.
Variable s will mark the size(length) of the pattern sides
Variable l will hold the left pattern values.
Variable r will hold the right pattern values.
Variable p will be used to make the internal pattern.

We will check the limit of the integer input, if off-limit will throw an exception.
Note: we are using "try and catch" block for the input to catch any exception that might be caused

We will also notify the user of his or her input in the "try and catch"" block

                
    import java.util.Scanner;
    
    public class Program {
    
        public static void main (String[] args) {
        
            int n, s, l, r, p;
            
            try {
                n = new Scanner(System.in).nextInt();
                
                if(n < 2)
                throw new Exception();
                
                else
                System.out.println("Input No.: " + n);
            } 
            catch(Exception e) {
                n = 5;
                
                System.out.println("Bad input\nDefault No.: " + n);
            }
        }
    }

Lets now initialize our variables;

                
    import java.util.Scanner;
    
    public class Program {
    
        public static void main (String[] args) {
        
            int n, s, l, r;
            
            try {
                n = new Scanner(System.in).nextInt();
                
                if(n < 2)
                throw new Exception();
                
                else
                System.out.println("Input No.: " + n);
            } 
            catch(Exception e) {
                n = 5;
                
                System.out.println("Bad input\nDefault No.: " + n);
            }
            
            s = n*2 − 1;
            l = n*4 + 2;
            r = n*2 − 3;
            p = 1;
        }
    }

We are now done with the first part, let's go right away to the pattern itself.
Now to do this, will use the for-loop statement. Remember what we analysed earlier; the height, width and the pattern, review analysis we gonna use just that.

                
    import java.util.Scanner;
    
    public class Program {
    
        public static void main (String[] args) {
        
            int n, s, l, r, p;
            
            try {
                n = new Scanner(System.in).nextInt();
                
                if(n < 2)
                throw new Exception();
                
                else
                System.out.println("Input No.: " + n);
            } 
            catch(Exception e) {
                n = 5;
                
                System.out.println("Bad input\nDefault No.: " + n);
            }
            
            s = n*2 − 1;
            l = n*4 + 2;
            r = n*2 − 3;
            p = 1;
            
            // S T A R T  O F  P A T T E R N
            for(int y=1; y<=s; y++) { // rows(line)
            
                for(int x=1; x<=s; x++) { // columns(numbers or integers)
                
                    if(x<=p)
                    System.out.printf("%3d", (l–=4)); // left side(pattern)
                    
                    else if(x>s–p)
                    System.out.printf("%3d", (r+=2)); // right side(pattern)
                    
                    else
                    System.out.printf("%3s", ""); // print white space
                }
                l = n*4 + 2; // resetting l
                p = (y < n)? ++p: --p; // updating p
                r = (y != n-1)? s–(p*2): 1; // updating r
                System.out.println(); // finishing row(line)
            }
            // E N D  O F  P A T T E R N
        }
    }

This is what is happening in the for-loop code above.

The first for-loop will loop through the lines of the pattern see pattern. The code
y<=s;, will limit the loop to the height of the pattern.

The second for-loop will loop through the columns of the pattern. The loop is limited to the width we calculated earlier.

We are using variable p to make the internal pattern. I know you might say we could have used variable y instead. For purposes of simplicity i opted to use that.

Note: we initialized variables l and r to 4 steps forward and 2 steps back beacuse code; l–=4 and r+=2 will change the variables before using them, respectively.

When updating r we are moving 2 steps back, because of reasons explained in the analysis review analysis. Additionally, i believe you've noticed have added a condition there. remember the pattern initially review, i included 1 as a virtual number to complete the pattern. Well since the program will not print any value of r when x is equal to p, then the first value of r at line n will be 1. to solve this, i added that condition, to return it to 1 so that, the program will assume it has alredy printed 1 (remember the virtual 1? review) and when it starts printing at line n, the value will be 3.

I think the "if-else" statement is self explanatory after reading the comments in the code above. In case of any difficulty, kindly ask in the comments section.

challenge #48 explained