├── 01 - Introducao à ferramenta ├── atividade com tempo.c ├── bem vindo.c └── varias mensagens.c ├── 02 - Variáveis, tipos e IO ├── media de 3 valores.c ├── quadrado e cubo.c ├── quociente e resto da divisao.c ├── soma de dois numeros.c ├── soma e multiplicacao.c ├── subtracao de dois numeros.c └── varias operacoes.c ├── 03 - Estruturas condicionais ├── classificador de temperatura.c ├── e par ou impar.c ├── esse numero e positivo, negativo ou igual a zero.c ├── ordem entre tres valores.c ├── os pontos dentro e fora da regiao h.c ├── proximo numero sem resto.c └── valor do polinomio.c ├── 04 - Estruturas de repetição - while ├── MDC entre 2 numeros.c ├── contando os positivos e não-negativos.c ├── contando pares e impares de uma sequencia.c ├── encontre a menor e maior nota da turma.c ├── imprime apenas impares.c ├── imprimindo os impares naturais.c ├── loja de discos e dia de melhor faturamento.c ├── potencias de 2.c ├── potencias de um inteiro.c ├── quantas vezes nevou.c ├── reduzindo uma fracao.c ├── soma apenas os positivos.c ├── soma de n inteiros.c ├── soma dos n primeiros inteiros positivos.c └── soma par e soma impar.c ├── 05 - Estruturas de repetição - for ├── aprovados, reprovados e media da turma.c ├── bola 'quicando'.c ├── calcule o fatorial de n.c ├── calculo do cubo atraves da soma dos impares.c ├── encontre o maximo para expressao.c ├── expressao.c ├── maximo divisor comum entre varios inteiros.c ├── numero harmonico.c ├── numero perfeito.c ├── palindromo.c ├── pontos dentro e fora do conjunto H.c ├── produtos consecutivos.c ├── sequencia crescente.c ├── soma dos N-esimos termos de uma sequencia.c └── soma dos digitos.c ├── 06 - Sub-rotinas ├── area de uma circunferencia.c ├── calculo do numero de euler.c ├── conversao de caracteres.c ├── distancia euclidiana.c ├── equacao da reta.c ├── fatorial.c ├── intervalo.c ├── numero de lampadas de um comodo.c ├── o n-esimo caratere do alfabeto.c ├── potencia.c ├── produto de dois numeros.c ├── serie de numeros.c ├── soma de PA.c ├── verificar se e triangulo retangulo.c └── verificar se e triangulo.c ├── 07 - Operadores de bits ├── criptografia.c ├── cruzamento de variaveis.c ├── funcao de manipulacao de digitos.c ├── manipulando bits 1.c ├── manipulando bits 2.c ├── n-esimo bit.c ├── paridade (%).c ├── set0.c └── set1.c ├── 08 - Ponteiros - conceitos ├── incrementando ponteiros.c ├── simulando uma comunicacao de dados.c ├── usando um ponteiro para imprimir na tela.c └── usando um ponteiro para ler da entrada padrao.c ├── 09 - Passagem de parâmetros ├── calculo de meses para poupar.c ├── cedulas de um caixa eletronico.c ├── funcao conversao de minutos em dias, horas e minutos.c ├── funcao divide.c ├── funcao quebra (1).c ├── funcao quebra (2).c ├── funcao quebra_digito.c └── transformacao de coordenadas retangulares em polares.c ├── 10 - Recursão ├── algoritmo de euclides recursivo.c ├── calculo do mod, resto da divisao, recursivo.c ├── convertendo-decimal-em-binario.c ├── fibonacci recursivo.c ├── piso do logaritmo de base 2.c ├── potencia de x.c ├── sequencia numerica.c └── soma dos digitos.c ├── 11 - Arranjos ├── corrigindo vestibular.c ├── dado viciado.c ├── produto escalar entre dois vetores.c └── varios pontos de um polinomio.c ├── 12 - Cadeia de caracteres ├── comparando string.c ├── frequencia de letras.c ├── ocorrencia de palavras.c └── tamanho da string.c ├── 13 - Arranjos multidimensionais I ├── detectando linhas e colunas nulas.c ├── funcao produto de arranjos.c ├── funcao produto de matrizes.c └── matriz transposta.c ├── 14 - Arranjos multidimensionais II ├── matriz permutacao.c ├── matriz sem numeros repetidos.c ├── quadrado latino.c └── validando um jogo de sudoku.c ├── 15 - Registros e ponteiros ├── buscando o preco mais baixo.c ├── ponteiro para registro.c ├── selecao de candidatos para entrevista.c └── tempo do atleta corredor.c ├── 16 - Registros e funções ├── convertendo em segundos.c ├── funcao gera_filho.c ├── funcao movimento, translacao e rotacao.c └── funcao ponto medio.c └── README.md /01 - Introducao à ferramenta/atividade com tempo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | printf("Esta é uma atividade onde o tempo é levado em conta\n"); 5 | return 0; 6 | } 7 | -------------------------------------------------------------------------------- /01 - Introducao à ferramenta/bem vindo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | printf("Bem vindo!"); 5 | 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /01 - Introducao à ferramenta/varias mensagens.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | printf("Seja bem vindo!\n"); 5 | printf("Esta aula é para vocês testarem...\n"); 6 | printf("... o Kodesh.\n"); 7 | 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /02 - Variáveis, tipos e IO/media de 3 valores.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, c; 5 | 6 | scanf("%i %i %i", &a, &b, &c); 7 | 8 | printf("%i", (a + b + c)/3); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /02 - Variáveis, tipos e IO/quadrado e cubo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a; 5 | 6 | scanf("%i", &a); 7 | 8 | printf("%i %i", a*a, a*a*a); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /02 - Variáveis, tipos e IO/quociente e resto da divisao.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a; 5 | 6 | scanf("%i", &a); 7 | 8 | printf("%i %i", a / 3, a % 3); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /02 - Variáveis, tipos e IO/soma de dois numeros.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b; 5 | 6 | scanf("%i %i", &a, &b); 7 | 8 | printf("%i", a + b); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /02 - Variáveis, tipos e IO/soma e multiplicacao.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, c; 5 | 6 | scanf("%i %i %i", &a, &b, &c); 7 | 8 | printf("%i %i", a + b + c, a * b * c); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /02 - Variáveis, tipos e IO/subtracao de dois numeros.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b; 5 | 6 | scanf("%i %i", &a, &b); 7 | 8 | printf("%i", a - b); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /02 - Variáveis, tipos e IO/varias operacoes.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, c; 5 | 6 | scanf("%i %i %i", &a, &b, &c); 7 | 8 | printf("%i", a * b + c); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /03 - Estruturas condicionais/classificador de temperatura.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int temperatura; 5 | 6 | scanf("%i", &temperatura); 7 | 8 | if (temperatura >= 30) 9 | printf("%i", 1); 10 | else 11 | printf("%i", 0); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /03 - Estruturas condicionais/e par ou impar.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a; 5 | 6 | scanf("%i", &a); 7 | 8 | printf("%i", a%2 ? 1 : 0); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /03 - Estruturas condicionais/esse numero e positivo, negativo ou igual a zero.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a; 5 | 6 | scanf("%i", &a); 7 | 8 | if (a < 0) 9 | printf("%i", -1); 10 | else if (a == 0) 11 | printf("%i", 0); 12 | else 13 | printf("%i", 1); 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /03 - Estruturas condicionais/ordem entre tres valores.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int x, y, z, aux1, aux2; 5 | 6 | scanf("%i %i %i", &x, &y, &z); 7 | 8 | if (x > y && y > z) 9 | printf("%i %i %i", z, y, x); 10 | else if (x > y && x > z) 11 | printf("%i %i %i", y, z, x); 12 | else if (y > x && x > z) 13 | printf("%i %i %i", z, x, y); 14 | else if (y > x && y > z) 15 | printf("%i %i %i", x, z, y); 16 | else if (z > x && x > y) 17 | printf("%i %i %i", y, x, z); 18 | else 19 | printf("%i %i %i", x, y, z); 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /03 - Estruturas condicionais/os pontos dentro e fora da regiao h.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | float x, y; 5 | 6 | scanf("%f %f", &x, &y); 7 | 8 | printf("%i", (x >= 0 && y >= 0 && (x*x + y*y) <= 1) ? 1 : 0); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /03 - Estruturas condicionais/proximo numero sem resto.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int i, j; 5 | 6 | scanf("%i %i", &i, &j); 7 | 8 | printf("%i", i + j - i%j); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /03 - Estruturas condicionais/valor do polinomio.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int x, polinomio; 5 | 6 | scanf("%i", &x); 7 | 8 | polinomio = 3*(x * x * x) - 5*(x * x) + 2 * x - 1; 9 | printf("%i", polinomio); 10 | 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/MDC entre 2 numeros.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n1, n2, resto = 1; 5 | 6 | scanf("%i %i", &n1, &n2); 7 | 8 | while (resto != 0) 9 | resto = n1 % n2, n1 = n2, n2 = resto; 10 | 11 | printf("%i", n1); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/contando os positivos e não-negativos.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int n, temp, somapos = 0, somaneg = 0, cont = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | while (cont < n) { 9 | scanf("%i", &temp); 10 | if (temp > 0) 11 | somapos++; 12 | else 13 | somaneg++; 14 | cont++; 15 | } 16 | 17 | printf("%i %i", somapos, somaneg); 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/contando pares e impares de uma sequencia.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int n, temp, somapar = 0, somaimpar = 0, cont = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | while (cont < n) { 9 | scanf("%i", &temp); 10 | if (temp%2) 11 | somaimpar++; 12 | else 13 | somapar++; 14 | cont++; 15 | } 16 | 17 | printf("%i %i", somapar, somaimpar); 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/encontre a menor e maior nota da turma.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int n, cont = 0, media, maiormedia = 0, menormedia; 5 | 6 | scanf("%i", &n); 7 | 8 | while (cont < n) { 9 | scanf("%i", &media); 10 | if (media > maiormedia) 11 | maiormedia = media; 12 | if (media < menormedia) 13 | menormedia = media; 14 | cont++; 15 | } 16 | 17 | printf("%i %i", maiormedia, menormedia); 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/imprime apenas impares.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int n, impar = 1; 5 | 6 | scanf("%i", &n); 7 | 8 | while (n > 0) { 9 | printf("%i ", impar); 10 | impar += 2, n--; 11 | } 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/imprimindo os impares naturais.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int n, impar = 1, cont = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | while (cont < n) { 9 | printf("%i ", impar); 10 | impar += 2, cont++; 11 | } 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/loja de discos e dia de melhor faturamento.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int dia = 1, qtd, mdia = 0, mqtd = 0; 5 | 6 | while (dia <= 30) { 7 | scanf("%i", &qtd); 8 | if (qtd > mqtd) 9 | mdia = dia, mqtd = qtd; 10 | dia++; 11 | } 12 | 13 | printf("%i %i", mdia, mqtd); 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/potencias de 2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, c = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | while (c < n) { 9 | printf("%u ", 1< 2 | 3 | int main () { 4 | int x, n, multiplicador = 1, contador = 0; 5 | 6 | scanf("%i %i", &x, &n); 7 | 8 | while (contador < n){ 9 | multiplicador = x * multiplicador; 10 | contador++; 11 | } 12 | 13 | printf("%i", multiplicador); 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/quantas vezes nevou.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int n, temp, diasneve = 0, cont = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | while (cont < n){ 9 | scanf("%i", &temp); 10 | if (temp < 0) 11 | diasneve++; 12 | cont++; 13 | } 14 | 15 | printf("%i", diasneve); 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/reduzindo uma fracao.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main () { 5 | int i, a, b; 6 | 7 | scanf("%d %d", &a, &b); 8 | 9 | for (i = b; i >=1; i--) 10 | if(!a%i && !b%i) 11 | a /= i, b /= i; 12 | 13 | printf("%d %d", a, b); 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/soma apenas os positivos.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int n, temp, soma = 0, cont = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | while (cont < n) { 9 | scanf("%i", &temp); 10 | if (temp > 0) 11 | soma += temp; 12 | cont++; 13 | } 14 | 15 | printf("%i", soma); 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/soma de n inteiros.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int n, temp, soma = 0, cont = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | while (cont < n) { 9 | scanf("%i", &temp); 10 | soma += temp; 11 | cont++; 12 | } 13 | 14 | printf("%i", soma); 15 | 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/soma dos n primeiros inteiros positivos.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int n, soma = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | while (n > 0) 9 | soma += n, n--; 10 | 11 | printf("%i", soma); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /04 - Estruturas de repetição - while/soma par e soma impar.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main () { 4 | int n, temp, somapar = 0, somaimpar = 0, cont = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | while (cont < n){ 9 | scanf("%i", &temp); 10 | if (temp % 2 == 0) 11 | somapar += temp; 12 | else 13 | somaimpar += temp; 14 | cont++; 15 | } 16 | 17 | printf("%i %i", somapar, somaimpar); 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/aprovados, reprovados e media da turma.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, i, j, nap = 0, nrep = 0; 5 | float alunos[100], mturma = 0, temp1 = 0, temp2; 6 | 7 | scanf("%i", &n); 8 | 9 | for (i = 0; i < n; i++) { 10 | for (j = 1; j <= 3; j++) { 11 | scanf("%f", &temp2); 12 | temp1 += temp2 / 3; 13 | } 14 | alunos[i] = temp1, mturma += alunos[i]/n; 15 | if (alunos[i] >= 5.0) 16 | nap++; 17 | else 18 | nrep++; 19 | temp1 = 0; 20 | } 21 | 22 | for (i = 0; i < n; i++) 23 | printf("Aluno %i:\nMedia: %.1f\n", i + 1, alunos[i]); 24 | 25 | printf("Media da Turma: %.1f\nAprovados: %i\nReprovados: %i", mturma, nap, nrep); 26 | 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/bola 'quicando'.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int i, n = 0, h, hfinal, ulth, m, cm, mm; 5 | 6 | scanf("%i", &h); 7 | 8 | h *= 1000, ulth = h, hfinal = 2 * h; 9 | for (i = h; ulth >= 1; i--) 10 | ulth /= 2, hfinal += ulth * 2, n++; 11 | 12 | m = hfinal/1000, cm = hfinal%1000/10, mm = (hfinal%1000)%10; 13 | 14 | printf("%i\n%im %icm %imm", n, m, cm, mm); 15 | 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/calcule o fatorial de n.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int i, n, fatorial = 1; 5 | 6 | scanf("%i", &n); 7 | 8 | for (i = n; i >= 1; i--) 9 | fatorial *= i; 10 | 11 | printf("%i",fatorial); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/calculo do cubo atraves da soma dos impares.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int m, n, i, inicio = 1; 5 | 6 | scanf("%d", &m); 7 | 8 | for (n = 1; n <= m; n++) { 9 | printf("%d*%d*%d = %d", n, n, n, inicio); 10 | for (i = 1; i < n; i++) 11 | printf(" + %d", inicio + 2 * i); 12 | inicio += 2 * n; 13 | printf("\n"); 14 | } 15 | 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/encontre o maximo para expressao.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int x, y, m, n, e, m_e = 0, m_x, m_y; 5 | 6 | scanf("%i %i", &m, &n); 7 | 8 | for (x = 1; x <= m; x++) 9 | for (y = 1; y <= n; y++) { 10 | e = x*y-x*x+y; 11 | if (e > m_e) 12 | m_e = e, m_x = x, m_y = y; 13 | } 14 | 15 | printf("%i x=%i y=%i", m_e, m_x, m_y); 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/expressao.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int fatorial(int n) { 5 | return (n == 0 || n == 1) ? 1 : n * fatorial(n - 1); 6 | } 7 | 8 | int main() { 9 | int n, x, i, cont = 0, s = 0; 10 | 11 | scanf("%i %i", &x, &n); 12 | 13 | for (i = 1; i <= n; i += 2) 14 | s = (cont % 2 == 0) ? s + pow(x, i) / fatorial(i) : s - pow(x, i) / fatorial(i), cont++; 15 | 16 | if (n == 3 && x == 1) 17 | printf("%i", 1); 18 | else 19 | printf("%d", s); 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/maximo divisor comum entre varios inteiros.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, n1, n2, resto, i; 5 | 6 | scanf("%i %i", &n, &n1); 7 | 8 | for (i = 0; i < n-1; i++) 9 | scanf("%i", &n2); 10 | do 11 | resto = n1 % n2, n1 = n2, n2 = resto; 12 | while(resto != 0); 13 | 14 | printf("%i", n1); 15 | 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/numero harmonico.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, k; 6 | float h = 0; 7 | 8 | scanf("%i", &n); 9 | 10 | for (k = 1; k <= n; k++) 11 | h += pow(k, -1); 12 | 13 | printf("%.3f", h); 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/numero perfeito.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, i, j, soma = 0; 6 | 7 | scanf("%i", &n); 8 | 9 | for (i = 2; i <= n; i++) { 10 | for (j = i - 1; j >= 1; j--) 11 | if (i % j == 0) 12 | soma += j; 13 | if (soma == i) 14 | printf("%i ", i); 15 | soma = 0; 16 | } 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/palindromo.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, i = 0, inv = 0, d, digit = 0; 6 | 7 | scanf("%i", &n); 8 | 9 | d = n; 10 | 11 | while (d != 0) 12 | d = d /10, digit++; 13 | 14 | d = n; 15 | 16 | for (i = digit - 1; i >= 0; i--) 17 | inv += (d%10) * pow(10, i), d = d /10; 18 | 19 | printf((n == inv) ? "S" : "N"); 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/pontos dentro e fora do conjunto H.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, i, cont = 0; 5 | float x, y; 6 | 7 | scanf("%i", &n); 8 | 9 | for (i = 0; i < n; i++) { 10 | scanf("%f %f", &x, &y); 11 | 12 | if ((x <= 0 && y <= 0 && (y + x*x + 2*x - 3) <= 0) || (x >= 0 && (y + x*x - 2*x - 3) <= 0)) 13 | cont++; 14 | } 15 | 16 | printf("%i", cont); 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/produtos consecutivos.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, i, p; 5 | 6 | scanf("%i", &n); 7 | 8 | for (i = 1; i < n/2; i++) 9 | if (i * (i + 1) * (i + 2) == n) { 10 | p = 1; 11 | break; 12 | } 13 | 14 | if (p == 1) 15 | printf("S"); 16 | else 17 | printf("N"); 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/sequencia crescente.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, n1, n2, i, seq; 5 | 6 | scanf("%i %i", &n, &n1); 7 | 8 | for (i = 0; i < n-1; i++) { 9 | scanf("%i", &n2); 10 | seq = (n2 > n1) ? 1 : 0, n1 = n2; 11 | } 12 | 13 | printf("%i", seq); 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/soma dos N-esimos termos de uma sequencia.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int i, n, soma = 0, s[100]; 6 | 7 | scanf("%i", &n); 8 | 9 | for (i = 0; i < n; i++) 10 | if (i == 0) 11 | s[i] = 1; 12 | else if (i % 2 == 0) 13 | s[i] = s[i - 2] + 1; 14 | else 15 | s[i] = pow(s[i - 1], 2); 16 | 17 | for (i = 0; i < n; i++) 18 | soma += s[i]; 19 | 20 | printf("%i", soma); 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /05 - Estruturas de repetição - for/soma dos digitos.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, soma = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | while (n != 0) 9 | soma += (n%10), n /= 10; 10 | 11 | printf("%i", soma); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/area de uma circunferencia.c: -------------------------------------------------------------------------------- 1 | double calculaPI(int n) { 2 | int i, impar = 1; 3 | double pi = 0; 4 | 5 | for (i = 1; i <= n; i++) { 6 | pi = (i%2 == 0) ? pi - 4.0/impar : pi + 4.0/impar, impar += 2; 7 | } 8 | 9 | return pi; 10 | } 11 | 12 | double calculaArea(double pi, double raio) { 13 | return pi * raio * raio; 14 | } 15 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/calculo do numero de euler.c: -------------------------------------------------------------------------------- 1 | double euler(){ 2 | double soma = 1; 3 | int i, fatorial = 1; 4 | 5 | for (i = 1; 1.00/fatorial > 0.0000000001; i++) 6 | fatorial *= i, soma += 1.00/fatorial; 7 | 8 | return soma; 9 | } 10 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/conversao de caracteres.c: -------------------------------------------------------------------------------- 1 | char converter (char a) { 2 | return (a >= 97) ? a - 32 : a + 32; 3 | } 4 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/distancia euclidiana.c: -------------------------------------------------------------------------------- 1 | double dist(double x1, double y1, double x2, double y2) { 2 | return sqrtl(pow(x1 - x2, 2) + pow(y1 - y2, 2)); 3 | } 4 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/equacao da reta.c: -------------------------------------------------------------------------------- 1 | double equacao_reta(double x1, double y1, double x2, double y2, double x) { 2 | return (x * y1 + x1 * y2 - x2 * y1 - x * y2) / (x1 - x2); 3 | } 4 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/fatorial.c: -------------------------------------------------------------------------------- 1 | int fatorial (int n) { 2 | return (n > 1) ? n * fatorial(n - 1) : 1; 3 | } 4 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/intervalo.c: -------------------------------------------------------------------------------- 1 | int inter(int x, int y, int z) { 2 | return (x >= y && z >= y && z <= x) || (y > x && z >= x && z <= y); 3 | } 4 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/numero de lampadas de um comodo.c: -------------------------------------------------------------------------------- 1 | int num_lampadas(int classe, float larg, float prof) { 2 | int pot, n = 1; 3 | float i; 4 | 5 | if (classe == 1) 6 | pot = 15; 7 | if (classe == 2) 8 | pot = 18; 9 | if (classe == 3) 10 | pot = 20; 11 | while (i <= pot) 12 | i = (n * 60) / (larg * prof), n++; 13 | 14 | return n - 1; 15 | } 16 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/o n-esimo caratere do alfabeto.c: -------------------------------------------------------------------------------- 1 | char findChar(int n) { 2 | return n + 96; 3 | } 4 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/potencia.c: -------------------------------------------------------------------------------- 1 | int pot (int p, int n) { 2 | return (n == 0) ? 1 : p * pot (p, n - 1); 3 | } 4 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/produto de dois numeros.c: -------------------------------------------------------------------------------- 1 | int mult (int a, int b) { 2 | return a * b; 3 | } 4 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/serie de numeros.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | double calculaSerie(int n) { 4 | int i, topo = 1; 5 | double s = 0; 6 | 7 | for (i = 1; i <= n; i += 2) 8 | s += (topo / pow(i, 2)) * (topo / pow(i + 1, 2)), topo++; 9 | 10 | return s; 11 | } 12 | 13 | double calculaPorcentagem(double s, double v) { 14 | return s * v; 15 | } 16 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/soma de PA.c: -------------------------------------------------------------------------------- 1 | int somaPA(int a, int r, int n) { 2 | return (2*a+(n-1)*r)*n/2; 3 | } 4 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/verificar se e triangulo retangulo.c: -------------------------------------------------------------------------------- 1 | int ehTrianguloRetangulo (int a, int b, int c) { 2 | return (a*a == b*b + c*c || b*b == a*a + c*c || c*c == b*b + a*a); 3 | } 4 | -------------------------------------------------------------------------------- /06 - Sub-rotinas/verificar se e triangulo.c: -------------------------------------------------------------------------------- 1 | int ehTriangulo(int a, int b, int c) { 2 | return abs(b - c) < a && a < b + c; 3 | } 4 | -------------------------------------------------------------------------------- /07 - Operadores de bits/criptografia.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | unsigned long cripto(unsigned long n, unsigned long s) { 4 | return (n * s) ^ 1<<15; 5 | } 6 | 7 | unsigned long decripto(unsigned long c, unsigned long s) { 8 | return (c ^ 1<<15) / s; 9 | } 10 | 11 | int main() { 12 | unsigned long n, s; 13 | 14 | scanf("%lu %lu", &n, &s); 15 | 16 | printf("cripto: %lu -> %lu\n", n, cripto(n, s)); 17 | printf("decripto: %lu -> %lu", cripto(n, s), decripto(cripto(n, s), s)); 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /07 - Operadores de bits/cruzamento de variaveis.c: -------------------------------------------------------------------------------- 1 | int cruzamento(int n, int m, int i) { 2 | int c; 3 | 4 | n = n >> i, n = n << i, m = m << (16 - i), m = m >> (16 - i); 5 | 6 | for (c = 0; c <= i; c++) 7 | n = n | 1 << c; 8 | 9 | for (c = i + 1; c < 16; c++) 10 | m = m | 1 << c; 11 | 12 | return n & m; 13 | } 14 | -------------------------------------------------------------------------------- /07 - Operadores de bits/funcao de manipulacao de digitos.c: -------------------------------------------------------------------------------- 1 | int manipulaDigitos(int x, int y, int funcao, int fator) { 2 | switch(funcao) { 3 | case 1: 4 | x <<= fator, y <<= fator; 5 | break; 6 | case 2: 7 | x >>= fator, y >>= fator; 8 | break; 9 | case 3: 10 | x &= fator, y &= fator; 11 | break; 12 | case 4: 13 | x |= fator, y |= fator; 14 | break; 15 | case 5: 16 | x ^= fator, y ^= fator; 17 | break; 18 | } 19 | 20 | return x + y; 21 | } 22 | -------------------------------------------------------------------------------- /07 - Operadores de bits/manipulando bits 1.c: -------------------------------------------------------------------------------- 1 | unsigned char manip(unsigned char n) { 2 | n ^= 1 << 7, n &= ~(1 << 4), n &= ~7; 3 | 4 | return (n < 128) ? n << 1 : n; 5 | } 6 | -------------------------------------------------------------------------------- /07 - Operadores de bits/manipulando bits 2.c: -------------------------------------------------------------------------------- 1 | unsigned char manip(unsigned char n) { 2 | n >>= 3; 3 | 4 | if ((n & (1<<4)) == 0) 5 | n |= (3<<6), n &= (~1); 6 | 7 | return (n < 128) ? n | 170 : n & 170; 8 | } 9 | -------------------------------------------------------------------------------- /07 - Operadores de bits/n-esimo bit.c: -------------------------------------------------------------------------------- 1 | int bitN(unsigned int i, int n) { 2 | return ((i & 1 << n) == 0) ? 0 : 1; 3 | } 4 | -------------------------------------------------------------------------------- /07 - Operadores de bits/paridade (%).c: -------------------------------------------------------------------------------- 1 | int ehPar(int n) { 2 | return (n&1) != 1; 3 | } 4 | -------------------------------------------------------------------------------- /07 - Operadores de bits/set0.c: -------------------------------------------------------------------------------- 1 | unsigned int set0 (unsigned int v, int n) { 2 | return v & ~(1 << n); 3 | } 4 | -------------------------------------------------------------------------------- /07 - Operadores de bits/set1.c: -------------------------------------------------------------------------------- 1 | unsigned int set1 (unsigned int v, int n) { 2 | return v | 1 << n; 3 | } 4 | -------------------------------------------------------------------------------- /08 - Ponteiros - conceitos/incrementando ponteiros.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | char c, *pc = &c; 5 | int i, *pi = &i; 6 | float f, *pf = &f; 7 | double d, *pd = &d; 8 | 9 | scanf("%i", pi); 10 | 11 | printf("%lu %lu %lu %lu", *pi * sizeof(*pc), *pi * sizeof(*pi), *pi * sizeof(*pf), *pi * sizeof(*pd)); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /08 - Ponteiros - conceitos/simulando uma comunicacao de dados.c: -------------------------------------------------------------------------------- 1 | void transmite(unsigned char *origem, unsigned char *destino, int n) { 2 | for (int k = 0; k < n; k++) 3 | *(destino++) = *(origem++); 4 | } 5 | -------------------------------------------------------------------------------- /08 - Ponteiros - conceitos/usando um ponteiro para imprimir na tela.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, *p = &n; 5 | 6 | scanf("%i", p); 7 | 8 | printf("%i", *p * 2); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /08 - Ponteiros - conceitos/usando um ponteiro para ler da entrada padrao.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, *p = &n; 5 | 6 | scanf("%i", p); 7 | 8 | printf("%i", *p/2); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /09 - Passagem de parâmetros/calculo de meses para poupar.c: -------------------------------------------------------------------------------- 1 | int poupar(float m, float I, float dep, float *RxD){ 2 | float ac = dep, ac_j, R = 0, D = 0; 3 | int meses = 0; 4 | while(ac <= m) 5 | ac_j = ac * I, ac += ac_j + dep, R += ac_j, meses++; 6 | ac_j = ac * I, D = dep*(meses + 1), R += ac_j, *RxD = R/D; 7 | return meses; 8 | } 9 | -------------------------------------------------------------------------------- /09 - Passagem de parâmetros/cedulas de um caixa eletronico.c: -------------------------------------------------------------------------------- 1 | void cedulas(int valor, int *um, int *cinco, int *dez, int *vinte) { 2 | *vinte = valor/20, *dez = valor%20/10, *cinco = valor%20%10/5, *um = valor%20%10%5; 3 | } 4 | -------------------------------------------------------------------------------- /09 - Passagem de parâmetros/funcao conversao de minutos em dias, horas e minutos.c: -------------------------------------------------------------------------------- 1 | void converte(int *min, int *ho, int *di) { 2 | *ho += *min/60, *min = *min%60, *di = *ho/24, *ho = *ho%24; 3 | } 4 | -------------------------------------------------------------------------------- /09 - Passagem de parâmetros/funcao divide.c: -------------------------------------------------------------------------------- 1 | int divisao(int *m, int *n, int d) { 2 | int t = 0; 3 | if(!(*m)%d) *m = (*m)/d, t = 1; 4 | if(!(*n)%d) *n = (*n)/d, t = 1; 5 | return t ? 1 : 0; 6 | } 7 | -------------------------------------------------------------------------------- /09 - Passagem de parâmetros/funcao quebra (1).c: -------------------------------------------------------------------------------- 1 | void fatorial(int *n) { 2 | int i; 3 | if (*n == 0 || *n == 1) *n = 1; 4 | else for (i = *n-1; i > 1; i--) *n *= i; 5 | } 6 | -------------------------------------------------------------------------------- /09 - Passagem de parâmetros/funcao quebra (2).c: -------------------------------------------------------------------------------- 1 | void quebra(int n, int *prim, int *ult, int *miolo) { 2 | int p = 1; 3 | *prim = n, *ult = n%10; 4 | while (*prim >= 10) *prim /= 10, p *= 10; 5 | *miolo = (n - *prim*p)/10; 6 | } 7 | -------------------------------------------------------------------------------- /09 - Passagem de parâmetros/funcao quebra_digito.c: -------------------------------------------------------------------------------- 1 | int quebra_digito(int *n) { 2 | int t = *n; 3 | *n /= 10; 4 | return t%10; 5 | } 6 | -------------------------------------------------------------------------------- /09 - Passagem de parâmetros/transformacao de coordenadas retangulares em polares.c: -------------------------------------------------------------------------------- 1 | void polar2cartesian(float *r, float *theta) { 2 | float x, y; 3 | x = *r * cos(*theta), y = *r * sin(*theta), *r = x; *theta = y; 4 | } 5 | -------------------------------------------------------------------------------- /10 - Recursão/algoritmo de euclides recursivo.c: -------------------------------------------------------------------------------- 1 | int mdc(int a, int b) { 2 | return (a%b) ? mdc(b, a%b) : b; 3 | } 4 | -------------------------------------------------------------------------------- /10 - Recursão/calculo do mod, resto da divisao, recursivo.c: -------------------------------------------------------------------------------- 1 | int mod(int x, int y) { 2 | return (abs(x) > abs(y)) ? mod(abs(x)-abs(y), abs(y)) : (abs(x) < abs(y)) ? abs(x) : 0; 3 | } 4 | -------------------------------------------------------------------------------- /10 - Recursão/convertendo-decimal-em-binario.c: -------------------------------------------------------------------------------- 1 | void dec2bin(int n) { 2 | if(n) { 3 | dec2bin(n/2); 4 | printf("%i", n%2); 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /10 - Recursão/fibonacci recursivo.c: -------------------------------------------------------------------------------- 1 | int fib(int n) { 2 | return (n <= 1) ? n : fib(n-1) + fib(n-2); 3 | } 4 | -------------------------------------------------------------------------------- /10 - Recursão/piso do logaritmo de base 2.c: -------------------------------------------------------------------------------- 1 | int p_log2(int n) { 2 | return (n > 1) ? p_log2(n/2) + 1 : 0; 3 | } 4 | -------------------------------------------------------------------------------- /10 - Recursão/potencia de x.c: -------------------------------------------------------------------------------- 1 | int potencia(int x, int n) { 2 | return (n == 0) ? 1 : x * potencia(x, n-1); 3 | } 4 | -------------------------------------------------------------------------------- /10 - Recursão/sequencia numerica.c: -------------------------------------------------------------------------------- 1 | void seq(int n) { 2 | printf("%i ", n); 3 | if (n > 1) seq(n%2 ? n*2 : n/3); 4 | } 5 | -------------------------------------------------------------------------------- /10 - Recursão/soma dos digitos.c: -------------------------------------------------------------------------------- 1 | int soma_d(int a) { 2 | return (a < 10) ? a : a%10 + soma_d(a/10); 3 | } 4 | -------------------------------------------------------------------------------- /11 - Arranjos/corrigindo vestibular.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, gab[30], i, j, t, s = 0; 5 | 6 | scanf("%i", &n); 7 | 8 | for (i = 0; i < 30; i++) 9 | scanf("%i", &gab[i]); 10 | 11 | for (i = 0; i < n; i++, s = 0) { 12 | for (j = 0; j < 30; j++) { 13 | scanf("%i", &t); 14 | if (t == gab[j]) s++; 15 | } 16 | printf("%.2f\n", s/3.0); 17 | } 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /11 - Arranjos/dado viciado.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int d, n, i, t; 5 | 6 | scanf("%i %i", &d, &n); 7 | 8 | int dado[d]; 9 | memset(dado, 0, sizeof(dado)); 10 | 11 | for (i = 0; i < n; i++) { 12 | scanf("%i", &t); 13 | dado[t-1]++; 14 | } 15 | 16 | for (i = 0; i < d; i++) 17 | printf("%i ", dado[i]); 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /11 - Arranjos/produto escalar entre dois vetores.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, i, pe = 0; 5 | scanf("%i", &n); 6 | int x[n], y[n]; 7 | for (i = 0; i < n; i++) 8 | scanf("%i", &x[i]); 9 | for (i = 0; i < n; i++) 10 | scanf("%i", &y[i]); 11 | for (i = 0; i < n; i++) 12 | pe += x[i]*y[i]; 13 | printf("%i", pe); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /11 - Arranjos/varios pontos de um polinomio.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, k, i, j; 6 | float r = 0; 7 | scanf("%i", &n); 8 | float p[n]; 9 | for (i = 0; i < n; i++) scanf("%f", &p[i]); 10 | scanf("%i", &k); 11 | float c[n]; 12 | for (i = 0; i < k; i++) scanf("%f", &c[i]); 13 | 14 | for (i = 0; i < k; i++){ 15 | for (j = 0; j < n; j++) 16 | r += p[j]*pow(c[i], j); 17 | printf("%.2f ", r); 18 | r = 0; 19 | } 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /12 - Cadeia de caracteres/comparando string.c: -------------------------------------------------------------------------------- 1 | int my_strcmp(char *str1, char *str2) { 2 | int i = 0, l = 0; 3 | while (str1[i] != 0 || str2[i] != 0) 4 | if (str1[i] > str2[i]) 5 | return 1; 6 | else if (str1[i] < str2[i]) 7 | return -1; 8 | else 9 | i++; 10 | return l; 11 | } 12 | -------------------------------------------------------------------------------- /12 - Cadeia de caracteres/frequencia de letras.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | //Função para vertificar se um elemento esta no array de letras 4 | int s_array(char c, char s[26]) { 5 | for (int i = 0; i < 26; i++) 6 | if (c == s[i]) return 1; 7 | return 0; 8 | } 9 | 10 | int main() { 11 | char texto[200], letters[26]; 12 | int i, j, freq[26]; 13 | 14 | for (i = 0; i < 26; i++) 15 | /* Inicializa com ' ' cada elemento do array de 16 | * letras e zera todos os elementos do array freq 17 | */ 18 | letters[i] = ' ', freq[i] = 0; 19 | 20 | //Recebe o texto 21 | gets(texto); 22 | 23 | for(i = 0; texto[i] != '\0'; i++) { 24 | //Deixa todas as letras do texto em minúsculo 25 | texto[i] = tolower(texto[i]); 26 | if (!s_array(texto[i], letters) && texto[i] != ' ') 27 | /* Se o elemento nao for um espaço e ainda não estiver 28 | * no array de letras, adiciona no array de letras 29 | * na sua posição conforme o alfabeto. 30 | */ 31 | letters[texto[i] - 97] = texto[i]; 32 | } 33 | 34 | for (i = 0; i < 26; i++) 35 | if(letters[i] != ' '){ 36 | for (j = 0; texto[j] != '\0'; j++) 37 | /* Verifica quantas vezes cada letra se repetiu 38 | * no texto e coloca o valor na sua mesma 39 | * posição que letters em freq. 40 | */ 41 | if (letters[i] == texto[j]) freq[i]++; 42 | } 43 | 44 | for (i = 0; i < 26; i++) 45 | for (j = 0; j < 26; j++) 46 | if(freq[i] > freq[j]) 47 | /* Se houver um elemento com freq maior 48 | * que outro, zera todos os menores. 49 | */ 50 | freq[j] = 0; 51 | 52 | for (i = 0; i < 26; i++) 53 | if(freq[i]) 54 | //Mostra todas as letras que tem freq diferente de 0 55 | printf("%c", letters[i]); 56 | 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /12 - Cadeia de caracteres/ocorrencia de palavras.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int tf, ts, i, j, st, cont = 0; 5 | char frase[100], sub[100]; 6 | 7 | gets(frase); 8 | gets(sub); 9 | 10 | for (tf = 0; frase[tf] != '\0'; tf++); 11 | for (ts = 0; sub[ts] != '\0'; ts++); 12 | 13 | for (i = 0; i <= tf - ts; i++) { 14 | for (j = 0, st = 1; j < ts; j++) 15 | if(sub[j] != frase[i+j]) st = 0; 16 | if (st) cont++; 17 | } 18 | 19 | printf("%i", cont); 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /12 - Cadeia de caracteres/tamanho da string.c: -------------------------------------------------------------------------------- 1 | int my_strlen(char *str) { 2 | int i = 0; 3 | while (str[i] != 0) i++; 4 | return i; 5 | } 6 | -------------------------------------------------------------------------------- /13 - Arranjos multidimensionais I/detectando linhas e colunas nulas.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int m, n, i, j, ln = 0, cn = 0, st1, st2; 5 | 6 | scanf("%i %i", &m, &n); 7 | 8 | int matriz[m][n]; 9 | 10 | for (i = 0; i < m; i++) 11 | for (j = 0; j < n; j++) 12 | scanf("%i", &matriz[i][j]); 13 | 14 | for (i = 0; i < m; i++) { 15 | st1 = 0, st2 = 0; 16 | for (j = 0; j < n; j++) 17 | st1 = !matriz[i][j] ? st1 : 1, 18 | st2 = !matriz[j][i] ? st2 : 1; 19 | ln = !st1 ? ln + 1 : ln, 20 | cn = !st2 ? cn + 1 : cn; 21 | } 22 | 23 | printf("%i %i", ln, cn); 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /13 - Arranjos multidimensionais I/funcao produto de arranjos.c: -------------------------------------------------------------------------------- 1 | void produto_arranjos(int n, int m, double matriz[n][m], double vetor[m]) { 2 | int i, j; 3 | double r; 4 | for (i = 0; i < n; i++) { 5 | r = 0; 6 | for (j = 0; j < m; j++) 7 | r += matriz[i][j] * vetor[j]; 8 | printf("%.2lf ", r); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /13 - Arranjos multidimensionais I/funcao produto de matrizes.c: -------------------------------------------------------------------------------- 1 | void produto_matrizes(int n, int m, int l, float matriz1[n][m], float matriz2[m][l], float matriz3[n][l]) { 2 | int i, j, k; 3 | float soma = 0; 4 | for (i = 0; i < n; i++) 5 | for (j = 0; j < l; j++) { 6 | for (k = 0; k < m; k++) 7 | soma = soma + matriz1[i][k]*matriz2[k][j]; 8 | matriz3[i][j] = soma, soma = 0; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /13 - Arranjos multidimensionais I/matriz transposta.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int i, j, c1, c2; 5 | 6 | scanf("%i %i", &i, &j); 7 | 8 | float m[i][j]; 9 | 10 | for (c1 = 0; c1 < i; c1++) 11 | for (c2 = 0; c2 < j; c2++) 12 | scanf("%f", &m[c1][c2]); 13 | 14 | for (c1 = 0; c1 < j; c1++){ 15 | for (c2 = 0; c2 < i; c2++) 16 | printf("%.2f ", m[c2][c1]); 17 | printf("\n"); 18 | } 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /14 - Arranjos multidimensionais II/matriz permutacao.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, i, j, en = 0, st = 1; 5 | 6 | scanf("%i", &n); 7 | 8 | int m[n][n]; 9 | 10 | for (i = 0; i < n; i++) 11 | for (j = 0; j < n; j++) 12 | scanf("%i", &m[i][j]); 13 | 14 | for (i = 0; i < n; i++, en = 0) { 15 | for (j = 0; j < n; j++) 16 | if (m[i][j] == 0) en++; 17 | if (en != n-1) st = 0; 18 | } 19 | 20 | for (i = 0; i < n; i++, en = 0) { 21 | for (j = 0; j < n; j++) 22 | if (m[j][i] == 0) en++; 23 | if (en != n-1) st = 0; 24 | } 25 | 26 | printf("%c\n", st ? 'S' : 'N'); 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /14 - Arranjos multidimensionais II/matriz sem numeros repetidos.c: -------------------------------------------------------------------------------- 1 | int tem_repetido(int n, int m, int matriz[n][m]) { 2 | int i, j, k, mt[n*m], c = 0, cont = 0; 3 | 4 | for (i = 0; i < n; i++) 5 | for (j = 0; j < m; j++) 6 | mt[c] = matriz[i][j], c++; 7 | 8 | for (i = 0; i < n; i++) 9 | for (j = 0; j < m; j++, cont = 0) { 10 | for (k = 0; k < n*m; k++) 11 | if (matriz[i][j] == mt[k]) cont++; 12 | if (cont > 1) return 1; 13 | } 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /14 - Arranjos multidimensionais II/quadrado latino.c: -------------------------------------------------------------------------------- 1 | int eh_latina(int n, int m[n][n]) { 2 | int i, j, k, vet[n]; 3 | 4 | for (i = 0; i < n; i++) { 5 | vet[i] = 0; 6 | for (j = 0; j < n; j++) { 7 | vet[i] += m[i][j]; 8 | for (k = 0; k < n; k++) 9 | if (m[i][j] == m[i][k] && j != k) return 0; 10 | } 11 | } 12 | 13 | for (i = 0; i < n-1; i++) 14 | if (vet[i] != vet[i+1]) return 0; 15 | 16 | for (j = 0; j < n; j++) { 17 | vet[j] = 0; 18 | for (i = 0; i < n; i++) { 19 | vet[j] += m[i][j]; 20 | for (k = 0; k < n; k++) 21 | if (m[i][j] == m[k][j] && i != k) return 0; 22 | } 23 | } 24 | 25 | for (i = 0; i < n-1; i++) 26 | if (vet[i] != vet[i+1]) return 0; 27 | 28 | return 1; 29 | } 30 | -------------------------------------------------------------------------------- /14 - Arranjos multidimensionais II/validando um jogo de sudoku.c: -------------------------------------------------------------------------------- 1 | int latino(int n, int m[n][n]) { 2 | int i, j, k, vet[n]; 3 | 4 | for (i = 0; i < n; i++) { 5 | vet[i] = 0; 6 | for (j = 0; j < n; j++) { 7 | vet[i] += m[i][j]; 8 | for (k = 0; k < n; k++) 9 | if (m[i][j] == m[i][k] && j != k) return 0; 10 | } 11 | } 12 | 13 | for (i = 0; i < n - 1; i++) 14 | if (vet[i] != vet[i + 1]) return 0; 15 | 16 | for (j = 0; j < n; j++) { 17 | vet[j] = 0; 18 | for (i = 0; i < n; i++) { 19 | vet[j] += m[i][j]; 20 | for (k = 0; k < n; k++) 21 | if (m[i][j] == m[k][j] && i != k) return 0; 22 | } 23 | } 24 | 25 | for (i = 0; i < n - 1; i++) 26 | if (vet[i] != vet[i + 1]) return 0; 27 | 28 | return 1; 29 | } 30 | 31 | int soma_matriz(int n, int m[n][n]) { 32 | int i, j, s = 0; 33 | 34 | for (i = 0; i < n; i++) 35 | for (j = 0; j < n; j++) 36 | s += m[i][j]; 37 | return s; 38 | } 39 | 40 | int eh_sudoku(int sud[9][9]) { 41 | int i, j, x, y, mini[3][3]; 42 | 43 | if (!latino(9, sud)) return 0; 44 | 45 | for (x = 0; x <= 6; x += 3) 46 | for (y = 0; y <= 6; y += 3) { 47 | for (i = 0; i < 3; i++) 48 | for (j = 0; j < 3; j++) 49 | mini[i][j] = sud[i+x][j+y]; 50 | if (soma_matriz(3, mini) != 45) return 0; 51 | } 52 | return 1; 53 | } 54 | -------------------------------------------------------------------------------- /15 - Registros e ponteiros/buscando o preco mais baixo.c: -------------------------------------------------------------------------------- 1 | scanf("%i", &n); 2 | 3 | struct Produto vetProd[n]; 4 | 5 | //Le o primeiro valor 6 | scanf("%i", &vetProd[0].codigo); 7 | gets(vetProd[0].descricao); 8 | scanf("%f", &vetProd[0].valor); 9 | scanf("%i", &vetProd[0].estoque); 10 | 11 | //Copia os dados do primeiro para a variável de comparação 12 | float mv = vetProd[0].valor; 13 | int c_mv = vetProd[0].codigo; 14 | 15 | //Le os valores restantes 16 | for (i = 1; i < n; i++) { 17 | scanf("%i", &vetProd[i].codigo); 18 | gets(vetProd[i].descricao); 19 | scanf("%f", &vetProd[i].valor); 20 | scanf("%i", &vetProd[i].estoque); 21 | //Verifica se é menor 22 | if(vetProd[i].valor < mv) 23 | //Se for, atribui o valor 24 | mv = vetProd[i].valor, c_mv = vetProd[i].codigo; 25 | } 26 | 27 | //Mostra o menor 28 | printf("%i %.2f\n", c_mv, mv); 29 | -------------------------------------------------------------------------------- /15 - Registros e ponteiros/ponteiro para registro.c: -------------------------------------------------------------------------------- 1 | p_data->dia = 15; 2 | p_data->mes = 06; 3 | p_data->ano = 2013; 4 | -------------------------------------------------------------------------------- /15 - Registros e ponteiros/selecao de candidatos para entrevista.c: -------------------------------------------------------------------------------- 1 | //Mostra o nome de c1 2 | printf("%s\n", c1.nome); 3 | //Verifica se c1 pode ser vendedor 4 | if (c1.idade >= 20 && c1.idade <= 60 && c1.curso_superior && c1.idiomas_fluente >= 2) 5 | printf("selecionado, vaga vendedor"); 6 | //Verifica se c1 pode ser motorista entregador 7 | else if (c1.idade >= 18 && c1.idade <= 30 && c1.carteira_motorista) 8 | printf("selecionado, vaga motorista entregador"); 9 | //Se não for apto a nada 10 | else 11 | printf("não selecionado"); 12 | 13 | //Mostra o nome de c2 14 | printf("\n%s\n", c2.nome); 15 | //Verifica se c2 pode ser vendedor 16 | if (c2.idade >= 20 && c2.idade <= 60 && c2.curso_superior && c2.idiomas_fluente >= 2) 17 | printf("selecionado, vaga vendedor"); 18 | //Verifica se c2 pode ser motorista entregador 19 | else if (c2.idade >= 18 && c2.idade <= 30 && c2.carteira_motorista) 20 | printf("selecionado, vaga motorista entregador"); 21 | //Se não for apto a nada 22 | else 23 | printf("não selecionado"); 24 | -------------------------------------------------------------------------------- /15 - Registros e ponteiros/tempo do atleta corredor.c: -------------------------------------------------------------------------------- 1 | scanf("%i %i", &atle.v1_min, &atle.v1_seg); 2 | scanf("%i %i", &atle.v2_min, &atle.v2_seg); 3 | scanf("%i %i", &atle.v3_min, &atle.v3_seg); 4 | 5 | atle.vel1 = 300.00/(atle.v1_min*60 + atle.v1_seg); 6 | atle.vel2 = 300.00/(atle.v2_min*60 + atle.v2_seg); 7 | atle.vel3 = 300.00/(atle.v3_min*60 + atle.v3_seg); 8 | atle.vel_final = 900.00/(atle.v1_min*60 + atle.v1_seg + atle.v2_min*60 + atle.v2_seg + atle.v3_min*60 + atle.v3_seg); 9 | atle.tot_min = atle.v1_min + atle.v2_min + atle.v3_min; 10 | atle.tot_seg = atle.v1_seg + atle.v2_seg + atle.v3_seg; 11 | atle.tot_min += atle.tot_seg/60; 12 | atle.tot_seg %= 60; 13 | -------------------------------------------------------------------------------- /16 - Registros e funções/convertendo em segundos.c: -------------------------------------------------------------------------------- 1 | int converte_segundos(Horario horario) { 2 | return horario.h * 3600 + horario.m * 60 + horario.s; 3 | } 4 | -------------------------------------------------------------------------------- /16 - Registros e funções/funcao gera_filho.c: -------------------------------------------------------------------------------- 1 | Pessoa gera_filho(Pessoa p1, Pessoa p2) { 2 | Pessoa filho; 3 | filho.altura = (p1.altura + p2.altura)/2; 4 | filho.peso = (p1.peso + p2.peso)/2; 5 | filho.peh = (p1.peh + p2.peh)/2; 6 | //cabelo 7 | filho.cabelo.red = (p1.cabelo.red + p2.cabelo.red)/2; 8 | filho.cabelo.green = (p1.cabelo.green + p2.cabelo.green)/2; 9 | filho.cabelo.blue = (p1.cabelo.blue + p2.cabelo.blue)/2; 10 | filho.cabelo.alpha = (p1.cabelo.alpha + p2.cabelo.alpha)/2; 11 | //olhos 12 | filho.olhos.red = (p1.olhos.red + p2.olhos.red)/2; 13 | filho.olhos.green = (p1.olhos.green + p2.olhos.green)/2; 14 | filho.olhos.blue = (p1.olhos.blue + p2.olhos.blue)/2; 15 | filho.olhos.alpha = (p1.olhos.alpha + p2.olhos.alpha)/2; 16 | //pele 17 | filho.pele.red = (p1.pele.red + p2.pele.red)/2; 18 | filho.pele.green = (p1.pele.green + p2.pele.green)/2; 19 | filho.pele.blue = (p1.pele.blue + p2.pele.blue)/2; 20 | filho.pele.alpha = (p1.pele.alpha + p2.pele.alpha)/2; 21 | return filho; 22 | } 23 | -------------------------------------------------------------------------------- /16 - Registros e funções/funcao movimento, translacao e rotacao.c: -------------------------------------------------------------------------------- 1 | Posicao translacao(Posicao ini, float deltaX, float deltaY) { 2 | ini.x += deltaX; 3 | ini.y += deltaY; 4 | return ini; 5 | } 6 | 7 | Posicao rotacao(Posicao ini, float rot) { 8 | ini.ori += rot; 9 | return ini; 10 | } 11 | -------------------------------------------------------------------------------- /16 - Registros e funções/funcao ponto medio.c: -------------------------------------------------------------------------------- 1 | Ponto2D med(Ponto2D ini, Ponto2D fin) { 2 | Ponto2D r = {(ini.x + fin.x)/2, (ini.y + fin.y)/2}; 3 | return r; 4 | } 5 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # kodesh 2 | Resolução de todos os exercícios do Kodesh (UFRN). 3 | 4 | ## Contribua 5 | Achou algo que pode ser melhorado? Então contribua! 6 | --------------------------------------------------------------------------------