kgin

você pode tratar a linha inteira como um vetor de caracteres (string) e só precisa trocar os 7s por 0s.

Exemplo

#include <stdio.h>

#define T_BUFFER 256

int main(void)
{
    char buffer[T_BUFFER] = {0};
    int numero, repete, contador;

    printf("Digite um numero\n");
    do {
        fgets(buffer, T_BUFFER, stdin);
        /* Checa se o numero e valido */
        if (sscanf(buffer, "%d", &numero) != 1) {
            repete = 1;
            puts("Digite apenas numeros!");
        } else {
            repete = 0;
        }
    } while (repete);

    printf("O numero que voce digitou %d\n", numero);

    /* Troca todos os 7 por 0s */
    for (contador = 0; buffer[contador] || contador < T_BUFFER; contador++) {
        if (buffer[contador] == '7')
            buffer[contador] = '0';
    }

    sscanf(buffer, "%d", &numero);
    printf("O numero modificado %d\n", numero);
    getchar();
    return(0);
}

@phililipe realmente é necessário usar vetores?

Poste o enunciado também para ficar mais fácil de te ajudar.

Aqui você está iniciando o vetor com zero posições, porque você não iniciou as variáveis i e j então os valores delas são indefinidos.

    int i, j;
    int vetPar[i];
    int vetImpar[j];

por isso você só está conseguindo armazenar um valor nos vetores vetPar e vetImpar.

@Matheus Dutra Em C para compara se algo está na faixa você tem que usar o operador AND(e logico) &&

Então você teria que colocar assim

if (media < 4)
  {
      printf("voce foi REPROVADO!\n");
  }
else if  (media >=  4 && media < 6)            
  {
      printf("voce está de RECUPERAÇÃO!\n");
  }
else if  (media >=  6 && media < 8)            
  {
      printf("voce foi APROVADO COM NOTA C!\n");
  }
else if (media > 8 && media <= 9)
  {
      printf("voce foi APROVADO COM NOTA B!\n");
  }
else if (media > 9)
  {
      printf("voce foi APROVADO COM NOTA A!\n");
  }

Um exemplo completo.

#include <stdio.h>

int main(void)
{
    float notas[4], soma = 0, media = 0;
    int contador;
    /* Pega as notas */
    for (contador = 0; contador < 4; contador++) {
        printf("Digite a %d nota\n", contador+1);
        scanf("%f%*c", &notas[contador]);
    }

    /* Tira a media */
    for (contador = 0; contador < 4; contador++) {
        soma += notas[contador];
    }

    media = soma/4;

    printf("A soma das notas e %.2f\n", soma);
    printf("A media e %.2f\n", media);

    if (media < 4) {
        puts("O aluno foi reprovado!");
    } else if (media > 4 && media < 6) {
        puts("O aluno esta de recuperacao!");
    } else if (media >= 6 && media < 8) {
        puts("O aluno foi aprovado com nota C");
    } else if (media == 8) {
        puts("O aluno foi aprovado com nota B");
    } else {
        printf("O aluno foi aprovado com nota A");
    }
    getchar();      /* Faz uma parada no programa */
}

Exemplo de como eliminar os candidatos.

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

#define T_NOME 30
#define Q_CANDIDATOS 8

#define T_BUFFER 256

/* Colocação de cada candidato */
const char *COLOCACAO[] = {"primeiro",
                           "segundo",
                           "terceiro",
                           "quarto",
                           "quinto",
                           "sexto",
                           "setimo",
                           "oitavo",
                           "nono",
                           "decimo"};


