Why isn't there a space in the middle of my pyramid? - c

Question

So I am trying to solve https://cs50.harvard.edu/x/2021/psets/1/mario/more/ this problem set from cs50.
It's taken me way too long to get this far (5-6 hours WITH help from youtube).
#include <cs50.h>
#include <stdio.h>
int get_positive_int(void);
int main(void)
{
int n = get_positive_int();
// Run a below loop until i is greater than n
for(int i = 0; i < n; i++)
{
// Run if statement on the same row until j is greater than n*2 + i+1
for(int j=0; j < n*2 + i+1; j++)
{
// Create a blank space in exact center of the pyramid
if(j + i - n == 0 || j + i - n == 1)
printf(" ");
//If the value of n-1 is less than the combined value of j and i, or
//if the value of i and n minus j is less than or equal to zero print #
else if ( j + i > n - 1 || i + n - j <= 0)
printf("#");
else
//otherwise print " "
printf(" ");
}
printf("\n");
}
}
Why doesn't the below create a two " " in the center of my pyramid?
if(j + i - n == 0 || j + i - n == 1)
printf(" ");
And why when I choose a value of 1 for n does the program not print anything?
What is this specific type of thinking/math called? I am having difficulty grasping it and I am not sure how to find information online because I don't know what it is called.
My output is below.
When N = 8
#######
#########
###########
#############
###############
#################
###################
#####################
The output I want is.
When N = 8
# #
## ##
### ###
#### ####
##### #####
###### ######
####### #######
######## ########
When I input a value of 1 I get.
What I want when I input 1 is,
# #
I'd like to know what specifically I did wrong in order to fix the issue myself, rather than the direct answer if possible.

Answer 1

First of all observe that your two for loops both start from 0. Thus at the beginning both i and j are equal to 0. Therefore, since n is a positive integer, both your if and else if clauses are evaluated as false and only the final else gets executed, which is printf(" ");
Now look at your pyramid. Your "pyramid" fills a space with n rows and 2*n + 2 columns. The first loop for (i = 0; i < n; i++) is for the rows, and it's correct, since there are n rows. Your second for loop, however, is faulty. It should be for (int j=0; j < n*2 + 2; j++).
Now when we look at the the i-th row we see that (remembering rows start from 0 because we started counting i from 0), you want to print n-1-i spaces, followed by i+1 # characters followed by 2 spaces, followed by i+1 # characters and finally followed by n-1-i spaces. So the "spaces" are when j < n-1-i (remember j also starts from 0), when j == n and j == n+1 and when j > n+2+i
This can be written as follows using if-else:
if ( j < (n-1-i) || j == n || j == n+1 || j > n+2+i) printf(" ");
else printf("#");
So the final code will look like:
#include <cs50.h>
#include <stdio.h>
int get_positive_int(void);
int main(void)
{
int n = get_positive_int();
for(int i = 0; i < n; i++)
{
for(int j=0; j < n*2 + 2; j++)
{
if ( j < (n-1-i) || j == n || j == n+1 || j > n+2+i) printf(" ");
else printf("#");
}
printf("\n");
}
}

Answer 2

Think about this mathematically. You have slope of -1, so we have j = -i + k. Our formula becomes k = i + j. If we have n = 5:
i j k
0 4 4
1 3 4
2 2 4
3 1 4
5 0 4
n = 6
i j k
0 5 5
1 4 5
2 3 5
3 2 5
4 1 5
5 0 5
so k = n - 1
That is first half, second is even easier, j = i + k, so k = j - i. It is positive slope moved by k. So for n=5
i j k
0 4 4
1 5 4
2 6 4
3 7 4
5 8 4
n = 6
i j k
0 5 5
1 6 5
2 7 5
3 8 5
4 9 5
5 10 5
look at that we have a match in both cases k = n - 1. So our formulas are
j = -i + n - 1 and j = i + n - 1.
Second in both cases we have maximum j at max(i) + k or in other words n - 1 + n - 1 so 2 * n - 2
so:
We got your lines.
Look closes and you will see how far your j has to go.
Here is the code:
// int get_positive_int(void);
int main(void)
{
int n = 5; //get_positive_int();
// Run a below loop until i is greater than n
for(int i = 0; i < n; i++)
{
// Run if statement on the same row until j is greater than n*2 + i+1
for(int j = 0; j < n * 2 - 1; j++)
{
// Create a blank space in exact center of the pyramid
if (j == n - i - 1 || j == n + i - 1)
printf("#");
else
//otherwise print " "
printf(".");
}
printf("\n");
}
}
Output:
....#....
...#.#...
..#...#..
.#.....#.
#.......#
Now you can optimize this to trim down number of inner loop execution by 25%, by looking at this. I do not need to go beyond the point where I print my second #, meaning beyond max(j) = j + 1 value of my second formula + 1 is because I still want to be able to go into loop, so we get maximum max(j) = (n + i - 1) + 1.
#include <stdio.h>
// int get_positive_int(void);
int main(void)
{
int n = 5; //get_positive_int();
// Run a below loop until i is greater than n
for(int i = 0; i < n; i++)
{
// Run if statement on the same row until j is greater than n*2 + i+1
for(int j = 0; j < n + i; j++)
{
// Create a blank space in exact center of the pyramid
if (j == n - i - 1 || j == n + i - 1)
printf("#");
else
//otherwise print " "
printf(".");
}
printf("\n");
}
}
output:
....#
...#.#
..#...#
.#.....#
#.......#
And if you notice, by thinking mathematically about this you save a lot of operations. For example in second for() loop, OP and other answer have more than 1 operations, where this has 1, in if/else both have more than 2 equality statements having, this one has 2.
NOTE: I used . instead of for demonstration.