Hey guys im working on this project. It wants me to find anagrams. My code works when im writing like 2 sentences. But it shows me a segmentation fault if i write more sentences then 5. I tried to find the problem but i cant figure it out. can some one check it for me? here is my code. Thanks alot!
int klinkercheck(char z)
{
if (z =='a')
return 1000;
else if (z == 'e')
return 10000;
else if (z == 'i')
return 100000;
else if (z == 'o')
return 1000000;
else if (z == 'u')
return 10000000;
else if (z == 10)
return 0;
else if (z == '.' || z== ' ')
return 0;
else
return 1;
}
int main()
{
int a,k,i,m,l,*tablecost,*testcost;
int **table, **test, **result;
char character;
scanf("%d",&a);
table = (int **)malloc(sizeof(int)*a);
tablecost = (int *)malloc(sizeof(int)*a);
for(k=0; k<a; k++) {
table[k]= (int *)malloc(sizeof(int)*26);
/*printf("tablecost = %d",tablecost[k]);*/
}
for(k=0; k<a; k++) {
for(i=0; i<2; i=i) {
scanf("%c",&character);
tablecost[k]= tablecost[k]+klinkercheck(character);
if(character=='.') {
/*printf("%d\n",k);*/
break;
} else if(character < 97) {
/* do nothing*/
} else {
table[k][character%97]++;
}
}
}
scanf("%d",&m);
test = (int **)malloc(sizeof(int)*m);
result = (int **)malloc(sizeof(int)*m);
testcost = (int *)malloc(sizeof(int)*m);
for(k=0; k<m; k++) {
test[k]= (int *)malloc(sizeof(int)*26);
result[k] = (int *)malloc(sizeof(int)*a);
}
for (k = 0 ; k < m ; k++) {
testcost[k]=0;
for(i=0; i<20; i=i) {
scanf("%c",&character);
testcost[k] =testcost[k]+klinkercheck(character);
if(character=='.') {
break;
} else if(character < 97) {
/* do nothing*/
} else {
test[k][character%97]++;
}
}
}
for (i = 0 ; i < m ; i++) {
for (k = 0 ; k < a ; k++) {
if (testcost[i] == tablecost[k]) {
for (l = 0 ; l < 26 ; l++) {
if (test[i][l] != table[k][l]) {
break;
} else if (l == 25) {
printf("%d ", k + 1);
}
}
}
}
printf("\n");
}
return 0;
}
table = (int **)malloc(sizeof(int)*a);
should be
table = malloc(sizeof(int *)*a);
and also
test = malloc(sizeof(int *)*m);
result = malloc(sizeof(int *)*m);
Dont cast malloc()
Unless sizeof(int)==sizeof(int*) on your platform the line:
table = (int **)malloc(sizeof(int)*a);
Will cause trouble. Use:
table = malloc(sizeof(*table)*a);
NB: Old boys get ventilated about casting the return of malloc().
Related
So i made a backtracking algorithm in c, where i get a txt file filled with words in each line and another txt file just has coordinates for the black squares of a square crossword. I know my implementation is extremelly simple, but i just want to have the barebones algorithm, to make it much faster later on with constraint satisfaction, forward checking etc.
However i have no idea how to get the basic code to work without segmentation faults and wrong solutions! Ant advice would be very helpful!
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX_WORDS 150000
#define MAX_DIMENSION 200
#define MAX_BLACK_SQUARES 250
int is_valid_word(char *word, int dimension, char crossword[MAX_DIMENSION][MAX_DIMENSION])
{
int i, j, k;
int word_length = strlen(word);
// check if word is too long
if (word_length > dimension)
{
return 0;
}
// check if word overlaps existing letters
for (i = 0; i < dimension; i++)
{
for (j = 0; j < dimension; j++)
{
if (crossword[i][j] != '_')
{
for (k = 0; k < word_length; k++)
{
if ((i + k < dimension && crossword[i + k][j] != '_' && crossword[i + k][j] != word[k]) ||
(j + k < dimension && crossword[i][j + k] != '_' && crossword[i][j + k] != word[k]))
{
return 0;
}
}
}
}
}
return 1;
}
int solve_crossword(int dimension, char crossword[MAX_DIMENSION][MAX_DIMENSION], char words[MAX_WORDS][30], int num_words, int word_index)
{
int i, j, k;
if (word_index >= num_words)
{
// all words have been placed, so return true
return 1;
}
// try placing the current word horizontally
for (i = 0; i < dimension; i++)
{
for (j = 0; j < dimension - strlen(words[word_index]); j++)
{
if (crossword[i][j] != '#')
{
// try placing the word here
int is_valid = 1;
for (k = 0; k < strlen(words[word_index]); k++)
{
if (crossword[i][j + k] != '_' && crossword[i][j + k] != words[word_index][k])
{
is_valid = 0;
break;
}
}
if (is_valid)
{
// place the word
for (k = 0; k < strlen(words[word_index]); k++)
{
crossword[i][j + k] = words[word_index][k];
}
// recursive call to place the next word
if (solve_crossword(dimension, crossword, words, num_words, word_index + 1))
{
return 1;
}
// backtrack by removing the word
for (k = 0; k < strlen(words[word_index]); k++)
{
crossword[i][j + k] = '_';
}
}
}
}
}
// try placing the current word vertically
for (i = 0; i < dimension - strlen(words[word_index]); i++)
{
for (j = 0; j < dimension; j++)
{
if (crossword[i][j] != '#')
{
// try placing the word here
int is_valid = 1;
for (k = 0; k < strlen(words[word_index]); k++)
{
if (crossword[i + k][j] != '_' && crossword[i + k][j] != words[word_index][k])
{
is_valid = 0;
break;
}
}
if (is_valid)
{
// place the word
for (k = 0; k < strlen(words[word_index]); k++)
{
crossword[i + k][j] = words[word_index][k];
}
// recursive call to place the next word
if (solve_crossword(dimension, crossword, words, num_words,word_index + 1))
{
return 1;
}
// backtrack by removing the word
for (k = 0; k < strlen(words[word_index]); k++)
{
crossword[i + k][j] = '_';
}
}
}
}
}
// if we get here, we were unable to place the word in either direction
return 0;
}
int main()
{
// open dictionary file
FILE *dict_file = fopen("dicts/EvenMoreWords.txt", "r");
if (dict_file == NULL)
{
printf("Unable to open dict.txt\n");
return 1;
}
// read dictionary into array
char words[MAX_WORDS][30];
int num_words = 0;
char buffer[30];
while (fgets(buffer, 30, dict_file) != NULL)
{
int word_length = strlen(buffer);
if (buffer[word_length - 1] == '\n')
{
buffer[word_length - 1] = '\0';
}
strcpy(words[num_words], buffer);
num_words++;
}
fclose(dict_file);
// open crossword file
FILE *crossword_file = fopen("crosswords/c1.txt", "r");
if (crossword_file == NULL)
{
printf("Unable to open crossword.txt\n");
return 1;
}
// read dimensions and black squares
int dimension, i, j, width, height;
fscanf(crossword_file, "%d", &dimension);
// initialize crossword
char crossword[MAX_DIMENSION][MAX_DIMENSION];
while (fscanf(crossword_file, "%d %d", &width, &height) != EOF)
{
crossword[width - 1][height - 1] = '#';
}
printf("\n\n\n");
for (i = 0; i < dimension; i++)
{
for (j = 0; j < dimension; j++)
{
if (crossword[i][j] != '#')
{
crossword[i][j] = '_';
printf("%c ", crossword[i][j]);
}
else
{
printf("%c ", crossword[i][j]);
}
}
printf("\n");
}
printf("\n\n\n");
// solve crossword
if (solve_crossword(dimension, crossword, words, num_words, 0))
{
// print solution
for (i = 0; i < dimension; i++)
{
for (j = 0; j < dimension; j++)
{
printf("%c ", crossword[i][j]);
}
printf("\n");
}
}
else
{
printf("Unable to find a solution\n");
}
return 0;
}
#include<stdio.h>
#include<time.h>
int main(void)
{
srand(time(NULL));
int answer;
int treatment = rand() % 4;
printf("###발모제 찾기###\n\n");
int cntShowBottle = 0;
int prevCntShowBottle = 0;
int ptr[4] = { 0,0,0,0 };
int bottle[4] = { 0, 0, 0, 0 };
int isincluded = 0;
for (int i = 1; i <= 3; i++)
{
do {
cntShowBottle = rand() % 2 + 2;
} while (cntShowBottle == prevCntShowBottle);
prevCntShowBottle = cntShowBottle;
printf(" %d 번째 시도 : ", i);
for (int j = 0; j < cntShowBottle; j++)
{
int randBottle = rand() % 4;
if (bottle[randBottle] == 0)
{
bottle[randBottle] = 1;
if (randBottle == treatment)
{
isincluded = 1;
}
}
else
{
j--;
}
}
}
if (bottle[0] == ptr[0] && bottle[1] == ptr[1] && bottle[2] == ptr[2] && bottle[3] == ptr[3])
{
int bottle[4] = { 0,0,0,0 };
for (int j = 0; j < cntShowBottle; j++)
{
int randBottle = rand() % 4;
if (bottle[randBottle] == 0)
{
bottle[randBottle] = 1;
if (randBottle == treatment)
{
isincluded = 1;
}
}
else
{
j--;
}
}
}
else
{
return 0;
}
for (int i = 0; i < 4; i++)
{
ptr[i] = bottle[i];
}
for (int k = 0; k < 4; k++)
{
if (bottle[k] == 1)
printf("%d ", k + 1);
}
printf("번 물약을 머리에 바릅니다.\n\n");
if (isincluded == 1)
{
printf("성공!\n");
}
else
{
printf("실패...\n");
}
printf("\n ...계속 하려면 아무키나 누르세요...");
getchar(0);
printf("\n\n발모제는 몇 번? : ");
scanf_s("%d", &answer);
if (answer == treatment+1)
{
printf("\n 정답! \n");
}
else
{
printf("\n 실패! \n 정답은 %d 였습니다.\n", treatment+1);
}
return 0;
}
in this loop, for (int j = 0; j < cntShowBottle; j++), 'bottle' array will be [0,1,1,1] or [1,1,0,0] etc. In this loop, how to get different array without overlapping(like [0,1,1,0] and again [0,1,1,0])?? I tried comparing each elements, if it takes overlapping array, makes 'bottle' array again. but it didn't run properly. please help..
I have an error somewhere in this code.
The number of neighbors is not being counted correctly, as per my understanding. The neighbors function is probably where the issue is. My field variable is a 12x12 char array, the '#' is an alive cell and '-' is a dead one.
I am relatively new to programming and would appreciate some help with this.
int neighbors(int l, int c)
{
int num = 0;
for (int i = -1; i < 2; i++)
{
for (int j = -1; j < 2; j++)
{
if ((l+i < 0 || l+i > 12) && (c+j < 0 || c+j > 12))
{
continue;
}
else if ((i != 0 || j != 0) && field[(l + i)][(c + j)] == '#')
{
num++;
}
}
}
return num;
}
//game logic
void logic()
{
char temp[12][12];
for (int i = 0; i < 12; i++)
{
for (int j = 0; j < 12; j++)
{
temp[i][j] = field[i][j];
}
}
for (int i = 0; i < 12; i++)
{
for (int j = 0; j < 12; j++)
{
if (field[i][j] == '#')
{
if (neighbors(i, j) < 1 || neighbors(i, j) > 3)
{
temp[i][j] = '-';
}
else
{
temp[i][j] = '#';
}
}
if (field[i][j] = '-')
{
if (neighbors(i, j) == 3)
{
temp[i][j] = '#';
}
else
{
temp[i][j] = '-';
}
}
field[i][j] = temp[i][j];
}
}
}
If the array has dimensions 12x12, the maximum index value is 11, hence the test if ((l+i < 0 || l+i > 12) && (c+j < 0 || c+j > 12)) is incorrect. It should be:
if (l+i < 0 || l+i >= 12 || c+j < 0 || c+j >= 12)
continue;
Another major problem is you update field[i][j] = temp[i][j]; inside the update loop: this corrupts the computation for the neighbors of the adjacent cells. You should first compute the whole temp array and update field in a subsequent loop, or with a single call to memcpy().
Furthermore, the standard rules for Conway's Game of Life are somewhat different from your implementation: if (neighbors(i, j) < 1 || neighbors(i, j) > 3) keeps a cell with a single neighbour alive whereas under the standard rules it should die. Change this test to:
if (neighbors(i, j) < 2 || neighbors(i, j) > 3)
temp[i][j] = '-';
Here is a simplified version:
int neighbors(int l, int c) {
int num = 0;
for (int i = -1; i < 2; i++) {
for (int j = -1; j < 2; j++) {
if (l+i >= 0 && l+i < 12 && c+j >= 0 && c+j < 12
&& (i != 0 || j != 0) && field[l+i][c+j] == '#') {
num++;
}
}
}
return num;
}
//game logic
void logic() {
char temp[12][12];
for (int i = 0; i < 12; i++) {
for (int j = 0; j < 12; j++) {
temp[i][j] = field[i][j];
}
}
for (int i = 0; i < 12; i++) {
for (int j = 0; j < 12; j++) {
int nb = neighbors(i, j);
if (nb < 2 || nb > 3) {
temp[i][j] = '-';
} else
if (nb == 3) {
temp[i][j] = '#';
}
}
}
for (int i = 0; i < 12; i++) {
for (int j = 0; j < 12; j++) {
field[i][j] = temp[i][j];
}
}
}
here is my code a part of a project when i initialize CHAR_1,CHAR_2 it works but when i read them by scanf it stopped working.
int repair_beta(char beta[11][11])
{
int i = 0, j = 0;
int count = 0, n = 0;
int fail = 0;
for(i = 1; i < 11; i++)
{
for(j = 1; j < 11; j++)
{
if(beta[i][j] == stronghold)
{
count++;
}
}
}
if(count == 4)
{
return 1;
}
else if(count < 4)
{
char CHAR_1 = 'A', CHAR_2 = '5';
for(n = 0; n < 3; n++)
{
printf("\n\t\t <<choose to repair>>\n\t\t\t ");
scanf("%c", &CHAR_1);
scanf("\n%c", &CHAR_2);
for(i = 1; i < 11; i ++)
{
if(CHAR_1 == 'A' + i - 1)
{
break;
}
}
for(j = 1; j < 11; j++)
{
if(CHAR_2 == '0' + j - 1)
{
break;
}
}
if(beta[i][j] == LAND || beta[i][j] == land)
{
beta[i][j] = stronghold;
prize_beta--;
printf("\n\t\t\t <<repaired>>");
printf("\n****************************************************************************\n");
return 1;
}
else
{
fail++;
}
}
if(fail == 3)
{
printf("\n\t\t <<you failed to repair>>");
prize_beta;
printf("\n****************************************************************************\n");
}
}
}
it is my firs time i use stackoverflow so excuse me if i ask my question in bad way.
I have been writing this program that tries to find how to put 12 knights on a chess board so all squares are either taken up by a knight or one of 12 knights can reach them in one move. So far I have created 2 functions: one takes a board with 12 knights and fills all the squares they can reach with 'T' and another that takes a filled chess board and checks if there are left any squares not taken up by a knight nor dominated by it (meaning no knight can reach it in one move).
Now I am dealing with the problem of how can I try out all the possible combinations of knights. My idea is that after every single combination of 12 knights on a board, I will send the board with 12 knights to be filled with 'T's for all the squares they can reach, and then send it to another function to check if all squares are dominated.
Here is my code:
#include <stdio.h>
#include <stdlib.h>
int filling(char array[8][8])
{
int i, j;
for (i = 0;i < 8;i++)
{
for (j = 0; j < 8;j++)
{
if(array[i][j] == 'H')
{
if(i-1>-1 && j+2<8 && array[i-1][j+2]!='H') array[i-1][j+2]='T';
if(i+1<8 && j+2<8 && array[i+1][j+2]!='H') array[i+1][j+2]='T';
if(i-2>-1 && j+1<8 && array[i-2][j+1]!='H') array[i-2][j+1]='T';
if(i+2<8 && j+1<8 && array[i+2][j+1]!='H') array[i+2][j+1]='T';
if(i-2>-1 && j-1>-1 && array[i-2][j-1]!='H') array[i-2][j-1]='T';
if(i+2<8 && j-1>-1 && array[i+2][j-1]!='H') array[i+2][j-1]='T';
if(i-1>-1 && j-2>-1 && array[i-1][j-2]!='H') array[i-1][j-2]='T';
if(i+1<8 && j-2>-1 && array[i+1][j-2]!='H') array[i+1][j-2]='T';
}
}
}
}
int checking(char array[8][8])
{
int i, j;
for(i = 0;i < 8;i++)
{
for(j = 0;j < 8;j++)
{
if(array[i][j] != 'H' && array[i][j] != 'T')
return 0;
}
}
return 1;
}
int main()
{
int i, j;
char board[8][8];
for(i = 0; i < 8; i++)
{
for(j = 0; j < 8; j++)
board[i][j] = '0';
}
// The following lines are here to test if the checking and filling work
/*board[2][1] = 'H';
board[2][2] = 'H';
board[3][2] = 'H';
board[5][2] = 'H';
board[6][2] = 'H';
board[5][3] = 'H';
board[2][4] = 'H';
board[1][5] = 'H';
board[2][5] = 'H';
board[4][5] = 'H';
board[5][5] = 'H';
board[5][6] = 'H'; */
filling(board);
if(checking(board) == 1) printf (" \n Works");
else printf ("\n Doesnt work");
for(i = 0; i < 8; i++)
{
printf("\n");
for(j = 0; j < 8; j++)
printf("%c ", board[i][j]);
}
return 0;
}
What kind of algorithm I could use to try out every combo? Thank you for your answers.
You need these things:
A sorting rule that puts all possible combinations in a well-defined order.
An initialization rule that defines the board's first such combination.
An increment rule that transitions a board from its current combination to the next combination in the well-defined order.
A rule that detects when the board is in the last combination.
Then you just use algorithm 2 to put the board in the first state. Then check with algorithm 4 to see if you're in the last state. If not, use algorithm 3 to go to the next state.
Algorithm 1 is probably the hard one. One simple rule is just to convert the board's position to a binary number with a zero for an empty square and a one for a full square in a well-defined order, say starting from the top left and going across, then moving to the next row.
If you're on decent, or even semi-decent hardware, you've got a 64-bit unsigned integral type available to you. Let's call that uint64_t.
You can store a chessboard with knight positions as a single uint64_t. You can also store a "dominated" mask in the same type. You simply establish a correlation between the 64 bits in the type and the 64 spaces on the chessboard.
Since there are 64 possible locations, you can pre-compute the possible threat masks for each position, storing that as an array of 64 uint64_t values.
You need to set the position of each knight. But you can safely do them in a certain order, so that knight #1 is always the "highest" knight - his bit position is always highest, or lowest, or whatever. So you could write code like this:
for (k0 = 64; k0 > 11; --k0)
for (k1 = k0 - 1; k1 > 10; --k1)
for (k2 = k1 - 1; k2 > 9; --k2)
...
for (k11 = k10 - 1; k11 >= 0; --k11)
/* do stuff */
But that's horrible, because there are a squillion possibilities (squillion = 1573144097507348889600, thanks #jwd!).
That said, the threat mask for each knight can be computed "incrementally" from the masks of the outer knights, so it might be faster to perform all the computations than to try to store/mark/compute the rotations and flips of the board.
Something like this:
for (kXX = kYY - 1; kXX > (11-XX); --kXX) {
threat_XX = threat_YY | pre_computed_threat[kXX];
for (kZZ = KXX - 1; kZZ > (11-ZZ); --kZZ) {
threat_ZZ = threat_XX | pre_computed_threat[kZZ];
The nice thing about this approach is that your objective is total coverage by threats - all 1 bits in the threat_11 map, in other words. You can test just by inverting the bits and comparing with zero.
Well thanks to my questions of today I got myself blocked from asking more until my rep gets better, but for what its worth I managed to solve the problem myself. I had to take 3 positions in each quarter of the board that can only be reached by seperate horses, that way making my 12 for cycles shorter, as they only had to go through specific locations, instead of trying every single of of them. The execution times is just above one second and it finds two different layouts for 12 knights, marking them 'H' and the positions they can reach in one turn 'T'. Here is the code if anyone ever comes to a problem like this:
#include <stdio.h>
#include <stdlib.h>
struct horses
{
int x;
int y;
};
void fill(struct horses arkliai[12], char array[8][8])
{
int i,j;
for(i = 0; i < 8; i++)
{
for(j = 0; j < 8; j++)
array[i][j] = '0';
}
for(i = 0; i < 12; i++)
{
array[arkliai[i].x][arkliai[i].y] = 'H';
}
pildymas(array);
}
void startingpositions(struct horses arkliai[12])
{
int i = 0;
int j = 0;
int a = 0;
for(a = 0; a < 12; a++)
{
if(i > 7)
{
i = 0;
j++;
}
arkliai[a].x = i;
arkliai[a].y = j;
i++;
}
}
void combinacijos(struct horses h[12], char array[8][8])
{
int a,b,c,d,e,f,g,hi,ii,ji,k,l;
for(a = 0; a < 2; a++)
{
if(a == 0)
{
h[0].x = 1;
h[0].y = 2;
}
if(a == 1)
{
h[0].x = 2;
h[0].y = 1;
}
for(b = 0; b < 2; b++)
{
if(b == 0)
{
h[1].x = 5;
h[1].y = 1;
}
if(b == 1)
{
h[1].x = 6;
h[1].y = 2;
}
for(c = 0; c < 2; c++)
{
if(c == 0)
{
h[2].x = 1;
h[2].y = 5;
}
if(c == 1)
{
h[2].x = 2;
h[2].y = 6;
}
for(d = 0; d <2;d++)
{
if(d == 0)
{
h[3].x = 5;
h[3].y = 6;
}
if(d == 1)
{
h[3].x = 6;
h[3].y = 5;
}
for(e = 0; e < 3; e++)
{
if(e == 0)
{
h[4].x = 2;
h[4].y = 0;
}
if(e == 1)
{
h[4].x = 2;
h[4].y = 2;
}
if(e == 2)
{
h[4].x = 1;
h[4].y = 3;
}
for (f = 0; f < 3; f++)
{
if(f == 0)
{
h[5].x = 1;
h[5].y = 4;
}
if(f == 1)
{
h[5].x = 2;
h[5].y = 5;
}
if(f == 2)
{
h[5].x = 2;
h[5].y = 7;
}
for (g = 0; g < 3; g++)
{
if(g == 0)
{
h[6].x = 5;
h[6].y = 7;
}
if(g == 1)
{
h[6].x = 5;
h[6].y = 5;
}
if(g == 2)
{
h[6].x = 6;
h[6].y = 4;
}
for(hi = 0; hi < 3; hi++)
{
if(hi == 0)
{
h[7].x = 5;
h[7].y = 0;
}
if(hi == 1)
{
h[7].x = 5;
h[7].y = 2;
}
if(hi == 2)
{
h[7].x = 6;
h[7].y = 3;
}
for(ii = 0; ii < 4; ii++)
{
if (ii == 0)
{
h[8].x = 3;
h[8].y = 0;
}
if (ii == 1)
{
h[8].x = 3;
h[8].y = 2;
}
if (ii == 2)
{
h[8].x = 0;
h[8].y = 3;
}
if (ii == 3)
{
h[8].x = 2;
h[8].y = 3;
}
for(ji = 0; ji < 4; ji++)
{
if (ji == 0)
{
h[9].x = 3;
h[9].y = 7;
}
if (ji == 1)
{
h[9].x = 3;
h[9].y = 5;
}
if (ji == 2)
{
h[9].x = 2;
h[9].y = 4;
}
if (ji == 3)
{
h[9].x = 0;
h[9].y = 4;
}
for(k = 0; k < 4; k++)
{
if (k == 0)
{
h[10].x = 4;
h[10].y = 7;
}
if (k == 1)
{
h[10].x = 4;
h[10].y = 5;
}
if (k == 2)
{
h[10].x = 5;
h[10].y = 4;
}
if (k == 3)
{
h[10].x = 7;
h[10].y = 4;
}
for(l = 0;l < 64;l++)
{
if(h[11].x == 7)
{
if(h[11].y == 7)
{
h[11].x = 0;
h[11].y = 0;
break;
}
h[11].x = 0;
h[11].y = h[11].y +1;
}
else { h[11].x= h[11].x+1; }
fill(h, array);
}
}
}
}
}
}
}
}
}
}
}
}
}
int pildymas(char array[8][8])
{
int i, j;
for (i = 0;i < 8;i++)
{
for (j = 0; j < 8;j++)
{
if(array[i][j] == 'H')
{
if(i-1>-1 && j+2<8 && array[i-1][j+2]!='H') array[i-1][j+2]='T';
if(i+1<8 && j+2<8 && array[i+1][j+2]!='H') array[i+1][j+2]='T';
if(i-2>-1 && j+1<8 && array[i-2][j+1]!='H') array[i-2][j+1]='T';
if(i+2<8 && j+1<8 && array[i+2][j+1]!='H') array[i+2][j+1]='T';
if(i-2>-1 && j-1>-1 && array[i-2][j-1]!='H') array[i-2][j-1]='T';
if(i+2<8 && j-1>-1 && array[i+2][j-1]!='H') array[i+2][j-1]='T';
if(i-1>-1 && j-2>-1 && array[i-1][j-2]!='H') array[i-1][j-2]='T';
if(i+1<8 && j-2>-1 && array[i+1][j-2]!='H') array[i+1][j-2]='T';
}
}
}
tikrinimas(array);
}
int tikrinimas(char array[8][8])
{
int i, j;
for(i = 0;i < 8;i++)
{
for(j = 0;j < 8;j++)
{
if(array[i][j] != 'H' && array[i][j] != 'T')
return 0;
}
}
printas(array);
}
int printas(char array[8][8])
{
int i,j;
for(j = 0; j <8; j++)
{
printf("\n");
for(i = 0; i <8 ; i++)
printf("%c ", array[i][7-j]);
}
printf("\n");
}
int main()
{
struct horses hr[12];
char board[8][8];
startingpositions(hr);
combinacijos(hr, board);
return 0;
}