int main(void)
{
    int contador, opcao;
    /* Os candidatos restantes */
    int rest_candidatos[Q_CANDIDATOS] = {0};
    int total_candidatos = 0;
    /* Cria uma matriz de caracteres */
    char candidatos[Q_CANDIDATOS][T_NOME];
    char buffer[T_BUFFER];      /* Buffer para ser usado no teclado */

    /* Pega os nomes dos candidatos */
    for (contador = 0; contador < Q_CANDIDATOS; contador++) {
        printf("Digite o nome o %s candidato\n", COLOCACAO[contador]);
        do {
            /* Pega a entrada do teclado */
            if (fgets(buffer, T_BUFFER, stdin) != NULL) {
                /* Verifica se a entrada é valída */
                if (buffer[0] != '\n' && strlen(buffer) < T_NOME-1) {
                    strcpy(candidatos[contador], buffer);
                    /* Sinaliza que o cadidato e valido */
                    rest_candidatos[contador] = 1;
                    total_candidatos++;
                } else {
                    printf("Digite uma entrada valida!\n");
                }
            }
        /* Repete novamente se a entrada for invalida */
        } while (buffer[0] == '\n' || strlen(buffer) > T_NOME-1);
    }

    printf("Total de candidatos no sistema %d\n", total_candidatos);

    do {
        /* Mostra os candidatos restantes no sistema */
        printf("Total de candidatos restantes %d\n", total_candidatos);
        for (contador = 0; contador < Q_CANDIDATOS; contador++) {
            if (rest_candidatos[contador] == 1)
                printf("%d-%s candidato %s", contador+1, COLOCACAO[contador], candidatos[contador]);
        }

        printf("Digite o numero do candidato para ser eleminado\n");
        /* Pega a posição do candidato */
        do {
            if (fgets(buffer, T_BUFFER, stdin) != NULL) {
                if (sscanf(buffer, "%d", &opcao) != 1) {
                    printf("Digite uma opcao valida!\n");
                    opcao = -1;
                }
            }
        } while (opcao < 1 || opcao > Q_CANDIDATOS);

        if (rest_candidatos[opcao-1] == 1) {
            printf("Candidato %s\teliminado!\n", candidatos[opcao-1]);
            /* Retira o candidato */
            rest_candidatos[opcao-1] = 0;
            total_candidatos--;
        } else {
            printf("O candidato ja foi eleminado!\n");
        }
    } while (total_candidatos > 3);

    printf("Candidatos restantes\n");
    for (contador = 0; contador < Q_CANDIDATOS; contador++) {
        if (rest_candidatos[contador] == 1) {
            printf("%s", candidatos[contador]);
        }
    }
    getchar();
    return(0);
}

@tbtld1 Se o seu enunciado e o mesmo que o do @GustavoZN então declare uma variável do tipo int iniciada em 0 para guardar a quantidade de números pares.

	int q_pares = 0;		/* utilizado para guardar a quantidade numeros pares */

Então incremente-a quando você testar que o numero e par.

	q_pares++;	/* Adiciona +1 a variavel */

De pois e só mostrar no final do programa.

	printf("A quantidade numeros pares e %d\n", q_pares);

@tbtld1 Eu dei uma "arrumada" no seu código

#include <stdio.h>

int main(void)
{
    int inicio, fim, contador;
    printf("\n Digite o numero inicial\n");
    scanf ("%d",&inicio);

    printf("\n Digite o numero final\n");
    scanf ("%d",&fim);
    
    for (contador = inicio; contador <= fim; contador++) {
        if(contador%2 == 0) {
            printf ("O numero %d e PAR!\n", contador);
        } else {
            printf("O numero %d e IMPAR!\n", contador);

        }
    }
    return(0);
}

Pelo seu código eu acho que você está utilizando o DevC++, eu não recomendo você continuar utilizando-o para aprender a programar porque ele está muito desatualizado.

Se você quiser algo mais moderno você pode utilizar o codeblocks ou um IDE online como o replit.

18 minutos atrás, GustavoZx disse:

so ta faltando agora eu por a quantidade de numeros pares encontrado, vou tentar, fico muito grato pela ajuda!!

Você pode declarar uma variável para guardar a quantidade de números pares e ir incrementando quando você testar que o numero e par.

Depois é só imprimir a quantidade de números pares no final do programa.

1 hora atrás, GustavoZx disse:

espero um dia ficar bom tanto quanto vocês

Tomara que você fique bem melhor do que eu, porque até hoje eu nunca estudei C (nunca tive paciência para ler um livro sobre C).

Se você puder aprender outra linguagem de programação com calma eu recomendo esse curso do google

https://grasshopper.app/pt_br/

