$course$/top/OnlineCompiler.io C (English) Free CodeRunner questions from OnlineCompiler.io (https://onlinecompiler.io/coderunner-question-packs), licensed under CC BY 4.0. They use CodeRunner's built-in question types, so they run on any Jobe server.

]]> Write a program that reads a temperature in degrees Celsius and prints it in degrees Fahrenheit, using F = C × 9 / 5 + 32. Print the result with exactly one digit after the decimal point.

The input is one real number, possibly negative, written with a decimal point (for example 36.6).

]]> 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 Write a function void print_duration(int seconds) that prints a duration given in seconds as hours, minutes and seconds in the form H:MM:SS, followed by a new line. Minutes and seconds always use two digits; hours use as many digits as they need, with no leading zeros. For example, print_duration(3725) prints 1:02:05.

0 ≤ seconds ≤ 106. The function prints the result; it doesn't return anything.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c io Write a function bool is_leap_year(int year) that returns true if year is a leap year in the Gregorian calendar and false otherwise. The rule: a year divisible by 4 is a leap year, except that a year divisible by 100 is a leap year only if it is also divisible by 400. So 2000 was a leap year and 1900 was not.

1 ≤ year ≤ 9999. <stdbool.h> is already included. The tests print the result with %d, so true shows as 1 and false as 0.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c conditionals Write a function int quadrant(int x, int y) that returns the quadrant of the Cartesian plane that contains the point (x, y):

  • 1 if x > 0 and y > 0;
  • 2 if x < 0 and y > 0;
  • 3 if x < 0 and y < 0;
  • 4 if x > 0 and y < 0;
  • 0 if the point lies on an axis (x or y is 0), because then it belongs to no quadrant.
]]> 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 Write a program that reads integers until the end of the input and prints how many were even and how many were odd, separated by a space.

]]> 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 Write a function void floyd(int rows) that prints Floyd's triangle with rows rows. Row 1 has one number, row 2 has two, row 3 has three, and so on; the numbers count up from 1 and carry on from one row to the next. Separate the numbers in a row with one space and end every row with a new line. For example, floyd(4) prints:

1
2 3
4 5 6
7 8 9 10

1 ≤ rows ≤ 20. Every call starts counting from 1 again.

]]> 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 Write a function long long factorial(int n) that returns n! for 0 ≤ n ≤ 20. Remember that 0! is 1.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c functions Write a function bool is_prime(int n) that returns true if n is prime and false otherwise. A prime is an integer greater than 1 whose only positive divisors are 1 and itself, so 0, 1 and negative numbers are not prime.

−106 ≤ n ≤ 106. It is enough to try divisors up to the square root of n. The tests print the result with %d (1 for true, 0 for false).

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c functions Write a function void reverse_array(int a[], int n) that reverses the first n elements of the array a in place: the first element swaps places with the last of those n, the second with the second to last, and so on. Any elements after the first n stay where they are. Don't use a second array.

0 ≤ n ≤ 1000; for n = 0 or 1 nothing changes. The function returns nothing: the caller sees the change because an array parameter refers to the caller's own array.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c lists Write a program that reads an integer n (1 ≤ n ≤ 1000) and then n integers, each between −106 and 106, separated by spaces or new lines. Print how many of the n numbers are strictly greater than their average.

You will need to keep the numbers in an array, because the average is only known after reading all of them.

]]> 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 Write a function bool is_palindrome(const char s[]) that returns true if the string s reads the same from left to right as from right to left, and false otherwise. Compare characters exactly: uppercase and lowercase letters are different, and spaces count like any other character. The empty string is a palindrome.

s has at most 1000 characters. The tests print the result with %d (1 or 0).

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c strings Write a function void caesar(char s[], int k) that encrypts the string s in place with a Caesar cipher: every letter moves k places forward in the alphabet, wrapping around from z to a. Uppercase letters stay uppercase and lowercase letters stay lowercase; every other character (digits, spaces, punctuation) is left unchanged. With k = 3, abc XYZ becomes def ABC.

0 ≤ k ≤ 1000, and s contains only ASCII characters.

]]> 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 A function returns only one value, but it can hand back more results through pointers. Write a function void min_max(const int a[], int n, int *min, int *max) that stores the smallest element of a in *min and the largest in *max.

1 ≤ n ≤ 1000, and the elements can be negative. min and max point to variables that belong to the caller; the function returns nothing.

]]> 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 Write a function char *repeat(const char *s, int k) that returns a new string made of k copies of s, one after another. For example, repeat("ab", 3) returns "ababab".

Allocate the new string with malloc, leaving room for the terminating '\0'. The caller owns the result and releases it with free. Don't modify s. If k is 0 or s is empty, return a new empty string, not NULL. 0 ≤ k ≤ 100, and s has at most 100 characters.

]]> 1.0000000 0.0000000 0 c_function 0 1 10, 20, ... 0 0 0 15 100 1 0 onlinecompiler.io c pointers A fraction is stored in this struct, where num is the numerator and den the denominator. It is already in the answer box; keep it in your answer.

struct Fraction {
    int num;
    int den;
};

Write a function struct Fraction add_fractions(struct Fraction a, struct Fraction b) that returns the sum a + b in lowest terms, with a positive denominator. If the sum is zero, return 0/1. For example, 1/6 + 1/3 = 3/6, which in lowest terms is 1/2.

In the arguments, −1000 ≤ num ≤ 1000 and 1 ≤ den ≤ 1000. Hint: divide the numerator and the denominator by their greatest common divisor, taking care with negative numerators.

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