$course$/top/OnlineCompiler.io Python (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 two integers, one per line, and prints their sum on the first line and their difference (the first minus the second) on the second line.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
io
Write a program that reads a whole number of seconds (0 or more) and prints it as hours, minutes and seconds in the form H:MM:SS. Minutes and seconds always have two digits; hours have no leading zeros and can go past 24. For example, 3725 prints 1:02:05.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
io
Write a function distance(x1, y1, x2, y2) that returns the straight-line distance between the points (x1, y1) and (x2, y2), that is, the square root of (x2 - x1)**2 + (y2 - y1)**2. Coordinates can be negative or have decimals. Return the distance without printing it; the tests print it with two decimal places, so distance(0, 0, 3, 4) shows as 5.00. You can use math.sqrt after import math.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
functions
A museum sets its ticket price by age: children under 4 go in free (price 0), ages 4 to 11 pay 8, ages 12 to 59 pay 15, and people aged 60 or over pay 10. Write a function ticket_price(age) that returns the price for a visitor of that age. age is a whole number, 0 or more.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
conditionals
In the Gregorian calendar a year is a leap year if it is divisible by 4, except for years divisible by 100, which are leap years only if they are also divisible by 400. Write a function is_leap_year(year) that returns True if year is a leap year and False otherwise.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
conditionals
Write a function quadrant(x, y) that returns the quadrant of the plane the point (x, y) lies in: 1 when x > 0 and y > 0, 2 when x < 0 and y > 0, 3 when x < 0 and y < 0, and 4 when x > 0 and y < 0. A point on either axis (x or y equal to 0) is in no quadrant: return 0.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
0 and y > 0:
return 1
elif x < 0 and y > 0:
return 2
elif x < 0 and y < 0:
return 3
elif x > 0 and y < 0:
return 4
else:
return 0
]]>
1
0
onlinecompiler.io
python
conditionals
Write a program that reads an integer n and prints the multiplication table of n from 1 to 10, one line per product, in the form n x i = result (a lowercase x, with one space on each side of x and of =). For example, for 7 the first line is 7 x 1 = 7 and the last is 7 x 10 = 70. n can be zero or negative.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
loops
Write a function digit_sum(n) that returns the sum of the decimal digits of the integer n. For a negative number, add up the digits of its absolute value; digit_sum(0) is 0. Use a while loop with % 10 (the last digit) and // 10 (drops the last digit) rather than turning the number into a string.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
0:
total += n % 10
n = n // 10
return total
]]>
1
0
onlinecompiler.io
python
loops
Starting from a positive integer n, repeat this step until the number becomes 1: if it is even, halve it; if it is odd, multiply it by 3 and add 1. Write a function collatz_steps(n) that returns how many steps that takes. For example, 6 goes 6, 3, 10, 5, 16, 8, 4, 2, 1, which is 8 steps; collatz_steps(1) is 0.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
loops
Write two functions. is_prime(n) returns True if the integer n is prime and False otherwise; numbers less than 2 (including 0 and negative numbers) are not prime. count_primes(a, b) returns how many primes there are from a to b, both included, and should use is_prime; if a is greater than b, it returns 0.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
functions
Write a function count_vowels(text) that returns how many vowels (a, e, i, o, u, upper or lower case) text contains.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
strings
Write a function is_palindrome(text) that returns True if text reads the same forwards and backwards, and False otherwise. Only letters and digits count (the characters for which isalnum() is true), and upper and lower case are treated as the same, so "Was it a car or a cat I saw?" is a palindrome. A string with no letters or digits, such as "", is a palindrome.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
strings
Write a function caesar(text, shift) that returns text encrypted with a Caesar cipher: each letter from a to z and from A to Z moves shift places forward in the alphabet, wrapping around after z, and keeps its case. Every other character (digits, spaces, punctuation and letters such as ç, ñ or é) stays as it is. shift can be any integer: negative values move letters backwards, and 27 works like 1.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
strings
Write a function running_total(numbers) that takes a list of numbers and returns a new list of the same length in which each element is the sum of the elements of numbers up to and including that position. For example, running_total([1, 2, 3, 4]) returns [1, 3, 6, 10]. An empty list gives an empty list, and the original list must not change.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
lists
Write a function second_largest(numbers) that returns the second largest distinct value in the list numbers. Repeated values count once, so for [5, 5, 3] the answer is 3. If the list has fewer than two distinct values (for example [] or [7, 7]), return None. The numbers can be negative. Don't change the list.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
largest:
second = largest
largest = n
elif n < largest and (second is None or n > second):
second = n
return second
]]>
1
0
onlinecompiler.io
python
lists
A matrix is stored as a list of rows, each row a list of numbers, all rows the same length. Write a function transpose(matrix) that returns a new matrix, as a list of lists, whose rows are the columns of matrix: the element in row i, column j moves to row j, column i. The matrix need not be square. For the empty matrix [], return [].]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
lists
Write a function count_words(text) that returns a dictionary mapping each word in text to the number of times it appears. Words are separated by one or more spaces (there may also be spaces at the start or end) and are compared ignoring case: store every word in lower case. The text has no punctuation, and an empty text gives an empty dictionary. The tests print sorted(count_words(text).items()), so the order in which you add keys doesn't matter.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
maps
Write a program that counts votes. The first line of input holds the number of votes n (at least 1), and each of the next n lines holds one candidate's name. Print the name of the candidate with the most votes, a space, and their number of votes. If several candidates tie for the most votes, print the one whose name comes first in alphabetical order (names are single unaccented words with a capital first letter and the rest lower case, so comparing them with < gives that order). Use a dictionary to count.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
votes[winner]:
winner = name
print(winner, votes[winner])
]]>
1
0
onlinecompiler.io
python
maps
A nested list is a list whose elements are integers or other nested lists, to any depth, such as [1, [2, 3], [[4]], 5]. Write a recursive function nested_sum(items) that returns the sum of all the integers inside items, at every level. Empty lists add nothing, so nested_sum([]) is 0. Hint: isinstance(x, list) tells you whether x is a list.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
recursion
Write a function binary_search(items, target) that returns the index of target in the list items, or -1 if it isn't there. items is sorted in increasing order with no repeated values, and may be empty. Use binary search: keep track of the range of indices where target could still be, look at the middle element, and discard the half that can't contain it. Don't use items.index, the in operator or a loop that checks every element.]]>
1.0000000
0.0000000
0
python3
0
1
10, 20, ...
0
0
0
15
100
1
0
onlinecompiler.io
python
algorithms