Ele ensina JavaScript que e uma linguagem mais simples e bem mais visual.

Eu marcaria onde é, mas não tem mais código na pagina.

Então apague no seu código do comando for até o comando return (não apague o return) e cole esse meu aí.

@GustavoZx Você é o @GustavoZN?

Seu programa está no caminho certo, só falta você fazer a função que retorna se e par e colocar um else no if

for (i=inicial; i<=final; i++)
{   
    if ((i % 2) == 0)    
    	printf("numero par %d \n", i);
  else 
    	printf("numero impar %d\n", i);
}

2 minutos atrás, Um mero usuário disse:

@kginseu executavel nao funcionou no meu linux... ele classificou como "DOS/Windows executável" e mesmo pelo terminal não rodou...

Você tem wineHQ?

Descompacte o arquivo novamente e retire o "com" do final e reexecute.

@GustavoZN Poste o que você já fez!

Qual seria a sua dificuldade?

Já fez alguma coisa?

26 minutos atrás, GustavoZN disse:

Desenvolver um programa para que o usuário possa realizar a digitação de dois números (número inicial e número final). Dentro de uma estrutura de repetição será preciso verificar se o número que está sendo alimentado é um número par ou ímpar. A checagem do número deverá ser feita em uma função a ser criada. A função é quem deverá verificar a informação recebida e retornar o status se é par ou ímpar. Dentro da estrutura de repetição será preciso exibir uma mensagem com o valor do número e mais uma frase dizendo se ele é par ou ímpar. Após o término da estrutura de repetição será preciso informar a quantidade total de números pares encontrados.>

Aqui.

checa_impar.com.zip

Funciona no windows e linux.

53 minutos atrás, devair1010 disse:

 o enunciado diz para verificar na listagem , já existente ,  de matriculas , e então não precisa pegar essas informações do usuário ,

Pois é, mas logo em seguida o enunciado diz

4 horas atrás, kgin disse:

Após ler essas listagens verifique quem são os alunos.

após ler essas listagens, ler de onde?

Ou só é para comparar o vetor já carregado?

Como eu disse o enunciado está meio vago, não explica muito bem o que é pra fazer.

59 minutos atrás, sthearc disse:

O Departamento de Computação deseja saber se existem alunos cursando, simultaneamente, as disciplinas D1 e D2. Existe disponível uma listagem com os números de matrículas dos alunos das duas disciplinas. Após ler essas listagens verifique quem são os alunos.

Eu não sei se entendi direito, mas você não deveria ler dois vetores do usuário?

Dessa maneira

    int d1[Q_ALUNOS], d2[Q_ALUNOS], quantidade_alunos = 0;
    int contador1, contador2;

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        printf("Digite o aluno da matricula [%d] da turma d1\n", contador1);
        scanf("%d%*c",&d1[contador1]);
    }

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        printf("Digite o aluno da matricula [%d] da turma d2\n", contador1);
        scanf("%d%*c",&d2[contador1]);
    }

Depois não seria só verificar os alunos?

1 hora atrás, sthearc disse:

Após ler essas listagens verifique quem são os alunos.

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        for (contador2 = 0; contador2 < Q_ALUNOS; contador2++) {
            if (d1[contador1] == d2[contador2]) {
                printf("O aluno %i esta matriculado na matricula [%d] da turma d1 e na matricula [%d] da turma d2\n", d1[contador1], contador1, contador2);
            }
        }
    }

Exemplo completo.

#include <stdio.h>


#define Q_ALUNOS 5


int main(void)
{
    int d1[Q_ALUNOS], d2[Q_ALUNOS], quantidade_alunos = 0;
    int contador1, contador2;

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        printf("Digite o aluno da matricula [%d] da turma d1\n", contador1);
        scanf("%d%*c",&d1[contador1]);
    }

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        printf("Digite o aluno da matricula [%d] da turma d2\n", contador1);
        scanf("%d%*c",&d2[contador1]);
    }

    for (contador1 = 0; contador1 < Q_ALUNOS; contador1++) {
        for (contador2 = 0; contador2 < Q_ALUNOS; contador2++) {
            if (d1[contador1] == d2[contador2]) {
                printf("O aluno %i esta matriculado na matricula [%d] da turma d1 e na matricula [%d] da turma d2\n", d1[contador1], contador1, contador2);
            }
        }
    }
    return(0);
}

