printing memory junk

Question

This program must load words from a file txt to a vector, Draw 10 words, put them in vector and then print on screen. The problem is that it is printing memory junk and do not know how to solve this problem.

How to solve the problem?

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>

typedef struct
{    
    char VetorFacil[20];    
} VETORES;

void carregaPalavrasFacil(VETORES *vetorFuncFacil);
void mostraPalavrasFacil();
void pontuacao();

void main()
{

    int op, i;
    VETORES vetorFuncFacil[10] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};

    printf("Escolha o nivel em que deseja jogar: \n");
    puts("1) Facil");
    puts("2) Medio");
    puts("3) Dificil");
    puts("4) Ajuda");
    fflush(stdin);
    scanf("%i", &op);

    switch (op)
    {
        case 1:
        {
            carregaPalavrasFacil(vetorFuncFacil);
            break;
        }
        case 2:
        {
            printf("Sim\n");
            break;
        }
        case 3:
        {
            printf("Sim\n");
            break;
        }
        case 4:
        {
            puts("Ajuda!");
            break;
        }
        default:
        {
            puts("Opção Inválida!");
            break;
        }
    }
}

void carregaPalavrasFacil(VETORES *vetorFuncFacil)
{

    int i, cont = 0, pegalinha, para;
    char line[20];
    FILE *arquivo;
    arquivo = fopen("facil.txt", "r");
    if (arquivo == NULL)
    {
        printf("Arquivo Inválido!\n");
        exit(1);
    }
    else
    {
        for (cont = 0; cont < 20; cont++)
        {
            int numero = rand() % 20;
            do
            {
                if (pegalinha == numero)
                {
                    fgets(line, sizeof(line), arquivo);
                    strcpy((*vetorFuncFacil).VetorFacil, line);
                    para = 1;
                }
                else
                {
                    pegalinha++;
                }
            } while (para != 1);
        }
    }

    for (i = 0; i <= 10; i++)
    {
        printf("%s\n", vetorFuncFacil[i].VetorFacil);
    }

    fclose(arquivo);
}

Here is the file with the words to not give invalid file error: https://pastebin.com/w65SnD4Q

Answer 1

Follows a program capable of meeting the problem statement in a very clear and efficient way using dynamic memory allocation.

Note that each function is responsible for a part of the task and have very suggestive names:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>


#define ARQ_LISTA_PALAVRAS        "facil.txt"
#define LINHA_MAX_TAM             (100)
#define QTD_PALAVRAS_SORTEADAS    (10)


typedef struct lista_palavras_s
{
    char ** palavras;
    int cont;
} lista_palavras_t;


lista_palavras_t * carregar_lista_palavras( const char * arq )
{
    char linha[ LINHA_MAX_TAM + 1 ] = {0};
    int n = 0;
    FILE * pf = NULL;
    lista_palavras_t * lst = NULL;

    pf = fopen( arq, "r");

    if( !pf )
        return NULL;

    lst = (lista_palavras_t*) calloc( 1, sizeof(lista_palavras_t) );

    while( fgets( linha, LINHA_MAX_TAM, pf ) )
    {
        linha[strcspn(linha, "\n")] = 0;
        linha[strcspn(linha, "\r")] = 0;

        n++;

        lst->palavras = (char**) realloc( lst->palavras, sizeof(char*) * n );

        lst->palavras[n-1] = (char*) calloc( strlen(linha) + 1, sizeof(char) );

        strcpy( lst->palavras[n-1], linha );
    }

    fclose(pf);

    lst->cont = n;

    return lst;
}


lista_palavras_t * sortear_palavras( lista_palavras_t * lst, int qtd )
{
    int i = 0;
    lista_palavras_t * sort = NULL;

    sort = (lista_palavras_t*) calloc( 1, sizeof(lista_palavras_t) );

    sort->palavras = (char**) calloc( qtd, sizeof(char*) );

    for( i = 0; i < qtd; i++ )
        sort->palavras[i] = strdup( lst->palavras[ rand() % lst->cont ] );

    sort->cont = qtd;

    return sort;
}


void exibir_lista_palavras( lista_palavras_t * lst )
{
    int i = 0;

    for( i = 0; i < lst->cont; i++ )
        fprintf( stdout, "%d - %s\n", i + 1, lst->palavras[i] );
}


void liberar_lista_palavras( lista_palavras_t * lst )
{
    int i = 0;

    for( i = 0; i < lst->cont; i++ )
        free(lst->palavras[i]);

    free(lst->palavras);

    free(lst);
}


int main( int argc, char ** argv )
{
    lista_palavras_t * lst = NULL;
    lista_palavras_t * sort = NULL;

    srand(time(NULL));

    lst = carregar_lista_palavras( ARQ_LISTA_PALAVRAS );

    if( !lst )
    {
        fprintf( stderr, "Erro ao carregar arquivo: %s\n", ARQ_LISTA_PALAVRAS );
        return EXIT_FAILURE;
    }

    sort = sortear_palavras( lst, QTD_PALAVRAS_SORTEADAS );

    exibir_lista_palavras( sort );

    liberar_lista_palavras( lst );
    liberar_lista_palavras( sort );

    return EXIT_SUCCESS;
}

Test #1:

1 - informal
2 - endógeno
3 - cumprido
4 - conflito
5 - moderado
6 - presente
7 - proceder
8 - plenária
9 - patético
10 - angariar

Test #2:

1 - preterir
2 - mediante
3 - informal
4 - sarcasmo
5 - arguição
6 - sinônimo
7 - perfazer
8 - hediondo
9 - fortuito
10 - apetecer