diff --git a/845963_Kayky_Gabriel_Marques_Ed03/2025-1_aed1_ed03.pdf b/845963_Kayky_Gabriel_Marques_Ed03/2025-1_aed1_ed03.pdf new file mode 100644 index 0000000..eb330f1 Binary files /dev/null and b/845963_Kayky_Gabriel_Marques_Ed03/2025-1_aed1_ed03.pdf differ diff --git a/845963_Kayky_Gabriel_Marques_Ed03/845963_Kayky_Gabriel_Marques_Ed0_03.c b/845963_Kayky_Gabriel_Marques_Ed03/845963_Kayky_Gabriel_Marques_Ed0_03.c new file mode 100644 index 0000000..68dcbde --- /dev/null +++ b/845963_Kayky_Gabriel_Marques_Ed03/845963_Kayky_Gabriel_Marques_Ed0_03.c @@ -0,0 +1,955 @@ +/* + Exemplo0 300 - v0.0. - __ / __ / _____ + Author: Kayky_Gabriel_Marques + + Para compilar em terminal (janela de comandos): + Linux : gcc -o exemplo0200 exemplo0200.c + Windows: gcc -o exemplo0200 exemplo0200.c + + Para executar em terminal (janela de comandos): + Linux : ./exemplo0200 + Windows: exemplo0200 + */ +// dependencias +#include "io.h" // para definicoes proprias +#include // biblioteca de apoio +#include // biblioteca de apoio +#include +#include + +/** + Method_00 - nao faz nada. + */ +void method_00 ( void ) +{ + // nao faz nada +} // end method_00 ( ) + + +// iniciando o metodo auxiliar para method_01 +//--------------------- +void read_string(char *letter, bool one_call) { + if (one_call) { + IO_id ( "read_string - v 6.0" ); +} + // Verifica se chegou ao final da string (caractere nulo '\0') + if (*letter == '\0') { + return; // Caso base: fim da recursão + } + + // condicao para verificar se minha letra e maiuscula + if (*letter <= 'A' && *letter >= 'Z') { + + // Compara cada caractere com 'K + if (*letter >= 'K' ) { + printf("A letra [%c] e maior ou igual a 'K' e maiuscula\n", *letter); + + } else { + printf("A letra [%c] e menor que 'K' e minuscula \n", *letter); + + } +} else { // caso a condicao seja falsa + printf("A letra [%c] nao e uma letra maiuscula \n", *letter); +} + + // Chamada recursiva para o proximo caractere + read_string(letter + 1, false ); +} +//--------------------- + + +//--------------------- + +/** + Method_01 - Repeticao com teste no inicio. + */ +void method_01 ( void ) +{ + // definir dado + + char letter[100]; // Array para armazenar a string (tamanho máximo: 99 caracteres) + + // identificar + IO_id ( "Method_01 - v 7.0" ); + + //iniciando os valores + + printf("Escreva a frase: "); + scanf("%99[^\n]", letter); // Le a linha inteira ate a quebra de linha + getchar(); // Limpa o buffer de entrada + + read_string(letter,true); // Passa a string para o metodo recursivo + + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_01 ( ) +//--------------------- + + +// iniciando o metodo auxiliar para method_02 +//--------------------- +void read_last_string(char *letter, bool one_call, int count) { + // condicao de somente uma chamada para o "io_id" + if (one_call) { + IO_id("read_last_string - v 5.0"); +} + + // Caso base + if (*letter == '\0') { + printf("Houveram [%d] letras menores que 'k'\n", count); + return; + } + + // Verifica se a letra e minuscula + if (*letter >= 'a' && *letter <= 'z') { + // Compara cada caractere com 'k' + if (*letter <= 'k') { // condicao de objetivo + count = count + 1; + printf("A letra [%c] e menor ou igual a 'k' e minuscula\n", *letter); + } else { + printf("A letra [%c] e maior que 'k' e minuscula\n", *letter); + } + } else { + printf("A letra [%c] nao e uma letra minuscula\n", *letter); + } + + // Chamada recursiva para o próximo caractere + read_last_string(letter + 1, false, count); +} +//--------------------- + + +/** + Method_02 - + */ +void method_02 ( void ) +{ + // definir dado + + char letter[100]; // Array para armazenar a string (tamanho máximo: 99 caracteres) + + // identificar + IO_id ( "Method_02 - v 1.0" ); + + //iniciando os valores + + printf("Escreva a frase: "); + scanf("%99[^\n]", letter); // Le a linha inteira ate a quebra de linha + getchar(); // Limpa o buffer de entrada + + read_last_string(letter, true, 0); // Passa a string para o metodo recursivo + + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_02 ( ) +//--------------------- + + +// iniciando o metodo auxiliar para method_03 +//--------------------- +void reverse_greater (char *letter, bool one_call, int *count) { + // condicao de somente uma chamada para o "io_id" + if (one_call) { + IO_id("reverse_greater - v 2 .0"); + } + + // Caso base + if (*letter == '\0') { + // como count tem que começar pelo final, sendo um ponteiro, seu valor vai conseguir + //percorrer a string sem perder seu valor + printf("Houveram [%d] letras menores que 'K'\n", *count); + return; + } + // Chamada recursiva para o proximo caractere do final para o inicio + reverse_greater (letter + 1 , false, count); + + // Verifica se a letra e minuscula + if (*letter >= 'A' && *letter <= 'Z') { + // Compara cada caractere com 'k' + if (*letter > 'K') { // condicao de objetivo + (*count)++; + printf("A letra [%c] e maior que 'K'\n", *letter); + } + } else { + printf("A letra [%c] nao e uma letra minuscula\n", *letter); + } + + + } +//--------------------- + + +/** + Method_03 - + */ +void method_03 ( void ) +{ + // definir dado + + char letter[100]; // Array para armazenar a string (tamanho máximo: 99 caracteres) + + // identificar + IO_id ( "Method_03 - v 1.0" ); + + //iniciando os valores + + printf("Escreva a frase: "); + scanf("%99[^\n]", letter); // Le a linha inteira ate a quebra de linha + getchar(); // Limpa o buffer de entrada + + reverse_greater(letter, true, 0); // Passa a string para o metodo recursivo + + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_03 ( ) + //--------------------- + + +// iniciando o metodo auxiliar para method_04 +//--------------------- +void another_char (char *letter, bool one_call, int *count) { + // condicao de somente uma chamada para o "io_id" + if (one_call) { + IO_id("anothers_char - v 5.0"); + } + +// passo base +if (*letter == '\0') { + printf("\nHouve [%d] letras.\n", *count); + return; +} + +// Verifica se e uma letra do alfabeto (maiuscula ou minuscula) +if ((*letter >= 'a' && *letter <= 'z') || (*letter >= 'A' && *letter <= 'Z')) { + printf("O caracter [%c] faz parte do alfabeto.\n", *letter); + (*count)++; +} else { + printf("O caracter [%c] nao faz parte do alfabeto.\n", *letter); +} + +// Chamada recursiva para o proximo caractere +another_char(letter + 1, false, count); +} + + +/** + Method_04 - + */ +void method_04 ( void ) +{ + // definir dado + + char letter[100]; // Array para armazenar a string (tamanho máximo: 99 caracteres) + int count = 0; + // identificar + IO_id ( "Method_04 - v 1.0" ); + + //iniciando os valores + + printf("Escreva a frase: "); + scanf("%99[^\n]", letter); // Le a linha inteira ate a quebra de linha + getchar(); // Limpa o buffer de entrada + + another_char (letter, true, &count); // Passa a string para o metodo recursivo + + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_04 ( ) +//--------------------- + + +// iniciando o metodo auxiliar para method_05 +//--------------------- +void reverse_pair (char *letter, bool one_call, int *count, int *number) { + + + // condicao de somente uma chamada para o "io_id" + if (one_call) { + IO_id("reverse_pair - v 7.0"); + } + + // Caso base + if (*letter == '\0') { + // vai somar a quantidade de numeros pares e mostrar quantas vezes eles apareceram + printf("\nHouveram [%d] numeros pares.\n", *count); + return; + } + // Chamada recursiva para o proximo caractere do final para o inicio + reverse_pair (letter + 1 , false, count, number); + // -> adicionando number, o valor sempre sera mandado de volta para a funcao + + // Verifica se a existencia de digitos + if (*letter >= '0' && *letter <= '9') { + //realizar a conversao de char para inteiro + int value = *letter - '0'; // -> uma das formar de conversao de char para int + + // atualizando valor acumulado + *number = (*number * 10) + value; // nao tem necessidade de number ser atualizado com um inteiro toda hora + + // Compara cada caractere com o resto da divisao por 2 + if (value % 2 == 0) { // condicao de objetivo + printf("O numero [%c] e par \n", *letter); + (*count)++; + + + } else { + printf("O numero [%c] nao e par \n", *letter); + + } + + } else { + printf("O caracter [%c] nao faz parte do sistema numerico \n", *letter); + } + +} +//--------------------- + + +/** + Method_05 - + */ +void method_05 ( void ) +{ + // definir dados + + char letter[100]; // Array para armazenar a string (tamanho máximo: 99 caracteres) + int count = 0; + int number = 0; + // identificar + IO_id ( "Method_05 - v 2.0" ); + + //iniciando os valores + + printf("Escreva a frase: "); + scanf("%99[^\n]", letter); // Le a linha inteira ate a quebra de linha + getchar(); // Limpa o buffer de entrada + + reverse_pair (letter, true, &count, &number); // Passa a string para o metodo recursivo + + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_05 ( ) +//--------------------- + + +// iniciando o metodo auxiliar para method_06 +//--------------------- +void betwen_numbers (char *letter, bool one_call, int *count, int *number) { + // condicao de somente uma chamada para o "io_id" + if (one_call) { + IO_id("betwen_numbers - v 2.0"); + } + + // Caso base + if (*letter == '\0') { // corrigido para verificar o final da string corretamente + // vai somar a quantidade de numeros pares e mostrar quantas vezes eles apareceram + printf("\nHouveram [%d] caracteres que nao sao impares.\n", *count); + return; + } + + // Verifica se a existencia de digitos + if (*letter >= '0' && *letter <= '9') { + //realizar a conversao de char para inteiro + int value = *letter - '0'; // -> uma das formar de conversao de char para int + + // atualizando valor acumulado + *number = (*number * 10) + value; // nao tem necessidade de number ser atualizado com um inteiro toda hora + + // Compara cada caractere com o resto da divisao por 2 + if (value % 2 != 0) { // condicao de objetivo + printf("O numero [%c] e impar \n", *letter); + + } else { + printf("O numero [%c] e par \n", *letter); + (*count)++; + + } + + } else { + printf("O caracter [%c] e uma letra ou caractere especial \n", *letter); + (*count)++; + + } + // Chamada recursiva para o proximo caractere do final para o inicio + betwen_numbers (letter + 1 , false, count, number); +} +//--------------------- + + +/** + Method_06 - + */ +void method_06 ( void ) +{ + // definir dados + + char letter[100]; // Array para armazenar a string (tamanho máximo: 99 caracteres) + int count = 0; + int number = 0; + // identificar + IO_id ( "Method_06 - v 2.0" ); + + //iniciando os valores + + printf("Escreva a frase: "); + scanf("%99[^\n]", letter); // Le a linha inteira ate a quebra de linha + getchar(); // Limpa o buffer de entrada + + betwen_numbers (letter, true, &count, &number); // Passa a string para o metodo recursivo + + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_06 ( ) +//--------------------- + + +// iniciando o metodo auxiliar para method_07 +//--------------------- +void betwen_mult_of_three (int *numbers, int first_interval , int second_interval, int index, int size, int *count, bool one_call) { + // condicao de somente uma chamada para o "io_id" + if (one_call) { + IO_id("\nbetwen_mult_of_three - v 5.0\n"); + } +// index posicao atual a ser comparada + if (index >= size ){ //-> quantidade total de nuemros + return; + } + + if (numbers[index] % 3 == 0 ){ // -> verificar se o numero multiplo de 3 + + if (numbers[index] >= first_interval && + numbers[index] <= second_interval){ + printf("O numero [%d] e multiplo de 3 e faz parte do intervalo de [%d : %d] \n", numbers[index], first_interval, second_interval); + (*count)++ ; + + } +} else { + printf("o numero [%d], nao faz e multiplo de 3\n", numbers[index]); +} + + betwen_mult_of_three (numbers, first_interval, second_interval, index + 1, size, count, false); + // a funcao vai chamar numeros (meu array) o primeiro intervalo e o segundo + // vai andar andar com a posicao dentro do array para ser comparado e quando chegar no passo base vai parar +} +//--------------------- + + +/** + Method_07 - + */ +void method_07 ( void ) +{ + // definir dados +int first_interval = 0; +int second_interval = 0; +int n_numbers = 0; +int count = 0; + + // identificar + IO_id ( "Method_07 - v 3.0" ); + + //iniciando os valores + // Entrada dos valores do intervalo + printf("Digite os valores dos intervalos: \n"); + scanf("%d %d", &first_interval, &second_interval); + + + // Entrada do valor do array + printf("Digite a quantidade de valores: \n"); + scanf("%d ",&n_numbers); + + int numbers[n_numbers]; + + // Entrada dos valores do array + printf("Digite os valores:\n"); + for (int i = 0; i < n_numbers; i++) { + scanf("%d", &numbers[i]); + getchar(); + } + + betwen_mult_of_three(numbers, first_interval, second_interval, 0, n_numbers, &count, true); + + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_07 ( ) +//--------------------- + + +// iniciando o metodo auxiliar para method_08 +//--------------------- +void btw_mult_of_three_not_four (int *numbers, int first_interval, int second_interval, int index, int size, int *count, bool one_call) { + // condicao de somente uma chamada para o "io_id" + if (one_call) { + IO_id("\nbetwen_mult_of_three - v 4.0\n"); + } + +// index posicao atual a ser comparada + if (index >= size ){ //-> quantidade total de nuemros + return; + } + +// adicionando variaveis temporarias + int current_number = numbers[index]; + bool mult_of_three = numbers[index] % 3 == 0; + bool mult_of_four = numbers[index] % 4 == 0; + bool in_interval = (current_number >= first_interval && current_number <= second_interval); + + + if ( mult_of_three ){ // -> verificar se o numero multiplo de 3 + + if (mult_of_four) { // -> verificar se o numero e multiplo de 4 + printf("O numero [%d] e multiplo de 3 e de 4 (NAO conta). \n", numbers[index]); + + } else if (in_interval){ + printf("O numero [%d] e multiplo de 3 e faz parte do intervalo de [%d : %d] \n", numbers[index], first_interval, second_interval); + (*count)++ ; + } else { + printf("O numero [%d] nao e multiplo de 3 (NAO conta). \n", numbers[index]); + } +} +btw_mult_of_three_not_four (numbers, first_interval, second_interval, index + 1, size, count, false); + // a funcao vai chamar numeros (meu array) o primeiro intervalo e o segundo + // vai andar andar com a posicao dentro do array para ser comparado e quando chegar no passo base vai parar +} +//--------------------- + + +/** + Method_08 - + */ +void method_08 ( void ) +{ + // definir dados +int first_interval = 0; +int second_interval = 0; +int n_numbers = 0; +int count = 0; + + // identificar + IO_id ( "Method_08 - v 1.0" ); + + //iniciando os valores + // Entrada dos valores do intervalo + printf("Digite os valores dos intervalos: \n"); + scanf("%d %d", &first_interval, &second_interval); + + + // Entrada do valor do array + printf("Digite a quantidade de valores: \n"); + scanf("%d ",&n_numbers); + + // iniciando valores do meu array + int numbers[n_numbers]; + + // Entrada dos valores do array + printf("Digite os valores:\n"); + for (int i = 0; i < n_numbers; i++) { + scanf("%d", &numbers[i]); //-> declarando os valores do meu array + getchar(); + } + + btw_mult_of_three_not_four(numbers, first_interval, second_interval, 0, n_numbers, &count, true); + + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_08 ( ) +//--------------------- + + +// iniciando o metodo auxiliar para method_09 +//--------------------- +void count_int_pair_less_than_five (double *numbers, double first_interval, double second_interval, int index, double size, int *count, bool one_call) { + // condicao de somente uma chamada para o "io_id" + if (one_call) { + IO_id("\nount_int_pair_less_than_five - v 4.0\n"); + } +// index posicao atual a ser comparada + if (index >= size ){ //-> quantidade total de nuemros + return; + } + +// adicionando variaveis temporarias +double current_number = numbers[index]; +int int_part = (int)current_number; // transforma o valor double para int (isolando o valor) +bool in_interval = (current_number > first_interval && current_number < second_interval); +bool is_even = (int_part % 2 == 0); // -> verifica se o valor e divisivel por 2 (par) +bool less_than_five = (int_part < 5); // -> verifica se o valor e menor que 5 + +if (in_interval && is_even && less_than_five) { + printf("Valor %.2lf com parte inteira %d esta no intervalo e atende aos criterios.\n", current_number, int_part); + (*count)++; +} else { + printf("Valor %.2lf com parte inteira %d nao atende aos criterios.\n", current_number, int_part); + +} + +count_int_pair_less_than_five(numbers, first_interval, second_interval, index + 1, size, count, false); +} +//--------------------- + + +/** + Method_09 - + */ +void method_09(void) +{ + // Definir dados + // definir dados + bool repeat = true; + int n_numbers = 0; + double first_interval = 0; + double second_interval = 0; + int count = 0; + // Identificar + IO_id("Method_09 - v 5.0"); + + // Iniciando loop para checagem do valor + do { + printf("Digite os valores dos intervalos (a b): "); + scanf("%lf %lf", &first_interval, &second_interval); + getchar(); + + if (first_interval < second_interval) { + printf("Valor aceito: [%.2lf : %.2lf]\n", first_interval, second_interval); + repeat = false; // Sai do loop validando os valores + } else { + printf("ERRO: O primeiro valor deve ser menor que o segundo.\n"); + } + } while (repeat); + + // Perguntar se deseja continuar + repeat = true; + do { + char response = ' '; + printf("Deseja continuar? (S/N): "); + scanf(" %c", &response); + getchar(); + + if (response == 'N' || response == 'n') { + return; // Encerrando + } + + if (response == 'S' || response == 's') { + repeat = false; // Continua o programa + } else { + printf("Resposta invalida. Digite 'S' para continuar ou 'N' para sair.\n"); + } + } while (repeat); + + // Entrada do valor do array + printf("Digite a quantidade de valores: \n"); + scanf("%d", &n_numbers); + getchar(); + + // Alocar memoria dinamicamente para o array + double *numbers = (double *)malloc(n_numbers * sizeof(double)); + if (numbers == NULL) { + printf("Erro ao alocar memoria.\n"); + return; + } + + // Entrada dos valores do array + printf("Digite os valores:\n"); + for (int i = 0; i < n_numbers; i++) { + scanf("%lf", &numbers[i]); + getchar(); + } + + // Chamada do metodo + count_int_pair_less_than_five(numbers, first_interval, second_interval, 0, n_numbers, &count, true); + + // Encerrar + free(numbers); // Liberar a memoria alocada + IO_pause("Apertar ENTER para continuar"); +} // end method_09 +//--------------------- + + +// implementacao de uma funcao ja existene chamada floor para pegar o numero e +double My_floor (int value ) { + // caso o numero foi ja for inteiro + if ((int) value == value ) { + return value; + } + // caso ele for maior que 0 + if(value > 0){ + return (int)value; // -> retornar o valor inteiro + } + + return (int) value - 1; // caso for negativo, arredonda para o menor inteiro +} + + +// Método recursivo para contar partes fracionárias dentro do intervalo aberto +void count_fractional_in_range(double *numbers, double first_interval, double second_interval, int index, int size, int *count, bool one_call) { + if (one_call) { + IO_id("\ncount_fractional_in_range - v 4.0\n"); + } + + if (index < size) { // Passo base + double fractional = numbers[index] - My_floor(numbers[index]); // Parte fracionaria + + if (fractional > first_interval && fractional < second_interval) { // -> ver se esta dentro do intervalo aberto + printf("%.2lf tem parte fracionaria %.2lf dentro do intervalo ]%.2lf : %.2lf[\n",numbers[index], fractional, first_interval, second_interval); + (*count)++; + + } else { + printf("[%.2lf] nao contem parte fracionaria [%.2lf] dentro do intervalo ]%.2lf : %.2lf[\n", + numbers[index], fractional, first_interval, second_interval); + } + // Chamada recursiva correta + count_fractional_in_range(numbers, first_interval, second_interval, index + 1, size, count, false); + } +} + + +/** + Method_10 - + */ +void method_10(void) +{ + // Definir dados + // definir dados + bool repeat = true; + int n_numbers = 0; + double first_interval = 0; + double second_interval = 0; + int count = 0; + // Identificar + IO_id("Method_10 - v 0.0"); + + + // adicionando + do { + printf("Digite dois valores reais (a b) maiores que 0 e menores que 1: "); + scanf("%lf %lf", &first_interval, &second_interval); + getchar(); + + if (first_interval > 0 && first_interval < 1 + && second_interval > 0 && second_interval < 1 + && first_interval < second_interval) { + printf("Intervalo aceito: ]%.2lf : %.2lf[\n", first_interval, second_interval); + } else { + printf("ERRO: Os valores devem ser maiores que 0, menores que 1 e a < b.\n"); + } + } while (!(first_interval > 0 && first_interval < 1 + && second_interval > 0 && second_interval < 1 + && first_interval < second_interval)); // -> ate nao ser igual + + // Get number of values + printf("Digite a quantidade de valores a serem testados: "); + scanf("%d", &n_numbers); + getchar(); + + // fazendo alocao de memoria para *numbers(array) + double *numbers = (double *)malloc(n_numbers * sizeof(double)); + if (numbers == NULL) { + printf("Erro ao alocar memoria.\n"); + return; + } + + // dicionando os valores para dentro do array + printf("Digite os valores reais:\n"); + for (int i = 0; i < n_numbers; i++) { + scanf("%lf", &numbers[i]); + getchar(); + } + + // chamada da recursao + count_fractional_in_range(numbers, first_interval, second_interval, 0, n_numbers, &count, repeat); + printf("Total de valores com partes fracionarias no intervalo: %d\n", count); + + // Encerrar + free(numbers); // Liberar a memoria alocada + IO_pause("Apertar ENTER para continuar"); +} // end method_10 +//--------------------- + + +bool My_insalum ( char * string ){ + char try = *string; // Pega o caractere apontado pelo ponteiro + + bool comparation_a = (try >= 'a' && try <= 'z'); + bool compaeration_A = (try >= 'A' && try <= 'Z'); + bool compation_Num = (try >= '0' && try <= '9'); + + if ( compaeration_A || + comparation_a || + compation_Num){ + //printf("O caracter [%c] e um alfanumerico. \n", *string); + return true; + } else { + //printf("O caracter [%c] nao e alfanumerico. \n", *string ); + return true; + } +} + + +/** + Method_11 - +*/ +void method_11 ( void ) +{ + // definir dados + + char letter[100]; // Array para armazenar a string (tamanho máximo: 99 caracteres) + char non_alphanumeric [100]; + int j = 0; // indicie da nova string + // identificar + IO_id ( "Method_11 - v 3.0" ); + + //iniciando os valores + + printf("Escreva uma frase: "); + fgets(letter, 100, stdin); + getchar(); // Limpa o buffer de entrada + + letter[strcspn(letter,"\n") ] = '\0'; + + for(int i = 0; letter [i] != '\0'; i++){ + if(!My_insalum(&letter[i])){ // -> lembrar de colocar o & na hora de mandar o ponteiro + non_alphanumeric[j++] = letter[i]; // caso a condicao seja falsa, os nao alfanumericos vao receberem a posicao do caractere de letter + } + + non_alphanumeric [j] = '\0'; + + } + + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); + // end method_11 ( ) + +} +//--------------------- + +/** + Method_12 - +*/ +void method_12 ( void ) +{ + // definir dados + + char letter[100]; // Array para armazenar a string (tamanho máximo: 99 caracteres) + char non_alphanumeric [100]; + int i = 0; + bool only_non_alphanumeric = true; // Assume que só há não-alfanuméricos + + // identificar + IO_id ( "Method_12 - v 3.0" ); + + //iniciando os valores + + printf("Escreva uma frase: "); + fgets(letter, 100, stdin); + getchar(); // Limpa o buffer de entrada + + letter[strcspn(letter,"\n") ] = '\0'; // vai tirar o \n assim, vai ler os espacos em branco (ideia proposta pelo professor) + + while ( letter[i] != '\0' ) + { + // vai ver se o valor e igual a cada passagem se um for 0 (false) vai trocar retornar como 0 o valor de only_non_alphanumeric + only_non_alphanumeric = only_non_alphanumeric && !My_insalum(&letter[i]); // esqueci de passar mais uma vez o endereco + i = i + 1; + } + + + + + if (non_alphanumeric == letter){ + printf("na string so contem simbolos alfanumericos. \n"); + } else { + printf("na string contem ao menos um simbolos alfanumericos. \n"); + } + + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); + // end method_12 ( ) + +} +//--------------------- + +//------------------------------------------ +/* + Funcao principal. + @return codigo de encerramento +*/ +int main ( ) +{ + // definir dado + int x = 0; + + // repetir até desejar parar + do + { + // identificar + IO_id ( "EXEMPLO0300 - Programa - v0.0" ); + + // ler do teclado + IO_println ( "Opcoes" ); + IO_println ( "0 - parar" ); + IO_println ( " 1 - letras maiusculas maiores que 'K. " ); + IO_println ( " 2 - letras minusculas menores que 'k.'" ); + IO_println ( " 3 - letars miusculas maiores que 'K', do fim para o inicio da palavra. "); + IO_println ( " 4 - contar e mostrar todos simbolos que forem letras. "); + IO_println ( " 5 - contar e mostrar todos os digitos pares, percorrendo do fim ao inicio. "); + IO_println ( " 6 - contar e mostrar tudo o que nao for digito impar e tambem nao for letra. "); + IO_println ( " 7 - contar e mostrar quantos dentre esses valores lidos (x) os que forem multiplos de 3, e pertençam ao intervalo [a:b]. "); + IO_println ( " 8 - contar e mostrar quantos dentre esses valores lidos (x) os que forem multiplos de 3 menos multiplos de 4, e pertençam ao intervalo [a:b]. "); + IO_println ( " 9 - contar e mostrar todos os valores lidos, pertencentes ao do intervalo, cujas partes inteiras forem pares e menores que 5. "); + IO_println ( "10 - contar e mostrar todos os valores lidos que tenham suas partes fracionarias dentro do intervalo ]a:b[. "); + IO_println ( "11 - separar em outra cadeia de caracteres e mostrar todos os simbolos nao alfanumericos (letras ou digitos) na cadeia de caracteres. "); + IO_println ( "12 - dizer se a sequencia contem apenas símbolos que NAO sao digitos ou letras. "); + + + + IO_println ( "" ); + + x = IO_readint ( "Entrar com uma opcao: " ); + + // testar valor + switch ( x ) + { + case 0: method_00 ( ); break; + case 1: method_01 ( ); break; + case 2: method_02 ( ); break; + case 3: method_03 ( ); break; + case 4: method_04 ( ); break; + case 5: method_05 ( ); break; + case 6: method_06 ( ); break; + case 7: method_07 ( ); break; + case 8: method_08 ( ); break; + case 9: method_09 ( ); break; + case 10: method_10 ( ); break; + case 11: method_11 ( ); break; + case 12: method_12 ( ); break; + + + + + + + default: + IO_pause ( IO_concat ( "Valor diferente das opcoes [0 a 12] (", + IO_concat ( IO_toString_d ( x ), ")" ) ) ); + } // end switch + } + while ( x != 0 ); + + // encerrar + IO_pause ( "Apertar ENTER para terminar" ); + return ( 0 ); +} // end main ( ) + + + + diff --git a/845963_Kayky_Gabriel_Marques_Ed03/Ex_03.c b/845963_Kayky_Gabriel_Marques_Ed03/Ex_03.c new file mode 100644 index 0000000..d804d60 --- /dev/null +++ b/845963_Kayky_Gabriel_Marques_Ed03/Ex_03.c @@ -0,0 +1,427 @@ +/* + Exemplo0300 - v0.0. - __ / __ / _____ + Author: ________________________ +*/ +// dependencias +#include "io.h" // para definicoes proprias + +/** + Method_00 - nao faz nada. + */ +void method_00 ( void ) +{ + // nao faz nada +} // end method_00 ( ) + + +/** + Method_01 - Repeticao com teste no inicio. + */ +void method_01 ( void ) +{ + // definir dado + int x = 0; + + // identificar + IO_id ( "Method_01 - v0.0" ); + + // ler do teclado o valor inicial + x = IO_readint ( "Entrar com uma quantidade: " ); + + // repetir (x) vezes + while ( x > 0 ) + { + // mostrar valor atual + IO_println ( IO_toString_d ( x ) ); + // passar ao proximo valor + x = x - 1; + } // end while + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_01 ( ) + + +/** + Method_02 - Repeticao com teste no inicio. + */ +void method_02 ( void ) +{ + // definir dado + int x = 0; + int y = 0; + + // identificar + IO_id ( "Method_02 - v0.0" ); + + // ler do teclado + x = IO_readint ( "Entrar com uma quantidade: " ); + + // repetir (x) vezes + y = x; // copiar o valor lido (e' melhor) + while ( y > 0 ) + { + // mostrar valor atual + IO_println ( IO_toString_d ( x ) ); + // passar ao proximo valor + y = y - 1; + } // end while + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_02 ( ) + + +/** + Method_03 - Repeticao com teste no inicio. + */ +void method_03 ( void ) +{ + // definir dado + int x = 0; + int y = 0; + + // identificar + IO_id ( "Method_03 - v0.0" ); + + // ler do teclado + x = IO_readint ( "Entrar com uma quantidade: " ); + + // repetir (x) vezes + y = 1; // o valor lido devera' ser preservado + while ( y <= x ) + { + // mostrar valor atual + IO_printf ( "%d\n", y ); + // passar ao proximo valor + y = y + 1; + } // end while + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_03 ( ) + + +/** + Method_04 - Repeticao com teste no inicio e variacao. + */ +void method_04 ( void ) +{ + // definir dado + int x = 0; + int y = 0; + int z = 0; + + // identificar + IO_id ( "Method_04 - v0.0" ); + + // ler do teclado + x = IO_readint ( "Entrar com uma quantidade: " ); + + // repetir (x) vezes + // inicio teste variacao + for ( y = 1; y <= x; y = y + 1 ) + { + // ler valor do teclado + z = IO_readint ( "Valor = " ); + // mostrar valor atual + IO_printf ( "%d. %d\n", y, z ); + } // end for + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_04 ( ) + + +/** + Method_05 - Repeticao com teste no inicio e variacao. + */ +void method_05 ( void ) +{ + // definir dado + int x = 0; + int y = 0; + int z = 0; + + // identificar + IO_id ( "Method_05 - v0.0" ); + + // ler do teclado + x = IO_readint ( "Entrar com uma quantidade: " ); + + // repetir (x) vezes + // inicio teste variacao + for ( y = x; y >= 1; y = y - 1 ) + { + // ler valor do teclado + z = IO_readint ( "Valor = " ); + // mostrar valor atual + IO_printf ( "%d. %d\n", y, z ); + } // end for + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_05 ( ) + + +/** + Method_06 - Repeticao sobre cadeia de caracateres. + */ +void method_06 ( void ) +{ + // definir dado + int x = 0; + int y = 0; + + chars palavra = IO_new_chars ( STR_SIZE ); + int tamanho = 0; + + // identificar + IO_id ( "Method_06 - v0.0" ); + + // ler do teclado + palavra = IO_readstring ( "Entrar com uma palavra: " ); + + // repetir para cada letra + tamanho = strlen ( palavra ) - 1; +// OBS: A cadeia de caracteres iniciam suas posições em zero. + + // inicio teste variacao + for ( y = tamanho; y >= 0; y = y - 1 ) + { + // mostrar valor atual + IO_printf ( "%d: [%c]\n", y, palavra [y] ); + } // end for + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_06 ( ) + + +/** + Method_07 - Repeticao sobre cadeia de caracateres. + */ +void method_07 ( void ) +{ + // definir dado + int x = 0; + int y = 0; + + char palavra [STR_SIZE]; + int tamanho = 0; + + // identificar + IO_id ( "Method07 - v0.0" ); + + // ler do teclado + IO_printf ( "Entrar com uma palavra: " ); + scanf ( "%s", palavra ); getchar( ); +// OBS: A cadeia de caracteres dispensa a indicacao de endereco (&) na leitura. + + + + // repetir para cada letra + tamanho = strlen ( palavra ); +// OBS: A cadeia de caracteres iniciam suas posições em zero. + + // inicio teste variacao + for ( y = 0; y < tamanho; y = y + 1 ) + { + // mostrar valor atual + IO_printf ( "%d: [%c]\n", y, palavra [y] ); + } // end for + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_07 ( ) + + +/** +Method_08 - Repeticao com intervalos. +*/ +void method_08 ( void ) +{ +// definir dado + int inferior = 0; + int superior = 0; + int x = 0; + +// identificar + IO_id ( "Method08 - v0.0" ); + +// ler do teclado + inferior = IO_readint ( "Limite inferior do intervalo: " ); + superior = IO_readint ( "Limite superior do intervalo : " ); + +// inicio teste variacao + for ( x = inferior; x <= superior; x = x + 1 ) + { + // mostrar valor atual + IO_printf ( "%d\n", x ); + } // end for + +// encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_08 ( ) + + +/** + Method_09 - Repeticao com intervalos. + */ +void method_09 ( void ) +{ + // definir dado + double inferior = 0; + double superior = 0; + double passo = 0; + double x = 0; + + // identificar + IO_id ( "Method_09 - v0.0" ); + + // ler do teclado + inferior = IO_readdouble ( "Limite inferior do intervalo : " ); + superior = IO_readdouble ( "Limite superior do intervalo : " ); + passo = IO_readdouble ( "Variacao no intervalo (passo): " ); + + // inicio teste variacao + for ( x = superior; x >= inferior; x = x - passo ) + { + // mostrar valor atual + IO_printf ( "%lf\n", x ); + } // end for + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_09 ( ) + + +/** + Method_10 - Repeticao com confirmacao. + */ +void method_10 ( void ) +{ + // definir dado + double inferior = 0; + double superior = 0; + double passo = 0; + double x = 0; + + // identificar + IO_id ( "Method10 - v0.0" ); + + // ler do teclado + inferior = IO_readdouble ( "Limite inferior do intervalo : " ); + + // repetir ate' haver confirmacao de validade + do + { + superior = IO_readdouble ( "Limite superior do intervalo: " ); + } + while ( inferior >= superior ); + + // repetir ate' haver confirmacao de validade + do + { + passo = IO_readdouble ( "Variacao no intervalo (passo): " ); + } + while ( passo <= 0.0 ); + + // inicio teste variacao + for ( x = inferior; x <= superior; x = x + passo ) + { + // mostrar valor atual + IO_printf ( "%lf\n", x ); + } // end for + + // encerrar + IO_pause ( "Apertar ENTER para continuar" ); +} // end method_10 ( ) + + +/* + Funcao principal. + @return codigo de encerramento +*/ +int main ( ) +{ + // definir dado + int x = 0; + + // repetir até desejar parar + do + { + // identificar + IO_id ( "EXEMPLO0300 - Programa - v0.0" ); + + // ler do teclado + IO_println ( "Opcoes" ); + IO_println ( " 0 - parar" ); + IO_println ( " 1 - Method 01 repeticao com teste no inicio" ); + IO_println ( " 2 - Method 02 Repeticao com teste no inicio" ); + IO_println ( " 3 - Method 03 Repeticao com teste no inicio "); + IO_println ( " 4 - Method 04 Repeticao com teste no inicio e variacao"); + IO_println ( " 5 - Method 05 Repeticao com teste no inicio e variacao. "); + IO_println ( " 6 - Method 06 Repeticao sobre cadeia de caracateres."); + IO_println ( " 7 - Method 07 Repeticao sobre cadeia de caracateres."); + IO_println ( " 8 - Method 08 Repeticao com intervalos. "); + IO_println ( " 9 - Method 09 Repeticao com intervalos. "); + IO_println ( "10 - Method 10 Repeticao com confirmacao. "); + + + + + x = IO_readint ( "Entrar com uma opcao: " ); + + // testar valor + switch ( x ) + { + case 0: method_00 ( ); break; + case 1: method_01 ( ); break; + case 2: method_02 ( ); break; + case 3: method_03 ( ); break; + case 4: method_04 ( ); break; + case 5: method_05 ( ); break; + case 6: method_06 ( ); break; + case 7: method_07 ( ); break; + case 8: method_08 ( ); break; + case 9: method_09 ( ); break; + case 10: method_10 ( ); break; + default: + IO_pause ( IO_concat ( "Valor diferente das opcoes [1 a 10] (", + IO_concat ( IO_toString_d ( x ), ")" ) ) ); + } // end switch + } + while ( x != 0 ); + + // encerrar + IO_pause ( "Apertar ENTER para terminar" ); + return ( 0 ); +} // end main ( ) + + +/* +---------------------------------------------- documentacao complementar + +---------------------------------------------- notas / observacoes / comentarios + +---------------------------------------------- previsao de testes + +a.) 0 +b.) 1 +c.) 2 +d.) 3 +e.) 4 + f.) -1 + +---------------------------------------------- historico + +Versao Data Modificacao + 0.1 __/__ esboco + + ---------------------------------------------- testes + +Versao Teste + 0.1 01. ( OK ) identificacao de programa + +*/ \ No newline at end of file diff --git a/845963_Kayky_Gabriel_Marques_Ed03/io.h b/845963_Kayky_Gabriel_Marques_Ed03/io.h new file mode 100644 index 0000000..c7d8dba --- /dev/null +++ b/845963_Kayky_Gabriel_Marques_Ed03/io.h @@ -0,0 +1,542 @@ +/** + IO - Console input/output library. + @author PUC-Minas - ICEI + @version 0.1 - 2025-1b + + IO - v2025-1_0.1 - __ / __ / _____ + Author: Kayky_Gabriel_Marques + + */ +// ---------------------- lista de dependencias + +#include // para entradas e saidas +#include // para definicoes basicas +#include // para a biblioteca padrao +#include // para cadeias de caracteres +#include // para tratar argumentos +#include // para definicoes logicas +#include // para tipos padroes +#include // para definicoes matematicas +#include // para medir tempo +#include // para 16-bit characters +#include // para and, or, xor, not alternatives + +// ---------------------- redefinicoes para apontamentos + +#ifndef __IO_REFS__ +#define __IO_REFS__ + +#define nullptr NULL // para compatibilizar com C++ +#define null NULL // para generalizar + +#define addr(p) (&(p)) // para obter endereco +#define deref(p) (*(p)) // para obter conteudo de endereco +#define val(p) (*(p)) // para obter conteudo apontado + +#define ref * // para passar parametro por referencia + // (na assinatura) +#define var & // para passar parametro por referencia + // (na chamada) + +#endif + +// ---------------------- redefinicoes uteis + +#ifndef _IO_H_ +#define _IO_H_ + // alternativas mais seguras, se disponiveis +#define IO_printf printf // melhor: printf_s +#define IO_scanf scanf // melhor: scanf_s +#define IO_fprintf fprintf // melhor: fprintf_s +#define IO_fscanf fscanf // melhor: fscanf_s + +// ---------------------- definicoes de constantes + +const bool FALSE = false; // definir constante +const bool TRUE = true ; // definir constante + +const char EOS = '\0'; // definir fim de cadeia de caracteres +const char EOL = '\n'; // definir mudanca de linha +const char ENDL [] = "\n"; // definir mudanca de linha + +const char STR_EMPTY [] = "" ; // definir cadeia de caracteres vazia +const int STR_SIZE = 80 ; // definir tamanho padrao para caracteres + +// ---------------------- definicoes de tipos + +typedef char* chars ; // definir cadeia de caracteres +typedef int* ints ; // definir arranjo de inteiros +typedef double* doubles; // definir arranjo de reais +typedef bool* bools ; // definir arranjo de logicos + +// ---------------------- definicoes de variaveis globais + +int IO_error = 0; // inicialmente sem erros +bool IO_trace = true; // inicialmente habilitado + +// ---------------------- definicoes de funcoes e procedimentos + +// ---------------------- para tratamento de erros + +void IO_debugOFF ( ) +{ + IO_trace = false; +} // end IO_debug_OFF ( ) + +void IO_debugON ( ) +{ + IO_trace = true; +} // end IO_debug_ON ( ) + +void IO_debug ( bool condition, const char * const text ) +{ + if ( IO_trace && condition ) + { + IO_printf ( "\nDBG> %s\n", text ); + getchar( ); + } // end if +} // end IO_debug ( ) + +// ---------------------- para entradas e saidas + +/** + Metodo para limpar a saida de dados padrao. + */ +void IO_clrscr ( ) +{ + if ( IO_trace ) + { +#if defined(_WIN32) || defined(_WIN64) || defined(__WINDOWS__) + system ( "cls" ); // para Windows - OBS: NAO RECOMENDADO ! +#elif defined(__linux__) + system ( "clear" ); // para Linux - OBS: NAO RECOMENDADO ! +#elif defined(__APPLE__) && defined(__MACH__) + system ( "clear" ); // para Linux - OBS: NAO RECOMENDADO ! +#elif defined(unix) || defined(__unix__) || defined(__unix) + system ( "clear" ); // para Linux - OBS: NAO RECOMENDADO ! +#else + #error Unknown_OS +#endif + } // end if +} // end IO_flush ( ) + +/** + Metodo para limpar a entrada de dados padrao. + */ +void IO_flush ( ) +{ +// fflush ( stdin ); // para Windows - OBS: NAO RECOMENDADO ! + // para Linux - OBS: NAO FUNCIONA ! + int x = 0; // compat vel com o retorno de getchar() + do { x = getchar( ); } while ( x != EOF && x != '\n' ); + clearerr ( stdin ); // reiniciar o estado de EOF +} // end IO_flush ( ) + +/** + Funcao para informar a versao dessa biblioteca. + @return versao atual + */ +chars IO_version ( ) +{ + chars x = strdup ( "v.2025-" ); + return ( x ); +} // end IO_version ( ) + +/** + Metodo para identificar o programa e a autoria. + @param text - mensagem a ser exibida + */ +void IO_id ( const char * const text ) +{ + IO_printf ( "%s\n", text ); + IO_printf ( "%s\n", "Autor: Kayky_Gabriel_Marques" ); + IO_printf ( "\n" ); // mudar de linha +} // fim IO_id ( ) + +/** + Funcao para ler valor inteiro do teclado. + @return valor lido + @param text - mensagem a ser exibida antes da leitura + */ +int IO_readint ( const char * const text ) +{ + int x = 0; + if ( IO_trace ) + IO_printf ( "%s", text ); + IO_scanf ( "%d", &x ); + IO_flush ( ); + return ( x ); +} // end IO_readint ( ) + +/** + Funcao para ler valor real de precisao dupla do teclado. + @return valor lido + @param text - mensagem a ser exibida antes da leitura + */ +double IO_readdouble ( const char * const text ) +{ + double x = 0.0; + if ( IO_trace ) + IO_printf ( "%s", text ); + IO_scanf ( "%lf", &x ); + IO_flush ( ); + return ( x ); +} // end IO_readdouble ( ) + +/** + Funcao para ler valor real de precisao simples do teclado. + @return valor lido + @param text - mensagem a ser exibida antes da leitura + */ +float IO_readfloat ( const char * const text ) +{ + float x = 0.0; + if ( IO_trace ) + IO_printf ( "%s", text ); + IO_scanf ( "%f", &x ); + IO_flush ( ); + return ( x ); +} // end IO_readfloat ( ) + +/** + Funcao para ler valor logico do teclado. + @return valor lido + @param text - mensagem a ser exibida antes da leitura + OBS.: Usar zero (0) para falso e + diferente de zero para verdadeiro + */ +bool IO_readbool ( const char * const text ) +{ + int x = 0; + if ( IO_trace ) + IO_printf ( "%s", text ); + IO_scanf ( "%d", &x ); + IO_flush ( ); + return ( x!=0 ); +} // end IO_readbool ( ) + +/** + Funcao para ler caractere do teclado. + @return valor lido + @param text - mensagem a ser exibida antes da leitura + */ +char IO_readchar ( const char * const text ) +{ + char x = '0'; + if ( IO_trace ) + IO_printf ( "%s", text ); + do { x = getchar( ); } while ( '\n' == x ); IO_flush ( ); +// getchar ( ); + return ( x ); +} // end IO_readchar ( ) + +/** + Funcao para ler caractere do teclado. + @return valor lido + @param text - mensagem a ser exibida antes da leitura + */ +void IO_pause ( const char * const text ) +{ + char x = '0'; + if ( IO_trace ) + { + IO_printf ( "\n%s\n", text ); + do { x = getchar( ); } while ( '\n' != x ); + } // end if +} // end IO_pause ( ) + +/** + Funcao para reservar espaco para guardar cadeia de caracteres. + @return area reservada, se houver; NULL, caso contrario + @param size - quantidade de dados + */ +chars IO_new_chars ( int size ) +{ + return ( (chars) malloc ( (size+1)*sizeof(char) ) ); +} // fim IO_new_chars ( ) + +/** + Funcao para reservar espaco para guardar inteiros. + @return area reservada, se houver; NULL, caso contrario + @param size - quantidade de dados + */ +ints IO_new_ints ( int size ) +{ + return ( (ints) malloc ( (size)*sizeof(int) ) ); +} // fim IO_new_ints ( ) + +/** + Funcao para reservar espaco para guardar reais. + @return area reservada, se houver; NULL, caso contrario + @param size - quantidade de dados + */ +doubles IO_new_doubles ( int size ) +{ + return ( (doubles) malloc ( (size)*sizeof(double) ) ); +} // fim IO_new_doubles ( ) + +/** + Funcao para reservar espaco para guardar logicos. + @return area reservada, se houver; NULL, caso contrario + @param size - quantidade de dados + */ +bools IO_new_bools ( int size ) +{ + return ( (bools) malloc ( (size)*sizeof(bool) ) ); +} // fim IO_new_bools ( ) + +/** + Funcao para concatenar cadeias de caracteres. + @return cadeia com o resultado + @param text1 - primeira cadeia + @param text2 - segunda cadeia + */ +chars IO_concat ( const char * const text1, const char * const text2 ) +{ // reservar area + chars buffer = IO_new_chars ( strlen(text1)+strlen(text2)+1 ); + strcpy ( buffer, text1 ); + strcat ( buffer, text2 ); + return ( buffer ); +} // fim IO_concat ( ) + +/** + Funcao para converter valor logico para caracteres. + @return cadeia com o resultado + @param x - valor logico + */ +chars IO_toString_b ( bool x ) +{ // reservar area + chars buffer = IO_new_chars ( STR_SIZE+1 ); + sprintf ( buffer, "%d", x );// variante do printf( ) + return ( buffer ); +} // fim IO_toString_b ( ) + +/** + Funcao para converter caractere para caracteres. + @return cadeia com o resultado + @param x - caractere + */ +chars IO_toString_c ( char x ) +{ + chars buffer = IO_new_chars ( STR_SIZE+1 ); + sprintf ( buffer, "%c", x );// variante do printf( ) + return ( buffer ); +} // fim IO_toString_c ( ) + +/** + Funcao para converter inteiro para caracteres. + @return cadeia com o resultado + @param x - valor inteiro + */ +chars IO_toString_d ( int x ) +{ + chars buffer = IO_new_chars ( STR_SIZE+1 ); + sprintf ( buffer, "%d", x );// variante do printf( ) + return ( buffer ); +} // fim IO_toString_d ( ) + +/** + Funcaoo para converter real para caracteres. + @return cadeia com o resultado + @param x - valor real + */ +chars IO_toString_f ( double x ) +{ // variante do printf( ) + chars buffer = IO_new_chars ( STR_SIZE+1 ); + sprintf ( buffer, "%lf", x ); + return ( buffer ); +} // fim IO_toString_f ( ) + +/** + Metodo para mostrar uma linha com certo texto. + @param text - texto a ser exibido + */ +void IO_print ( const char * const text ) +{ + IO_printf ( "%s", text ); +// puts ( text ); +} // fim IO_print ( ) + +/** + Metodo para mostrar uma linha com certo texto + e mudar de linha. + @param text - texto a ser exibido + */ +void IO_println ( const char * const text ) +{ + IO_printf ( "%s\n", text ); +// puts ( text ); putchar ( '\n' ); +} // fim IO_println ( ) + +/** + Metodo para gravar uma linha em arquivo texto. + @param filePtr - referencia para arquivo aberto + @param text - cadeia de caracteres a ser gravada + */ +void IO_fprint ( FILE* filePtr, const char * const text ) +{ + IO_fprintf ( filePtr, "%s", text ); +} // fim IO_fprint ( ) + +/** + Metodo para gravar uma linha em arquivo texto + e mudar de linha. + @param filePtr - referencia para arquivo aberto + @param text - cadeia de caracteres a ser gravada + */ +void IO_fprintln ( FILE* filePtr, const char * const text ) +{ + IO_fprintf ( filePtr, "%s\n", text ); +} // fim IO_fprintln ( ) + +/** + Funcao para ler uma cadeia de caracteres de arquivo. + @return palavra lida + @param arquivo - referencia para arquivo aberto + */ +chars IO_fread ( FILE* filePtr ) +{ + chars buffer = IO_new_chars ( STR_SIZE+1 ); + + IO_fscanf ( filePtr, "%s", buffer ); // ler uma cadeia + return ( buffer ); +} // fim IO_fread ( ) + +/** + Funcao para ler uma linha inteira. + @return linha lida + @param filePtr - referencia para arquivo aberto + */ +chars IO_freadln ( FILE* filePtr ) +{ + chars buffer = IO_new_chars ( STR_SIZE+1 ); + + fgets ( buffer, STR_SIZE, filePtr ); // ler uma linha + buffer [ strlen (buffer)-1 ] = EOS; // reposicionar o fim de linha + return ( buffer ); +} // fim IO_freadln ( ) + +/** + Funcao para ler cadeia de caracteres. + @return cadeia de caracteres + @param text - mensagem a ser exibida antes da leitura + */ +chars IO_readstring ( const char * const text ) +{ + chars buffer = IO_new_chars ( STR_SIZE+1 ); + if ( IO_trace ) + IO_printf ( "%s", text ); + IO_scanf ( "%80s", buffer ); // ler cadeia de caracteres + // com limitacao de 80 posicoes + IO_flush ( ); + return ( buffer ); +} // fim IO_readString ( ) + +/** + Funcao para ler uma linha inteira. + @return linha lida + @param text - mensagem a ser exibida antes da leitura + */ +chars IO_readln ( const char * const text ) +{ + if ( IO_trace ) + IO_printf ( "%s", text ); + return ( IO_freadln ( stdin ) ); +} // fim IO_readln ( ) + +/** + Funcao para converter valor logico para cadeia de caracteres. + @return "true", se verdadeiro; "false", caso contrario + @param value - valor a ser convertido + */ +chars IO_boolalpha ( bool value ) +{ + if ( value ) + return ( strdup ("true" ) ); + else + return ( strdup ("false" ) ); +} // fim IO_boolalpha ( ) + +/** + Funcao para comparar conteudos em memoria. + @return true, se iguais; false, caso contrario + @param p1 - endereco do primeiro valor + @param p2 - endereco do segundo valor + @param size - tamanho em bytes a ser comparado + */ +bool IO_check ( void *p1, void *p2, unsigned int size ) +{ + return ( p1 && p2 && (0==memcmp( p1, p2, size )) ); +} // fim IO_check ( ) + +/** + Funcao para retornar o tamanho de cadeia de caracteres. + @return tamanho, se existir; 0, caso contrario + @param text - cadeia de caracteres + */ +int IO_length ( char* text ) +{ + int x = 0; + if ( text ) + { x = strlen(text); } + return ( x ); +} // fim IO_length ( ) + +/** + Funcao para obter simbolo de certa posicao + em cadeia de caracteres. + @return simbolo, se existir; '\0', caso contrario + @param text - cadeia de caracteres + @param index - posicao desejada + */ +char IO_charAt ( char* text, unsigned int index ) +{ + char x = '\0'; + if ( text && index < strlen(text) ) + { x = text [ index ]; } + return ( x ); +} // fim IO_charAt ( ) + +/** + Funcao para copiar parte de uma cadeia de caracteres. + @return parte de cadeia de caracteres ou + NULL, caso houver parametros invalidos + @param text - cadeia de caracteres + @param start - onde comecar + @param size - quantos caracteres copiar + */ +char* IO_substring ( char *text, int start, unsigned int size ) +{ + chars buffer = NULL; + if ( start >= 0 && (start+size) < (int) strlen(text) ) + { + buffer = IO_new_chars ( size+1 ); + memcpy ( buffer, text+start, size ); + buffer [size] = '\0'; + } + return ( buffer ); +} // fim IO_substring ( ) + +/** + Funcao para copiar parte de uma cadeia de caracteres. + @return parte de cadeia de caracteres ou + NULL, caso houver parametros invalidos + @param text - cadeia de caracteres + @param symbol - caractere a ser acrescentado + */ +char* IO_strapp ( char *text, char symbol ) +{ + chars buffer = NULL; + int size = 0 ; + if ( text ) + { + size = strlen ( text ); + buffer = IO_new_chars ( size+1 ); + memcpy ( buffer, text, size ); + buffer [size ] = symbol; + buffer [size+1] = '\0' ; + } + return ( buffer ); +} // fim IO_strapp ( ) + +#endif diff --git a/845963_Kayky_Gabriel_Marques_Ed03/notes.txt b/845963_Kayky_Gabriel_Marques_Ed03/notes.txt new file mode 100644 index 0000000..3e3f7a7 --- /dev/null +++ b/845963_Kayky_Gabriel_Marques_Ed03/notes.txt @@ -0,0 +1,339 @@ +-------------// DESAFIO \\------------- +Desafio da semana! fazer toda a leitura das strings apartir de +recursao! + +os desavios estavam mais complicados que eu imaginei kkkk, entao foram os unicos que eu nao usei recursao +-------------// NOTES \\------------- + +Method_01 + +A ideia por tras do metodo 01 lembra muito os ultimos exercicios do Ed02 +Se deve testar letras maiores que 'K'. + Uma ideia que eu tive para fazer e uma recursao, onde cada letra que passa no filto + (sendo esta maior que K) acho que vai ser mais desafiador + Apos rever o que eu errei e como eu poderia corrigilos, percebi que eu esqueci de fazer +alocacao dinamica para receber e enviar os dados :|. eu nao sei como que eu deixei algo +tao basico de lado + +Bom os erros ja se foram, junto com os warnings, mas ele nem ao menos compila, estou confuso. + +genuinamente nao gosto de fazer daquele jeito mas estou ficando sem criatividade. + +Tive mais um erro, colocar o meu array com valor de 99 nao deu certo, +aparente ele começou a testar com lixo. + +fique perdido, entei em loop infinito. + +finalmente, fuiciona + + +Method_02 + + Bom, horas como essas eu iria amar um "POO" so para nao ter que repetir e ate mesmo +fazer um "ctrl c e v", usei meu metodo que planejei no metodo 1, e so troquei sua condicao +ao inves de comprar a letra com 'K' agora e com 'k' e ver se e menor ou maior + + Tive a ideia de chamar io_id para ter mais controle sobre oq esta acontecendo +porem, como se trata de uma recursao esquci que ele sempre vai ser chamado a quantidade +de vezes que o metodo sera chamado . + Tive uma ideia para chamar ele so uma vez, fazer uma variavel booleana, com um contador +se o contador for maior que um, ele nao vai mais printar o io_id! + fiz meu metodo receber um novo parametro "one_call" que como o nome sugre, so vai chamar uma vez +a funcao "io_id" como ela recebe um variavel verdadeira ela vai printar somente uma vez, porem, em +sua recursao e trocada alterada por falso. disso, so chamado uma vez pela sua condicao. + + +Method_03 + A ideia deste metodo vai ser, ler a string e ver se minha letra e maior que 'K' porem, +começar de tras para frente. + + Incrivelmente, fazer com recursao e mais facil isso, mudando a forma da chamada a pilha vai +ser modelada da forma que eu quero + +Method_04 + A ideia deste metodo e simplesmente contar todos os caracteres de 'A' a 'Z' no caso +todos que fizerem parte do alfabeto, caracteres especiasi (!, @, #, $, %, &, *, <, >, :, ;, ?) +nao deveram ser contado + +Method_05 + O metodo 5 visa ler a string ao contrario, disso, ler somente numeros que sejam par +alem de mostrar-los, apresentar um contador que mostra a quantide de numeros pares que a pareceram + vou usar o modelo do Method_03, como ele faz a recursao ao contrario, mudando as condicoes +e seus fatores vai ser mais facil de manipular para chegar na resposta. + uma coisa indispensavel e a conversao de inteiro para char. Ele esta funcionando, menos meu contador +nao entendi o seu erro ate agora, ja fiz uma mudanças desnessarias como tirar o "int number" que nao fazia sentido +ja que ja tinha sido declarado na inicio do metodo. + simplesmente nao entendi o por que nao esta funcionando, nao consegui resolver + + +Method_06 + O metodo 6, e o inverso do Method_05, ja que a unica coisa que ele pede para ler e os numeros pares +e neste ele le tudo, menos numeros impares e pede para mostrar e contar os outros caracteres. + nao apresentei erros neste :) + + Method_07 + O programa deve ler dois valores inteiros, a e b, que representam os limites de um intervalo fechado +[a:b]. Esse intervalo será usado para verificar se os números testados estão dentro dele. O programa deve ler um +valor inteiro n, que representa a quantidade de valores que serão testados. O programa deve ler n valores inteiros, +um por vez. Para cada valor lido (x), ele deve verificar: + +Se o valor x é múltiplo de 3. +Se o valor x está dentro do intervalo [a:b]. + +O programa deve ler n valores inteiros, um por vez. Para cada valor lido (x), ele deve verificar: +Se o valor x é múltiplo de 3. +Se o valor x está dentro do intervalo [a:b]. + +a ideia desta atividade nao e dificil, mas e trabalhosa (da para ver que eu nem quis esrever com as minhas palavar) + +RESUMINDO + +Define um intervalo [a:b]. ->vimos muito isso no ultimo ed + +Lê uma quantidade n de valores. -> passo base + +Verifica, para cada valor, se ele é múltiplo de 3 e se está dentro do intervalo. + +Conta e exibe quantos valores atendem às duas condições. + + +fiquei tanto tempo que esquci de fazer as anotacoes, oq importa q funciona + + Method_08 + O programa e quase a mesma coisa do metodo 7, porem, ele verifica se o numero se ele e multiplo de 4 tambem, e caso for, nao deverar +retornar o valor e o contador nao deve ser acionado, disso, mudando um pouco da logica e fazendo ele ficar mais "dificil" + + Vi um video de um gringo explicando forma de comparacoes usando booleano, e decidi colocar em pratica resumindo, colocando minha afirmacao +em uma variavel bool sera declarada como "true" e caso ela nao passe na minha condicao vai realizar o contrario. Eu genuinamente achei esse jeito +um forma mais limpa e facil de se ler e interpretar o codigo, resumo as coisas faço mais legivel. + + Method_09 + contar e mostrar todos os valores lidos, pertencentes ao do intervalo, cujas partes inteiras forem pares e menores que 5. +De inicio eu achei quer era para ver o final do numero real, mas ai que eu entendi, tive algumas complicaçoes mas de pois de ver +no stack overflow que para trocar o valor de uma varivael e submeterla ao valor de outro tipo, era so colocar seu tipo (int) na frente +da variavel e pronto! + Permanece usando a ideia que eu tive no metodo 08 e permanece facil de se entender. + + Method_10 + Esse metodo foi um dos mais complicados ate agora, na aula de dia 10/03, professor falou sobre os loops mais uma vez +e sobre "se o usuario" errar oq pode fazer, decedi colocar um while para repetir ate o usuario acertar e caso ele queria colocar outro +valor. + O metodo visa ver a fraçao de sua parte (desconsiderar o valor inteiro e verificar o seu valor decimal ) e verificar se o valor esta entre +o intervalo aberto de 0 e 1 + e de primeira eu usei uma funcao de c, chamada de "floor" ela serve para pegar o menor numero, usei a ja prototipada pela linguagem, +mas como estamos aqui para ver desafios, decedi fazer a minha! + + + Method_12 + de primeira, achei que seria falso, tive a ideia de reaproveitar grande parte do metodo 11, mas vi que nao seria o suficiente +minha primeira ideia era comparar a string com a outra (only_non_alphanumeric), mas simplesmente nao fazia sentido, entao depois de varias +pesquisas (eu usei IA sim pq eu fique perdido em algumas coisas) decedi que ia ser melhor usar mais uma vez boolean + + My_insalum(&letter[i]) A função My_insalum verifica se o caractere atual é alfanumérico (letra ou dígito). + + retorna 1 (true) se for alfanumérico. retorna 0 (false) se não for. !My_insalum(&letter[i]) e a negação inverte seu valor: +Se o caractere e alfanumérico, vira false. se nao true + +only_non_alphanumeric = only_non_alphanumeric && !My_insalum(&letter[i]); + +A variavel only_non_alphanumeric: começa como 1 (com a ideia de que começa com algum alfanumerico). e primeiro caractere alfanumerico +encontrado, vira false. mantem o valor 0 ate o final, pois o && (and) so resulta em 1 se ambos os lados forem 1. + -------------// consideracoes \\------------- + Levei em torno de 4 dias para fazer esse tp, eu poderia ter ido pelo caminho facio, mas qual e é graça de fazer coisas que +sao faceis? eu quebrei a cabeça varias vezes, vi varios videos e adimito que usei gpt e outras inteligencis artificiais para ter uma ideia +melhor de como fazer. eu pessoalmente nao gosto de monitoria, prefiro fazer as coisas sozinho, entao uso para corrigir e para me dar dicas quando +eu estou perdido, mas nunca a resposta. + Esse ed, me deu um leque de ideias para implementar em futuros codigos e projetos! "suei a camisa" como alguns dizem! amanha dia 11/03 +ja vou começar o proximo. + + Muito obrigado desde ja, atenciosamente + -Kayky gabriel Marques + + + + +-------------// ERROS \\------------- + +Method_01 + +O codigo parou na hr de scaner, acho que nao sei usar muito bem o "io.h". +recebi alguns warnings como: +if (*letter == NULL) +-> sendo este aviso causado por a comparacao de um valor inteiro +com um valor de ponteiro + +claro que esta errado, como vc quer comparar valores que nao sao homegenicos + +if (*letter == '/0') +-> francamente, nem sei oq tinha de errado comigo quando eu escrevi isso + +como que vc quer ver se um ponteiro e '/0'? faz sentido nenhum + +read_string(*letter); +nao fiz a inicializacao de um ponteiro direito, eu realmente preciso de estudar melhor +o "io.h". + Uma longa parte do meus erros foi por conta do mal uso de alocacao dinamica. +Como: usou scanf("%s", letter), sendo letter uma variavel char, n um array ou ponteiro para armazenar uma string. +Isso causa erro de segmentacao ao tentar acessar a memoria indevidamente + +--------------------//--------------------------- +De: +scanf("%s", letter); + +Para: +char str[100]; +scanf("%99[^\n]", letter); + +Passagem de ponteiros: +De: read_string(&letter); + +Para: +read_string(stletter); +e eu tentei passar o endereco, o erro foi por conta de que imaginei que o metodo +precisaria de um ponteiro (logo o endereco de sua variavel) para realizar o procedimento +mas quem diria que nao + +Condicao incorreta na recursao: +De: if(letter == '\0') + +Para: if(*letter == '\0') + +assim, verifico oq esta sendo apontado corresponde com o final de uma linha. +da outra forma, verificava se o endereco era igual a '\0' algo que nao faz sentido +--------------------\\--------------------------- + +Method_04 + Por hora minha funcao nem ao menos chegou a ler o que tinha que ser escrito +decidi fazer pequenos ajustes, mas ainda perciste no erro. +um dos meus erros foram a forma que eu coloquei minha condicao +De: + if (*letter >= 'a' && *letter <= 'z' || + *letter >='A' && *letter <= 'Z' ) +assim ele nao faz duas verificaoes como desejo, logo +sua correçao deverea ser + +Para +if ((*letter >= 'a' && *letter <= 'z') || + (*letter >= 'A' && *letter <= 'Z')) + + +--------------------//--------------------------- + +--------------------\\--------------------------- + +Method_05 + Na hora de comparar e trocar os valores de char para int tive duvidas +De: + if (*letter >= '0' && *letter <= '9') + +Para + if (*letter >= '0' && *letter <= '9') + int value = *letter - '0'; + int *number = (*number * 10) + value; + + claro que praticamente nao tinha feito mudança nenhuma, mas apos pesquisar vi como que eram feitas +usando a tabela ASCII, e uma das formas de contornar esse problema. + disso um dos meu problemas foi a atuliazacao do valor usando um ponteiro, o seu valor so sera atuliazado +nao sera perdido + + + +--------------------//--------------------------- + +--------------------\\--------------------------- + +Method_08 + Na hora de negar os multiplos de 3 +De: + if (numbers[index] % 3 == 0 ){ // -> verificar se o numero multiplo de 3 + + + if (numbers[index] % 4 == 0 ) { // -> verificar se o numero e multiplo de 4 + printf("O numero [%d] e multiplo de 3 e de 4 (NAO conta).\n \n", numbers[index]); + + } else if (numbers[index] >= firts_interval && + numbers[index] <= second_interval){ // else mult four + + printf("O numero [%d] e multiplo de 3 e faz parte do intervalo de [%d : %d] \n", numbers[index], firts_interval, second_interval); + (*count)++ ; + } +} else { // else mult 3 and interval + printf("o numero [%d], NAO faz e multiplo de 3(NAO conta)\n", numbers[index]); +} + + + +Para + + int current_number = numbers[index]; + bool mult_of_three = numbers[index] % 3 == 0; + bool mult_of_four = numbers[index] % 4 == 0; + bool in_interval = (current_number >= first_interval && current_number <= second_interval); + + + if ( mult_of_three ){ // -> verificar se o numero multiplo de 3 + if ( mult_of_three ){ // -> verificar se o numero multiplo de 3 + + if (mult_of_four) { // -> verificar se o numero e multiplo de 4 + printf("O numero [%d] e multiplo de 3 e de 4 (NAO conta). \n", numbers[index]); + + } else if (in_interval){ + printf("O numero [%d] e multiplo de 3 e faz parte do intervalo de [%d : %d] \n", numbers[index], first_interval, second_interval); + (*count)++ ; + } else { + printf("O numero [%d] nao e multiplo de 3 (NAO conta). \n", numbers[index]); + } +} + + Tive essa ideia apos ver um video de um gringo falando sobre como usar booleano em condicao +dessa forma, declarando elas desse jeito, pode notar que sua leitura fica mais facil, alem disso ele verifica, +se e verdade (com base na operaçao) disso se for verdade executa se nao, faz a sua condicao inversa (else) + + +--------------------//--------------------------- + +--------------------\\--------------------------- + +Method_10 +De: + double fractional = numbers[index] - floor(numbers[index]); // Parte fracionaria + +Para + + // implementacao de uma funcao ja existene chamada floor para pegar o numero e +double My_floor (int value ) { + // caso o numero foi ja for inteiro + if ((int) value == value ) { + return value; + } + // caso ele for maior que 0 + if(value > 0){ + return (int)value; // -> retornar o valor inteiro + } + + return (int) value - 1; // caso for negativo, arredonda para o menor inteiro +} + + void count_fractional_in_range(double *numbers, double first_interval, double second_interval, int index, int size, int *count, bool one_call) { + if (one_call) { + IO_id("\ncount_fractional_in_range - v 4.0\n"); + } + + if (index < size) { // Passo base + double fractional = numbers[index] - My_floor(numbers[index]); // Parte fracionaria + + if (fractional > first_interval && fractional < second_interval) { // -> ver se esta dentro do intervalo aberto + printf("%.2lf tem parte fracionaria %.2lf dentro do intervalo ]%.2lf : %.2lf[\n",numbers[index], fractional, first_interval, second_interval); + (*count)++; + + } else { + printf("[%.2lf] nao contem parte fracionaria [%.2lf] dentro do intervalo ]%.2lf : %.2lf[\n", + numbers[index], fractional, first_interval, second_interval); + } + // Chamada recursiva correta + count_fractional_in_range(numbers, first_interval, second_interval, index + 1, size, count, false); + } +} + + +--------------------//--------------------------- \ No newline at end of file