Ao menos foi isso que eu entendi (o enunciado e meio vago também) .

31 minutos atrás, sthearc disse:

Olá, estou estudando programação em c++, então não sou muito boa, estou fazendo um exercício sem sucesso algum  

Qual seria o curso ou material que você está utilizando para aprender?

32 minutos atrás, sthearc disse:

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

Eu vejo essa linha em vários algoritmos aqui no fórum e isso me deixou curioso para saber de onde vem.

Agora vamos ao seu código, ele está correto só que você colocou o simbolo de igual "==" aqui

35 minutos atrás, sthearc disse:

 x[i] == '@';

Ao invés do simbolo de atribuição "="

	x[i] = '@';

Com isso resolve o problema.

Uma melhoria para o seu programa seria colocar o caractere de controle %*c no scanf

	scanf("%c%*c", &x[i]);

Por hora e melhor usar o %*c do que um espaço, ele com o tempo deixa as coisa um pouco complicadas e mais para frente e melhor usar fgets para ler a entrada.

outra melhoria seria colocar um loop a mais para mostrar a modificação do vetor.

dessa maneira

	for (i=0; i<tam; i++){
        printf("nova sequencia  %c \n", x[i]);
    }

Código consertado.

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

#define tam 5
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char** argv) {
   char x[tam];
    int i;

    for (i=0; i<tam; i++) {
        printf("Digite um caracter: ");
        scanf(" %c", &x[i]);
    }
    
    for (i=0; i<tam; i++){
        if (x[i]=='a'){
            x[i] = '@';
        }
    }

    for (i=0; i<tam; i++){
        printf("nova sequencia  %c \n", x[i]);
    }
    return 0;
}

Agora e só adicionar as outras vogais.

É você não está escrevendo nada na linguagem C++ tudo isso que você fez e em C.

@criatividade Qual seria o erro que você está recebendo?

por que ao meu ver o algoritmo está correto, mas você está usando uma biblioteca que o meu compilador não tem e provavelmente o seu também não deve ter.

19 minutos atrás, criatividade disse:

#include <conio.h>

essa biblioteca não e implementada mais desde o borland turbo c++(do sistema DOS) então o que eu fiz foi tirar ela e colocar a cstdio e trocar o getch() por getchar()

#include <iostream>
#include <cstdio>
#include <math.h>

using namespace std;

int X_elevado_a_Z(int X, int Z)
    {
        int i,potencia=1;
        for (i=1; i<=Z; i++)
            potencia = potencia*X;
        return (potencia);
    }
    int main ()
    {
        int a,b;
        cout << "Escreva X\n";
        cin >> a;
        cout << "\nEscreva Z\n";
        cin >> b;
        cout << "\n------------------------\nX elevado a Z = " << X_elevado_a_Z(a,b);
        getchar ();
    }

tá aí!

funcionando perfeitamente.

14 minutos atrás, isrnick disse:

Mas não reduz o código muito, a vantagem é que também funciona para tamanhos de velha maiores do que 3x3, mas esse é o tamanho padrão do jogo da velha.

Se a minha memoria não me falha (que com certeza ela falha) eu acho que isso serve para aquele jogo chines chamado go também.

Eu dei uma olha do seu código e a ideia e realmente a mesma, mas aquele código do devair o cara tava aprendendo e criptografia porque eu não entendi nada daquele código dele.

Poste o que você já fez para podermos ajudá-lo.

@Leanderson Pinheiro Poderia ser feito dessa maneira também.

int linhas, colunas, objeto, vezes;

    /* Checa as linhas */
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        vezes = 1;
        objeto = tabuleiro[linhas][0];
        for (colunas = 1; colunas < Q_COLUNAS; colunas++) {
            if (objeto == tabuleiro[linhas][colunas]) {
                vezes++;
            }
        }

        if ((vezes == Q_LINHAS)&&(objeto != TAB_VAZIO)) {
            return(objeto);
        }
    }

