Luhn's Checksum Algorithm

arithmeticfunctions.cpp

@@ -0,0 +1,21 @@
+#include "arithmeticfunctions.h"
+#include <cmath>
+
+// Compute x^3
+int cube(int x){
+    return pow(x, 3);
+}
+
+// Compute the maximum of x and y
+int max(int x, int y){
+    if (x>y) {
+    	return x;
+    } else {
+        return y;
+    }
+}
+
+// Compute x - y
+int difference(int x, int y){
+    return x - y;
+}

arithmeticfunctions.h

@@ -0,0 +1,20 @@
+#include <iostream>
+
+int cube(int x);
+int max(int x, int y);
+int difference(int x, int y);
+
+int main() {
+    int cube2 = cube(2);
+    if (cube2 != 8) {
+        std::cout << "ERROR: cube(2) = " << cube2 << ", expected 8" << std::endl;
+    }
+    int max85 = max(8, 5);
+    if (max85 != 8) {
+        std::cout << "ERROR: max(8, 5) = " << max85 << ", expected 8" << std::endl;
+    }
+    int diff102 = difference(10, 2);
+    if (diff102 != 8) {
+        std::cout << "ERROR: difference(10, 2) = " << diff102 << ", expected 8" << std::endl;
+    }
+}

basketballoneonone.py

@@ -0,0 +1,19 @@
+def end_game(winner):
+    print(winner)
+    exit()
+
+
+game_records = input()
+a_score = 0
+b_score = 0
+
+for i in range(0, len(game_records), 2):
+    if game_records[i] == "A":
+        a_score += int(game_records[i + 1])
+    else:
+        b_score += int(game_records[i + 1])
+
+    if a_score >= 11 and (b_score < 10 or a_score - b_score >= 2):
+        end_game("A")
+    if b_score >= 11 and (a_score < 10 or b_score - a_score >= 2):
+        end_game("B")

conformity.py

@@ -0,0 +1,21 @@
+n = int(input())
+
+combinations = {}
+maxcombi = 0
+combinations[maxcombi] = 0
+
+for _ in range(n):
+    combi = "".join(sorted(input().strip().split()))
+    if combi in combinations.keys():
+        combinations[combi] += 1
+        if combinations[maxcombi] < combinations[combi]:
+            maxcombi = combi
+    else:
+        combinations[combi] = 1
+
+max_value = combinations[maxcombi]
+most_popular = sum(
+    [max_value for key in combinations if combinations[key] == max_value]
+)
+
+print(most_popular if most_popular > 0 else len(combinations.keys()) - 1)

fodelsedagsmemorisering.py

@@ -0,0 +1,21 @@
+n = int(input())
+
+memory = {}
+names = []
+for _ in range(n):
+    name, likes, birthday = input().split()
+    likes = int(likes)
+
+    if birthday in memory.keys():
+        if memory[birthday][1] < likes:
+            names.remove(memory[birthday][0])
+            memory[birthday] = (name, likes)
+            names.append(name)
+    else:
+        memory[birthday] = (name, likes)
+        names.append(name)
+
+print(len(memory.keys()))
+names.sort()
+for name in names:
+    print(name)

goombastacks.py

@@ -0,0 +1,9 @@
+n = int(input())
+g_total = 0
+for _ in range(n):
+    g, b = map(int, input().split())
+    g_total += g
+    if b > g_total:
+        print("impossible")
+        exit()
+print("possible")

jointjogjam.py

@@ -0,0 +1,5 @@
+ksx, ksy, osx, osy, kex, key, oex, oey = map(int, input().split())
+
+d1 = ((ksx - osx) ** 2 + (ksy - osy) ** 2) ** (0.5)
+d2 = ((kex - oex) ** 2 + (key - oey) ** 2) ** (0.5)
+print(max((d1, d2)))

loorolls.py

@@ -0,0 +1,11 @@
+L, N = map(int, input().split())
+
+rollen = 0
+prev_taken = 0
+while True:
+    rollen += 1
+    restant = L % (N - prev_taken)
+    if restant == 0:
+        print(rollen)
+        exit()
+    prev_taken += restant

luhnchecksum.py

@@ -0,0 +1,21 @@
+def luhn_checksum(card_number):
+    def digits_of(n):
+        return [int(d) for d in str(n)]
+
+    digits = digits_of(card_number)
+    odd_digits = digits[-1::-2]
+    even_digits = digits[-2::-2]
+    checksum = 0
+    checksum += sum(odd_digits)
+    for d in even_digits:
+        checksum += sum(digits_of(d * 2))
+    return checksum % 10
+
+
+def is_luhn_valid(card_number):
+    return luhn_checksum(card_number) == 0
+
+
+n = int(input())
+for _ in range(n):
+    print("PASS" if is_luhn_valid(input()) else "FAIL")

schoolspirit.py

@@ -0,0 +1,17 @@
+n = int(input())
+scores = [int(input()) for _ in range(n)]
+
+
+def calculate_score(scores: list) -> float:
+    return (1 / 5) * sum([score * ((4 / 5) ** i) for i, score in enumerate(scores)])
+
+
+print(calculate_score(scores))
+
+new_scores = []
+for score in scores:
+    cpy_scores = scores.copy()
+    cpy_scores.remove(score)
+    new_scores.append(calculate_score(cpy_scores))
+
+print(sum(new_scores) / len(new_scores))

tripletexting.py

@@ -0,0 +1,6 @@
+s = input()
+wordlen = len(s) // 3
+s1 = s[:wordlen]
+s2 = s[wordlen : wordlen * 2]
+s3 = s[wordlen * 2 :]
+print(s1 if s1 == s2 or s1 == s3 else s2)