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
  9. bryonmajor

    codingd

    Joined:
    Jun 12, 2020
    Messages:
    6
    Likes Received:
    0
    Sorry, I lost my previous logins. My code has improved a lot. It works properly.

    You can decrease the number of words to be placed in the grid by decreasing the range of this line at the beginning of the main function of the program :

    int rand0 = random(20, 30);

    And the range to choose a word at random or to replace a word must be adapted to the size of your dictionary:

    int rand3 = random(100, 20000);

    Indeed the dictionary I use is about 22000 lines which explains this line.
     
    codingd, Jun 12, 2020
    #9
  10. bryonmajor

    codingd

    Joined:
    Jun 12, 2020
    Messages:
    6
    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;

    //Vectors for recording word coordinates
    std::vector<double> coord_col;
    std::vector<double> coord_row;
    //Vectors for recording words
    std::vector<std::string > words_vect;

    constexpr char empty = '.';
    constexpr int GridSize = 26;
    char grid[GridSize][GridSize];

    //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
    void PlaceHorizontal(int col, int row, int id_word, std::string &word)
    {
        coord_col.push_back(col);
        coord_row.push_back(row);
        unsigned taille = word.length();
        for (unsigned int j = 0; j < taille; j++)
        {
            grid[col][row + j] = word[j];
        }
    }

    //Function placing words vertically
    void PlaceVertical(int col, int row, int id_word, std::string &word)
    {
        coord_col.push_back(col);
        coord_row.push_back(row);
        unsigned taille = word.length();
        for (unsigned int j = 0; j < taille; j++)
        {
            grid[col + j][row] = word[j];
        }
    }

    //function that assigns a score to the place chosen for the word
    bool can_place(int col, int row, int id_word, std::string &word)
    {
        int score = 0;
        unsigned taille = word.length();

        if (id_word % 2 != 0)
        {
            if (col < 0 || col >= GridSize || row < 0 || row + taille >= GridSize) return false;
            for (unsigned int j = 0; j < taille; j++)
            {
                char word_letter = word[j];
                if (grid[col][row + j] == empty)
                {
                    score = score + 1;
                }
                else if (grid[col][row + j] != word_letter)
                {
                    return false;
                }
            }
        }
        else if (id_word % 2 == 0)
        {
            if (col < 0 || col + taille >= GridSize || row < 0 || row >= GridSize) return false;

            for (unsigned int j = 0; j < taille; j++)
            {
                char word_letter = word[j];
                if (grid[col + j][row] == empty)
                {
                    score = score + 1;
                }
                else if (grid[col + j][row] != word_letter)
                {
                    return false;
                }
            }
        }

        if (score < taille)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    //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;
    }

    void replace_word(std::string &current_word)
    {
        int rand3 = random(100, 20000);
        std::string replacement = randomword(rand3);
        std::replace(words_vect.begin(), words_vect.end(), current_word, replacement);

    }

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

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

    int Align(float value, float size)
    {
        int pos = (size / 2) - value;
        return pos;
    }

    int main(int argc, char *argv[])
    {
        srand(time(0));
        memset(grid, '.', sizeof(grid));
        bool place_v = false;
        bool place_h = false;
        int n;
        //number of words to place
        int rand0 = random(20, 30);
        int num = rand0;

        //position of the horizontal and vertical intersection letter
        int x_word2_intersection_h;
        int x_word1_intersection_h;
        int x_word2_intersection_v;
        int x_word1_intersection_v;
        std::string prec_word;
        std::string current_word;
        int temp_intersec_2;
        int temp_intersec_1;
        //score for horizontal and vertical positioning
        bool score_h = false;
        bool score_v = false;

        //random word retrieval and addition to vector
        for (unsigned int i = 0; i < num; i++)
        {
            //depending on the size of the dictionary
            int rand1 = random(100, 20000);
            std::string word1 = randomword(rand1);
            words_vect.push_back(word1);
        }

        std::string word1 = words_vect[0];
        unsigned len_word1 = word1.length();

        int pos_word1 = Align(len_word1, GridSize);
        PlaceVertical(pos_word1, (GridSize / 2), 0, words_vect[0]);

        for (unsigned int k = 1; k < words_vect.size(); k++)
        {
            back:
                // start of testing
                prec_word = words_vect[k - 1];
            current_word = words_vect[k];
            std::string intersec = find_intersection(words_vect[k - 1], words_vect[k]);

            if (intersec.empty())
            {
                std::cout << " Replacing current word " << words_vect[k] << "\n";
                replace_word(current_word);
                goto back;
            }
            else
            {
                //for each intersecting letter of the word in the vector
                for (unsigned int j = 0; j < intersec.length(); j++)
                {
                     //temporary position of the selected intersection letter

                    if (k % 2 != 0)
                    {
                        temp_intersec_2 = current_word.find_last_of(intersec[j]);
                        temp_intersec_1 = prec_word.find_last_of(intersec[j]);
                        score_h = can_place(coord_col[k - 1] + temp_intersec_2, coord_row[k - 1] - temp_intersec_1, k, current_word);
                        //if the horizontal score of the position is equal to the size of the word

                        if (score_h && k % 2 != 0)
                        {
                            place_h = true;
                            std::cout << " Testing word " << k << "/" << num << "\n";
                            std::cout << " Current word1 " << prec_word << " Current word2 " << current_word << "\n";
                            std::cout << "-----" << "\n";
                            x_word2_intersection_h = temp_intersec_2;
                            x_word1_intersection_h = temp_intersec_1;
                            goto placing_word;
                        }
                        else
                        {
                            place_h = false;
                        }
                    }

                    if (k % 2 == 0)
                    {
                        temp_intersec_2 = current_word.find_last_of(intersec[j]);
                        temp_intersec_1 = prec_word.find_last_of(intersec[j]);
                        score_v = can_place(coord_col[k - 1] - temp_intersec_1, coord_row[k - 1] + temp_intersec_2, k, current_word);

                        //if the vertical score of the position is equal to the size of the word

                        if (score_v && k % 2 == 0)
                        {
                            place_v = true;
                            std::cout << " Testing word " << k << "/" << num << "\n";
                            std::cout << " Current word1 " << prec_word << " Current word2 " << current_word << "\n";
                            std::cout << "-----" << "\n";
                            x_word2_intersection_v = temp_intersec_2;
                            x_word1_intersection_v = temp_intersec_1;
                            goto placing_word;
                        }
                        else
                        {
                            place_v = false;
                        }
                    }
                }
            }

            placing_word:

                if (place_h && k % 2 != 0)
                {
                    PlaceHorizontal(coord_col[k - 1] + x_word2_intersection_h, coord_row[k - 1] - x_word1_intersection_h, k, current_word);
                }
            else if (!place_h && k % 2 != 0)
            {
                std::cout << " Replacing current word " << words_vect[k] << "\n";
                replace_word(words_vect[k]);
                goto back;
            }

            if (place_v && k % 2 == 0)
            {
                PlaceVertical(coord_col[k - 1] - x_word1_intersection_v, coord_row[k - 1] + x_word2_intersection_v, k, current_word);
            }
            else if (!place_v && k % 2 == 0)
            {
                std::cout << " Replacing current word " << words_vect[k] << "\n";
                replace_word(words_vect[k]);
                goto back;
            }
        }

        showGrid();

        words_vect.clear();
    }
     
    codingd, Jun 12, 2020
    #10
  11. bryonmajor

    codingd

    Joined:
    Jun 12, 2020
    Messages:
    6
    Likes Received:
    0
    Even better! lol Don't worry, I have help... Because I'm a beginner too. But I think it's important to share the code! My superhero is dhayden, whom I thank very much.

    Code (C):
    #include <iostream>

    #include <string>

    #include <algorithm>

    #include <bits/stdc++.h>

    #include <stdlib.h>

    #include <sstream>

    #include <ctime>

    #include <vector>

    using namespace std;

    //Vectors for recording word coordinates
    std::vector < double > coord_col;
    std::vector < double > coord_row;
    //Vectors for recording words
    std::vector < std::string > words_vect;

    constexpr char empty = '.';
    constexpr int GridSize = 26;
    char grid[GridSize][GridSize];

    //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
    //Horizontal word placement function
    void PlaceHorizontal(int col, int row, int id_word, std::string & word) {
      words_vect.push_back(word);
      coord_col.push_back(col);
      coord_row.push_back(row);
      unsigned taille = word.length();
      for (unsigned int j = 0; j < taille; j++) {
        grid[col][row + j] = word[j];
      }
    }

    //Function placing words vertically
    void PlaceVertical(int col, int row, int id_word, std::string & word) {
      words_vect.push_back(word);
      coord_col.push_back(col);
      coord_row.push_back(row);
      unsigned taille = word.length();
      for (unsigned int j = 0; j < taille; j++) {
        grid[col + j][row] = word[j];
      }
    }

    //function that assigns a score to the place chosen for the word
    bool can_place(int col, int row, int id_word, std::string & word) {
      int score = 0;
      unsigned taille = word.length();

      if (id_word % 2 != 0) {
        if (col < 0 || col >= GridSize || row < 0 || row + taille >= GridSize) return false;
        for (unsigned int j = 0; j < taille; j++) {
          char word_letter = word[j];
          if (grid[col][row + j] == empty) {
            score = score + 1;
          } else if (grid[col][row + j] != word_letter) {
            return false;
          }
        }
      } else if (id_word % 2 == 0) {
        if (col < 0 || col + taille >= GridSize || row < 0 || row >= GridSize) return false;

        for (unsigned int j = 0; j < taille; j++) {
          char word_letter = word[j];
          if (grid[col + j][row] == empty) {
            score = score + 1;
          } else if (grid[col + j][row] != word_letter) {
            return false;
          }
        }
      }

      if (score < taille) {
        return true;
      } else {
        return false;
      }
    }

    //Function randomly retrieving words from the dictionary
    std::string randomword() {
      // 22000 words in the dictionary. "static" means doesn't get destroyed each time the function returns
      static std::vector < std::string > words;
      std::string s;

      if (words.size() == 0) {
        // If the size is zero then this must be the first time it's called. Read the dictionary
        // file into the words array. This only happens the first time the function is called
        std::string ifileName = "dictionary.txt";
        std::ifstream f(ifileName);

        if (!f) {
          std::cerr << "File '" << ifileName << "' couldn't opened!\n";
          exit(1); // fatal error
        }
        for (int i = 0; i <= 22000; i++) {
          std::getline(f, s);
          std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) {
            return std::tolower(c);
          });
          words.push_back(s); // save the word
        }
      }

      // When you get here, the dictionary file has been read into the words vector.
      int randomline = random(20, 22000); // pick a random number 20 - 22,000
      return words[randomline]; // return that word from the dictionary
    }

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

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

    int Align(float value, float size) {
      int pos = (size / 2) - value / 2;
      return pos;
    }

    int main(int argc, char * argv[]) {
      srand(time(0));
      memset(grid, '.', sizeof(grid));
      bool score;
      //number of words to place
      int rand0 = random(20, 30);
      int num = rand0;

      //position of the horizontal and vertical intersection letter
      int cur_word_pos_inter;
      int prec_word_pos_inter;

      std::string prec_word;
      std::string current_word;
      int prec_intersec;
      int cur_intersec;

      std::string intersec;

      std::string word1 = randomword();
      unsigned len_word1 = word1.length();
      int pos_word1 = Align(len_word1, GridSize);
      PlaceVertical(pos_word1, (GridSize / 2), 0, word1);

      // For each word to place
      for (int k = 1; k < num; k++) {

        std::cout << " Testing word " << k << "/" << num << "\n";
        // Loop to try to place random words
        do {

          current_word = randomword();
          prec_word = words_vect[k - 1];

          intersec = find_intersection(words_vect[k - 1], current_word);
          score = false;

          for (unsigned int j = 0; !score && j < intersec.length(); j++) {
            //temporary position of the selected intersection letter
            cur_intersec = current_word.find_last_of(intersec[j]);
            prec_intersec = prec_word.find_last_of(intersec[j]);
            //if the horizontal score of the position is equal to the size of the word
            if (k % 2 != 0) {
              score = can_place(coord_col[k - 1] + cur_intersec, coord_row[k - 1] - prec_intersec, k, current_word);
              if (score) {
                cur_word_pos_inter = cur_intersec;
                prec_word_pos_inter = prec_intersec;
              }
            } else if (k % 2 == 0) {
              score = can_place(coord_col[k - 1] - prec_intersec, coord_row[k - 1] + cur_intersec, k, current_word);
              if (score) {
                cur_word_pos_inter = cur_intersec;
                prec_word_pos_inter = prec_intersec;
              }
            }

          }

        } while (!score);

        if (k % 2 != 0) {
          PlaceHorizontal(coord_col[k - 1] + cur_word_pos_inter, coord_row[k - 1] - prec_word_pos_inter, k, current_word);
        } else if (k % 2 == 0) {
          PlaceVertical(coord_col[k - 1] - prec_word_pos_inter, coord_row[k - 1] + cur_word_pos_inter, k, current_word);
        }
      }
      showGrid();

    }
     
    codingd, Jun 14, 2020
    #11
  12. bryonmajor

    codingd

    Joined:
    Jun 12, 2020
    Messages:
    6
    Likes Received:
    0
    A little crazier!

    Code (C):
    #include <iostream>

    #include <string>

    #include <algorithm>

    #include <bits/stdc++.h>

    #include <stdlib.h>

    #include <sstream>

    #include <ctime>

    #include <vector>

    using namespace std;

    //Vectors for recording word coordinates
    std::vector < double > coord_col;
    std::vector < double > coord_row;
    //Vectors for recording words
    std::vector < std::string > words_vect;

    constexpr char empty = '.';
    constexpr int GridSize = 26;
    char grid[GridSize][GridSize];

    //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;
    }

    //Function placing words vertically
    void Place(int col, int row, int id_word, int dr, int dc, std::string & word) {
      words_vect.push_back(word);
      coord_col.push_back(col);
      coord_row.push_back(row);
      unsigned taille = word.length();
      for (unsigned int j = 0; j < taille; j++) {
        grid[col][row] = word[j];
        col += dc;
        row += dr;
      }
    }
    //function that assigns a score to the place chosen for the word
    bool can_place(int col, int row, int id_word, int dr, int dc, std::string & word) {
      int score = 0;
      unsigned taille = word.length();

      if (col < 0 || col + dc * taille >= GridSize || row < 0 || row + dr * taille >= GridSize) return false;
      for (unsigned int j = 0; j < taille; j++) {
        char word_letter = word[j];

        if (grid[col][row] == empty) {
          score = score + 1;
        } else if (grid[col][row] != word_letter) {
          return false;
        }
        row += dr;
        col += dc;
      }

      if (score < taille) {
        return true;
      } else {
        return false;
      }
    }

    //Function randomly retrieving words from the dictionary
    std::string randomword() {
      // 22000 words in the dictionary. "static" means doesn't get destroyed each time the function returns
      static std::vector < std::string > words;
      std::string s;

      if (words.size() == 0) {
        // If the size is zero then this must be the first time it's called. Read the dictionary
        // file into the words array. This only happens the first time the function is called
        std::string ifileName = "dictionary.txt";
        std::ifstream f(ifileName);

        if (!f) {
          std::cerr << "File '" << ifileName << "' couldn't opened!\n";
          exit(1); // fatal error
        }
        for (int i = 0; i <= 22000; i++) {
          std::getline(f, s);
          std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) {
            return std::tolower(c);
          });
          words.push_back(s); // save the word
        }
      }

      // When you get here, the dictionary file has been read into the words vector.
      int randomline = random(20, 22000); // pick a random number 20 - 22,000
      return words[randomline]; // return that word from the dictionary
    }

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

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

    int Align(float value, float size) {
      int pos = (size / 2) - value / 2;
      return pos;
    }

    int main(int argc, char * argv[]) {
    // x-axis direction table
      int x[] = { -1,  -1,  -1,  0,  0,  1,  1,  1 };
    // y-axis direction table
      int y[] = {  -1,  0,  1,  -1,  1,  -1,  0,  1 };

      srand(time(0));
      memset(grid, '.', sizeof(grid));
      bool score;
      //number of words to place
      int rand0 = random(15, 30);
      int num = rand0;

      //position of the horizontal and vertical intersection letter
      int cur_word_pos_inter;
      int prec_word_pos_inter;

      std::string prec_word;
      std::string current_word;
      int prec_intersec;
      int cur_intersec;
      int index_direction;
      std::string intersec;

      std::string word1 = randomword();
      unsigned len_word1 = word1.length();
      int pos_word1 = Align(len_word1, GridSize);
      Place(pos_word1, (GridSize / 2), 0, 0, 1, word1);

      // For each word to place
      for (int k = 1; k < num; k++) {

        // Loop to try to place random words
        do {

          current_word = randomword();
          prec_word = words_vect[k - 1];

          intersec = find_intersection(words_vect[k - 1], current_word);
          score = false;

          for (unsigned int j = 0; !score && j < intersec.length(); j++) {
            //temporary position of the selected intersection letter
            cur_intersec = current_word.find_last_of(intersec[j]);
            prec_intersec = prec_word.find_last_of(intersec[j]);
           
             // test every possible direction to place the word
            for (unsigned int i = 0; !score && i < 8; i++) {
              score = can_place(coord_col[k - 1] + cur_intersec, coord_row[k - 1] - prec_intersec, k, x[i], y[i], current_word);

              if (score) {
                cur_word_pos_inter = cur_intersec;
                prec_word_pos_inter = prec_intersec;
               // if placement in the direction is possible keep the index of the chosen direction
                index_direction = i;

              }
            }

          }

        } while (!score);
        // place the word in the chosen direction
        Place(coord_col[k - 1] + cur_word_pos_inter, coord_row[k - 1] - prec_word_pos_inter, k, x[index_direction], y[index_direction], current_word);

      }
      showGrid();
      // Show the word list
      std::cout << "\n Word List:\n";
      for (auto & word: words_vect) {
        std::cout << word << '\n';
      }

    }
     
    codingd, Jun 15, 2020
    #12
  13. bryonmajor

    codingd

    Joined:
    Jun 12, 2020
    Messages:
    6
    Likes Received:
    0
  14. bryonmajor

    tioooels

    Joined:
    Jul 4, 2020
    Messages:
    5
    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.
     
    tioooels, Jul 5, 2020
    #14
  15. bryonmajor

    codingd

    Joined:
    Jun 12, 2020
    Messages:
    6
    Likes Received:
    0
    "All the intelligence in the world is helpless against fashionable idiocy."
     
    codingd, Jul 12, 2020
    #15
    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.