Código do exemplo.

#include <stdio.h>

#define Q_LINHAS 3
#define Q_COLUNAS 3

#define TAB_VAZIO 0
#define TAB_X 1
#define TAB_O 2
#define TAB_VELHA 3

void mostraTabuleiro(int tabuleiro[Q_LINHAS][Q_COLUNAS]);

int checaVitoria(int tabuleiro[Q_LINHAS][Q_COLUNAS]);

int main(void)
{
    int vitoria;
    /* Velha */
    int tabuleiro1[Q_LINHAS][Q_COLUNAS] = {{1,2,1},
                                           {2,1,1},
                                           {1,2,2}};

    /* X */
    int tabuleiro2[Q_LINHAS][Q_COLUNAS] = {{1,2,1},
                                           {2,1,1},
                                           {1,2,1}};

    /* O */
    int tabuleiro3[Q_LINHAS][Q_COLUNAS] = {{2,2,1},
                                           {1,2,1},
                                           {1,2,2}};

    printf("\ntabuleiro 1\n");
    mostraTabuleiro(tabuleiro1);
    vitoria = checaVitoria(tabuleiro1);
    switch (vitoria) {
        case TAB_O:
            printf("Vitoria do O\n");
            break;

        case TAB_X:
            printf("Vitoria do X\n");
            break;

        case TAB_VELHA:
            printf("Deu velha!\n");
            break;

        default:
            printf("Ninguem ganhou ainda!\n");
    }

    printf("\ntabuleiro 2\n");
    mostraTabuleiro(tabuleiro2);
    vitoria = checaVitoria(tabuleiro2);
    switch (vitoria) {
        case TAB_O:
            printf("Vitoria do O\n");
            break;

        case TAB_X:
            printf("Vitoria do X\n");
            break;

        case TAB_VELHA:
            printf("Deu velha!\n");
            break;

        default:
            printf("Ninguem ganhou ainda!\n");
    }

    printf("\ntabuleiro 3\n");
    mostraTabuleiro(tabuleiro3);
    vitoria = checaVitoria(tabuleiro3);
    switch (vitoria) {
        case TAB_O:
            printf("Vitoria do O\n");
            break;

        case TAB_X:
            printf("Vitoria do X\n");
            break;

        case TAB_VELHA:
            printf("Deu velha!\n");
            break;

        default:
            printf("Ninguem ganhou ainda!\n");
    }

    getchar();
    return(0);
}

void mostraTabuleiro(int tabuleiro[Q_LINHAS][Q_COLUNAS])
{
    int linhas, colunas;
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
            if (colunas < Q_COLUNAS-1) {
                if (tabuleiro[linhas][colunas] == TAB_X) {
                    printf("X|");
                } else {
                    printf("O|");
                }
            } else {
                if (tabuleiro[linhas][colunas] == TAB_X) {
                    printf("X");
                } else {
                    printf("O");
                }
            }
        }
        putchar('\n');
    }
}

