Crossword

Discussion in 'C Programming' started by bryonmajor, May 13, 2020.

  1. bryonmajor

    bryonmajor

    Joined:
    May 11, 2020
    Messages:
    15
    Likes Received:
    0
    Hello I posted in the wrong place I think the last time I tried to make a crossword puzzle generator in C++. I manage to crosswords most of the time but I'd like to make it recursive.
    Code (C):
    #include <iostream>
    #include <string>
    #include <algorithm>
    #include <bits/stdc++.h>
    #include <stdlib.h>
    #include <sstream>
    #include <ctime>
    #include <vector>
    using namespace std;
    std::vector<double> coord_x;
    std::vector<double> coord_y;
    std::vector<std::string > commonchar;
    char grid[26][26] = {
            {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' }
    };

    int random(int from, int to)
    {
        return rand() % (to - from + 1) + from;
    }

    std::string find_intersection(std::string &first, std::string &second)
    {
        std::sort(first.begin(), first.end());
        std::sort(second.begin(), second.end());
        int length = std::min(first.length(), second.length());
        std::string result(length, ' ');
        std::set_intersection(first.begin(), first.end(), second.begin(), second.end(), result.begin());
        return result;
    }
    int PlaceHorizontal(int x, int y, std::string &word)
    {
        coord_x.push_back(x);
        coord_y.push_back(y);
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
            if (grid[x][y + j] == '.' || grid[x][y + j] == word[j])
            {
                grid[x][y + j] = word[j];
            }
            else {}
        }
    }
    int PlaceVertical(int x, int y, std::string &word)
    {
        coord_x.push_back(x);
        coord_y.push_back(y);
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
            if (grid[x + j][y] == '.' || grid[x + j][y] == word[j])
            {
                grid[x + j][y] = word[j];
            }
            else {}
        }
    }
    std::string randomword(int randomline)
    {

        std::string word1;
        std::string ifileName = "dicoFrancais.txt";
        std::ifstream f(ifileName);

        if (!f) std::cerr << "File '" << ifileName << "' couldn't opened!\n";

        std::string s;

        for (int i = 1; i <= randomline; i++)
        {
            std::getline(f, s);
            word1 = s;
        }
        return word1;
    }

    int main(int argc, char *argv[])
    {
        string word1;
        string word2;
        string word3;
        string word4;
        string word5;
        string word6;
        string word7;

        int x_word1_intersection;
        int x_word2_intersection;
        int x_word23_intersection;
        int x_word32_intersection;
        int x_word13_intersection;
        int x_word31_intersection;
        int x_word34_intersection;
        int x_word43_intersection;
        int x_word45_intersection;
        int x_word54_intersection;
        int x_word56_intersection;
        int x_word65_intersection;
        int x_word67_intersection;
        int x_word76_intersection;
        srand(time(0));

        int rand1 = random(1000, 2000);
        word1 = randomword(rand1);

        int rand2 = random(1000, 2000);
        word2 = randomword(rand2);

        int rand3 = random(1000, 2000);
        word3 = randomword(rand3);

        int rand4 = random(1000, 2000);
        word4 = randomword(rand4);

        int rand5 = random(1000, 2000);
        word5 = randomword(rand5);

        int rand6 = random(1000, 2000);
        word6 = randomword(rand6);

        int rand7 = random(1000, 2000);
        word7 = randomword(rand7);

        std::cout << "Word-1 : " << word1 << "\n";
        std::cout << "Word-2 : " << word2 << "\n";
        std::cout << "Word-3 : " << word3 << "\n";
        std::cout << "Word-4 : " << word4 << "\n";
        std::cout << "Word-5 : " << word5 << "\n";
        std::cout << "Word-6 : " << word6 << "\n";
        std::cout << "Word-7 : " << word7 << "\n";
        int x = 8;
        int y = 8;
        int indice1 = 0;
        int indice2 = 0;
        int indice3 = 0;
        int indice4 = 0;
        int indice5 = 0;
        int indice6 = 0;

        PlaceHorizontal(x, y, word1);
        std::string temp1 = word1;
        std::string temp2 = word2;
        std::string intersec = find_intersection(temp1, temp2);

        x_word1_intersection = word1.find_last_of(intersec[0]);
        x_word2_intersection = word2.find_last_of(intersec[0]);
        PlaceVertical(coord_x[0] - x_word2_intersection, coord_y[0] + x_word1_intersection, word2);

        std::string temp3 = word3;
        std::string intersec1 = find_intersection(temp2, temp3);
        if (intersec[0] = intersec1[0] && intersec1.length() > 0)
        {
            if (indice1 += 1 <= intersec1.length())
            {
                indice1 += 1;
            }
        }
        else
        {
            indice1 = 0;
        }
        x_word23_intersection = word2.find_last_of(intersec1[indice1]);
        x_word32_intersection = word3.find_last_of(intersec1[indice1]);

        PlaceHorizontal(coord_x[1] + x_word23_intersection, coord_y[1] - x_word32_intersection, word3);

        std::string temp4 = word4;
        std::string intersec2 = find_intersection(temp3, temp4);
        if (intersec1[indice1] = intersec2[0])
        {
            if (indice2 += 1 <= intersec2.length())
            {
                indice2 += 1;
            }
        }
        else
        {
            indice2 = 0;
        }
        x_word34_intersection = word3.find_last_of(intersec2[indice2]);
        x_word43_intersection = word4.find_last_of(intersec2[indice2]);

        PlaceVertical(coord_x[2] - x_word43_intersection, coord_y[2] + x_word34_intersection, word4);

        std::string temp5 = word5;
        std::string intersec3 = find_intersection(temp4, temp5);
        if (intersec2[indice2] = intersec3[0])
        {
            if (indice3 += 1 <= intersec3.length())
            {
                indice3 += 1;
            }
        }
        else
        {
            indice3 = 0;
        }
        x_word45_intersection = word4.find_last_of(intersec3[indice3]);
        x_word54_intersection = word5.find_last_of(intersec3[indice3]);

        PlaceHorizontal(coord_x[3] + x_word45_intersection, coord_y[3] - x_word54_intersection, word5);

        std::string temp6 = word6;
        std::string intersec4 = find_intersection(temp5, temp6);
        if (intersec3[indice3] = intersec4[0])
        {
            if (indice4 += 1 <= intersec4.length())
            {
                indice4 += 1;
            }
        }
        else
        {
            indice4 = 0;
        }
        x_word56_intersection = word5.find_last_of(intersec4[indice4]);
        x_word65_intersection = word6.find_last_of(intersec4[indice4]);

        PlaceVertical(coord_x[4] - x_word65_intersection, coord_y[4] + x_word56_intersection, word6);

        std::string temp7 = word7;
        std::string intersec5 = find_intersection(temp6, temp7);
        if (intersec4[indice4] = intersec5[0])
        {
            if (indice5 += 1 <= intersec5.length())
            {
                indice5 += 1;
            }
        }
        else
        {
            indice5 = 0;
        }
        x_word67_intersection = word6.find_last_of(intersec5[indice5]);
        x_word76_intersection = word7.find_last_of(intersec5[indice5]);
        PlaceHorizontal(coord_x[5] + x_word45_intersection, coord_y[5] - x_word54_intersection, word7);

        for (int i = 0; i < 26; i++)
        {
            for (int j = 0; j < 26; j++)
            {
                std::cout << grid[i][j];
                std::cout << " ";
            }
            std::cout << "\n";
        }
    }
    I thought of alternating the meaning of the words (vertical / horizontal) with even and odd numbers with a loop like this one but I couldn't figure out how to do it. Can you help me?

    Code (C):
    #include <iostream>

    using namespace std;

    int main()
    {
        //declare variables
        int number;
        int n;

        cout << "Enter value less than 100: ";
        cin >> n; //take user input

        // print odd values
        cout << "The odd numbers are:";
        for (number = n + 1 - (n % 2); number <= 100; number += 2)
        {
            cout << " " << number;
        }
        cout << endl;

        // print even values
        cout << "The even numbers are:";
        for (number = n + (n % 2); number <= 100; number += 2)
        {
            cout << " " << number;
        }
        cout << endl;

        return 0; //end of program
    }
     
    bryonmajor, May 13, 2020
    #1
    1. Advertisements

  2. bryonmajor

    bryonmajor

    Joined:
    May 11, 2020
    Messages:
    15
    Likes Received:
    0
    Good morning, I figured it out tonight. It's great. There's still a few misspelled words, but the idea is there. I hope that some beginners will be able to get some inspiration from it because this code required a lot of thought from me, I'm not an expert either.
    Code (C):
    #include <iostream>
    #include <string>
    #include <algorithm>
    #include <bits/stdc++.h>
    #include <stdlib.h>
    #include <sstream>
    #include <ctime>
    #include <vector>
    using namespace std;
    std::vector<double> coord_x;
    std::vector<double> coord_y;
    std::vector<std::string > words_hori;
    std::vector<std::string > words_verti;
    std::vector<std::string > words;
    std::vector<double> intersections;
    char grid[26][26] = {
            {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' }
    };

    int random(int from, int to)
    {
        return rand() % (to - from + 1) + from;
    }

    std::string find_intersection(std::string &first, std::string &second)
    {
        std::sort(first.begin(), first.end());
        std::sort(second.begin(), second.end());
        int length = std::min(first.length(), second.length());
        std::string result(length, ' ');
        std::set_intersection(first.begin(), first.end(), second.begin(), second.end(), result.begin());
        return result;
    }

    int PlaceHorizontal(int x, int y, std::string &word)
    {
        coord_x.push_back(x);
        coord_y.push_back(y);
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
            if (grid[x][y + j] == '.' || grid[x][y + j] == word[j])
            {
                grid[x][y + j] = word[j];
            }
            else {}
        }
    }

    int PlaceVertical(int x, int y, std::string &word)
    {
        coord_x.push_back(x);
        coord_y.push_back(y);
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
            if (grid[x + j][y] == '.' || grid[x + j][y] == word[j])
            {
                grid[x + j][y] = word[j];
            }
            else {}
        }
    }

    std::string randomword(int randomline)
    {
        std::string word1;
        std::string ifileName = "dictionary.txt";
        std::ifstream f(ifileName);

        if (!f) std::cerr << "File '" << ifileName << "' couldn't opened!\n";

        std::string s;

        for (int i = 1; i <= randomline; i++)
        {
            std::getline(f, s);
            word1 = s;

        }

        return word1;
    }

    int main(int argc, char *argv[])
    {
        string word1;
        string word2;
        string word3;
        string word4;
        string word5;
        string word6;
        string word7;
        std::string temp1;
        std::string temp2;
        std::string temp3;
        std::string temp4;
        std::string temp5;
        int x_word1_intersection;
        int x_word2_intersection;
        int x_word23_intersection;
        int x_word32_intersection;
        int x_word13_intersection;
        int x_word31_intersection;
        int x_word34_intersection;
        int x_word43_intersection;
        int x_word45_intersection;
        int x_word54_intersection;
        int x_word56_intersection;
        int x_word65_intersection;
        int x_word67_intersection;
        int x_word76_intersection;
        srand(time(0));
        int x = 8;
        int y = 8;
        int indice1 = 0;
        int indice2 = 0;
        int indice3 = 0;
        int indice4 = 0;
        int indice5 = 0;
        int indice6 = 0;
        std::string intersec1;
        std::string intersec;
        std::string intersec2;

        int n;
        std::cout << "Number of words to be placed in the grid : " << "\n";
        std::cin >> n;
        int number;

        for (int i = 0; i < n; i++)
        {
            int rand1 = random(1000, 2000);
            word1 = randomword(rand1);
            words.push_back(word1);

        }

        PlaceVertical(x, y, words[0]);

        for (int i = 1; i < words.size(); i++)
        {
            if (i % 2 == 0)
            {
                temp1 = words[i - 1];

                intersec = find_intersection(temp1, temp2);
                temp2 = words[i];
                word2 = words[i];

                words_hori.push_back(word2);
                if (i < 2)
                {
                    indice2 = 0;
                }
                else
                {
                    if (intersec[0] = intersec1[0] && intersec.length() > 0)
                    {
                        if (indice1 += 1 <= intersec.length())
                        {
                            indice2 += 1;
                        }
                    }
                    else
                    {
                        indice2 = 0;
                    }
                }

                x_word1_intersection = word1.find_last_of(intersec[indice2]);
                x_word2_intersection = word2.find_last_of(intersec[indice2]);

                PlaceHorizontal(coord_x[i - 1] + x_word2_intersection, coord_y[i - 1] - x_word1_intersection, word2);
            }

            if (i % 2 != 0)
            {
                temp2 = words[i - 1];
                temp3 = words[i];
                word3 = words[i];
                words_verti.push_back(word3);

                intersec1 = find_intersection(temp2, temp3);
                if (intersec[0] = intersec1[0] && intersec1.length() > 0)
                {
                    if (indice1 += 1 <= intersec1.length())
                    {
                        indice1 += 1;
                    }
                }
                else
                {
                    indice1 = 0;
                }

                x_word23_intersection = word2.find_last_of(intersec1[indice1]);
                x_word32_intersection = word3.find_last_of(intersec1[indice1]);

                PlaceVertical(coord_x[i - 1] - x_word23_intersection, coord_y[i - 1] + x_word32_intersection, word3);
            }
        }

        for (int i = 0; i < 26; i++)
        {
            for (int j = 0; j < 26; j++)
            {
                std::cout << grid[i][j];
                std::cout << " ";
            }

            std::cout << "\n";
        }

        std::cout << "Words placed horizontally : " << "\n";
        for (int i = 1; i < words_hori.size(); i++)
        {
            std::cout << i << ": " << words_hori[i] << "\n";
        }

        std::cout << "Words placed vertically : " << "\n";
        for (int i = 1; i < words_verti.size(); i++)
        {
            std::cout << i << ": " << words_verti[i] << "\n";
        }
    }
     
    bryonmajor, May 14, 2020
    #2
    1. Advertisements

  3. bryonmajor

    bryonmajor

    Joined:
    May 11, 2020
    Messages:
    15
    Likes Received:
    0
    Hello, there is still a lot of error, I think that the loop that alternates (even number and odd number) vertical and horizontal placement does not totally solve the recursivity problem. I think that the common letter detection is not done correctly. Then the placement loop does not check the grid cells correctly and makes the errors persist despite the if loop. If you could help me that would be nice. Thanks again.
     
    bryonmajor, May 15, 2020
    #3
  4. bryonmajor

    bryonmajor

    Joined:
    May 11, 2020
    Messages:
    15
    Likes Received:
    0
    Code (C):
    #include <iostream>
    #include <string>
    #include <algorithm>
    #include <bits/stdc++.h>
    #include <stdlib.h>
    #include <sstream>
    #include <ctime>
    #include <vector>
    using namespace std;
    std::vector<double> coord_x;
    std::vector<double> coord_y;
    std::vector<std::string > words_hori;
    std::vector<std::string > words_verti;
    std::vector<std::string > words;

    char grid[26][26] = {
            {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' }
    };

    int random(int from, int to)
    {
        return rand() % (to - from + 1) + from;
    }

    std::string find_intersection(std::string &first, std::string &second)
    {
        std::sort(first.begin(), first.end());
        std::sort(second.begin(), second.end());
        int length = std::min(first.length(), second.length());
        std::string result(length, ' ');
        std::set_intersection(first.begin(), first.end(), second.begin(), second.end(), result.begin());
        return result;
    }

    int PlaceHorizontal(int x, int y, std::string &word)
    {
        coord_x.push_back(x);
        coord_y.push_back(y);
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
            if (grid[x][y + j] == '.' || grid[x][y + j] == word[j])
            {
                grid[x][y + j] = word[j];
            }
            else {}
        }
    }

    int PlaceVertical(int x, int y, std::string &word)
    {
        coord_x.push_back(x);
        coord_y.push_back(y);
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
            if (grid[x + j][y] == '.' || grid[x + j][y] == word[j])
            {
                grid[x + j][y] = word[j];
            }
            else {}
        }
    }

    std::string randomword(int randomline)
    {
        std::string word1;
        std::string ifileName = "dictionary.txt";
        std::ifstream f(ifileName);

        if (!f) std::cerr << "File '" << ifileName << "' couldn't opened!\n";

        std::string s;

        for (int i = 1; i <= randomline; i++)
        {
            std::getline(f, s);
            word1 = s;

        }

        return word1;
    }

    int main(int argc, char *argv[])
    {
        string word1;
        string word2;
        string word3;

        std::string temp1;
        std::string temp2;
        std::string temp3;
        int x_word1_intersection;
        int x_word2_intersection;
        int x_word23_intersection;
        int x_word32_intersection;

        srand(time(0));
        int x = 8;
        int y = 8;
        int indice1 = 0;
        int indice2 = 0;

        std::string intersec1;
        std::string intersec;
        std::string replace;

        int n;
        std::cout << "Number of words to be placed in the grid : " << "\n";
        std::cin >> n;
        int number;

        for (int i = 0; i < n; i++)
        {
            int rand1 = random(2000, 4000);
            word1 = randomword(rand1);
            words.push_back(word1);

        }

        PlaceVertical(x, y, words[0]);

        for (int i = 1; i < words.size(); i++)
        {
            if (i % 2 == 0)
            {
                temp1 = words[i - 1];
                temp2 = words[i];
                word2 = words[i];

                intersec = find_intersection(temp1, temp2);
                if (intersec.empty())
                {
                    int rand2 = random(2000, 4000);
                    replace = randomword(rand2);
                    word2 = replace;
                    std::replace(words.begin(), words.end(), temp2, replace);
                    intersec = find_intersection(temp1, temp2);
                }

                words_hori.push_back(word2);
                if (i < 2)
                {
                    indice2 = 0;
                }
                else
                {
                    if (intersec[0] = intersec1[0] && intersec.length() > 0)
                    {
                        if (indice1 += 1 <= intersec.length())
                        {
                            indice2 += 1;
                        }
                    }
                    else
                    {
                        indice2 = 0;
                    }
                }

                x_word1_intersection = word1.find_last_of(intersec[indice2]);
                x_word2_intersection = word2.find_last_of(intersec[indice2]);

                PlaceHorizontal(coord_x[i - 1] + x_word2_intersection, coord_y[i - 1] - x_word1_intersection, word2);
            }

            if (i % 2 != 0)
            {
                temp2 = words[i - 1];
                temp3 = words[i];
                word3 = words[i];
                words_verti.push_back(word3);

                intersec1 = find_intersection(temp2, temp3);
                if (intersec1.empty())
                {
                    int rand3 = random(2000, 4000);
                    replace = randomword(rand3);
                    word3 = replace;
                    std::replace(words.begin(), words.end(), temp3, replace);
                    intersec1 = find_intersection(temp2, temp3);
                }

                if (intersec[0] = intersec1[0] && intersec1.length() > 0)
                {
                    if (indice1 += 1 <= intersec1.length())
                    {
                        indice1 += 1;
                    }
                }
                else
                {
                    indice1 = 0;
                }

                x_word23_intersection = word2.find_last_of(intersec1[indice1]);
                x_word32_intersection = word3.find_last_of(intersec1[indice1]);

                PlaceVertical(coord_x[i - 1] - x_word23_intersection, coord_y[i - 1] + x_word32_intersection, word3);
            }
        }

        for (int i = 0; i < 26; i++)
        {
            for (int j = 0; j < 26; j++)
            {
                std::cout << grid[i][j];
                std::cout << " ";
            }

            std::cout << "\n";
        }

        std::cout << "Words placed horizontally : " << "\n";
        for (int i = 1; i < words_hori.size(); i++)
        {
            std::cout << i << ": " << words_hori[i] << "\n";
        }

        std::cout << "Words placed vertically : " << "\n";
        for (int i = 1; i < words_verti.size(); i++)
        {
            std::cout << i << ": " << words_verti[i] << "\n";
        }

        words.clear();
    }

     
     
    bryonmajor, May 15, 2020
    #4
  5. bryonmajor

    bryonmajor

    Joined:
    May 11, 2020
    Messages:
    15
    Likes Received:
    0
    Hello, I've made some progress: I made a scoring of the places assigned to the current word and a search for the intersection letter if the score is bad.

    Code (C):
    #include <iostream>
    #include <string>
    #include <algorithm>
    #include <bits/stdc++.h>
    #include <stdlib.h>
    #include <sstream>
    #include <ctime>
    #include <vector>
    using namespace std;
    std::vector<double> coord_x;
    std::vector<double> coord_y;
    std::vector<std::string > words;
    //vector to know how the word is placed in the grid vertically or horizontally (v / h)
    std::vector<std::string > place;
    constexpr char empty = '.';
    char grid[26][26] = {
            {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' }
    };
    //Random number generating function
    int random(int from, int to)
    {
        return rand() % (to - from + 1) + from;
    }

    //Function searching for letters common to two words
    std::string find_intersection(std::string &first, std::string &second)
    {
        std::sort(first.begin(), first.end());
        std::sort(second.begin(), second.end());
        int length = std::min(first.length(), second.length());
        std::string result(length, ' ');
        std::set_intersection(first.begin(), first.end(), second.begin(), second.end(), result.begin());
        return result;
    }

    //Horizontal word placement function
    int PlaceHorizontal(int x, int y, int id_word, std::string &word)
    {
        int x_word1_intersection;
        int x_word2_intersection;
        std::string intersec;
        std::string temp1 = word;
        std::string temp2;
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
            char letter_in_grid = grid[x][y + j];
            if (letter_in_grid == empty || letter_in_grid == word[j])
            {
                grid[x][y + j] = word[j];
                coord_x.push_back(x);
                coord_y.push_back(y);
                place.push_back("h");
            }
            else {}
        }
    }

    //Function placing words vertically
    int PlaceVertical(int x, int y, int id_word, std::string &word)
    {
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
            char letter_in_grid = grid[x + j][y];
            if (letter_in_grid == empty || letter_in_grid == word[j])
            {
                grid[x + j][y] = word[j];
                coord_x.push_back(x);
                coord_y.push_back(y);
                place.push_back("v");

            }
            else {}
        }
    }
    //function that assigns a score to the place chosen for the word
    int can_place(int x, int y, int id_word, std::string &word)
    {
        int score = 0;
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
            if (place[id_word - 1] == "h")
            {
                char letter_in_grid = grid[x + j][y];
                if (letter_in_grid == empty || letter_in_grid == word[j])
                {
                    score = score + 1;
                }
                else
                {
                    score = score - 1;
                }
            }

            if (place[id_word - 1] == "v")
            {
                char letter_in_grid = grid[x][y + j];
                if (letter_in_grid == empty || letter_in_grid == word[j])
                {
                    score = score + 1;
                }
                else
                {
                    score = score - 1;
                }
            }
        }

        return score;

    }

    //Function randomly retrieving words from the dictionary
    std::string randomword(int randomline)
    {
        std::string word1;
        std::string ifileName = "dictionary.txt";
        std::ifstream f(ifileName);

        if (!f) std::cerr << "File '" << ifileName << "' couldn't opened!\n";

        std::string s;

        for (int i = 1; i <= randomline; i++)
        {
            std::getline(f, s);
            std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c)
            {
                return std::tolower(c);
        });
            word1 = s;

        }

        return word1;
    }
    int main(int argc, char *argv[])
    {
        string word1;
        string word2;
        string word3;
        int score;
        int x_replace;
        int y_replace;
        std::string temp1;
        std::string temp2;
        std::string temp3;
        int x_word1_intersection;
        int x_word2_intersection;
        int x_word23_intersection;
        int x_word32_intersection;

        srand(time(0));
        int x = 8;
        int y = 8;
        int indice1 = 0;
        int indice2 = 0;

        std::string intersec1;
        std::string intersec;
        std::string replace;
        int n;
        int rand0 = random(4, 40);
        n = rand0;

        int number;
        //random word retrieval and addition to vector
        for (int i = 0; i < n; i++)
        {
            int rand1 = random(2000, 4000);
            word1 = randomword(rand1);
            words.push_back(word1);

        }

        //first word placement
        PlaceVertical(x, y, 0, words[0]);
        intersec1 = "";

        for (int i = 1; i < words.size(); i++)
        {
            temp1 = words[i - 1];
            temp2 = words[i];
            word2 = words[i];
            //if there is no common letter between the two words running to look for a new word
            intersec = find_intersection(temp1, temp2);
            if (intersec.empty())
            {
                int rand2 = random(2000, 4000);
                replace = randomword(rand2);
                word2 = replace;
                std::replace(words.begin(), words.end(), temp2, replace);
                intersec = find_intersection(temp1, temp2);
            }

            if (i < 2)
            {
                indice2 = 0;
            }
            else
            {
                //if the letters common to the two previous words are the same as for the two current words change the common letter if possible
                if (intersec[0] == intersec1[0] && intersec.length() > 0)
                {
                    if (indice2 + 1 <= intersec.length())
                    {
                        indice2 = indice2 + 1;
                    }
                }
                else
                {
                    indice2 = 0;
                }
            }

            x_word1_intersection = word1.find_last_of(intersec[indice2]);
            x_word2_intersection = word2.find_last_of(intersec[indice2]);
                    //if the number i is even
            if (i % 2 == 0)
            {
                score = can_place(coord_x[i - 1] + x_word2_intersection, coord_y[i - 1] - x_word1_intersection, i, word2);
                            //if the score is equal to the size of the word place the word normally
                if (score == word2.length())
                {
                    PlaceHorizontal(coord_x[i - 1] + x_word2_intersection, coord_y[i - 1] - x_word1_intersection, i, word2);
                }
                            //Otherwise look for the common letter in the grid and place the word if the score is equal to the size of the word.
                else
                {
                    for (int i = 0; i < 26; i++)
                    {
                        for (int j = 0; j < 26; j++)
                        {
                            if (grid[i][j] == intersec[indice2])
                            {
                                x_replace = i;
                                y_replace = j;
                            }
                        }
                    }

                    score = can_place(x_replace + x_word2_intersection, y_replace, i, word2);
                    if (score == word2.length())
                    {
                        PlaceHorizontal(x_replace + x_word2_intersection, y_replace, i, word2);
                    }
                }
            }
                    //if the number i is odd
            if (i % 2 != 0)
            {
                score = can_place(coord_x[i - 1] - x_word1_intersection, coord_y[i - 1] + x_word2_intersection, i, word2);
                            //if the score is equal to the size of the word place the word normally
                if (score == word2.length())
                {
                    PlaceVertical(coord_x[i - 1] - x_word1_intersection, coord_y[i - 1] + x_word2_intersection, i, word2);
                }
                            //Otherwise look for the common letter in the grid and place the word if the score is equal to the size of the word.
                else
                {
                    for (int i = 0; i < 26; i++)
                    {
                        for (int j = 0; j < 26; j++)
                        {
                            if (grid[i][j] == intersec[indice2])
                            {
                                x_replace = i;
                                y_replace = j;
                            }
                        }
                    }

                    score = can_place(x_replace, y_replace + x_word2_intersection, i, word2);
                    if (score == word2.length())
                    {
                        PlaceVertical(x_replace, y_replace + x_word2_intersection, i, word2);
                    }
                }
            }
        }

        //grid view
        for (int i = 0; i < 26; i++)
        {
            for (int j = 0; j < 26; j++)
            {
                std::cout << grid[i][j];
                std::cout << " ";
            }

            std::cout << "\n";
        }

        words.clear();

    }
     
    bryonmajor, May 22, 2020
    #5
  6. bryonmajor

    bryonmajor

    Joined:
    May 11, 2020
    Messages:
    15
    Likes Received:
    0
    I think it works pretty well with a random number of words and the best placement possible. There are still some bugs, but it works overall.
    Code (C):
    #include <iostream>
    #include <string>
    #include <algorithm>
    #include <bits/stdc++.h>
    #include <stdlib.h>
    #include <sstream>
    #include <ctime>
    #include <vector>
    using namespace std;
    std::vector<double> coord_x;
    std::vector<double> coord_y;

    std::vector<double> temporary_coord_x;
    std::vector<double> temporary_coord_y;

    std::vector<std::string > words;
    //vector to know how the word is placed in the grid vertically or horizontally (v / h)
    std::vector<std::string > place;
    constexpr char empty = '.';
    char grid[26][26] = {
            {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' }
    };
    //Random number generating function
    int random(int from, int to)
    {
        return rand() % (to - from + 1) + from;
    }

    //Function searching for letters common to two words
    std::string find_intersection(std::string &first, std::string &second)
    {
        std::sort(first.begin(), first.end());
        std::sort(second.begin(), second.end());
        int length = std::min(first.length(), second.length());
        std::string result(length, ' ');
        std::set_intersection(first.begin(), first.end(), second.begin(), second.end(), result.begin());
        return result;
    }

    //Horizontal word placement function
    int PlaceHorizontal(int x, int y, int id_word, std::string &word)
    {
        int x_word1_intersection;
        int x_word2_intersection;
        std::string intersec;
        std::string temp1 = word;
        std::string temp2;
        int taille = word.length();
        for (int j = 0; j <= taille; j++)
        {
            char letter_in_grid = grid[x][y + j];
            if (letter_in_grid == empty || letter_in_grid == word[j])
            {
                grid[x][y + j] = word[j];
                coord_x.push_back(x);
                coord_y.push_back(y);
                place.push_back("h");
            }
            else {}
        }
    }

    //Function placing words vertically
    int PlaceVertical(int x, int y, int id_word, std::string &word)
    {
        int taille = word.length();
        for (int j = 0; j <= taille; j++)
        {
            char letter_in_grid = grid[x + j][y];
            if (letter_in_grid == empty || letter_in_grid == word[j])
            {
                grid[x + j][y] = word[j];
                coord_x.push_back(x);
                coord_y.push_back(y);
                place.push_back("v");
            }
            else {}
        }
    }
    //function that assigns a score to the place chosen for the word
    int can_place(int x, int y, int id_word, std::string &word)
    {
        int score = 0;
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
                   //if the previous word is placed horizontally place the word vertically
            if (place[id_word - 1] == "h")
            {
                char letter_in_grid = grid[x + j][y];
                if (letter_in_grid == empty || letter_in_grid == word[j])
                {
                    score = score + 1;
                }
                else
                {
                    score = score - 1;
                }
            }
                    //if the previous word is placed vertically place the word horizontally
            if (place[id_word - 1] == "v")
            {
                char letter_in_grid = grid[x][y + j];
                if (letter_in_grid == empty || letter_in_grid == word[j])
                {
                    score = score + 1;
                }
                else
                {
                    score = score - 1;
                }
            }
        }

        return score;

    }

    //Function randomly retrieving words from the dictionary
    std::string randomword(int randomline)
    {
        std::string word1;
        std::string ifileName = "dictionary.txt";
        std::ifstream f(ifileName);

        if (!f) std::cerr << "File '" << ifileName << "' couldn't opened!\n";

        std::string s;

        for (int i = 1; i <= randomline; i++)
        {
            std::getline(f, s);
            std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c)
            {
                return std::tolower(c);
        });
            word1 = s;
        }

        return word1;
    }
    int main(int argc, char *argv[])
    {
        string word1;
        string word2;
        string word3;
        int score;
        int x_replace;
        int y_replace;
        std::string temp1;
        std::string temp2;
        std::string temp3;
        int x_word1_intersection;
        int x_word2_intersection;
        int x_word23_intersection;
        int x_word32_intersection;

        srand(time(0));
        int x = 8;
        int y = 8;
        int indice1 = 0;
        int indice2 = 0;

        std::string intersec1;
        std::string intersec;
        std::string replace;
        int n;
        int rand0 = random(4, 40);
        n = rand0;

        int number;
        //random word retrieval and addition to vector
        for (int i = 0; i < n; i++)
        {
            int rand1 = random(2000, 4000);
            word1 = randomword(rand1);
            words.push_back(word1);
        }

        //first word placement
        PlaceVertical(x, y, 0, words[0]);
        intersec1 = "";

        for (int i = 1; i < words.size(); i++)
        {
            temp1 = words[i - 1];
            temp2 = words[i];
            word2 = words[i];
            //if there is no common letter between the two words running to look for a new word
            intersec = find_intersection(temp1, temp2);
            if (intersec.empty())
            {
                int rand2 = random(2000, 4000);
                replace = randomword(rand2);
                word2 = replace;
                std::replace(words.begin(), words.end(), temp2, replace);
                intersec = find_intersection(temp1, temp2);
            }

            if (i < 2)
            {
                indice2 = 0;
            }
            else
            {
                //if the letters common to the two previous words are the same as for the two current words change the common letter if possible
                if (intersec[0] == intersec1[0] && intersec.length() > 0)
                {
                    if (indice2 + 1 <= intersec.length())
                    {
                        indice2 = indice2 + 1;
                    }
                }
                else
                {
                    indice2 = 0;
                }
            }

            x_word1_intersection = word1.find_last_of(intersec[indice2]);
            x_word2_intersection = word2.find_last_of(intersec[indice2]);
            //if the number i is even
            if (i % 2 == 0)
            {
                score = can_place(coord_x[i - 1] + x_word2_intersection, coord_y[i - 1] - x_word1_intersection, i, word2);
                //if the score is equal to the size of the word place the word normally
                if (score == word2.length())
                {
                    PlaceHorizontal(coord_x[i - 1] + x_word2_intersection, coord_y[i - 1] - x_word1_intersection, i, word2);
                }
                //Otherwise search each letter of the word test the position and record the position
                else
                {
                    for (int k = 0; k <= word2.length(); k++)
                    {
                        for (int i = 0; i < 26; i++)
                        {
                            for (int j = 0; j < 26; j++)
                            {
                                if (grid[i][j] == word2[k])
                                {

                                    temporary_coord_x.push_back(i);
                                    temporary_coord_y.push_back(j);
                                }
                            }
                        }
                    }
                    //note all previously saved positions - if the score is equal to the size of the word place the word
                    for (int l = 0; l != temporary_coord_x.size(); l++)
                    {
                        score = can_place(temporary_coord_x[l] + x_word2_intersection, temporary_coord_y[l], i, word2);
                        if (score == word2.length())
                        {
                            x_replace = temporary_coord_x[l];
                            y_replace = temporary_coord_y[l];
                        }
                    }
                    PlaceHorizontal(x_replace + x_word2_intersection, y_replace, i, word2);
                    temporary_coord_x.clear();
                    temporary_coord_y.clear();
                }
            }
            //if the number i is odd
            if (i % 2 != 0)
            {
                score = can_place(coord_x[i - 1] - x_word1_intersection, coord_y[i - 1] + x_word2_intersection, i, word2);
                //if the score is equal to the size of the word place the word normally
                if (score == word2.length())
                {
                    PlaceVertical(coord_x[i - 1] - x_word1_intersection, coord_y[i - 1] + x_word2_intersection, i, word2);
                }
                //Otherwise search each letter of the word test the position and record the position
                else
                {
                    for (int k = 0; k <= word2.length(); k++)
                    {
                        for (int i = 0; i < 26; i++)
                        {
                            for (int j = 0; j < 26; j++)
                            {
                                if (grid[i][j] == word2[k])
                                {
                                    temporary_coord_x.push_back(i);
                                    temporary_coord_y.push_back(j);
                                }
                            }
                        }
                    }
                                    //note all previously saved positions - if the score is equal to the size of the word place the word
                    for (int l = 0; l != temporary_coord_x.size(); l++)
                    {
                        score = can_place(temporary_coord_x[l], temporary_coord_y[l] + x_word2_intersection, i, word2);
                        if (score == word2.length())
                        {
                            x_replace = temporary_coord_x[l];
                            y_replace = temporary_coord_y[l];
                        }
                    }
                    PlaceVertical(x_replace, y_replace + x_word2_intersection, i, word2);
                    temporary_coord_x.clear();
                    temporary_coord_y.clear();
                }
            }
        }

        //grid view
        for (int i = 0; i < 26; i++)
        {
            for (int j = 0; j < 26; j++)
            {
                std::cout << grid[i][j];
                std::cout << " ";
            }

            std::cout << "\n";
        }

        words.clear();

    }
     
     
    bryonmajor, May 22, 2020
    #6
  7. bryonmajor

    bryonmajor

    Joined:
    May 11, 2020
    Messages:
    15
    Likes Received:
    0
    Hello there's the end of the story!

    Code (C):
    #include <iostream>
    #include <string>
    #include <algorithm>
    #include <bits/stdc++.h>
    #include <stdlib.h>
    #include <sstream>
    #include <ctime>
    #include <vector>
    using namespace std;
    std::vector<double> coord_x;
    std::vector<double> coord_y;
    std::vector<double> intersec_temp1; //I think it's unused.
    std::vector<double> intersec_temp2; //I think it's unused.
    std::vector<double> intersec_temp3; //I think it's unused.
    std::vector<double> intersec_temp4; //I think it's unused.

    //Vectors for recording word coordinates
    std::vector<double> temporary_coord_x;
    std::vector<double> temporary_coord_y;

    std::vector<std::string > words;
    //vector to know how the word is placed in the grid vertically or horizontally (v / h)
    std::vector<std::string > place;
    constexpr char empty = '.';
    char grid[26][26] = {
            {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' },
        {
            '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.' }
    };
    //Random number generating function
    int random(int from, int to)
    {
        return rand() % (to - from + 1) + from;
    }

    //Function searching for letters common to two words
    std::string find_intersection(std::string &first, std::string &second)
    {
        std::sort(first.begin(), first.end());
        std::sort(second.begin(), second.end());
        int length = std::min(first.length(), second.length());
        std::string result(length, ' ');
        std::set_intersection(first.begin(), first.end(), second.begin(), second.end(), result.begin());
        return result;
    }

    //Horizontal word placement function
    int PlaceHorizontal(int x, int y, int id_word, std::string &word)
    {
        int x_word1_intersection;
        int x_word2_intersection;
        std::string intersec;
        std::string temp1 = word;
        std::string temp2;
        int taille = word.length();
        for (int j = 0; j <= taille; j++)
        {
            char letter_in_grid = grid[x][y + j];
            if (letter_in_grid == empty || letter_in_grid == word[j])
            {
                grid[x][y + j] = word[j];
                coord_x.push_back(x);
                coord_y.push_back(y);
                place.push_back("h");
            }
            else {}
        }
    }

    //Function placing words vertically
    int PlaceVertical(int x, int y, int id_word, std::string &word)
    {
        int taille = word.length();
        for (int j = 0; j <= taille; j++)
        {
            char letter_in_grid = grid[x + j][y];
            if (letter_in_grid == empty || letter_in_grid == word[j])
            {
                grid[x + j][y] = word[j];
                coord_x.push_back(x);
                coord_y.push_back(y);
                place.push_back("v");
            }
            else {}
        }
    }

    //function that assigns a score to the place chosen for the word
    int can_place(int x, int y, int id_word, std::string &word)
    {
        int score = 0;
        int taille = word.length();
        for (int j = 0; j != taille; j++)
        {
            //if the previous word is placed horizontally place the word vertically
            if (place[id_word - 1] == "h")
            {
                char letter_in_grid_v = grid[x + j][y];
                if (letter_in_grid_v == empty || letter_in_grid_v == word[j])
                {
                    score = score + 1;
                }
                else
                {
                    score = score - 1;
                }
            }

            //if the previous word is placed vertically place the word horizontally
            if (place[id_word - 1] == "v")
            {
                char letter_in_grid_h = grid[x][y + j];
                if (letter_in_grid_h == empty || letter_in_grid_h == word[j])
                {
                    score = score + 1;
                }
                else
                {
                    score = score - 3;
                }
            }
        }

        return score;

    }

    //Function randomly retrieving words from the dictionary
    std::string randomword(int randomline)
    {
        std::string word1;
        std::string ifileName = "dictionary.txt";
        std::ifstream f(ifileName);

        if (!f) std::cerr << "File '" << ifileName << "' couldn't opened!\n";

        std::string s;

        for (int i = 1; i <= randomline; i++)
        {
            std::getline(f, s);
            std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c)
            {
                return std::tolower(c);
        });
            word1 = s;
        }

        return word1;
    }

    int main(int argc, char *argv[])
    {
        string word1;
        string word2;
        string word3;
        int score;
        int x_replace;
        int y_replace;
        std::string temp1;
        std::string temp2;
        std::string temp3;
        int x_word1_intersection;
        int x_word2_intersection;
        int x_word23_intersection;
        int x_word32_intersection;

        srand(time(0));
        int x = 8;
        int y = 8;
        int indice1 = 0;
        int indice2 = 0;

        std::string intersec;
        std::string intersec1; //I think it's unused.
        std::string replace;

        //number of words to be placed in the grid
        int n;
        int rand0 = random(15, 40);
        n = rand0;

        int number;
        //random word retrieval and addition to vector
        for (int i = 0; i < n; i++)
        {
            //depending on the size of the dictionary
            int rand1 = random(2000, 4000);
            word1 = randomword(rand1);
            words.push_back(word1);
        }

        //first word placement
        PlaceVertical(x, y, 0, words[0]);

        for (int i = 1; i < words.size(); i++)
        {
            temp1 = words[i - 1];
            temp2 = words[i];
            word2 = words[i];

            intersec = find_intersection(temp1, temp2);
            while (intersec.empty())
            {
                int rand2 = random(2000, 4000);
                replace = randomword(rand2);
                word2 = replace;
                std::replace(words.begin(), words.end(), temp2, replace);
                intersec = find_intersection(temp1, temp2);
            }
            //for all intersecting letters, test the position
            for (int j = 0; j < intersec.length(); j++)
            {
                int temp_intersec_1 = word1.find_last_of(intersec[j]);
                int temp_intersec_2 = word2.find_last_of(intersec[j]);
                score = can_place(coord_x[i - 1] + temp_intersec_2, coord_y[i - 1] - temp_intersec_1, i, word2);
                if (score == word2.length())
                {
                    x_word1_intersection = word1.find_last_of(intersec[j]);
                    x_word2_intersection = word2.find_last_of(intersec[j]);
                }
            }
            //if the number i is odd
            if (i % 2 != 0)
            {
                score = can_place(coord_x[i - 1] + x_word2_intersection, coord_y[i - 1] - x_word1_intersection, i, word2);
                //if the score is equal to the size of the word place the word normally
                if (score == word2.length())
                {
                    PlaceHorizontal(coord_x[i - 1] + x_word2_intersection, coord_y[i - 1] - x_word1_intersection, i, word2);
                }

                //Otherwise search each letter of the word test the position and record the position
                else
                {
                    for (int k = 0; k <= word2.length(); k++)
                    {
                        for (int i = 0; i < 26; i++)
                        {
                            for (int j = 0; j < 26; j++)
                            {
                                if (grid[i][j] == empty || grid[i][j] == word2[k])
                                {
                                    temporary_coord_x.push_back(i);
                                    temporary_coord_y.push_back(j);
                                }
                            }
                        }
                    }

                    //note all previously saved positions - if the score is equal to the size of the word place the word
                    for (int l = 0; l != temporary_coord_x.size(); l++)
                    {
                        score = can_place(temporary_coord_x[l] + x_word2_intersection, temporary_coord_y[l], i, word2);
                        if (score == word2.length())
                        {
                            x_replace = temporary_coord_x[l];
                            y_replace = temporary_coord_y[l];
                        }
                        else {}
                    }
                    //word placement
                    PlaceHorizontal(x_replace + x_word2_intersection, y_replace, i, word2);
                    temporary_coord_x.clear();
                    temporary_coord_y.clear();
                }
            }
            //if the number i is even
            if (i % 2 == 0)
            {
                score = can_place(coord_x[i - 1] - x_word1_intersection, coord_y[i - 1] + x_word2_intersection, i, word2);
                //if the score is equal to the size of the word place the word normally
                if (score == word2.length())
                {
                    PlaceVertical(coord_x[i - 1] - x_word1_intersection, coord_y[i - 1] + x_word2_intersection, i, word2);
                }

                //Otherwise search each letter of the word test the position and record the position
                else
                {
                    for (int k = 0; k <= word2.length(); k++)
                    {
                        for (int i = 0; i < 26; i++)
                        {
                            for (int j = 0; j < 26; j++)
                            {
                                if (grid[i][j] == empty || grid[i][j] == word2[k])
                                {
                                    temporary_coord_x.push_back(i);
                                    temporary_coord_y.push_back(j);
                                }
                            }
                        }
                    }

                    //note all previously saved positions - if the score is equal to the size of the word place the word
                    for (int l = 0; l != temporary_coord_x.size(); l++)
                    {
                        score = can_place(temporary_coord_x[l], temporary_coord_y[l] + x_word2_intersection, i, word2);
                        if (score == word2.length())
                        {
                            x_replace = temporary_coord_x[l];
                            y_replace = temporary_coord_y[l];
                        }
                        else {}
                    }
                    //word placement
                    PlaceVertical(x_replace, y_replace + x_word2_intersection, i, word2);
                    temporary_coord_x.clear();
                    temporary_coord_y.clear();
                }
            }
        }

        //grid view
        for (int i = 0; i < 26; i++)
        {
            for (int j = 0; j < 26; j++)
            {
                std::cout << grid[i][j];
                std::cout << " ";
            }

            std::cout << "\n";
        }
        //cleaning the vector containing the words to prevent certain words
        //from remaining in memory the next time the program is executed
        words.clear();

    }
     
    Last edited: May 23, 2020
    bryonmajor, May 23, 2020
    #7
  8. bryonmajor

    bryonmajor

    Joined:
    May 11, 2020
    Messages:
    15
    Likes Received:
    0
    I've had a lot of difficulty, but I hope this will help those who would like to look into the problem. Code one day always code !
     
    bryonmajor, May 23, 2020
    #8
    1. Advertisements

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.