I am having trouble printing out the values stored in the array. It seems to be printing out the memory address instead. Here is my code:
#include <stdio.h>
int main() {
int a[4];
int sum[4];
printf ("Record the scores of the teams according to A:B, A:C, A:D, B:C, B:D and C:D.\n");
for (int i = 0; i < 3; i++) {
for (int j = 1; i + j < 4; j++) {
scanf ("%d", &a[i]);
scanf ("%d", &a[i + j]);
sum[i] = sum[i] + a[i];
sum[i + j] = sum[i + j] + a[i + j];
printf ("%d\n", sum[i + j]);
}
}
for (int i = 0; i < 4; ++i)
printf ("%d\n", sum[i]);
return 0;
}
The output should be:
Record the scores of the teams according to A:B, A:C, A:D, B:C, B:D and C:D.
1 1
1 1
1 1
1 1
1 1
1 1
3
3
3
3
Instead, it shows:
Record the scores of the teams according to A:B, A:C, A:D, B:C, B:D and C:D.
1 1
1 1
1 1
1 1
1 1
1 1
3
3
\-1646415677
21995
How should I solve this?
I want to know how to display what I have entered
Yoi have uninitialized variables. Fix:
int a[4] = { 0 };
int sum[4] = { 0 };
Single zero is enough, because C will have the rest initialized to 0 when you initialize just 1 element of a struct or an array.
Related
I am a beginner in programming, I studied all about C, I started to solve problems from hackerrank.com, there I faced a problem to print a pattern like given below
(the output of problem program):
4 4 4 4 4 4 4
4 3 3 3 3 3 4
4 3 2 2 2 3 4
4 3 2 1 2 3 4
4 3 2 2 2 3 4
4 3 3 3 3 3 4
4 4 4 4 4 4 4
the input will be an integer which will provide the data for the length of pattern square, here it is 4 in image,
I tried a lot to type a proper logic and I end up with this useless code bellow:
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
int main()
{
int n;
scanf("%d", &n);
int array[n- 1 + n][n - 1 + n];
array[(n - 1 + n) / 2][(n - 1 + n) / 2] = 1;
int f[n];
for(int i = 0; i < n; i++) {
f[i] = i;
}
for(int i = 0; i < n - 1 + n; i++) {
for(int j = 0; j < n - 1 + n; j++) {
array[j][i] = n - f[j]; //top
array[i][j] = n - f[j]; //left
array[(2 * n - 1 - 1) - i][j] = n - f[i]; //bottem
array[j][(2 * n - 1 - 1) - i] = n - f[i]; //rigth
}
}
for(int i = 0; i < n - 1 + n; i++) {
for(int j = 0; j < n - 1 + n; j++) {
printf("%d ", array[i][j]);
}
printf("\n");
}
return 0;
}
my logic was to make all four borders correct in for loop which will end at center, but its not working, I want a new logic or to improve my logic, if you want to help me out then please give me the way to solve problem instead of giving me a direct code.
It is observable that the pattern consists of n stacked squares:
Square #0 is drawn with ns.
Square #1 is drawn with n-1s.
...
Square #n-1 is drawn with 1s.
Implementing the above:
void draw_pattern(const size_t n)
{
const size_t dim = 2*n-1;
int array[dim][dim];
for (size_t i = 0; i < n; ++i) { // Outer square #i
// Row #0 of the outer square #i
for (size_t j = i; j < dim-i; ++j)
array[i][j] = n-i;
// Row #n-1 of the outer square #i
for (size_t j = i; j < dim-i; ++j)
array[dim-i-1][j] = n-i;
// Col #0 of the outer square #i
for (size_t j = i; j < dim-i; ++j)
array[j][i] = n-i;
// Col #n-1 of the outer square #i
for (size_t j = i; j < dim-i; ++j)
array[j][dim-i-1] = n-i;
}
print_array(dim, array);
}
This is print_array():
void print_array(const size_t dim, int array[dim][dim])
{
for (size_t i = 0; i < dim; ++i) {
for(size_t j = 0; j < dim; ++j)
printf("%d ", array[i][j]);
printf("\n");
}
}
Output:
4 4 4 4 4 4 4
4 3 3 3 3 3 4
4 3 2 2 2 3 4
4 3 2 1 2 3 4
4 3 2 2 2 3 4
4 3 3 3 3 3 4
4 4 4 4 4 4 4
The worst case time complexity is O(n2).
When you get a problem like this, try to dumb it down as much a possible. This square can be separated into 8 same, just rotated "slices" that look like:
4 | 4444 | 4444 | 4
43 | 333 | 333 | 34
432 | 22 | 22 | 234
4321 | 1 | 1 | 1234
... and the same for the bottom half, just flipped.
You can see this in the code bellow, to check what line is writing what part of the square, comment it and you will see what section shows zeroes.
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
int main() {
int n;
scanf("%d", &n);
int array[2 * n - 1][2 * n - 1];
for(int i = 0; i < 2 * n - 1; i++){
for(int j = 0; j < 2 * n - 1; j++){
array[i][j] = 0;
}
}
int f[n];
for(int i = 0; i < n; i++)
{
f[i] = i;
}
for(int i = 0; i < n; i++)
{
for(int j = i; j < n; j++)
{
array[i][j] = n - i;
array[j][i] = n - i;//top left
array[j][2*n - i - 2] = n - i;
array[i][2*n - j - 2] = n - i;//bottom left
array[2*n - j - 2][i] = n - i;
array[2*n - i - 2][j] = n - i;//top right
array[2*n - i - 2][2*n - j - 2] = n - i;
array[2*n - j - 2][2*n - i - 2] = n - i;//bottom right
}
}
for(int i = 0; i < n - 1 + n; i++)
{
for(int j = 0; j < n - 1 + n; j++)
{
printf("%d ", array[i][j]);
}
printf("\n");
}
return 0;
}
I need to program a number pattern pyramid like that:
Here is my code:
#include<stdio.h>
int main()
{
int i, j, rows = 5;
for (i = 1; i <= 5; i++)
{
for (j = 1; j <= i; j++)
{
printf("%d ", j);
}
printf("\n");
}
for (i = 0; i <= 5; i++)
{
for (j = 0; j <= i; j++)
{
printf("%d ", j);
}
printf("\n");
}
}
Where am I doing wrong? I need to flip somehow the first triangle pattern and mix it with the second. Please help.
Your pyramid is 6 levels high. The max number is 5. This is not a coincidence. There is a direct relationship.
If n is 5, you need to do something 6 times, from 0 to n. There's a loop.
for (int i = 0; i <= n; i++) {
...
}
On each row you need to do print from i to 0, and then from 1 to i. That's two loops.
for (int j = i; j > 0; j--) {
...
}
for (int j = 1; j <= i; j++) {
...
}
Of course, you also need to indent a number of spaces inversely related to i, which is another loop.
for (int j = 0; j <= /* Fill in here for inverse relationship */; j++) {
...
}
I need to flip somehow the first triangle pattern and mix it with the second.
TL;DR The trick is very simple: your row index i should start from |n - j| (or abs(n - j)) where j is the column index and n is the number.
Here is how you can do it:
for (int j = 0; j < ncols; ++j) {
for (int i = abs(n - j); i < nrows; ++i) {
matrix[i][j] = '0' + abs(n - j);
}
}
Explanation:
Imagine you have a matrix. In order to build a pyramid with a number n, you will need:
n + 1 rows (since you will have 0 included in the top). Let's call it nrows.
2n + 1 columns (2n because the numbers will appear twice in a row, 1 because you will have one 0 per row). Let's call it ncols.
0 1 2 3 4 5 6 7 8 9 10
- - - - - - - - - - -
0 | 0
1 | 1 0 1
2 | 2 1 0 1 2
3 | 3 2 1 0 1 2 3
4 | 4 3 2 1 0 1 2 3 4
5 | 5 4 3 2 1 0 1 2 3 4 5
First, you want to fill the first half, i.e. from column 0 to n: for (int j = 0; j <= n; ++j).
J | End | Start | Pattern of Start
---------------------------------------
0 | N | N | N - 0
---------------------------------------
1 | N | N - 1 | N - 1
---------------------------------------
2 | N | N - 2 | N - 2
---------------------------------------
... | ... | ..... | N - J
---------------------------------------
N | N | 0 | N - N
The pattern is: for (int i = n - j; i < nrows; ++i). You would fill that first half with n - j.
Second, you want to fill the second half, i.e. from column n + 1 to 2n: for (int j = n + 1; j < ncols; ++j).
J | End | Start | Pattern of Start
------------------------------------------
N + 1 | N | 1 | N + 1 - N = J - N
------------------------------------------
N + 2 | N | 2 | N + 2 - N = J - N
------------------------------------------
N + 3 | N | 3 | N + 3 - N = J - N
------------------------------------------
..... | ... | ..... | N + X - N = J - N
------------------------------------------
2N | N | N | 2N - N = J - N
The pattern is: for (int i = j - n; i < nrows; ++i). You would fill that second half with j - n.
Now, you can do two separate for loops to fill the first and second halves.
// Fill first half
for (int j = 0; j <= n; ++j) {
for (int i = n - j; i < nrows; ++i) {
matrix[i][j] = '0' + n - j;
}
}
// Fill second half
for (int j = n + 1; j < ncols; ++j) {
for (int i = j - n; i < nrows; ++i) {
matrix[i][j] = '0' + j - n;
}
}
You can write one for loop by replacing n - j and j - n with abs(n - j), since both of them are positive values (see TL;DR above, or the code below).
Full functionning code:
#include <stdio.h>
#include <stdlib.h>
void print_matrix(const int nrows, const int ncols, const char matrix[nrows][ncols])
{
for (int i = 0; i < nrows; ++i) {
for (int j = 0; j < ncols; ++j)
printf("%c ", matrix[i][j]);
printf("\n");
}
}
void init_matrix(const int nrows, const int ncols, char matrix[nrows][ncols], const char value)
{
for (int i = 0; i < nrows; ++i)
for (int j = 0; j < ncols; ++j)
matrix[i][j] = value;
}
void print_pyramid(const int n)
{
// Calculate the number of rows and columns
const int nrows = n + 1;
const int ncols = n * 2 + 1;
char matrix[nrows][ncols];
// Initialization
init_matrix(nrows, ncols, matrix, '\0');
// Fill the matrix
for (int j = 0; j < ncols; ++j) {
for (int i = abs(n - j); i < nrows; ++i) {
matrix[i][j] = '0' + abs(n - j);
}
}
// Printing
print_matrix(nrows, ncols, matrix);
}
int main(void)
{
print_pyramid(5);
}
You have to include all 3 for loops in one for loop which runs 6 times. First you have to print spaces. Then first half of the triangle and then the other half. After that you have to print \n .
#include<stdio.h>
int main()
{
int i, j,k,l;
for (i = 0; i <=5; i++)
{
for (j = 5; j > i; j--)
{
printf(" ");
}
for (k = i; k >=0; k--)
{
printf("%d ", k);
}
for (l = 1; l <=i; l++)
{
printf("%d ", l);
}
printf("\n");
}
}
#include<stdio.h>
int main()
{
int n ;
printf("Input the number of rows: ");
scanf("%d", &n);
for(int i = 1; i <= n ; i++)
{
for(int j = 1 ; j <= i ; j++)
{
if(j == i + 1)
{
break;
}
printf("%3d", j);
}
for(int j = i - 1 ; j > 0; j--)
{
if(j == 0)
{
break;
}
printf("%3d", j);
}
printf("\n");
}
}
Program session
Number of rows for this output n = 3
My output:
1
1 2 1
1 2 3 2 1
Preferred output:
1
1 2 1
1 2 3 2 1
This here is an exercise where I have to print a pyramid of numbers where the central number of the pyramid is the number of the row. I understand the logic but as you can see I have not been able to fulfill the task successfully. Any tips?
As pointed out by #WeatherWane, you need to add logic to add extra spaces. If you notice carefully, number of spaces on each line(excluding padding you add with %3d is equal to 3 * (n - i)). You can create a simple method like this to add spacing:
void addSpaces(int N, int currentIndex, int padding) {
for (int index = currentIndex; index < N; index++)
for (int spaces = 0; spaces < padding; spaces++)
printf(" ");
}
then you can call it from your first for loop like this:
for(int i = 1; i <= n ; i++)
{
addSpaces(n, i, 3);
for(int j = 1 ; j <= i ; j++)
{
// ...
I tested it and it seems to align it correctly:
c-posts : $ ./a.out
Input the number of rows: 5
1
1 2 1
1 2 3 2 1
1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1
I've tried following this program by hand, but I still can't get it to work.
I have an array A = [4,3,2,1,4,3,2,1,4,3,2,1,4,3,2,1,4,3,2,1] and array X = [1,2,3].
I need to find the max number i for X^i that is a subsequence of A, and do this by binary search.
Since size of A is 20, and size of X is 3, the max possible i = 20/3 = 6. So my search will start at i = 3, which means that X^3 = [1,1,1,2,2,2,3,3,3].
This is not a subsequence of A, so binary search repeats for i = 1, X^1 = [1,2,3].
This is a subsequence of A, meaning it should pass and binary search should try again for i = 2.
However, my condition to see if the iteration passes or not is not working properly.
Here is the code:
#include <stdio.h>
#include <stdlib.h>
void create_initial_arrays(int size_a, int *A, int size_x, int *X);
void binary_search(int size_a, int * A, int size_x, int *X, int max_i, int min_i);
int main(){
int size_a, size_x;
scanf("%d", &size_a);
scanf("%d", &size_x);
int max_i = size_a / size_x;
int min_i = 0;
printf("Max: %d\n", max_i);
int *A = (int*) malloc(size_a *sizeof(int));
int *X = (int*) malloc(size_x *sizeof(int));
create_initial_arrays(size_a, A, size_x, X);
printf("Old X: ");
for(int i = 0; i < size_x; i++){
printf("%d ", X[i]);
}
printf("\n");
binary_search(size_a, A, size_x, X, max_i, min_i);
free(X);
free(A);
}
void create_initial_arrays(int size_a, int *A, int size_x, int *X){
int i, throwaway;
for(i = 0; i < size_a; i++){
scanf("%d", &A[i]);
}
scanf("%d", &throwaway);
for(i = 0; i < size_x; i++){
scanf("%d", &X[i]);
}
scanf("%d", &throwaway);
}
void binary_search(int size_a, int * A, int size_x, int *X, int max_i, int min_i){
int j, k, max_repeat = 0;
while(min_i <= max_i){
int i = 0, count = 0, repeats = (max_i + min_i)/2;
printf("\n");
int * temp = (int*) malloc(size_x * sizeof(int) * repeats);
for(k = 0; k < size_x; ++k){
for(j = 0; j < repeats; ++j){
temp[k * repeats + j] = X[k];
}
}
printf("New X: ");
for(i = 0; i < size_x * repeats; i++){
printf("%d ", temp[i]);
}
printf("A: ");
for (i = 0; i < size_a; i++){
printf("%d ", A[i]);
}
for(j = 0; j < size_a; j++){
if(A[j] == temp[i]){
count++;
i++;
}
}
printf("Count: %d", count);
if (count >= size_x * repeats){
printf("Low: %d Mid %d High % d Passes\n", min_i, repeats, max_i);
min_i = repeats + 1;
max_repeat++;
}
else{
printf("Low: %d Mid %d High % d Fails\n", min_i, repeats, max_i);
max_i = repeats - 1;
}
free(temp);
}
printf("Max repeat: %d", max_repeat);
}
And this is the section that I think must be problematic:
for(j = 0; j < size_a; j++){
if(A[j] == temp[i]){
count++;
i++;
}
}
I've output both Arrays to make sure they are populated correctly (they are) and the counter after each iteration. Here is my code output:
Old X: 1 2 3
New X: 1 1 1 2 2 2 3 3 3 A: 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 Count: 0Low: 0 Mid 3 High 6 Fails
New X: 1 2 3 A: 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 Count: 0Low: 0 Mid 1 High 2 Fails
New X: A: 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 4 3 2 1 Count: 0Low: 0 Mid 0 High 0 Passes
Max repeat: 1
Notice that count remains 0 throughout. On the first iteration for X^3 = [1,1,1,2,2,2,3,3,3], the condition is true 5 times ([1,1,1,2,2] is a subsequence of A, so count should be 5, but 5 is not >= size_x * repeats(3 * 3), so it fails as expected. Binary search reduces to Low 0 Mid 1 High 2, so i = repeats = 1.
X^1 = [1,2,3] is a subsequence of A, and count should be 5 on this iteration ([1,2,3] plus two extra counts of 3) which is >= size_x * repeats (3*1), so it should pass, and redo the search for i = 2. However, count remains zero and fails.
Why is count not updating? I know I need to keep it in the loop because I need it reset to 0 for each iteration, but I don't really understand why A[j] == temp[i] is not ever passing.
Code
#include <stdio.h>
int main()
{
long long int n, m, p, i, j, total_cost, cost;
scanf("%lld %lld %lld", &n, &m, &p);
long long int ar[n][m];
for(i = 1; i <= n; ++i)
{
for(j = 1; j <= m; ++j)
{
ar[i][j] = j;
}
}
while(p--)
{
scanf("%lld %lld", &i, &j);
ar[i][j] += 1;
}
/*
printf("\n");
for(i = 1; i <= n; ++i)
{
for(j = 1; j <= m; ++j)
{
printf("%d ", ar[i][j]);
}
printf("\n");
}
printf("\n");
*/
if(n == 1 && m == 1)
{
printf("0\n");
return 0;
}
if(m == 1)
{
for(i = 1; i <= n; ++i)
{
printf("0\n");
}
return 0;
}
for(i = 1; i <= n; ++i)
{
total_cost = 0, cost = 0;
for(j = m; j >= 2; --j)
{
cost = ar[i][j] - ar[i][j - 1];
if( cost < 0 )
{
printf("-1\n");
break;
}
total_cost += cost;
}
if(cost >= 0)
{
printf("%lld\n", total_cost);
}
}
return 0;
}
This is giving me WA. Here is the problem description CHEFBM.
Test cases I have checked:
1. 1 5 3
1 2
1 4
1 5
Output
5
2. 4 4 6
2 2
3 2
3 2
4 3
4 4
4 3
Output
3
3
-1
4
3. 1 4 5
1 3
1 2
1 2
1 1
1 1
Output
1
4. 4 4 6
3 2
2 3
3 2
2 4
1 2
3 2
Output
3
4
3
3
5. 4 1 1
1 1
Output
0
0
0
0
6. 1 4 3
1 1
1 1
1 4
Output
-1
7. 1 1 1
1 1
Output
0
8. 1 1 2
1 1
1 1
Output
0
9. 2 2 3
1 1
1 1
1 1
Output
-1
1
And many more. For which test case is this giving wrong answer?
As given in the constraints, n and m both can be 10^5. Allocating a 2-d array a[10^5][10^5], is not feasible here. You are running out of memory and hence you might be getting Run time error or Wrong answer. Your algorithm is O(n^2) so it will not pass in the given time limit. Try to optimize your code.
For further assistance, you can check my code.