$course$/top/OnlineCompiler.io C (português) Questões CodeRunner grátis do OnlineCompiler.io (https://onlinecompiler.io/pt/banco-de-questoes-coderunner), sob a licença CC BY 4.0. Usam os tipos de questão que já vêm com o CodeRunner, então rodam em qualquer servidor Jobe.

]]> Escreva um programa que leia uma temperatura em graus Celsius e imprima o valor em graus Fahrenheit, usando F = C × 9 / 5 + 32. Imprima o resultado com exatamente uma casa decimal.

A entrada é um único número real, possivelmente negativo, escrito com ponto decimal (por exemplo, 36.6), e a saída também usa ponto.

]]> 1.0000000 0.0000000 0 c_program 0 1 10, 20, ... 0 0 0 15 100 int main(void) { double celsius; if (scanf("%lf", &celsius) == 1) { double fahrenheit = celsius * 9.0 / 5.0 + 32.0; printf("%.1f\n", fahrenheit); } return 0; } ]]> 1 0 onlinecompiler.io c io Escreva uma função void print_duration(int seconds) que imprima uma duração dada em segundos como horas, minutos e segundos no formato H:MM:SS, seguida de uma quebra de linha. Minutos e segundos sempre têm dois dígitos; as horas usam quantos dígitos forem necessários, sem zeros à esquerda. Por exemplo, print_duration(3725) imprime 1:02:05.

0 ≤ seconds ≤ 106. A função imprime o resultado; ela não devolve nada.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c io Escreva uma função bool is_leap_year(int year) que devolva true se year for um ano bissexto no calendário gregoriano e false caso contrário. A regra: um ano divisível por 4 é bissexto, mas um ano divisível por 100 só é bissexto se também for divisível por 400. Assim, 2000 foi bissexto e 1900 não foi.

1 ≤ year ≤ 9999. <stdbool.h> já está incluído. Os testes imprimem o resultado com %d, então true aparece como 1 e false como 0.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c conditionals Escreva uma função int quadrant(int x, int y) que devolva o quadrante do plano cartesiano onde está o ponto (x, y):

  • 1 se x > 0 e y > 0;
  • 2 se x < 0 e y > 0;
  • 3 se x < 0 e y < 0;
  • 4 se x > 0 e y < 0;
  • 0 se o ponto estiver sobre um eixo (x ou y igual a 0), porque então ele não pertence a nenhum quadrante.
]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 0) { return y > 0 ? 1 : 4; } return y > 0 ? 2 : 3; } ]]> 1 0 onlinecompiler.io c conditionals Escreva um programa que leia inteiros até o fim da entrada e imprima quantos eram pares e quantos eram ímpares, separados por um espaço.

]]> 1.0000000 0.0000000 0 c_program 0 1 10, 20, ... 0 0 0 15 100 int main(void) { int x, even = 0, odd = 0; while (scanf("%d", &x) == 1) { if (x % 2 == 0) { even++; } else { odd++; } } printf("%d %d\n", even, odd); return 0; } ]]> 1 0 onlinecompiler.io c loops Escreva uma função void floyd(int rows) que imprima o triângulo de Floyd com rows linhas. A linha 1 tem um número, a linha 2 tem dois, a linha 3 tem três, e assim por diante; os números são contados a partir de 1 e continuam de uma linha para a seguinte. Separe os números de uma linha com um espaço e termine cada linha com uma quebra de linha. Por exemplo, floyd(4) imprime:

1
2 3
4 5 6
7 8 9 10

1 ≤ rows ≤ 20. Cada chamada começa a contar de 1 novamente.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 0) { printf(" "); } printf("%d", next); next++; } printf("\n"); } } ]]> 1 0 onlinecompiler.io c loops Escreva uma função long long factorial(int n) que devolva n! para 0 ≤ n ≤ 20. Lembre que 0! vale 1.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c functions Escreva uma função bool is_prime(int n) que devolva true se n for primo e false caso contrário. Um número primo é um inteiro maior que 1 cujos únicos divisores positivos são 1 e ele mesmo; portanto 0, 1 e os números negativos não são primos.

−106 ≤ n ≤ 106. Basta testar divisores até a raiz quadrada de n. Os testes imprimem o resultado com %d (1 para true, 0 para false).

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c functions Escreva uma função void reverse_array(int a[], int n) que inverta, no próprio vetor, os n primeiros elementos de a: o primeiro troca de lugar com o último desses n, o segundo com o penúltimo, e assim por diante. Os elementos que vêm depois dos n primeiros ficam onde estão. Não use um segundo vetor.

