Rimack Zelnick - Challenge 2 - FULL - C

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#include <stdio.h>

int main(int argc, char ** argv){
    /*
     * Declarar uma variável, tipo int, que armazenará o dia
     * correspondente ao da semana
     */
    int dia;

    /*
     * Pedir para que o usuário informe o número correspondente ao dia
     * da semana
     */
    printf("Digite um n\243mero de 1 a 7 referente ao dia da semana: ");
    scanf("%d", &dia);

    /*
     * Verificar se a entrada está fora de intervalo
     */
    if (dia < 1 || dia > 7){
        printf("N\243mero inv\240lido.\n");

        /*
         * Retornar um valor negativo indicando que houve um falha no
         * programa ao exercer a sua função
         */
        return -1;
    }

    /*
     * Exibir um prefixo comum em todas as saídas
     */
    printf("Dia %d \202 ", dia);

    /*
     * Processar o número referente ao dia da semana
     */

    switch (dia){
        case 1: printf("domingo");
                break;
        case 2: printf("segunda");
                break;
        case 3: printf("ter\207a");
                break;
        case 4: printf("quarta");
                break;
        case 5: printf("quinta");
                break;
        case 6: printf("sexta");
                break;
        case 7: printf("s\240bado");
                break;
    }

    /*
     * Adicionar um sufixo comum em todas as saídas
     */
    printf(".\n");

    /*
     * Retornar um valor nulo indicando que o programa executou
     * corretamente a sua função
     */
    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

#include <stdio.h>

/*
 * Prototipo da função que validará a nossa data, e outro prototipo da
 * função que fará o cálculo se o ano é bissexto ou não
 */
static int validar(int, int, int);
static int bissexto(int);

int main(int argc, char ** argv){
    /*
     * Declarar 3 variáveis, tipo int, que armazenará os valores do dia,
     * mês e ano.
     */
    int dia, mes, ano;

    /*
     * Pedir para que o usuário insira uma data
     */
    printf("Digite uma data com o seguinte formato dd/mm/aaaa: ");
    fscanf(stdin, "%d/%d/%d", &dia, &mes, &ano);

    /*
     * Imprimir os valores que foram lidos apartir daquele formato
     */
    printf("Dia = %d\nM\210s = %d\nAno = %d\n\n",
            dia,
            mes,
            ano
          );

    /*
     * Prefixo comum à todas as saídas
     */
    printf("Data ");

    /*
     * Validar data
     */
    if (validar(dia, mes, ano)){
        printf("v\240lida - ");
        if (bissexto(ano))
            printf("\220 bissexto");
        else
            printf("N\176\141o \202 bissexto");
    }else
        printf("inv\240lida");

    /*
     * Sufixo comum à todas as saídas
     */
    printf(".\n");

    /*
     * Retornar um valor nulo indicando que o programa executou a sua
     * função de forma correta
     */
    return 0;
}

static int validar(int dia, int mes, int ano){
    /*
     * Analisar cada período conforme o mês
     */
    switch (mes){
        /*
         * Meses que vão do dia 1 ao 31
         */
        case  1: //Janeiro
        case  3: //Março
        case  5: //Maio
        case  7: //Julho
        case  8: //Agosto
        case 10: //Outubro
        case 12: //Dezembro
            /*
             * Se o intervalo do dia do mês estiver entre 1 e 31
             */
            if (dia > 0 && dia < 32)
                /*
                 * Data válida
                 */
                return 1;
            break;

        /*
         * Meses que vão do dia 1 ao 30
         */
        case  4: //Abril
        case  6: //Junho
        case  9: //Setembro
        case 11: //Novembro
            /*
             * Se o intervalo do dia do mês estiver entre 1 e 30
             */
            if (dia > 0 && dia < 31)
                /*
                 * Data válida
                 */
                return 1;
            break;

        /*
         * Mês de fevereiro
         */
        case 2:
            /*
             * Verificar se o ano informado é bissexto ou não
             */
            if (bissexto(ano)){
                /*
                 * Verificar se o valor do dia está entre 1 e 29
                 */
                if (dia > 0 && dia < 30)
                    return 1;
            }else{
                /*
                 * Verificar se o valor do dia está entre 1 e 28
                 */
                if (dia > 0 && dia < 29)
                    return 1;
            }
            break;
    }

    /*
     * Após todos os testes se nenhum valor for retornado retornaremos
     * zero indicando que a data é inválida
     */
    return 0;
}

static int bissexto(int ano){
    /*
     * De acordo com o calendário gregoriano, a maioria dos anos que são
     * divisivéis por 4 são bissextos.
     *
     * Anos que são divisivéis por 100 não são bissextos, a não ser que
     * eles também sejam divisivéis por 400, nesse caso são bissextos
     */

    if (!(ano % 400))
        return 1;
    else if (!(ano % 100))
        return 0;
    else if (!(ano % 4))
        return 1;

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <stdio.h>

int main(int argc, char ** argv){
    /*
     * Declarar uma variável, tipo int, que armazenará o valor da nota
     */
    int nota;

    do{
        /*
         * Pedir para que o usuário informe a nota
         */
        printf("Digite uma nota de 0 a 10: ");
        scanf("%d", &nota);

        /*
         * Verificar o valor entrado
         */
        if (nota < 0 || nota > 10)
            printf("Valor inv\240lido\n");
    }while (nota < 0 || nota > 10);

    /*
     * Caso o valor esteja correto o laço se quebrará
     */
    printf("Valor correto\n");
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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

int main(int argc, char ** argv){
    /*
     * Declarar dois vetores, tipo char, que armazenará o valor do login
     * e da senha
     */
    char login[260], passwd[260];

    /*
     * Pedir para que o usuário informe o seu login e a sua senha
     */
    do{
        printf("Digite seu login: ");
        scanf("%s", login);

        printf("Digite sua senha: ");
        scanf("%s", passwd);

        /*
         * Comparar as duas strings
         */
        if (!strcmp(login, passwd))
            printf("Erro, a senha n\176\141 pode ser igual ao login.\n");
    }while (!strcmp(login, passwd));

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <stdio.h>

int main(int argc, char ** argv){
    /*
     * Declarar 3 variáveis, 2 do tipo int e 1 do tipo float, para
     * armazenar os valores de anos, cigarros por dia, e reais por
     * cigarro
     */
    int     ano, cigarros_por_dia;
    float   reais_por_cigarro;

    /*
     * Pedir para que o usuário entre os 3 valores
     */
    printf("O n\243mero de anos que ele fuma: ");
    scanf("%d", &ano);

    printf("O n\243mero de cigarros fumados por dia: ");
    scanf("%d", &cigarros_por_dia);

    printf("O pre\207o da carteira de cigarro: ");
    scanf("%f", &reais_por_cigarro);

    /*
     * Encontrar a relação entre reais por cigarro dividindo o preço da
     * cartela, que contêm 20 cigarros, pela quantidade de cigarros na
     * cartela.
     */
    reais_por_cigarro /= 20.0f;

    /*
     * Imprimir o total gasto pelo fumante usando a expressão:
     * 365 * ano * cigarros_por_dia * reais_por_cigarro
     */
    printf("Total gasto: %.2f\n", 365 * ano * cigarros_por_dia * reais_por_cigarro);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

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

/*
 * Criar uma estrutura de dados
 */
struct contato{
    char    * c_nome;
    char    * c_tel;
};

/*
 * Criar uma lista estática de contatos
 */
static struct contato lista[6] = {
    {"Fulano"  , "334-45566"},
    {"Cicrano" , "112-23344"},
    {"Beltrano", "551-12233"},
    {"Zé"      , "443-34422"},
    {"Toinho"  , "661-12233"},
    {"Luizinho", "776-65577"}
};

/*
 * Declarar uma função que fará a comparação dentre item por item na
 * lista telefônica
 */
static int comparar(const void*, const void*);

int main(int argc, char ** argv){
    /*
     * Declarar um vetor, tipo char, que armazenará o nome a ser
     * encontrado. E declarar uma variável, tipo contato, usado
     * para encontrar um determinado contato apartir do nome
     */
    char            nome[260];
    struct contato  * con, chave;

    /*
     * Pedir para que o usuário informe que ele deseja procurar
     */
    printf("Informe o nome a ser pesquisado na lista: ");
    scanf("%s", nome);

    /*
     * Para que haja uma pesquisa usando bsearch, é necessário que
     * rearranjemos a lista
     */
    qsort(lista, 6, sizeof(struct contato), comparar);

    /*
     * Atribuir ao membro da nossa estrutura 'c_nome' o valor que
     * queremos encontrar na lista
     */
    chave.c_nome = nome;

    /*
     * Procurar o nome do contato na lista
     */
    con = bsearch(&chave, lista, 6, sizeof(struct contato), comparar);

    if (!con)
        /*
         * Caso o valor retornado seja nulo: contato não encontrado
         */
        printf("Contato não encontrado.\n");
    else
        printf("Contato encontrado.\nNome: %s\nTelefone: %s\n", con->c_nome, con->c_tel);

    return 0;
}

static int comparar(const void * c1, const void * c2){
    /*
     * Fazer o cast de const void para a nossa estrutura
     */
    struct contato * con1 = (struct contato*)c1;
    struct contato * con2 = (struct contato*)c2;

    return strcmp(con1->c_nome, con2->c_nome);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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

int main(int argc, char ** argv){
    /*
     * Declarar uma matriz bidimensional de strings, uma matriz de
     * caracters e uma variável, tipo int, que nos auxiliará
     */
    char    vet[2][10][260];
    char    res[20][260];
    int     i, n;

    /*
     * Pedir para que o usuário preencha o vetor
     */
    for (n = 0; n < 2; n++)
        for (i = 0; i < 10; i++){
            printf("Informe o %do. elemento do %do. vetor: ", i+1, n+1);
            scanf("%s", vet[n][i]);
        }

    /*
     * Fazer a intercalação
     */
    memcpy(res, vet, 5200);

    for (i = 0; i < 20; i++)
        printf("%s, ", res[i]);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <stdio.h>

/*
 * Prototipo de função que fará o nosso menu
 */
static int menu(void);

int main(int argc, char ** argv){
    /*
     * Declarar uma variável, tipo int, que armazenará cada resposta
     */
    int res = 0;

    /*
     * Começar o questionamento
     */ 
    printf("Telefonou para a v\241tima?\n");
    res += menu();

    printf("Esteve no local do crime?\n");
    res += menu();

    printf("Mora perto da v\241tima?\n");
    res += menu();

    printf("Devia para a v\241tima?\n");
    res += menu();

    printf("J\240 trabalhou com a v\241tima?\n");
    res += menu();

    /*
     * Imprimir um prefixo comum à todas as saídas
     */

    printf("Fim de interrogat\242rio, seu ranking: ");

    /*
     * Processar o resultado do questionário
     */

    switch (res){
        case 2: printf("Suspeito");
                break;
        case 3:
        case 4: printf("C\243mplice");
                break;
        case 5: printf("Assassino");
                break;
        default: printf("Inocente");
    }

    /*
     * Imprimir um sufixo comum à todas as saídas
     */
    printf(".\n");

    return 0;
}

static int menu(void){
    int ret;

    do{
        printf("[1] Sim\n[0]N\204o\n->");
        scanf("%d", &ret);
    }while (ret < 0 || ret > 1);

    return ret;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

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

int main(int argc, char ** argv){
    /*
     * Declarar 1 matriz, tipo char, que armazenará os valores das duas
     * entradas. E uma variável auxiliar, tipo int, que fará a contagem.
     */
    char str[2][260];
    int i;

    /*
     * Pedir para que o usuário informe as 2 strings
     */
    for (i = 0; i < 2; i++){
        printf("String %d: ", i+1);
        fgets(str[i], 260, stdin);
    }

    /*
     * Remover a quebra de linha no final de string
     */

    str[0][strlen(str[0])-1] = 0;
    str[1][strlen(str[1])-1] = 0;


    /*
     * Imprimir o comprimento de ambas as strings
     */
    for (i = 0; i < 2; i++)
        printf("Tamanho da String %d \"%s\" : %d\n", i+1, str[i], strlen(str[i]));

    /*
     * Prefixo comum às saídas
     */
    printf("As duas strings s\204o de comprimentos ");
    if (strlen(str[0]) == strlen(str[1]))
         printf("iguais");
    else
        printf("diferentes");

    /*
     * Sufixo comum à saídas
     */
    printf(".\n");

    /*
     * Prefixo comum às saídas
     */
    printf("As duas strings possuem conte\243dos ");
    if (!strcmp(str[0], str[1]))
        printf("iguais");
    else
        printf("diferentes");

    /*
     * Sufixo comum às saídas
     */
    printf(".\n");

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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

/*
 * Prototipo da função para fazer a comparação
 */
static int comparar(const void*, const void*);

int main(int argc, char ** argv){
    /*
     * Declarar um vetor, tipo int, com os valores propostos pelo
     * exercício. Em adição a outra variável do mesmo tipo que fará a
     * contagem. E uma outra terceira que armazenará o valor repetido.
     */
    int vec[6] = {1, 2, 3, 4, 1, 5}, n, * rep = NULL; 

    /*
     * Processar a pesquisa
     */
    qsort(vec, 6, sizeof(int), comparar);
    for (n = 0; n < 6 && !rep; n++)
        rep = bsearch(&vec[n], vec, 6, sizeof(int), comparar);

    /*
     * Imprimir qual é o elemento repetido
     */
    printf("Elemento repetido: %d\n", vec[n-1]);

    /*
     * Retornar zero indicando que o programa cumpriu a sua função
     * corretamente.
     */
    return 0;
}

static int comparar(const void * param1, const void * param2){
    return (*(int*)param1 - *(int*)param2);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

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

int main(int argc, char ** argv){
    /*
     * Declarar duas matrizes, tipo char, que armzenará o nome dos
     * jogadores e o nome dos itens a serem sorteados (papel, pedra e
     * tesoura).
     * Em adição, um vetor, tipo int, que armazenará os números
     * sorteados.
     */
    char    jogador[2][260], * item[] = {
        "Pedra",
        "Papel",
        "Tesoura"
    };
    int     sorteio[2];

    /*
     * Começar o sorteio
     */
    srand(time(NULL));
    do{
        sorteio[0] = rand() % 3;
        sorteio[1] = rand() % 3;

        /*
         * Imprimir o resultado do sorteio
         */
        printf("Jogador #1: %s\nJogador #2: %s\n", item[sorteio[0]], item[sorteio[1]]);

        /*
         * Processar dados
         */

        if (sorteio[0] == sorteio[1]){
            printf("Houve empate!\n");
            continue;
        }

        /*
         * Imprimir um prefixo comum à todas as saídas
         */
        printf("Resultado: ");

        switch (sorteio[0] + sorteio[1]){
            case 1: printf("Papel");
                   break;
            case 2: printf("Pedra");
                   break;
            case 3: printf("Tesoura");
                   break;
        }

        /*
         * Imprimir um sufixo comum à todas as saídas
         */
        printf(".\n");

    }while (sorteio[0] == sorteio[1]);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

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

/*
 * Um prototipo de função que fará a comparação entre elementos
 */
static int comparar(const void*, const void*);

int main(int argc, char ** argv){
    /*
     * Declarar um vetor, tipo int, com 10 elementos. Um ponteiro do
     * tipo int que armazenará o e a posição em adição a uma variável
     * que me auxiliará
     */
    int vec[10], * item, n;

    /*
     * Gerar 10 números randômicos para a matriz. Mas antes vamos
     * alterar as configurações randômicas.
     */
    srand(time(0));
    for (n = 0; n < 10; n++){
        vec[n] = rand() % 100;
        printf("%d ", vec[n]);
    }

    qsort(vec, 10, sizeof(int), comparar);

    /*
     * Pedir ao usuário par que ele informe o valor a ser procurado
     * dentro do vetor
     */
    do{
        printf("Digite um n\243mero: ");
        scanf("%d", &n);

        item = bsearch(&n, vec, 10, sizeof(int), comparar);

        if (!item)
            printf("Este n\243mero n\204o existe no vetor.");
        else
            printf("O n\243mero %d est\240 na posi\207\204o %d!", * item, item - vec);
        printf("\n");
    }while (!item);

    return 0;
}

static int comparar(const void * prm1, const void * prm2){
    return (*(int*)prm1 - *(int*)prm2);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <stdio.h>
#include <math.h>

int main(int argc, char ** argv){
    /*
     * Declarar duas variáveis, tipo float, para armazenar a nota da prova
     * e a media do aluno.
     * E uma variável, tipo int, para fazer a contagem
     */
    float   nota, media;
    int     i, repetir;

    while (1){
        media = 0;
        repetir = 0;
        /*
         * Pedir ao usuário para que ele informe a nota
         */
        for (i = 0; i < 2; i++){
            printf("Informe a nota da %da. prova: ", i+1);
            scanf("%f", &nota);
            if (nota < 4.0f)repetir = 1;
            media += nota;
        }

        if (!repetir && round(media / 2.0f) >= 6.0f){
            printf("Parab\202ns voc\210 foi aprovado!\n");
            return 0;
        }

        printf("Reprovado, notas abaixo de 4 n\204o ser\204o v\240lidas. Informe a nota da 3a. prova: ");
        scanf("%f", &nota);

        media += nota;

        if (round(media / 3.0f) >= 6.0f){
            printf("Parab\202ns voc\210 foi aprovado!\n");
            return 0;
        }

        printf("Reprovado por nota!\n");
    }

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <stdio.h>

/*
 * Criar uma estrutura de dados para armazenar valores de acordo com a
 * minha preferência
 */

struct carro{
    char    * c_modelo;
    float   c_kpl;
    float   c_mvalor;
    float   c_uvalor;
    float   c_seguro;
    float   c_potencia;
};

/*
 * Declarar uma lista estática de carros
 */

static struct carro meu_carro[] = {
    {"Ferrari F50", 2.5e-1, 1.0e6, 7.5e5, 6.0e3, 5.13e2},
    {"Fiat Sedan", 9.96, 8.0e4, 5.0e4, 1.6e3, 8.0e1},
    {"Fiat Uno", 1.7e1, 3.0e4, 1.7e4, 5.0e2, 7.5e1},
    {"Fusca", 1.5e1, 7.0e3, 2.0e3, 4.65e2, 3.0e1},
    {"Opala", 1.7e1, 1.0e4, 7.5e3, 7.8e2, 4.0e1}
};

int main(int argc, char ** argv){
    /*
     * Declarar uma variável, tipo int, que armazenará a opção escolhida
     * pelo usuário
     */
    int i;

    /*
     * Exibir todos os modelos disponíveis na lista
     */
    for (i = 0; i < sizeof(meu_carro)/sizeof(struct carro); i++){
        printf("[%d] - %s\n", i, meu_carro[i].c_modelo);
    }

    printf("->");
    scanf("%d", &i);

    /*
     * Verificar o indice
     */
    if (i > 4)return 0;

    /*
     * Exibir carro selecionado
     */

    printf( "Modelo: %s\n"
            "KM por litro: %.2f\n"
            "Valor de mercado: %.2f\n"
            "Valor usado: %.2f\n"
            "Valor seguro: %.2f\n"
            "Valor potencia: %.2f\n",
            meu_carro[i].c_modelo,
            meu_carro[i].c_kpl,
            meu_carro[i].c_mvalor,
            meu_carro[i].c_uvalor,
            meu_carro[i].c_seguro,
            meu_carro[i].c_potencia
          );

    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109

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

/*
 * Criar uma estrutura de dados para armazenar valores de acordo com a
 * minha preferência
 */

struct carro{
    char    c_modelo[260];
    float   c_kpl;
    float   c_mvalor;
    float   c_uvalor;
    float   c_seguro;
    float   c_potencia;
};

/*
 * Declarar uma lista estática de carros
 */

static struct carro meu_carro[100] = {
    {"Ferrari F50", 2.5e-1, 1.0e6, 7.5e5, 6.0e3, 5.13e2},
    {"Fiat Sedan", 9.96, 8.0e4, 5.0e4, 1.6e3, 8.0e1},
    {"Fiat Uno", 1.7e1, 3.0e4, 1.7e4, 5.0e2, 7.5e1},
    {"Fusca", 1.5e1, 7.0e3, 2.0e3, 4.65e2, 3.0e1},
    {"Opala", 1.7e1, 1.0e4, 7.5e3, 7.8e2, 4.0e1}
};

int main(int argc, char ** argv){
    /*
     * Declarar uma variável, tipo int, que armazenará a opção escolhida
     * pelo usuário
     */
    int i, contador = 5;

    /*
     * Abrir o menu de opções
     */
    do{
        printf( "[0] Sair\n"
                "[1] Adicionar carros\n"
                "[2] Exibir carros\n"
                "->"
              );
        scanf("%d", &i);

        switch (i){
            case 1:
                printf("Nome: ");
                scanf("%s", meu_carro[contador].c_modelo);

                printf("KM por litro: ");
                scanf("%f", &meu_carro[contador].c_kpl);

                printf("Valor mercado: ");
                scanf("%f", &meu_carro[contador].c_mvalor);

                printf("Valor usado: ");
                scanf("%f", &meu_carro[contador].c_uvalor);

                printf("Seguro: ");
                scanf("%f", &meu_carro[contador].c_seguro);

                printf("Potencia: ");
                scanf("%f", &meu_carro[contador].c_potencia);
                
                contador++;
                break;
            case 2:
                /*
                 * Exibir todos os modelos disponíveis na lista
                 */
                for (i = 0; strlen(meu_carro[i].c_modelo) > 0; i++){
                    printf("[%d] - %s\n", i, meu_carro[i].c_modelo);
                }

                printf("->");
                scanf("%d", &i);

                /*
                 * Verificar o indice
                 */
                if (i > contador-1)return 0;

                /*
                 * Exibir carro selecionado
                 */

                printf( "Modelo: %s\n"
                        "KM por litro: %.2f\n"
                        "Valor de mercado: %.2f\n"
                        "Valor usado: %.2f\n"
                        "Valor seguro: %.2f\n"
                        "Valor potencia: %.2f\n",
                        meu_carro[i].c_modelo,
                        meu_carro[i].c_kpl,
                        meu_carro[i].c_mvalor,
                        meu_carro[i].c_uvalor,
                        meu_carro[i].c_seguro,
                        meu_carro[i].c_potencia
                      );
                i = 1;
                break;
        }
    }while (i != 0);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#include <stdio.h>

int main(int argc, char ** argv){
    /*
     * Declarar 3 variáveis, tipo int, que calculará a média de idade do
     * grupo e que armazenará as idades dos participantes e a contagem
     * do laço for
     */
    int media = 0, idade, i;

    /*
     * Questionar a idade de todos os 10 participantes
     */
    for (i = 0; i < 10; i++){
        printf("Qual sua idade? ");
        do{
            scanf("%d", &idade);
        }while (idade < 1); //Não aceitar idades menores que um
        /*
         * Adicionar à média
         */
        media += idade;
    }

    /*
     * Fazer a média aritmética
     */
    media /= 10;

    /*
     * Imprimir a média. E imprimir um prefixo comum à todas as saídas
     */
    printf("M\202dia de idade = %d.\nO grupo \202 : \"", media);

    /*
     * Processar a saída de acordo com a média de idade
     */
    if (media > 0 && media < 26)
        printf("Um grupo jovem");
    else if (media > 25 && media < 61)
        printf("Um grupo adulto");
    else if (media > 60)
        printf("Um grupo idoso");

    /*
     * Adicionar um sufixo comum à todas as saídas
     */
    printf(" \".\n");

    /*
     * Retornar zero indicando que o programa executou a sua função com
     * sucesso
     */
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>

int main(int argc, char ** argv){
    /*
     * Declarar 3 variáveis, tipo long long (2^64), para armazenar a tabuada, o
     * início e fim
     */
    long long tabuada, i, n;

    /*
     * Pedir informações para o usuário
     */
    printf("Montar tabuada de: ");
    scanf("%lld", &tabuada);
    printf("Come\207a por: ");
    scanf("%lld", &i);
    printf("Terminar em: ");
    scanf("%lld", &n);

    /*
     * Imprimir a tabuada
     */
    for (; i <= n; i++){
        printf("%03lld * %03lld = %03lld\n", tabuada, i, tabuada*i);
    }

    /*
     * Retornar zero indicando que o programa executou a sua função de
     * forma correta
     */
    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

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

/*
 * $$$Z7$8NDD8ZZZZ$$$$7I?II77IIII77I7I$IIIIII7Z$?III??7OZZD7$Z7
 * $7Z$7777I7I$$$7$$$Z$$OOZOO87$$777$$OOO$777O8O7?IZ$$$O8ZO+8ID
 * $777$$I7Z$ZOZZ8O8MMMMMMMMMMNO7I$7???OZ7OOD7O$II?77Z88MODZ8OD
 * $$7Z77I$O88O8NMMMMMMMMMMMMMMMMII+???OOZOZ?78O8?+?Z?OO8$DD8N7
 * Z$77777$OO8OMMMMMMMMMMMMMMMMMMMMN$?IDOOZI+OOZZN7I??+I$8?$IOD
 * O7$$$77Z8MMMMMMMMMMMMMMMMMMMMMMMMMOZ8OZOIO8$O?IZO7D8OZ8OODOO
 * 8ZO8$$O8MMMMMMMMMMMMMMMMMMMMMMMMMMMND8O7I$O$7$777I7$I?D8Z8OO
 * OZZ$Z8DDMMMMMMMMMMMMMMMMMMMMMNMNNMMMMDII????++?I????=+++++??
 * 7777Z8MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMD+?+++??+++~?78O~=I7IZ
 * III$MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMD77~7?+???$ZZ$OZZ=IZZ
 * 7IOMMMMMMMMMMMNNMMMMMMMMMMMMMMMMMMMMMMMM$7=~+=++?77$Z$Z++?II
 * $7MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM87I?~++?+?+I?7?~??++
 * $$MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNMMMN7??=?+++II+IZ$O7I+=
 * $DMMMMMMMMMMMMMMMMMMMMMMMNNNNNMMMMMMMMMMM$7?~==+?+I?+=+++?=+
 * $NMMMMMMMMMMMMMMMMMMMNMNMNMMNMMMMMMNNNMMMO???++?$7I?$+?II?++
 * 7OMMMMMMMMMMMMMMMMMMNNMMMNNNNMNMNNMMMMMMNO??+++++??I==~++++7
 * $ZMMMMMMMMMMMMNNMMMNNMMMMNDDDDNMNNMNNNNNM7I+~~====+===~++~~~
 * Z$8MMMMMMMMMMMMMMMNMNDD777I?DNNNMNMMNDDNNDZ$$$$$$778Z8DOII$7
 * OOO8MMMMMMMMMMMMMNNMODNNNNMMMMMMMNMMNMMNNNDO$77???~?$DDD?7ZO
 * 8Z7$NMMMMMMMMMMNNNNDNNNNNN8888O8NMNMMMMMMNDZOZ$7?=+?$777~===
 * OZ$7DMMMMMMMMMMMMNDN88OZI++??II8NDNMMMMNNMMN8OZIZ?+??$7I$+~:
 * ZZOZOMMMMMMMMMMMNNNN8$I+:,,,~~~=$NNNMMMMMNMMDDZ77:?IZO7Z?I?$
 * $7777OMMMNMMMMMMNNM8$?~~:,,,,::=?NNNNNMMMNNMMMNO7,=7~~IZ8Z?~
 * $$II7$ZMMNMMMMMNDM8?+=~~:,,,,,~:=+MNMMMMNNDNMMDDII+?I+Z7~?IZ
 * $$II7I7MMMMMMMMDMMI+=~=~::,,~Z,,==IDMMMMNDNNNMNO$+?I+7?I?+I?
 * $7I7777MNMMMMMM8NN?==~~~:~$D=:::8~~INMMMN8DNDMMN87?=~???7=:=
 * 777OZ$7DNMMMMMMMMMOI?+==~?+NMONNO:~~OMMMMNNDDNNN87+~++III?=+
 * 7II7ZOODMMMMMMMMMMMMO7+:,=$?O$:+,,:~?MMMMMNNDDNN8$=+~~=~?7$?
 * $7IIII7$NMMMMMNMMNN+7NI~,::?+=:,,,:=IDMMMMNNNNNMNO?+::+==77+
 * ZZZZZ$$ZZDMMMNN8ZD8$IOZ=,,,,::,..,:=?DMMMMMNNNDNND87I7?I7+++
 * ZZ$$OZZZ$78MMNII7II?7Z7+,,,,..,,,:~+?DMMMMMNMNNDNOZ77$7~7OI?
 * 7$$77$$$7$O8MM8III??7$7?,,,,,,,,,:=+=DMMMMNNNMMNN$I7??+????=
 * II7I?7$$77Z8MMM77III7$7?:,,,,::::~=~=NDMMNNNNMMMD8?I=+~~~=++
 * I77777Z$$7Z8MMMO7II7$Z??=,~:,,,,::~~=MNMMMNNNMMMDD77+?I?+?+,
 * 7$$7$$ZZ77ZNMN8D8II77$$Z7+,::,,,,:~=+MMMNMNNMMMMNN$I++=++I++
 * $$$777$$Z8MMDZ$O8$III77I==~~~:7~:~=+MMMMNMMNNNMMMM8????I??I+
 * $$77$ZO8NDNOZZ7ZO87IIII$77Z7=~::~~=8MDMMMMNDMMNMMNNOI+?$I+?I
 * 7$7II7DD8N8O~=I$ZO88?II777?++~~~~=ZNMIMMMMNNNMMMMMMMZ?++=I7I
 * 77III7ODD88OZ:=?7$ZZD7IIII??+=~:~$8MD7.MNMMMMMMMMMMMM$+?I++?
 * I7III$7Z77$ZZZ:=+?77DMN?I?++=~~+IZDMO7~MNMMMMMMMMMMMMD7$I?O7
 * Z$I??++7II7$7IZI~=??NND8OII?????7ODMZ7?MMMMMNNMMMMMMMN$$7$77
 * $?+======++?I?II7I,~8OZ$Z$$7IIII$8NM$7,MMMMMMMMMMMMMMMM$7?7?
 * ?==~~~~:~~~=++???7?+=,77I????III$8N$?+8DMMMMNMNMMMMMMMNMZ=?$
 * ===~:~:::::~~+=+?+??+=+?+==+?I77$O=:.I88DMMMNMMMMMMMMMMMM$??
 * =~=~:~::,,,:~==~+?+?==~I+=+?I7......~IZZNMMMMMMMMMMMMMMZM8II
 * ~~+~:~~:,..,,:=~:=+??+=~??IZ8+...,..:+I8NMMMMNNMMMMMMMMN+MMI
 * :=+~:::~~,...,:~:,~=++?+.I$8:.......=~+8MMMMMMMMMMMMMMMMOD+M
 * ~?+:,:,:~~,...,,~,,:~+=?=?8........:~:IDNMMMMMMMMMMMMMMMN7:=
 * =I+::~~,,:~:....,:,,,=~+?~........,,,~I8NNMMMMMDMMMMMMMMMM$:
 * ?I~:~~~,,,:~:....,:,.~~.~+.......,..~~?8DNMMMMNNNNMMMMNMMM8I
 * II:==~~:,.,,::,...,:,=:~.,=.....,..,~~?ZDNMMMMMMNDNMMMNMMNNN
 * I7=+++=,,,..,::,...,,=,.+.:........,~~+78DMMMMMMMNMMMNNMNMNN
 * ?Z+?++~,,,,,.,,:,...,=:.~:.........,,=+IZDMMMMMMMNNNNNMNMNMM
 * IZI?=~,::,,,,,,,,,,..~,,::.,......,:~~~?ONMMMMMMMMNDDNMMMMZM
 * 7$Z??=:,:,,,,,,,,,,,.:,..:~.....,:,,.,:?ONMMMMMMMNNDNNMMM8NM
 * 8DNI?II~:,,,,,,,,,,..,:,,,,..,,,,.....:?ZDMMMMNMMMMN8MMMNOM7
 * DDNI??+?~,,,:,,,,,,..+,..............,:=I8MMMMMMMMMNDMN?NM8:
 *                                              GlassGiant.com
 */

/*
 * Prototipo de função para inverter um vetor tipo char
 */
static void inverter(char*, int);

int main(int argc, char ** argv){
    /*
     * Declarar um vetor, tipo char, que armazenar o número.
     */
    char entrada[11];

    /*
     * Pedir para que o usuário informe um número
     */
    printf("Digite um n\243mero: ");
    scanf("%s", entrada);

    /*
     * Inverter a string
     */
    inverter(entrada, strlen(entrada));

    /*
     * Imprimir a string em forma de número
     */
    printf("Valor invertido = %d\n", atoi(entrada));

    /*
     * Retornar zero indicando que o programa executou a sua função
     * corretamente
     */
    return 0;
}

/*
 * Implementar a função de inverter o vetor
 */
static void inverter(char * str, int tam){
    /*
     * Declarar 2 variáveis, tipo int, que fará a contagem no laço for.
     * E um buffer temporário
     */
    int     i, n;
    char    * buffer;

    /*
     * Alocar o buffer temporário na memória, mas antes checar o tamanho
     * de 'tam'
     */
    if (tam > 0){
        buffer = malloc(tam+1);

        /*
         * Começar a inversão
         */
        for (i = tam-1, n = 0; i > -1; i--, n++)
            buffer[n] = str[i];

        /*
         * Copiar o buffer para str
         */
        memcpy(str, buffer, tam);

        /*
         * Desalocar o buffer temporário
         */
        free(buffer);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

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

static const char * text[] = {
    "#include <stdio.h>",
    "#include <string.h>",
    "",
    "static const char * text[] = {",
    "};",
    "",
    "int main(int argc, char ** argv){",
    "   /*",
    "    * Declarar vari\303\241vel, tipo int, para fazer a contagem no loop",
    "    */",
    "   int i;",
    "",
    "   /*",
    "    * Imprimir as 3 primeiras linhas do c\303\263digo-fonte",
    "    */",
    "   for (i = 0; i < 3; i++)",
    "       printf(\"%s\\n\", text[i]);",
    "",
    "   /*",
    "    * Imprimir a vari\303\241vel text",
    "    */",
    "   for (i = 0; text[i]; i++)",
    "       printf(\"%s\\n\", text[i]);",
    "",
    "   /*",
    "    * Imprimir o resto do c\303\263digo-fonte",
    "    */",
    "   for (i = 3; text[i]; i++)",
    "       printf(\"%s\\n\", text[i]);",
    "   /*",
    "    * Retornar zero indicando que o programa cumpriu a sua fun\303\247\303\243o",
    "    * de forma correta.",
    "    */",
    "   return 0;",
    "}",
    ""
};

int main(int argc, char ** argv){
    /*
     * Declarar variável, tipo int, para fazer a contagem no loop
     */
    int i;

    /*
     * Imprimir as 4 primeiras linhas do código-fonte
     */
    for (i = 0; i < 4; i++)
        printf("%s\n", text[i]);

    /*
     * Imprimir a variável text
     */
    for (i = 0; text[i]; i++)
       printf("\"%s\",\n", text[i]);

    /*
     * Imprimir o resto do código-fonte
     */
    for (i = 4; text[i] > 0; i++)
       printf("%s\n", text[i]);

    /*
     * Retornar zero indicando que o programa cumpriu a sua função
     * de forma correta.
     */
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

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

/*
 * Define uma constante
 */
#define NUM 2000000

int main(int argc, char ** argv){
    /*
     * Declarar um vetor, tipo char, que armazenará cada valor de 1 à
     * 2, 000, 000 sendo que cada elemento pode conter 1 (primo), 0 (não
     * primo). Declaremos também 3 variáveis, tipo int, um que fará a
     * contagem no laço for, para armazenar o próximo número primo da
     * lista e para armazenar o número total de primos na lista. E por
     * último temos a variável que vai armazenar a soma de todos os
     * primos.
     */
    char        num[NUM];
    int         i, n, primo = 0; 
    long long   soma = 0;

    /*
     * Definir todos os valores da lista como se fossem primos com
     * exceção de 0 e 1 que não são primos
     */
    memset(num, 1, NUM);
    num[0] = 0;
    num[1] = 0;

    /*
     * Este algoritmo deve ser repetido até que o número ao quadrado
     * seja maior ou igual ao número limite
     */
    while (pow(primo, 2) < NUM){
        /*
         * Procurar o próximo primo disponível na lista
         */
        while (!num[++primo]);

        /*
         * Todos os multiplos desse primo será considerado não primo
         */
        for (i = 2 * primo; i < NUM; i += primo)
            num[i] = 0;
    }

    /*
     * Fazer a contagem e a soma dos primos
     */
    for (i = 0, n = 0; i < NUM; i++){
        if (num[i] > 0){
            soma += i;
            n++;
        }
    }

    printf("Soma: %lld\nTotal de primos: %d\n", soma, n);
    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

#include <stdio.h>
#include <math.h>

/*
 * Constantes dos índices dentro da matriz
 */
#define X   0
#define Y   1
#define Z   2

/*
 * Declarar uma matriz, tipo int, para armazenar as soluções. E uma
 * variável para fazer a contagem das soluções.
 */
static int solucoes[9][3], i = 0;

/*
 * Essa parte consiste no prototipo de 3 funções:
 * testar_coeficientes, testar todos os valores possíveis para o calculo
 * simples, passando os fatores (a, b, c, e d) para calcular_fator.
 * calcular_fator, calcular os 4 fatores (a, b, c e d) e passar os
 * fatores (p, q, r e s) para adicionar_solucao.
 * adicionar_solucao, calcular as 3 incógnitas (x, y e z) dado os
 * valores de p, q, r e s.
 *
 * Para mais dúvidas leia:
 * maa.org/editorial/euler/HEDI%2065%20Sums%20that%20are%20squares.pdf
 */
static void testar_coeficientes();
static void calcular_fator(int, int, int, int);
static void adicionar_solucao(int, int, int, int);

int main(int argc, char ** argv){
    /*
     * Gerar valores para a matriz solucoes
     */
    testar_coeficientes();

    /*
     * Achar a solução em que x != y, x != z e y != z
     */
    for (
            i = 0;
            (solucoes[i][X] == solucoes[i][Y]) ||
            (solucoes[i][X] == solucoes[i][Z]) ||
            (solucoes[i][Y] == solucoes[i][Z]);
            i++
        );

    /*
     * Imprimir a solução
     */
    printf("X = %d, Y = %d e Z = %d\nX + Y + Z = %d\n",
            solucoes[i][X],
            solucoes[i][Y],
            solucoes[i][Z],
            solucoes[i][X] + solucoes[i][Y] + solucoes[i][Z]
          );

    /*
     * Retornar zero, indicando que o programa cumpriu a sua função
     */
    return 0;
}

static void testar_coeficientes(){
    int f, g;

    for (g = 1; g < 3; g++)
        for(f = 1; f < 3; f++)
            /*
             * Você pode ler no artigo e verás que:
             * a = 4f^2 * g^2
             * b = f^4 - 2f^2 * g^2 + 9 * g^4
             * c = f^4 + 2f^2 * g^2 + 9 * g^4
             * d = 4f^2 * g^2
             */
            calcular_fator(
                    4 * pow(f, 2) * pow(g, 2),
                    pow(f, 4) - 2 * pow(f, 2) * pow(g, 2) + 9 * pow(g, 4),
                    pow(f, 4) + 2 * pow(f, 2) * pow(g, 2) + 9 * pow(g, 4),
                    4 * pow(f, 2) * pow(g, 2)
                    );
}

static void calcular_fator(int a, int b, int c, int d){
    /*
     * No artigo você perceberá que para encontrarmos os valores de p,
     * q, r e s:
     * p = a * c + b * d
     * q = |a * d + b * c|
     * r = a * d + b * c
     * s = |a * c - b * d|
     */
    adicionar_solucao(
            a * c + b * d,
            abs(a * d - b * c),
            a * d + b * c,
            abs(a * c - b * d)
            );
}

static void adicionar_solucao(int p, int q, int r, int s){
    /*
     * E por fim essa função calcular a solução (x, y, z).
     * x = p^2 + q^2
     * y = 2 * p * q
     * z = 2 * r * s
     */
    solucoes[i][X] = pow(p, 2) + pow(q, 2);
    solucoes[i][Y] = 2 * p * q;
    solucoes[i][Z] = 2 * r * s;

    /*
     * Incrementa a posição na matriz
     */
    i++;
}