int checaVitoria(int tabuleiro[Q_LINHAS][Q_COLUNAS])
{
    int linhas, colunas, objeto, vezes;

    /* Checa as linhas */
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        vezes = 1;
        objeto = tabuleiro[linhas][0];
        for (colunas = 1; colunas < Q_COLUNAS; colunas++) {
            if (objeto == tabuleiro[linhas][colunas]) {
                vezes++;
            }
        }

        if ((vezes == Q_LINHAS)&&(objeto != TAB_VAZIO)) {
            return(objeto);
        }
    }

    /* Checa as colunas */
    for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
        vezes = 1;
        objeto = tabuleiro[0][colunas];
        for (linhas = 1; linhas < Q_LINHAS; linhas++) {
            if (objeto == tabuleiro[linhas][colunas]) {
                vezes++;
            }
        }

        if ((vezes == Q_COLUNAS)&&(objeto != TAB_VAZIO)) {
            return(objeto);
        }
    }

    /* Checa a diagonal esquerda */
    /* X|_|_
     * _|X|_
     *  | |X
     */
    objeto = tabuleiro[0][0];
    vezes = 1;
    for (linhas = colunas = 1; linhas < Q_LINHAS || colunas < Q_COLUNAS; linhas++, colunas++) {
        if (objeto == tabuleiro[linhas][colunas]) {
            vezes++;
        }
    }

    if ((vezes == Q_LINHAS || vezes == Q_COLUNAS) && (objeto != TAB_VAZIO)) {
        return(objeto);
    }

    /* Checa a diagonal direita */
    /* _|_|X
     * _|X|_
     * X| |
     */
    objeto = tabuleiro[0][Q_COLUNAS-1];
    vezes = 1;
    for (linhas = 0, colunas = Q_COLUNAS-2; linhas < Q_LINHAS || colunas > 0; linhas++, colunas--) {
        if (objeto == tabuleiro[linhas][colunas]) {
            vezes++;
        }
    }

    if ((vezes == Q_LINHAS || vezes == Q_COLUNAS) && (objeto != TAB_VAZIO)) {
        return(objeto);
    }

    /* Checa se deu velha ou galo */
    vezes = 0;
    for (linhas = 0; linhas < Q_LINHAS; linhas++) {
        for (colunas = 0; colunas < Q_COLUNAS; colunas++) {
            if (tabuleiro[linhas][colunas] == TAB_O || tabuleiro[linhas][colunas] == TAB_X) {
                vezes++;
            }
        }
    }

    if (vezes == (Q_LINHAS*Q_COLUNAS)) {
        return(TAB_VELHA);
    }

    /* Ninguém ganhou ainda */
    return(TAB_VAZIO);
}

@Atomicsub7 Não sei se isso te ajuda, mas eu dei uma modificada nessa lista que eu tenho aqui

/* Lista encadeada generica */
#include <stdio.h>
#include <stdlib.h>

struct no_t
{
    int valor;
    struct no_t *anterior, *proximo;
};

struct lista_t
{
    struct no_t *inicio, *fim;
};

void
apagaNo(struct no_t **no);
/*
 * Apaga apenas um nó
 */

struct no_t
*criaNo(int valor);
/*
 * Cria um nó
 */

void
apagaLista(struct lista_t **lista);
/*
 * Apaga toda uma lista
 */

struct lista_t
*criaLista(void);
/*
 * Cria uma lista vazia
 */

struct no_t
*colocaNoInicio(struct lista_t *lista, int valor);
/*
 * Coloca um nó no inicio da lista e devolve o nó colocado
 */

struct no_t
*colocaNoFim(struct lista_t *lista, int valor);
/*
 * Coloca um nó no fim da lista e devolve o nó colocado
 */

int main(void)
{
    struct lista_t *lista = criaLista();
    struct no_t *no = NULL;

    colocaNoFim(lista, 10);
    colocaNoFim(lista, 11);
    colocaNoFim(lista, 12);
    colocaNoInicio(lista, 1);
    colocaNoInicio(lista, 2);
    colocaNoInicio(lista, 3);

    printf("Mostra a lista do comeco ao fim\n");
    no = lista->inicio;
    while (no != NULL) {
        printf("%d\n", no->valor);
        no = no->proximo;
    }

    printf("Mostra a lista do fim ao comeco\n");
    no = lista->fim;
    while (no != NULL) {
        printf("%d\n", no->valor);
        no = no->anterior;
    }

    apagaLista(&lista);
    return(0);
}

void
apagaNo(struct no_t **no)
{
    if (*no != NULL) {
        (*no)->anterior = (*no)->proximo = NULL;
        free(*no);
    }
    *no = NULL;
}

struct no_t
*criaNo(int valor)
{
    struct no_t *no = malloc(sizeof(*no));
    if (no != NULL) {
        no->anterior = no->proximo = NULL;
        no->valor = valor;
        return(no);
    }

    return(NULL);
}

void
apagaLista(struct lista_t **lista)
{
    if (*lista != NULL) {
        struct no_t *tmp = (*lista)->inicio;
        while (tmp != NULL) {
            struct no_t *aux = tmp->proximo;
            apagaNo(&tmp);
            tmp = aux;
        }
        (*lista)->inicio = (*lista)->fim = NULL;
        free(*lista);
    }

    (*lista) = NULL;
}