0 ≤ n ≤ 1000; para n igual a 0 ou 1 nada muda. A função não devolve nada: a alteração aparece para quem a chamou porque um parâmetro do tipo vetor se refere ao próprio vetor passado na chamada.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c lists Escreva um programa que leia um inteiro n (1 ≤ n ≤ 1000) e depois n inteiros, cada um entre −106 e 106, separados por espaços ou quebras de linha. Imprima quantos desses n números são estritamente maiores que a média deles.

Você vai precisar guardar os números em um vetor, porque a média só é conhecida depois de ler todos.

]]> 1.0000000 0.0000000 0 c_program 0 1 10, 20, ... 0 0 0 15 100 int main(void) { int n; int values[1000]; long long sum = 0; if (scanf("%d", &n) != 1) { return 0; } for (int i = 0; i < n; i++) { if (scanf("%d", &values[i]) != 1) { return 0; } sum += values[i]; } double average = (double) sum / n; int count = 0; for (int i = 0; i < n; i++) { if (values[i] > average) { count++; } } printf("%d\n", count); return 0; } ]]> 1 0 onlinecompiler.io c lists Escreva uma função bool is_palindrome(const char s[]) que devolva true se a string s for lida da mesma forma da esquerda para a direita e da direita para a esquerda, e false caso contrário. Compare os caracteres exatamente: letras maiúsculas e minúsculas são diferentes, e espaços contam como qualquer outro caractere. A string vazia é um palíndromo.

s tem no máximo 1000 caracteres. Os testes imprimem o resultado com %d (1 ou 0).

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c strings Escreva uma função void caesar(char s[], int k) que criptografe a string s, no próprio vetor, com a cifra de César: cada letra avança k posições no alfabeto, voltando de z para a quando passa do fim. Letras maiúsculas continuam maiúsculas e minúsculas continuam minúsculas; qualquer outro caractere (dígitos, espaços, pontuação) fica como está. Com k = 3, abc XYZ vira def ABC.

0 ≤ k ≤ 1000, e s contém apenas caracteres ASCII.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 = 'a' && s[i] <= 'z') { s[i] = (char) ('a' + (s[i] - 'a' + k) % 26); } else if (s[i] >= 'A' && s[i] <= 'Z') { s[i] = (char) ('A' + (s[i] - 'A' + k) % 26); } } } ]]> 1 0 onlinecompiler.io c strings Uma função devolve um único valor, mas pode entregar outros resultados por meio de ponteiros. Escreva uma função void min_max(const int a[], int n, int *min, int *max) que guarde o menor elemento de a em *min e o maior em *max.

1 ≤ n ≤ 1000, e os elementos podem ser negativos. min e max apontam para variáveis de quem chamou a função; a função não devolve nada.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 *max) { *max = a[i]; } } } ]]> 1 0 onlinecompiler.io c pointers Escreva uma função char *repeat(const char *s, int k) que devolva uma nova string formada por k cópias de s, uma depois da outra. Por exemplo, repeat("ab", 3) devolve "ababab".

Aloque a nova string com malloc, reservando espaço para o '\0' final. Quem chamou a função passa a ser dono do resultado e o libera com free. Não modifique s. Se k for 0 ou s for vazia, devolva uma nova string vazia, e não NULL. 0 ≤ k ≤ 100, e s tem no máximo 100 caracteres.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c pointers Uma fração é guardada nesta struct, em que num é o numerador e den o denominador. Ela já está na caixa de resposta; mantenha-a na sua resposta.

struct Fraction {
    int num;
    int den;
};

Escreva uma função struct Fraction add_fractions(struct Fraction a, struct Fraction b) que devolva a soma a + b na forma irredutível, com denominador positivo. Se a soma for zero, devolva 0/1. Por exemplo, 1/6 + 1/3 = 3/6, que na forma irredutível é 1/2.

Nos argumentos, −1000 ≤ num ≤ 1000 e 1 ≤ den ≤ 1000. Dica: divida o numerador e o denominador pelo máximo divisor comum deles, com cuidado com numeradores negativos.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 25 100 1 0 onlinecompiler.io c structs