int main() {
int output = 0;
int ip1;
scanf("%d", &ip1);
int ip2;
scanf("%d", &ip2);
int ip3_size = 0;
int ip3_i;
scanf("%d\n", &ip3_size);
int ip3[ip3_size];
for(ip3_i = 0; ip3_i < ip3_size; ip3_i++) {
int ip3_item;
scanf("%d", &ip3_item);
ip3[ip3_i] = ip3_item;
output = GetJumpCount(ip1,ip2,ip3_size,ip3);
printf("%d\n", output);
return 0;
int GetJumpCount(int input1,int input2,int input3_size, int* input3)
int i,j,count=0;
for(i=0;i<input3_size;i++)
j = 0;
while(j<=input3[i]){
j+=input1;
count++;
if(j>=input3[i])
break;
j=j-input2;
return count;
/ Program to print all combination of size r in an array of size n
#include <stdio.h>
void combinationUtil(int arr[], int data[], int start, int end,
int index, int r);
// The main function that prints all combinations of size r
// in arr[] of size n. This function mainly uses combinationUtil()
void printCombination(int arr[], int n, int r)
{
// A temporary array to store all combination one by one
int data[r];
// Print all combination using temprary array 'data[]'
combinationUtil(arr, data, 0, n-1, 0, r);
}
/* arr[] ---> Input Array
data[] ---> Temporary array to store current combination
start & end ---> Staring and Ending indexes in arr[]
index ---> Current index in data[]
r ---> Size of a combination to be printed */
void combinationUtil(int arr[], int data[], int start, int end,
int index, int r)
{
// Current combination is ready to be printed, print it
if (index == r)
{
for (int j=0; j<r; j++)
printf("%d ", data[j]);
printf("\n");
return;
}
// replace index with all possible elements. The condition
// "end-i+1 >= r-index" makes sure that including one element
// at index will make a combination with remaining elements
// at remaining positions
for (int i=start; i<=end && end-i+1 >= r-index; i++)
{
data[index] = arr[i];
combinationUtil(arr, data, i+1, end, index+1, r);
}
}
// Driver program to test above functions
int main()
{
int arr[] = {1, 2, 3, 4, 5};
int r = 3;
int n = sizeof(arr)/sizeof(arr[0]);
printCombination(arr, n, r);
}
Output:
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
1. #include<stdio.h>
2. #include<string.h>
3. #define N 10
4.
5. void print(int *num, int n)
6. {
7. int i;
8. for ( i = 0 ; i < n ; i++)
9. printf("%d ", num[i]);
10. printf("\n");
11. }
12. int main()
13. {
14. int num[N];
15. int *ptr;
16. int temp;
17. int i, n, j;
18. printf("\nHow many number you want to enter: ");
19. scanf("%d", &n);
20. printf("\nEnter a list of numbers to see all combinations:\n");
21. for (i = 0 ; i < n; i++)
22. scanf("%d", &num[i]);
23. for (j = 1; j <= n; j++) {
24. for (i = 0; i < n-1; i++) {
25. temp = num[i];
26. num[i] = num[i+1];
27. num[i+1] = temp;
28. print(num, n);
29. }
30. }
31. return 0;
32. }
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
int appearanceCount(int input1,int input2,char* input3,char* input4)
int i,j,p;
int sum=0,s=0,count=0;
for (i = 0; i <input1; i++)
sum = sum + input3[i];
}
p=input1;
for(i=0;i<input2;i++)
for(j=i;j<i+p;j++)
s=s+input4[j];
if(sum==s)
count++;
s=0;
return count;
int main() {
int output = 0;
int ip1;
scanf("%d", &ip1);
int ip2;
scanf("%d", &ip2);
char* ip3;
ip3 = (char *)malloc(512000 * sizeof(char));
scanf("\n%[^\n]",ip3);
char* ip4;
ip4 = (char *)malloc(512000 * sizeof(char));
scanf("\n%[^\n]",ip4);
output = appearanceCount(ip1,ip2,ip3,ip4);
printf("%d\n", output);
return 0;
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
int GetJumpCount(int input1,int input2,int input3_size, int* input3);
int GetJumpCount(int input1,int input2,int input3_size, int* input3)
int i,sum=0,j=0,c=0;
for(i=0;i<input3_size;i++)
if(input1>=input3[i])
j++;
else
while(input3[i]!=sum)
{
sum=sum+input1;
if(input3[i]<=sum)
j++;
break;
else
sum=sum-input2;
j++;
c=c+j;
return (c);
int main() {
int output = 0;
int ip1;
scanf("%d", &ip1);
int ip2;
scanf("%d", &ip2);
int ip3_size = 0;
int ip3_i;
scanf("%d\n", &ip3_size);
int ip3[ip3_size];
for(ip3_i = 0; ip3_i < ip3_size; ip3_i++) {
int ip3_item;
scanf("%d", &ip3_item);
ip3[ip3_i] = ip3_item;
output = GetJumpCount(ip1,ip2,ip3_size,ip3);
printf("%d\n", output);
return 0;
int row()
int i=0;
while(i<input1_size_rows)
int j=0;
while(j<input1_size_cols)
int n=0;
while(n<input1_size_rows)
if(input1[j]==input1[n]||input1[j]!=0||input1[n]!=0)
printf("0");
goto BREAK;
else
{
goto PRINT;
n++;
j++;
i++;
BREAK:break;break;break;
PRINT:printf("1");
return 0;
int column()
int j=0;
while(j<input1_size_cols)
int i=0;
while(i<input1_size_rows)
int n=0;
while(n<input1_size_cols)
if(input1[i]==input1[j]||input1[i]=0||input1[n]=0)
printf("0");
goto BREAK;
else
{
goto PRINT;
n++;
i++;
j++;
BREAK:break;break;break;
PRINT:printf("1");
return 0;
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
int SolveMagicSquare(int input1_size_rows, int input1_size_cols, int** input1)
int r,p,q;
r=input1_size_rows;
p=input1_size_cols;
q=input1;
s=com(r,p,q);
}
int main() {
int output = 0;
int ip1_rows = 0;
int ip1_cols = 0;
scanf("%d", &ip1_rows);
scanf("%d", &ip1_cols);
int** ip1 = (int**)malloc(ip1_rows*sizeof(int*));
int ip1_init_i=0;
for(ip1_init_i=0 ; ip1_init_i<ip1_rows ; ++ip1_init_i)
ip1[ip1_init_i] = (int*)malloc(ip1_cols*(sizeof(int)));
int ip1_i, ip1_j;
for(ip1_i = 0; ip1_i < ip1_rows; ip1_i++) {
for(ip1_j = 0; ip1_j < ip1_cols; ip1_j++) {
int ip1_item;
scanf("%d", &ip1_item);
ip1[ip1_i][ip1_j] = ip1_item;
output = SolveMagicSquare(ip1_rows, ip1_cols,ip1);
printf("%d\n", output);
return 0;
#include <stdio.h>
void main() {
int i,n,column,m,show,full_rows,k,b,flag=0,flag_b=0;
do {
printf("please enter frame size and width<frame size > 2*width>:");
scanf("%d",&n);
scanf("%d",&m);
}
while (n<=2*m||m<0); /*gives the conditions for the input of the
program*/
for (i=0,k=0;k<23;i++,k++) {
for (column=0,b=0;b<79;column++,b++){
if (column==n){
column=0; /*restarts the building of the square*/
flag+=1;
}
if (i==n)
if ((n+1)%2)
flag_b+=1;
else
flag_b=0;
show=m>column;
show=show||m+column>=n; /*this are the conditions to create
a squre with the thicknes(m) in the columns that is needed*/
if(show)
printf("*");
else {
full_rows=m>i;
full_rows=full_rows||m+i>=n;
if (full_rows) /*the condition to create
thickness(m) in the rows that is needed*/
printf("*");
else
printf(" "); /*creates a blank in the
spots that do not fullfill the conditions */
}
if(b==78)
printf("\n");
i=i%n;
}
}
}
#include<stdio.h>
#include<stdlib.h>
#define chessBoardSize 12
int chessBoard[chessBoardSize][chessBoardSize] = {0};
typedef struct point{
int x, y;
}POINT;
int count=0;
int nextPosition(int x, int y, POINT* array){
int m=0;
/* finds the next possible points for the current
position in the chess board:
like
_ _ _ _ _ _
_ * _ * _ _
* _ _ _ * _
_ _ P _ _ _
* _ _ _ * _
_ * _ * _ _
as above if 'P' is the current (x,y)
* represents the next possible points and
also checks it exists within the chess board
*/
if( (x+2) < chessBoardSize ){
if( (y+1) < chessBoardSize ){
array[m].x = x+2;
array[m++].y = y+1;
}
if( (y-1) >-1 ){
array[m].x = x+2;
array[m++].y = y-1;
}
}
if( (x-2) > -1){
if( (y+1) < chessBoardSize ){
array[m].x = x-2;
array[m++].y = y+1;
}
if( (y-1) >-1 ){
array[m].x = x-2;
array[m++].y = y-1;
}
}
if( (y+2) < chessBoardSize){
if( (x+1) < chessBoardSize ){
array[m].x = x+1;
array[m++].y = y+2;
}
if( (x-1) >-1 ){
array[m].x = x-1;
array[m++].y = y+2;
}
}
if( (y-2) > -1){
if( (x+1) < chessBoardSize ){
array[m].x = x+1;
array[m++].y = y-2;
}
if( (x-1) >-1 ){
array[m].x = x-1;
array[m++].y = y-2;
}
}
return m;
}
void displayAnswer(){
int i, j, k;
printf("\n");
for(i=0; i<chessBoardSize; i++){
for(j=0; j<chessBoardSize; j++)
printf("%d\t",chessBoard[i][j]);
printf("\n\n");
}
}
// recursive function using backtrack method
void knightTravel(int x, int y){
POINT array[8] = {{0, 0}, {0, 0}};
// remainin initialized to zero automatically
volatile int noOfPossiblePoints = nextPosition(x, y, array);
volatile int i;
chessBoard[x][y] = ++count;
// base condition uses count
if( count == chessBoardSize * chessBoardSize ){
displayAnswer();
exit(0);
}
for(i=0; i< noOfPossiblePoints; i++)
if( chessBoard[array[i].x][array[i].y] == 0 )
knightTravel(array[i].x, array[i].y);
chessBoard[x][y] = 0;
count--;
}
int main()
{
knightTravel(0, 0);
printf("No solution exists\n");
return 0;
}
#include <bits/stdc++.h>
using namespace std;
struct cell
int x, y;
int dis;
cell() {}
cell(int x, int y, int dis) : x(x), y(y), dis(dis) {}
};
bool isInside(int x, int y)
if (x >= 1 && x <= 8 && y >= 1 && y <= 8)
return true;
return false;
int getStepCount(int input1, int input2,int input3,int input4)
int dx[] = {-2, -1, 1, 2, -2, -1, 1, 2};
int dy[] = {-1, -2, -2, -1, 1, 2, 2, 1};
queue<cell> q;
q.push(cell(input1, input2, 0));
cell t;
int x, y;
bool visit[8 + 1][8 + 1];
for (int i = 1; i <= 8; i++)
for (int j = 1; j <= 8; j++)
visit[i][j] = false;
visit[input1][input2] = true;
while (!q.empty())
t = q.front();
q.pop();
visit[t.x][t.y] = true;
if (t.x == input3 && t.y == input4)
return t.dis;
for (int i = 0; i < 8; i++)
x = t.x + dx[i];
y = t.y + dy[i];
if (isInside(x, y) && !visit[x][y])
q.push(cell(x, y, t.dis + 1));
int main()
int output;
int ip1;
cin>>ip1;
cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
int ip2;
cin>>ip2;
cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
int ip3;
cin>>ip3;
cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
int ip4;
cin>>ip4;
cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
output=getStepCount(ip1,ip2,ip3,ip4);
cout<<output<<endl;
return 0;