struct lista_t
*criaLista(void)
{
    struct lista_t *lista = malloc(sizeof(*lista));

    if (lista != NULL) {
        lista->inicio = lista->fim = NULL;
        return(lista);
    }
    return(NULL);
}


struct no_t
*colocaNoInicio(struct lista_t *lista, int valor)
{
    struct no_t *no = criaNo(valor);

    if (no != NULL) {
        if (lista->inicio == NULL) {
            lista->inicio = lista->fim = no;
        } else {
            lista->inicio->anterior = no;
            no->proximo = lista->inicio;
            lista->inicio = no;
        }
        return(no);
    }

    return(NULL);
}

struct no_t
*colocaNoFim(struct lista_t *lista, int valor)
{
    struct no_t *no = criaNo(valor);
    if (no != NULL) {
        if (lista->inicio == NULL) {
            lista->inicio = lista->fim = no;
        } else {
            lista->fim->proximo = no;
            no->anterior = lista->fim;
            lista->fim = no;
        }
        return(no);
    }

    return(NULL);
}

Eu não consegui compilar o seu algoritmo

Eu acho que seria melhor você postar o código completo, por que assim está meio difícil de entender o que está errado.

@Atomicsub7 Mas a entrada e fixa?

Digamos assim o usuário vai digitar x números na entrada?

1 hora atrás, Atomicsub7 disse:

preciso de um programa em C, que recebe o valor de uma carta se for maior que a anterior e colocado no fim da fila se for menor que a anterior é colocada no início 

eu cheguei a escrever esse código, se alguém puder dar aquele help

mas o que você quer fazer exatamente?

@Carolmarton você deveria começar assim ao invés de começar pelo menu

#include <stdio.h>

#define T_FRASE 6

char frase[T_FRASE];


void adiciona(void);

void imprime(void);

int main(void)
{
    adiciona();
    imprime();
    return(0);
}

void adiciona(void)
{
    printf("Digite alguma coisa de ate %d letras\n", T_FRASE-1);
    scanf("%[^\n]s", frase);	/* Recomendo usar fgets() para pegar uma string */
}

void imprime(void)
{
    printf("voce digitou %s\n", frase);
}

1 hora atrás, Carolmarton disse:

A)  Adicionar letras
void adicionar();
Um vetor de 5 posições deverá ser declarado em área global, bem como sua
dimensão. O usuário deve inserir todas as letras de uma vez, na chamada
deste módulo.

Se você começar por aqui e depois ir para

1 hora atrás, Carolmarton disse:

E)  Imprimir
void imprimir();
Imprime todos os elementos do vetor

Depois e só continuar fazendo as funções para no final fazer o menu.

esse exemplo no replit

https://replit.com/@KGin/Exemplo#main.c

45 minutos atrás, Carolmarton disse:

Um tempo atrás fiz esse, acredito que será mais o menos isso, só preciso colocar em módulos e incrementar o modulo contar, também preciso usar ponteiros no módulo contar, será minha maior dificuldade já que não peguei a manha de ponteiros ainda.

sim, é mais ou menos isso só que com caracteres.

para contar quantas as vogais e as consoantes não é tão difícil assim, faça algo mais ou menos assim.

void conta(int *vogais, int *consoantes)
{
    int contador;
    *vogais = *consoantes = '\0';
    for (contador = 0; frase[contador] != '\0'; contador++) {
        switch (frase[contador]) {
            case 'a':
            case 'A':
                (*vogais)++;
                break;

            case 'e':
            case 'E':
                (*vogais)++;
                break;
            
            case 'i':
            case 'I':
                (*vogais)++;
                break;

            case 'o':
            case 'O':
                (*vogais)++;
                break;

            case 'u':
            case 'U':
                (*vogais)++;
                break;

            default:
                if ((frase[contador] >= 'A' && frase[contador] <= 'Z') ||
                   (frase[contador] >= 'a' && frase[contador] <= 'z'))
                    (*consoantes)++;
        }
    }
}