├── 1001- 1100 ├── 1016.py ├── 1013.py ├── 1004.py ├── 1002.py ├── 1011.py ├── 1014.py ├── 1078.py ├── 1067.py ├── 1075.py ├── 1005.py ├── 1073.py ├── 1095.py ├── 1007.py ├── 1017.py ├── 1042.py ├── 1096.py ├── 1070.py ├── 1079.py ├── 1065.py ├── 1009.py ├── 1044.py ├── 1015.py ├── 1060.py ├── 1038.py ├── 1098.py ├── 1080.py ├── 1097.py ├── 1006.py ├── 1008.py ├── 1035.py ├── 1046.py ├── 1020.py ├── 1010.py ├── 1019.py ├── 1052.py ├── 1064.py ├── 1099.py ├── 1072.py ├── 1071.py ├── 1050.py ├── 1087.py ├── 1036.py ├── 1037.py ├── 1051.py ├── 1074.py ├── 1021.py ├── 1012.py ├── 1041.py ├── 1066.py ├── 1043.py ├── 1047.py ├── 1018.py ├── 1048.py ├── 1045.py ├── 1094.py ├── 1040.py ├── 1068.py ├── 1049.py ├── 1024.py └── 1022.py ├── .gitattributes ├── 1600- 1999 ├── 1959.py ├── 1864.py ├── 1612.py ├── 1924.py ├── 1984.py ├── 1921.py ├── 1933.py ├── 1930.py ├── 1858.py ├── 1962.py ├── 1963.py ├── 1957.py ├── 1759.py ├── 1866.py ├── 1871.py ├── 1893.py ├── 1837.py ├── 1794.py ├── 1865.py ├── 1961.py ├── 1743.py ├── 1805.py ├── 1929.py ├── 1943.py ├── 1983.py ├── 1960.py ├── 1985.py ├── 1914.py ├── 1789.py ├── 1867.py ├── 1873.py └── 1848.py ├── 2000- 3000 ├── 2147.py ├── 2006.py ├── 2651.py ├── 2510.py ├── 2160.py ├── 2165.py ├── 2172.py ├── 2235.py ├── 2164.py ├── 2334.py ├── 2483.py ├── 2581.py ├── 2717.py ├── 2234.py ├── 2176.py ├── 2061.py ├── 2174.py ├── 2146.py ├── 2679.py ├── 2691.py ├── 2356.py ├── 2175.py ├── 2311.py ├── 2170.py ├── 2167.py ├── 2242.py ├── 2722.py ├── 2023.py ├── 2029.py ├── 2670.py ├── 2547.py ├── 2557.py ├── 2140.py ├── 2653.py ├── 2543.py ├── 2157.py ├── 2650.py ├── 2682.py ├── 2062.py ├── 2479.py ├── 2551.py ├── 2702.py ├── 2523.py ├── 2152.py ├── 2031.py ├── 2540.py ├── 2059.py ├── 2137.py ├── 2060.py ├── 2692.py ├── 2108.py ├── 2534.py ├── 2544.py ├── 2633.py ├── 2694.py ├── 2149.py ├── 2313.py ├── 2150.py ├── 2712.py ├── 2028.py ├── 2486.py ├── 2674.py ├── 2310.py ├── 2630.py ├── 2690.py └── 2253.py ├── 1101- 1200 ├── 1155.py ├── 1177.py ├── 1173.py ├── 1144.py ├── 1178.py ├── 1169.py ├── 1133.py ├── 1143.py ├── 1154.py ├── 1114.py ├── 1172.py ├── 1153.py ├── 1156.py ├── 1132.py ├── 1149.py ├── 1170.py ├── 1113.py ├── 1116.py ├── 1157.py ├── 1159.py ├── 1142.py ├── 1146.py ├── 1174.py ├── 1158.py ├── 1197.py ├── 1117.py ├── 1145.py ├── 1101.py ├── 1150.py ├── 1164.py ├── 1175.py ├── 1151.py ├── 1165.py ├── 1115.py ├── 1161.py ├── 1134.py ├── 1181.py ├── 1182.py ├── 1160.py ├── 1176.py ├── 1171.py ├── 1120.py ├── 1180.py ├── 1118.py ├── 1199.py ├── 1168.py ├── 1131.py ├── 1183.py ├── 1184.py ├── 1185.py ├── 1187.py ├── 1110.py ├── 1186.py ├── 1188.py ├── 1103.py ├── 1179.py ├── 1124.py ├── 1189.py ├── 1190.py └── 1193.py ├── 1400- 1599 ├── 1585.py ├── 1589.py ├── 1546.py ├── 1564.py ├── 1547.py ├── 1541.py ├── 1581.py ├── 1436.py ├── 1542.py ├── 1548.py ├── 1555.py ├── 1478.py ├── 1534.py ├── 1467.py ├── 1557.py ├── 1435.py └── 1536.py ├── 1300- 1399 ├── 1387.py ├── 1329.py ├── 1308.py ├── 1397.py └── 1332.py ├── 1201- 1299 ├── 1235.py ├── 1241.py ├── 1216.py ├── 1240.py ├── 1272.py ├── 1273.py ├── 1237.py ├── 1238.py ├── 1253.py ├── 1234.py └── 1249.py ├── README.md └── .gitignore /1001- 1100/1016.py: -------------------------------------------------------------------------------- 1 | print(int(input()) * 2, "minutos") 2 | -------------------------------------------------------------------------------- /1001- 1100/1013.py: -------------------------------------------------------------------------------- 1 | print(max(map(int, input().split())), "eh o maior") 2 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto -------------------------------------------------------------------------------- /1600- 1999/1959.py: -------------------------------------------------------------------------------- 1 | data = input().split() 2 | print(int(data[0]) * int(data[1])) 3 | -------------------------------------------------------------------------------- /1001- 1100/1004.py: -------------------------------------------------------------------------------- 1 | a = int(input()) 2 | b = int(input()) 3 | print("PROD =", a * b) 4 | -------------------------------------------------------------------------------- /1600- 1999/1864.py: -------------------------------------------------------------------------------- 1 | data = int(input()) 2 | print("LIFE IS NOT A PROBLEM TO BE SOLVED"[: data]) -------------------------------------------------------------------------------- /2000- 3000/2147.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | print(format(0.01 * len(input()), ".2f")) -------------------------------------------------------------------------------- /1001- 1100/1002.py: -------------------------------------------------------------------------------- 1 | raio = float(input()) 2 | print("A=" + format(3.14159 * raio * raio, ".4f")) 3 | -------------------------------------------------------------------------------- /1001- 1100/1011.py: -------------------------------------------------------------------------------- 1 | print("VOLUME =", format((float(input()) ** 3) * 3.14159 * (4 / 3), ".3f")) 2 | -------------------------------------------------------------------------------- /1001- 1100/1014.py: -------------------------------------------------------------------------------- 1 | km = int(input()) 2 | l = float(input()) 3 | print(format(km/l, ".3f"), "km/l") 4 | -------------------------------------------------------------------------------- /1101- 1200/1155.py: -------------------------------------------------------------------------------- 1 | s = 0 2 | for i in range(1, 101): 3 | s += 1 / i 4 | print(format(s, ".2f")) 5 | -------------------------------------------------------------------------------- /1600- 1999/1612.py: -------------------------------------------------------------------------------- 1 | import math 2 | for i in range(int(input())): 3 | print(math.ceil(int(input()) / 2)) -------------------------------------------------------------------------------- /1101- 1200/1177.py: -------------------------------------------------------------------------------- 1 | data = int(input()) 2 | for i in range(1000): 3 | print("N[{}] = {}".format(i, i % data)) -------------------------------------------------------------------------------- /1001- 1100/1078.py: -------------------------------------------------------------------------------- 1 | data = int(input()) 2 | for i in range(1, 11): 3 | print(i, "x", data, "=", i * data) 4 | -------------------------------------------------------------------------------- /1001- 1100/1067.py: -------------------------------------------------------------------------------- 1 | numero = int(input()) 2 | for i in range(numero + 1): 3 | if i % 2 != 0: 4 | print(i) 5 | -------------------------------------------------------------------------------- /1001- 1100/1075.py: -------------------------------------------------------------------------------- 1 | numero = int(input()) 2 | for i in range(1, 10001): 3 | if i % numero == 2: 4 | print(i) 5 | -------------------------------------------------------------------------------- /1101- 1200/1173.py: -------------------------------------------------------------------------------- 1 | data = int(input()) 2 | for i in range(10): 3 | print("N[{}] = {}".format(i, data)) 4 | data *= 2 -------------------------------------------------------------------------------- /1600- 1999/1924.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | for i in range(loops): 3 | curso = input() 4 | print("Ciencia da Computacao") -------------------------------------------------------------------------------- /1600- 1999/1984.py: -------------------------------------------------------------------------------- 1 | a = input().strip() # Precisa por o strip() pq o test case do site é ineficiente para python 2 | print(a[::-1]) 3 | -------------------------------------------------------------------------------- /2000- 3000/2006.py: -------------------------------------------------------------------------------- 1 | correto = input() 2 | data = input().split() 3 | print(data.count(correto)) # Imprimime a qntd de chás corretos 4 | -------------------------------------------------------------------------------- /1001- 1100/1005.py: -------------------------------------------------------------------------------- 1 | n1 = float(input()) 2 | n2 = float(input()) 3 | print("MEDIA = " + format(((n1 * 3.5) + (n2 * 7.5)) / 11, ".5f")) 4 | -------------------------------------------------------------------------------- /1001- 1100/1073.py: -------------------------------------------------------------------------------- 1 | data = int(input()) 2 | for i in range(1, data + 1): 3 | if i % 2 == 0: 4 | print(str(i)+"^2 =", i * i) 5 | -------------------------------------------------------------------------------- /1001- 1100/1095.py: -------------------------------------------------------------------------------- 1 | j = 60 2 | i = 1 3 | while j > -1: 4 | print("I=" + str(i) + " J=" + str(j)) 5 | j -= 5 6 | i += 3 7 | -------------------------------------------------------------------------------- /1101- 1200/1144.py: -------------------------------------------------------------------------------- 1 | for i in range(1, int(input()) + 1): 2 | print(i, i * i, i * i * i) 3 | print(i, i * i + 1, i * i * i + 1) 4 | -------------------------------------------------------------------------------- /1400- 1599/1585.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | data = list(map(int, input().split())) 3 | print(data[0] * data[1] // 2, "cm2") -------------------------------------------------------------------------------- /1600- 1999/1921.py: -------------------------------------------------------------------------------- 1 | # formula de qntd de diagonais em um polígono 2 | lados = int(input()) 3 | print(format((lados * (lados - 3)) / 2, ".0f")) -------------------------------------------------------------------------------- /1001- 1100/1007.py: -------------------------------------------------------------------------------- 1 | a = int(input()) 2 | b = int(input()) 3 | c = int(input()) 4 | d = int(input()) 5 | print("DIFERENCA =", a * b - c * d) 6 | -------------------------------------------------------------------------------- /1600- 1999/1933.py: -------------------------------------------------------------------------------- 1 | # converte para int coloca os números em uma lista e retorna o maior 2 | print(sorted([int(i) for i in input().split()])[-1]) -------------------------------------------------------------------------------- /2000- 3000/2651.py: -------------------------------------------------------------------------------- 1 | data = input().lower() 2 | if "zelda" in data: 3 | print("Link Bolado") 4 | else: 5 | print("Link Tranquilo") 6 | -------------------------------------------------------------------------------- /1001- 1100/1017.py: -------------------------------------------------------------------------------- 1 | tempo_viagem = int(input()) 2 | velocidade_media = int(input()) 3 | print(format(tempo_viagem * velocidade_media / 12, ".3f")) 4 | -------------------------------------------------------------------------------- /1101- 1200/1178.py: -------------------------------------------------------------------------------- 1 | data = float(input()) 2 | for i in range(100): 3 | print("N[{}] = {}".format(i, format(data, ".4f"))) 4 | data /= 2 5 | -------------------------------------------------------------------------------- /2000- 3000/2510.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) # Vê a qntd de casos testes 2 | for i in range(loops): 3 | q = input() 4 | print("Y") # sempre será Y -------------------------------------------------------------------------------- /1600- 1999/1930.py: -------------------------------------------------------------------------------- 1 | data = input().split() 2 | print(sum(map(int, data)) - 3) # Converte tudo para int soma tudo subtrai 3(dá para ser feito em 1 só linha) -------------------------------------------------------------------------------- /1001- 1100/1042.py: -------------------------------------------------------------------------------- 1 | data = list(map(int, input().split())) 2 | for i in sorted(data): 3 | print(i) 4 | print() 5 | for j in data: 6 | print(j) 7 | -------------------------------------------------------------------------------- /1001- 1100/1096.py: -------------------------------------------------------------------------------- 1 | for k in range(1, 10, 2): 2 | j = 7 3 | for l in range(3): 4 | print("I=" + str(k), "J=" + str(j)) 5 | j -= 1 6 | -------------------------------------------------------------------------------- /1101- 1200/1169.py: -------------------------------------------------------------------------------- 1 | import math 2 | for i in range(int(input())): 3 | data = int(input()) 4 | print("{} kg".format(math.floor(math.pow(2, data)/12000))) -------------------------------------------------------------------------------- /1300- 1399/1387.py: -------------------------------------------------------------------------------- 1 | while True: 2 | num1, num2 = list(map(int, input().split())) 3 | if num1 + num2 == 0: 4 | break 5 | print(num1 + num2) -------------------------------------------------------------------------------- /1001- 1100/1070.py: -------------------------------------------------------------------------------- 1 | data = int(input()) 2 | for i in range(12): # 12 pois inclui os pares 3 | if data % 2 != 0: 4 | print(data) 5 | data += 1 6 | -------------------------------------------------------------------------------- /1001- 1100/1079.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | n1, n2, n3 = map(float, input().split()) 3 | print(format((n1 * 2 + n2 * 3 + n3 * 5) / 10, ".1f")) 4 | -------------------------------------------------------------------------------- /1600- 1999/1858.py: -------------------------------------------------------------------------------- 1 | inutil = input() 2 | data = list(map(int, input().split())) 3 | print(data.index(min(data)) + 1) # +1 pois index() conta a posição a partir do 0 -------------------------------------------------------------------------------- /2000- 3000/2160.py: -------------------------------------------------------------------------------- 1 | data = input() 2 | if len(data) in range(1, 81): # se o tamanho for de 1 a 80, é válido 3 | print("YES") 4 | else: 5 | print("NO") 6 | -------------------------------------------------------------------------------- /2000- 3000/2165.py: -------------------------------------------------------------------------------- 1 | data = input() 2 | if len(data) <= 140: # se o tamanho for menor que 140, é válido 3 | print("TWEET") 4 | else: 5 | print("MUTE") 6 | -------------------------------------------------------------------------------- /1001- 1100/1065.py: -------------------------------------------------------------------------------- 1 | pares = 0 2 | for i in range(5): 3 | data = int(input()) 4 | if data % 2 == 0: 5 | pares += 1 6 | print(pares, "valores pares") 7 | -------------------------------------------------------------------------------- /1001- 1100/1009.py: -------------------------------------------------------------------------------- 1 | nome = input() 2 | salario_base = float(input()) 3 | comissao = float(input()) * 0.15 4 | print("TOTAL = R$", format(salario_base + comissao, ".2f")) 5 | -------------------------------------------------------------------------------- /2000- 3000/2172.py: -------------------------------------------------------------------------------- 1 | while True: 2 | data = input().split() 3 | if int(data[0]) + int(data[1]) == 0: 4 | break 5 | print(int(data[0]) * int(data[1])) 6 | -------------------------------------------------------------------------------- /1001- 1100/1044.py: -------------------------------------------------------------------------------- 1 | numeros = list(map(int, input().split())) 2 | if max(numeros) % min(numeros): 3 | print("Nao sao Multiplos") 4 | else: 5 | print("Sao Multiplos") 6 | -------------------------------------------------------------------------------- /1101- 1200/1133.py: -------------------------------------------------------------------------------- 1 | n1, n2 = int(input()), int(input()) 2 | for numeros in range(min(n1, n2) + 1, max(n1, n2)): 3 | if numeros % 5 in [2, 3]: 4 | print(numeros) 5 | -------------------------------------------------------------------------------- /2000- 3000/2235.py: -------------------------------------------------------------------------------- 1 | a, b, c = list(map(int, input().split())) 2 | if a in [b, c] or b == c or a == b + c or b == a + c or c == a + b: 3 | print("S") 4 | else: 5 | print("N") -------------------------------------------------------------------------------- /1001- 1100/1015.py: -------------------------------------------------------------------------------- 1 | x1, y1 = map(float, input().split()) 2 | x2, y2 = map(float, input().split()) 3 | print(format((((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1))) ** 0.5, ".4f")) 4 | -------------------------------------------------------------------------------- /1001- 1100/1060.py: -------------------------------------------------------------------------------- 1 | positivos = 0 2 | for i in range(6): 3 | data = float(input()) 4 | if data > 0: 5 | positivos += 1 6 | print(positivos, "valores positivos") 7 | -------------------------------------------------------------------------------- /1001- 1100/1038.py: -------------------------------------------------------------------------------- 1 | codigo, quantidade = map(int, input().split()) 2 | tabela_precos = [4, 4.5, 5, 2, 1.5] 3 | print("Total: R$", format(quantidade * tabela_precos[codigo - 1], ".2f")) 4 | -------------------------------------------------------------------------------- /2000- 3000/2164.py: -------------------------------------------------------------------------------- 1 | import math 2 | data = int(input()) 3 | conta = (math.pow(1.618033988749895, data) - math.pow(-0.6180339887498949, data)) / math.sqrt(5) 4 | print(format(conta, ".1f")) -------------------------------------------------------------------------------- /2000- 3000/2334.py: -------------------------------------------------------------------------------- 1 | while True: 2 | data = int(input()) 3 | if data == -1: 4 | break 5 | if data == 0: 6 | print(0) 7 | else: 8 | print(data - 1) -------------------------------------------------------------------------------- /2000- 3000/2483.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | ases = "" 3 | for i in range(loops): 4 | ases += "a" # adiciona "a", pela qntd definida no input 5 | print("Feliz nat" + ases + "l!") 6 | -------------------------------------------------------------------------------- /2000- 3000/2581.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | for i in range(loops): # Vê a qntd de casos testes 3 | q = input() 4 | print("I am Toorg!") # Não importa o input esse sempre será output -------------------------------------------------------------------------------- /2000- 3000/2717.py: -------------------------------------------------------------------------------- 1 | final = int(input()) 2 | preciso = sum(list(map(int, input().split()))) 3 | if preciso > final: 4 | print("Deixa para amanha!") 5 | else: 6 | print("Farei hoje!") -------------------------------------------------------------------------------- /1001- 1100/1098.py: -------------------------------------------------------------------------------- 1 | i = 0 2 | while i <= 2: 3 | for j in range(1, 4): 4 | print("I={} J={}".format(format(i, ".1f"), format(j + i, ".1f")).replace(".0", "")) 5 | i += 0.2 6 | -------------------------------------------------------------------------------- /1101- 1200/1143.py: -------------------------------------------------------------------------------- 1 | numero = int(input()) 2 | for i in range(1, numero + 1): 3 | print(i, i * i, i * i * i) # O * é mto mais eficiente q **, sempre quando a potencia for pequena use * 4 | -------------------------------------------------------------------------------- /1101- 1200/1154.py: -------------------------------------------------------------------------------- 1 | idade, total, qntd = int(input()), 0, 0 2 | while idade > 0: 3 | total += idade 4 | qntd += 1 5 | idade = int(input()) 6 | print(format(total / qntd, ".2f")) 7 | -------------------------------------------------------------------------------- /1600- 1999/1962.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | data = 2015 - int(input()) 3 | if data <= 0: 4 | print(abs(data - 1), "A.C.") 5 | else: 6 | print(data, "D.C.") -------------------------------------------------------------------------------- /1101- 1200/1114.py: -------------------------------------------------------------------------------- 1 | while True: 2 | senha = input() 3 | if senha == "2002": 4 | print("Acesso Permitido") 5 | break 6 | else: 7 | print("Senha Invalida") 8 | -------------------------------------------------------------------------------- /1101- 1200/1172.py: -------------------------------------------------------------------------------- 1 | for i in range(10): 2 | data = int(input()) 3 | if data <= 0: 4 | print("X[{}] = 1".format(i)) 5 | else: 6 | print("X[{}] = {}".format(i, data)) 7 | -------------------------------------------------------------------------------- /1600- 1999/1963.py: -------------------------------------------------------------------------------- 1 | data = input().split() 2 | inicial = float(data[0]) 3 | final = float(data[1]) 4 | porcentagem = ((final * 100) / inicial) - 100 5 | print(format(porcentagem, ".2f") + "%") 6 | -------------------------------------------------------------------------------- /2000- 3000/2234.py: -------------------------------------------------------------------------------- 1 | data = input().split() # separa e coloca os inputs em uma lista 2 | hot_dog = int(data[0]) 3 | participantes = int(data[1]) 4 | print(format(hot_dog / participantes, ".2f")) 5 | -------------------------------------------------------------------------------- /1001- 1100/1080.py: -------------------------------------------------------------------------------- 1 | lista_numeros = [] 2 | for i in range(100): 3 | lista_numeros.append(int(input())) 4 | print("{}\n{}".format(max(lista_numeros), lista_numeros.index(max(lista_numeros)) + 1)) 5 | -------------------------------------------------------------------------------- /1101- 1200/1153.py: -------------------------------------------------------------------------------- 1 | import math 2 | numero = int(input()) 3 | print(math.factorial(numero)) 4 | ''' 5 | total = 1 6 | for i in range(int(input()), 0, -1): 7 | total *= i 8 | print(total)''' 9 | -------------------------------------------------------------------------------- /1600- 1999/1957.py: -------------------------------------------------------------------------------- 1 | numero = int(input()) 2 | # Tranforma um n° dec em hex usando {:x}, o upper é para retornar como maiúsculas os valores hex que são letras 3 | print("{:x}".format(numero).upper()) 4 | -------------------------------------------------------------------------------- /1101- 1200/1156.py: -------------------------------------------------------------------------------- 1 | s = 0 2 | div = 1 3 | for i in range(1, 40, 2): # o i vai de 1 a 39 pulando 2 a 2 4 | s += i / div 5 | div *= 2 # O divisor dobra a cada etapa 6 | print(format(s, ".2f")) 7 | -------------------------------------------------------------------------------- /1001- 1100/1097.py: -------------------------------------------------------------------------------- 1 | j = 7 2 | for i in range(1, 10, 2): 3 | for k in range(3): 4 | print("I=" + str(i), "J=" + str(j)) # Converti para str para grudar com o + 5 | j -= 1 6 | j += 5 7 | -------------------------------------------------------------------------------- /1101- 1200/1132.py: -------------------------------------------------------------------------------- 1 | n1, n2, total = int(input()), int(input()), 0 2 | maior, menor = max(n1, n2), min(n1, n2) 3 | for i in range(menor, maior + 1): 4 | if i % 13: 5 | total += i 6 | print(total) 7 | -------------------------------------------------------------------------------- /1101- 1200/1149.py: -------------------------------------------------------------------------------- 1 | data = list(map(int, input().split())) 2 | a, total = data[0], 0 3 | for i in data[1:]: 4 | if i > 0: 5 | for j in range(i): 6 | total += a + j 7 | print(total) 8 | -------------------------------------------------------------------------------- /1101- 1200/1170.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | for i in range(loops): 3 | data = float(input()) 4 | dias = 0 5 | while data > 1: 6 | data /= 2 7 | dias += 1 8 | print(dias, "dias") 9 | -------------------------------------------------------------------------------- /1300- 1399/1329.py: -------------------------------------------------------------------------------- 1 | while True: 2 | total = int(input()) 3 | if total == 0: 4 | break 5 | mary = input().count("0") 6 | print("Mary won {} times and John won {} times".format(mary, total - mary)) -------------------------------------------------------------------------------- /1001- 1100/1006.py: -------------------------------------------------------------------------------- 1 | a = float(input()) 2 | b = float(input()) 3 | c = float(input()) 4 | pesoa = a * 2 5 | pesob = b * 3 6 | pesoc = c * 5 7 | media = (pesoa + pesob) / 10 8 | print("MEDIA =", format(media,".1f")) 9 | -------------------------------------------------------------------------------- /1101- 1200/1113.py: -------------------------------------------------------------------------------- 1 | while True: 2 | n1, n2 = map(int, input().split()) 3 | if n1 == n2: 4 | break 5 | elif n1 > n2: 6 | print("Decrescente") 7 | else: 8 | print("Crescente") 9 | -------------------------------------------------------------------------------- /1101- 1200/1116.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | cima, baixo = map(float, input().split()) 3 | if baixo == 0: 4 | print("divisao impossivel") 5 | else: 6 | print(format(cima / baixo, ".1f")) -------------------------------------------------------------------------------- /1101- 1200/1157.py: -------------------------------------------------------------------------------- 1 | numero = int(input()) 2 | for i in range(1, numero + 1): 3 | if numero % i == 0: # Pega todos os divisores 1 por 1, não acho q seja o método mais eficiente mas é funcional 4 | print(i) 5 | -------------------------------------------------------------------------------- /1101- 1200/1159.py: -------------------------------------------------------------------------------- 1 | while True: 2 | numero = int(input()) 3 | if numero == 0: 4 | break 5 | if numero % 2: 6 | print((numero + 1) * 5 + 20) 7 | else: 8 | print(numero * 5 + 20) 9 | -------------------------------------------------------------------------------- /1300- 1399/1308.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | for i in range(loops): 3 | numero = int(input()) 4 | # Processo/Saída 5 | print(int(((2 * numero) + 0.25) ** 0.5 - 0.5)) # Fórmula para achar a resposta do exercício 6 | -------------------------------------------------------------------------------- /2000- 3000/2176.py: -------------------------------------------------------------------------------- 1 | data = input() 2 | if data.count("1") % 2 == 0: # se a qnt de 1 for par adiciona um 0 no final 3 | print(data + "0") 4 | else: # se for impar adiciona o 1 no final 5 | print(data + "1") 6 | -------------------------------------------------------------------------------- /1001- 1100/1008.py: -------------------------------------------------------------------------------- 1 | numero = int(input()) 2 | horas_trabalhadas = int(input()) 3 | salario_hora = float(input()) 4 | 5 | print("NUMBER = {}\nSALARY = U$ {}". format(numero, format(horas_trabalhadas * salario_hora, ".2f"))) 6 | -------------------------------------------------------------------------------- /1001- 1100/1035.py: -------------------------------------------------------------------------------- 1 | A, B, C, D = map(int, input().split()) 2 | if B > C and D > A and C + D > A + B and all(i > 0 for i in[C, D]) and A % 2 == 0: 3 | print("Valores aceitos") 4 | else: 5 | print("Valores nao aceitos") 6 | -------------------------------------------------------------------------------- /1001- 1100/1046.py: -------------------------------------------------------------------------------- 1 | inicio, fim = map(int, input().split()) 2 | if inicio >= fim: 3 | print("O JOGO DUROU {} HORA(S)".format(abs(inicio - 24) + fim)) 4 | else: 5 | print("O JOGO DUROU {} HORA(S)".format(fim - inicio)) 6 | -------------------------------------------------------------------------------- /2000- 3000/2061.py: -------------------------------------------------------------------------------- 1 | inicial, acao = list(map(int, input().split())) 2 | for i in range(acao): 3 | data = input() 4 | if data == "fechou": 5 | inicial += 1 6 | else: 7 | inicial -= 1 8 | print(inicial) -------------------------------------------------------------------------------- /2000- 3000/2174.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | lista1 = [] 3 | for i in range(loops): 4 | pomekon = input() 5 | lista1.append(pomekon) 6 | tamanho = len(set(lista1)) 7 | print("Falta(m)", 151 - tamanho, "pomekon(s).") 8 | -------------------------------------------------------------------------------- /1101- 1200/1142.py: -------------------------------------------------------------------------------- 1 | inicial = 1 2 | for i in range(int(input())): 3 | lista_numeros = [] 4 | for j in range(3): 5 | lista_numeros.append(inicial + j) 6 | inicial += 4 7 | print(" ".join(map(str, lista_numeros)), "PUM") 8 | -------------------------------------------------------------------------------- /1001- 1100/1020.py: -------------------------------------------------------------------------------- 1 | dias_total = int(input()) 2 | anos = dias_total // 365 3 | meses = (dias_total - (365 * anos)) // 30 4 | dias = (dias_total - (365 * anos)) - (30 * meses) 5 | print("{} ano(s)\n{} mes(es)\n{} dia(s)".format(anos, meses, dias)) 6 | -------------------------------------------------------------------------------- /1001- 1100/1010.py: -------------------------------------------------------------------------------- 1 | cod_peca1, qntd_peca1, valor_peca1 = input().split() 2 | cod_peca2, qntd_peca2, valor_peca2 = input().split() 3 | print("VALOR A PAGAR: R$", format((int(qntd_peca1) * float(valor_peca1)) + (int(qntd_peca2) * float(valor_peca2)), ".2f")) 4 | -------------------------------------------------------------------------------- /1101- 1200/1146.py: -------------------------------------------------------------------------------- 1 | while True: 2 | numero = int(input()) 3 | lista_numeros = [] 4 | if numero == 0: 5 | break 6 | for i in range(1, numero + 1): 7 | lista_numeros.append(str(i)) 8 | print(" ".join(lista_numeros)) 9 | -------------------------------------------------------------------------------- /1201- 1299/1235.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | for i in range(loops): 3 | data = input() 4 | metade = len(data) // 2 5 | print((data[:metade][::-1]) + (data[metade:][::-1])) 6 | # Pega a metade da frase e inverte cada uma delas mantendo a mesma ordem -------------------------------------------------------------------------------- /1001- 1100/1019.py: -------------------------------------------------------------------------------- 1 | segundos_total = int(input()) 2 | horas = segundos_total // 3600 3 | minutos = (segundos_total - (horas * 3600)) // 60 4 | segundos = (segundos_total - (horas * 3600)) - (minutos * 60) 5 | print("{}:{}:{}".format(horas, minutos, segundos)) 6 | -------------------------------------------------------------------------------- /1101- 1200/1174.py: -------------------------------------------------------------------------------- 1 | for i in range(100): 2 | numero = input() 3 | if float(numero) <= 10: # pega os números <= a 10 com 1 casa decimal 4 | print("A[" + str(i) + "] =", format(float(numero), ".1f")) # E imprime a posição dele na lista usando o i 5 | -------------------------------------------------------------------------------- /1001- 1100/1052.py: -------------------------------------------------------------------------------- 1 | mes = int(input()) 2 | tabela_meses = {1: "January", 2: "February", 3: "March", 4: "April", 5: "May", 6: "June", 7: "July", 8: "August", 3 | 9: "September", 10: "October", 11: "November", 12: "December"} 4 | print(tabela_meses[mes]) 5 | -------------------------------------------------------------------------------- /1101- 1200/1158.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | inicial, proximos = map(int, input().split()) 3 | total = 0 4 | for impares in range(inicial, inicial + (proximos * 2)): 5 | if impares % 2: 6 | total += impares 7 | print(total) 8 | -------------------------------------------------------------------------------- /1201- 1299/1241.py: -------------------------------------------------------------------------------- 1 | # Identico ao 1240 2 | for i in range(int(input())): 3 | a, b = input().split() 4 | if len(b) > len(a): 5 | print("nao encaixa") 6 | elif b == a[-len(b):]: 7 | print("encaixa") 8 | else: 9 | print("nao encaixa") -------------------------------------------------------------------------------- /1101- 1200/1197.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 2 | while True: 3 | try: 4 | data = input().split() 5 | except EOFError: 6 | break 7 | print(int(int(data[0]) * int(data[1]) * 2)) -------------------------------------------------------------------------------- /1201- 1299/1216.py: -------------------------------------------------------------------------------- 1 | qntd = 0 2 | total = 0 3 | while True: 4 | try: 5 | nomes = input() 6 | distancia = int(input()) 7 | except EOFError: 8 | break 9 | qntd += 1 10 | total += distancia 11 | print(format(total / qntd, ".1f")) -------------------------------------------------------------------------------- /1600- 1999/1759.py: -------------------------------------------------------------------------------- 1 | numero = int(input()) 2 | str_i = "" 3 | for i in range(numero): 4 | str_i += "Ho " # Junta ho e um espaço na variável str_i pelo número determinado 5 | print(str_i[:-1] + "!") # No fim elimina o último espaço usando o slice e adiciona o ! no fim 6 | -------------------------------------------------------------------------------- /2000- 3000/2146.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é umarquivo final ou valor EOF use esse método 2 | while True: 3 | try: 4 | data = int(input()) 5 | except EOFError: 6 | break 7 | print(data - 1) # A fórmula é o valor - 1 8 | -------------------------------------------------------------------------------- /1001- 1100/1064.py: -------------------------------------------------------------------------------- 1 | positivos = 0 2 | t_data = 0 3 | for i in range(6): 4 | data = float(input()) 5 | if data >= 0: 6 | positivos += 1 7 | t_data += data 8 | print(positivos, "valores positivos") 9 | print(format(t_data / positivos, ".1f")) 10 | -------------------------------------------------------------------------------- /1001- 1100/1099.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | data = map(int, input().split()) 3 | maior, menor, soma_impares = max(data), min(data), 0 4 | for j in range(menor + 1, maior): 5 | if j % 2: 6 | soma_impares += j 7 | print(soma_impares) 8 | -------------------------------------------------------------------------------- /1001- 1100/1072.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | dentro = 0 3 | fora = 0 4 | for i in range(loops): 5 | data = int(input()) 6 | if data in range(10, 21): 7 | dentro += 1 8 | else: 9 | fora += 1 10 | print(dentro, "in") 11 | print(fora, "out") 12 | -------------------------------------------------------------------------------- /1600- 1999/1866.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) # Vê a qntd de casos testes 2 | for i in range(loops): 3 | numero = int(input()) 4 | if numero % 2 == 0: # Não precisa fazer uma iteração imensa, se for par é 0 se for ímpar é 1 5 | print(0) 6 | else: 7 | print(1) 8 | -------------------------------------------------------------------------------- /1001- 1100/1071.py: -------------------------------------------------------------------------------- 1 | numero_inicial, numero_final = int(input()), int(input()) 2 | maior, menor = max(numero_final, numero_inicial), min(numero_final, numero_inicial) 3 | soma = 0 4 | for impares in range(menor + 1, maior): 5 | if impares % 2: 6 | soma += impares 7 | print(soma) 8 | -------------------------------------------------------------------------------- /1400- 1599/1589.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) # Pega o número de casos teste 2 | for i in range(loops): 3 | data = input().split() # Separa os números em itens de uma lista 4 | print(int(data[0]) + int(data[1])) # Pega o primeiro número e soma pelo segundo(convertesse para int primeiro) 5 | -------------------------------------------------------------------------------- /1600- 1999/1871.py: -------------------------------------------------------------------------------- 1 | while True: 2 | data = input().split() 3 | m = int(data[0]) 4 | n = int(data[1]) 5 | if m + n == 0: 6 | break # Se os 2 forem 0 fecha o programa 7 | total = str(m + n).replace("0", "") # Todos os 0 depois da soma serão removidos 8 | print(total) 9 | -------------------------------------------------------------------------------- /1600- 1999/1893.py: -------------------------------------------------------------------------------- 1 | passado, presente = map(int, input().split()) 2 | if presente in range(0, 3): 3 | print("nova") 4 | elif presente in range(3, 97): 5 | if passado > presente: 6 | print("minguante") 7 | else: 8 | print("crescente") 9 | else: 10 | print("cheia") -------------------------------------------------------------------------------- /1101- 1200/1117.py: -------------------------------------------------------------------------------- 1 | corretas, total_notas = 0, 0 2 | while corretas < 2: 3 | nota = float(input()) 4 | if nota < 0 or nota > 10: 5 | print("nota invalida") 6 | else: 7 | corretas += 1 8 | total_notas += nota 9 | print("media =", format(total_notas / 2, ".2f")) 10 | -------------------------------------------------------------------------------- /1001- 1100/1050.py: -------------------------------------------------------------------------------- 1 | ddd = int(input()) 2 | tabela = {61: "Brasilia", 71: "Salvador", 11: "Sao Paulo", 21: "Rio de Janeiro", 3 | 32: "Juiz de Fora", 19: "Campinas", 27: "Vitoria", 33: "Belo Horizonte"} 4 | if ddd in tabela.keys(): 5 | print(tabela[ddd]) 6 | else: 7 | print("DDD nao cadastrado") 8 | -------------------------------------------------------------------------------- /1001- 1100/1087.py: -------------------------------------------------------------------------------- 1 | while True: 2 | a, b, c, d = list(map(int, input().split())) 3 | if a + b + c + d == 0: 4 | break 5 | if a == c and b == d: 6 | print(0) 7 | elif a + b == c + d or a - b == c - d or a == c or b == d: 8 | print(1) 9 | else: 10 | print(2) -------------------------------------------------------------------------------- /1600- 1999/1837.py: -------------------------------------------------------------------------------- 1 | # Esse ex é um pouco diferente em python, td o q vc precisa fazer é modificar o % e // para que funcionem q nem no C++ 2 | data = input().split() 3 | a = int(data[0]) 4 | b = int(data[1]) 5 | div = divmod(a, abs(b)) 6 | if b < 0: 7 | print(- div[0], div[1]) 8 | else: 9 | print(div[0], div[1]) -------------------------------------------------------------------------------- /2000- 3000/2679.py: -------------------------------------------------------------------------------- 1 | numero = int(input()) 2 | # Não pode incluir o proprio número por isso o + 1, o + 3, é para incluir os 2 proximos números (1 deles será par) 3 | for i in range(numero + 1, numero + 3): 4 | if i % 2 == 0: # se for par imprime o número e fecha o programa 5 | print(i) 6 | break 7 | -------------------------------------------------------------------------------- /2000- 3000/2691.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | a, b = map(int, input().replace("x", " ").split()) 3 | for j in range(5, 11): 4 | if a == b: 5 | print("{} x {} = {}".format(a, j, a * j)) 6 | else: 7 | print("{} x {} = {} && {} x {} = {}".format(a, j, a * j, b, j, b * j)) -------------------------------------------------------------------------------- /1101- 1200/1145.py: -------------------------------------------------------------------------------- 1 | tamanho, maximo = map(int, input().split()) 2 | inicial = 0 3 | while inicial < maximo: 4 | lista_numeros = [] 5 | for i in range(tamanho): 6 | inicial += 1 7 | if inicial <= maximo: 8 | lista_numeros.append(str(inicial)) 9 | print(" ".join(lista_numeros)) 10 | -------------------------------------------------------------------------------- /1101- 1200/1101.py: -------------------------------------------------------------------------------- 1 | while True: 2 | data = list(map(int, input().split())) 3 | menor, maior, total = min(data), max(data), [] 4 | if any(j <= 0 for j in data): 5 | break 6 | for i in range(menor, maior + 1): 7 | total.append(i) 8 | print("{} Sum={}".format(" ".join(map(str, total)), sum(total))) 9 | -------------------------------------------------------------------------------- /2000- 3000/2356.py: -------------------------------------------------------------------------------- 1 | while True: 2 | try: 3 | seq1 = input() 4 | seq2 = input() 5 | except EOFError: 6 | break 7 | if seq2 in seq1: # Se a sequencia 2 estiver contida na sequencia 1, ela é resistente 8 | print("Resistente") 9 | else: 10 | print("Nao resistente") 11 | -------------------------------------------------------------------------------- /1001- 1100/1036.py: -------------------------------------------------------------------------------- 1 | a, b, c = map(float, input().split()) 2 | delta = (b * b) - (4 * a * c) 3 | if delta < 0 or a == 0: 4 | print("Impossivel calcular") 5 | else: 6 | r1 = (- b + delta ** 0.5) / (2 * a) 7 | r2 = (- b - delta ** 0.5) / (2 * a) 8 | print("R1 = {}\nR2 = {}".format(format(r1, ".5f"), format(r2, ".5f"))) 9 | -------------------------------------------------------------------------------- /1001- 1100/1037.py: -------------------------------------------------------------------------------- 1 | num = float(input()) 2 | if 0 <= num <= 25: 3 | print("Intervalo [0,25]") 4 | elif 25 < num <= 50: 5 | print("Intervalo (25,50]") 6 | elif 50 < num <= 75: 7 | print("Intervalo [50,75]") 8 | elif 75 < num <= 100: 9 | print("Intervalo (75,100]") 10 | else: 11 | print("Fora de intervalo") 12 | -------------------------------------------------------------------------------- /1101- 1200/1150.py: -------------------------------------------------------------------------------- 1 | numero1, numero2, contador = int(input()), int(input()), 0 2 | while numero2 <= numero1: 3 | numero2 = int(input()) 4 | total = numero1 5 | while total < numero2: 6 | total += numero1 + contador 7 | contador += 1 8 | if numero2 <= 0: 9 | print(contador) 10 | else: 11 | print(contador + 1) 12 | -------------------------------------------------------------------------------- /1101- 1200/1164.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | numero, total = int(input()), 0 3 | for divisores in range(1, numero): 4 | if numero % divisores == 0: 5 | total += divisores 6 | if total == numero: 7 | print(numero, "eh perfeito") 8 | else: 9 | print(numero, "nao eh perfeito") 10 | -------------------------------------------------------------------------------- /2000- 3000/2175.py: -------------------------------------------------------------------------------- 1 | data = input().split() 2 | otavio = float(data[0]) 3 | bruno = float(data[1]) 4 | ian = float(data[2]) 5 | 6 | if otavio < min(ian, bruno): 7 | print("Otavio") 8 | elif bruno < min(ian, otavio): 9 | print("Bruno") 10 | elif ian < min(otavio, bruno): 11 | print("Ian") 12 | else: 13 | print("Empate") -------------------------------------------------------------------------------- /1400- 1599/1546.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | for j in range(int(input())): 3 | data = input() 4 | if data == "1": 5 | print("Rolien") 6 | elif data == "2": 7 | print("Naej") 8 | elif data == "3": 9 | print("Elehcim") 10 | else: 11 | print("Odranoel") -------------------------------------------------------------------------------- /2000- 3000/2311.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | for i in range(loops): 3 | nome = input() 4 | dificuldade = float(input()) 5 | data = input().split() 6 | data_ordenada = sorted(map(float, data)) # tranforma os valores para float e ordena 7 | print(nome, format(sum(data_ordenada[1:-1]) * dificuldade, ".2f")) # [1:-1] remove o maior e o menor valor -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # URI ONLINE 2 | 3 | Exercicios aceitos pelo site urionlinejudge em python3, comentários em português 4 | 5 | Eu diminuí a quantidade de comentários, só vou comentar em questões que eu achar difícil agora. 6 | 7 | Update de junho/2018 - Aumenta a eficiencia(memória e desempenho) e diminuí a quantidade de código deixando ele um pouco mais legível 8 | -------------------------------------------------------------------------------- /1400- 1599/1564.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é valor vazio(n confundir com 0 ou "") ou valor EOF use esse método 2 | while True: 3 | try: 4 | data = int(input()) 5 | except EOFError: 6 | break 7 | if data == 0: 8 | print("vai ter copa!") 9 | else: 10 | print("vai ter duas!") 11 | -------------------------------------------------------------------------------- /2000- 3000/2170.py: -------------------------------------------------------------------------------- 1 | projeto = 0 2 | while True: 3 | try: 4 | inicial, final = map(float, input().split()) 5 | except EOFError: 6 | break 7 | projeto += 1 8 | total = (final - inicial) / inicial * 100 9 | print("Projeto {}:".format(projeto)) 10 | print("Percentual dos juros da aplicacao:", format(total, ".2f"), "%\n") -------------------------------------------------------------------------------- /1001- 1100/1051.py: -------------------------------------------------------------------------------- 1 | if 0 < salario <= 2000: 2 | print("Isento") 3 | else: 4 | if 2000 < salario <= 3000: 5 | imposto = (salario - 2000) * 0.08 6 | elif 3000 < salario <= 4500: 7 | imposto = 80 + (salario - 3000) * 0.18 8 | else: 9 | imposto = 350 + (salario - 4500) * 0.28 10 | print("R$", format(imposto, ".2f")) 11 | -------------------------------------------------------------------------------- /1101- 1200/1175.py: -------------------------------------------------------------------------------- 1 | vetorinvertido = [] 2 | for i in range(20): 3 | data = int(input()) 4 | vetorinvertido.append(data) # junta os valores em uma lista 5 | vetor = 0 6 | for j in vetorinvertido[::-1]: # inverte a lista 7 | print("N[{}] = {}".format(vetor, j)) # e imprime os valores em ordem inversa 8 | vetor += 1 # aumentando o vetor linha por linha 9 | -------------------------------------------------------------------------------- /1600- 1999/1794.py: -------------------------------------------------------------------------------- 1 | roupas = int(input()) 2 | min_1, max_1 = map(int, input().split()) # Lavadora 3 | min_2, max_2 = map(int, input().split()) # Secadora 4 | if roupas in range(min_1, max_1 + 1) and roupas in range(min_2, max_2 + 1): # +1 para incluir o próprio numero 5 | # Se couber nos dois é possível 6 | print("possivel") 7 | else: 8 | print("impossivel") -------------------------------------------------------------------------------- /1600- 1999/1865.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) # Vê a qntd de casos testes 2 | for i in range(loops): 3 | data = input().split() # Separa o nome de quem está levantando e a força utilizada 4 | nome = data[0] # A força não importa só o nome 5 | if nome == "Thor": # Apenas se for o thor vai levantar 6 | print("Y") 7 | else: 8 | print("N") 9 | -------------------------------------------------------------------------------- /1600- 1999/1961.py: -------------------------------------------------------------------------------- 1 | pulo = input().split() 2 | data = input().split() 3 | ultimo = int(pulo[0]) 4 | for i in data: 5 | # Se a diferenca entre um cano e outro for maior que o pulo vai dar game over 6 | if abs(int(i) - ultimo) > int(pulo[0]): 7 | print("GAME OVER") 8 | break 9 | ultimo = int(i) 10 | else: 11 | print("YOU WIN") 12 | -------------------------------------------------------------------------------- /2000- 3000/2167.py: -------------------------------------------------------------------------------- 1 | # Dá para reduzir esse código e dá para usar o método lista.index() tb 2 | qnt = int(input()) 3 | data = input().split() 4 | posicao = 1 5 | maior = 0 6 | for i in map(int, data): 7 | if i >= maior: 8 | maior = i 9 | posicao += 1 10 | else: 11 | print(posicao) 12 | break 13 | else: 14 | print(0) -------------------------------------------------------------------------------- /2000- 3000/2242.py: -------------------------------------------------------------------------------- 1 | # Poderia ser feito por regex, mas eu acho que nesse caso específico seria mais complicado 2 | data = input() 3 | vogais = [] 4 | for char in data: 5 | if char in ["a", "e", "i", "o", "u"]: 6 | vogais.append(char) 7 | if vogais == vogais[::-1]: # Só se as vogais formarem um palíndromo que imprime "S" 8 | print("S") 9 | else: 10 | print("N") -------------------------------------------------------------------------------- /1001- 1100/1074.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | numero = int(input()) 3 | if numero == 0: 4 | print("NULL") 5 | else: 6 | if numero % 2: 7 | print("ODD", end=" ") 8 | else: 9 | print("EVEN", end=" ") 10 | if numero > 0: 11 | print("POSITIVE") 12 | else: 13 | print("NEGATIVE") 14 | -------------------------------------------------------------------------------- /1101- 1200/1151.py: -------------------------------------------------------------------------------- 1 | inicial, segundo, lista_fibonacci, loops = 0, 1, ["0", "1"], int(input()) 2 | if loops == 1: 3 | print("0") 4 | elif loops == 2: 5 | print("0 1") 6 | else: 7 | for i in range(loops - 2): 8 | lista_fibonacci.append(inicial + segundo) 9 | inicial, segundo = segundo, inicial + segundo 10 | print(" ".join(map(str, lista_fibonacci))) 11 | -------------------------------------------------------------------------------- /1600- 1999/1743.py: -------------------------------------------------------------------------------- 1 | plug1 = input().split() 2 | plug2 = input().split() 3 | conta = 0 4 | for i in range(5): 5 | if plug1[i] != plug2[i]: # Se os plugs da mesma posição forem diferentes eles se conectam 6 | conta += 1 # Conta todos os que se conectam 7 | if conta == 5: # Se 5 se conectarem as 2 tomadas são compatíveis 8 | print("Y") 9 | else: 10 | print("N") 11 | -------------------------------------------------------------------------------- /2000- 3000/2722.py: -------------------------------------------------------------------------------- 1 | # Esse código é bem sujo e inficiente, da para melhorá-lo bastante 2 | for i in range(int(input())): 3 | nome1 = input() 4 | nome2 = input() 5 | final = "" 6 | for j in range(max(len(nome1), len(nome2))): # esse pegaria todos os casos, mas não é muito eficiente 7 | if j % 2 == 0: 8 | final += nome1[j:j+2] + nome2[j:j+2] 9 | print(final) -------------------------------------------------------------------------------- /1101- 1200/1165.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | numero = int(input()) 3 | if numero in [0, 1]: 4 | print(numero, "nao eh primo") 5 | continue 6 | for divisores in range(2, numero // 2 + 1): 7 | if numero % divisores == 0: 8 | print(numero, "nao eh primo") 9 | break 10 | else: 11 | print(numero, "eh primo") 12 | -------------------------------------------------------------------------------- /1600- 1999/1805.py: -------------------------------------------------------------------------------- 1 | inicio, fim = list(map(int, input().split())) 2 | """ Para achar a qntd de termos --- final = inicial + (qntd - 1) * razao 3 | no caso desse exercício isso será sempre qntd = fim - inicio + 1 4 | A soma de todos os naturais em um intervalo é: 5 | (inicial + final) + qntd de termos / 2""" 6 | final = (inicio + fim) * (fim - inicio + 1) / 2 # juntei tudo nessa fórmula 7 | print(int(final)) -------------------------------------------------------------------------------- /1600- 1999/1929.py: -------------------------------------------------------------------------------- 1 | def is_triangle(a, b, c): 2 | return (a + b > c) and (b + c > a) and (a + c > b) 3 | 4 | 5 | A, B, C, D = list(map(int, input().split())) 6 | if is_triangle(A, B, C): 7 | print("S") 8 | elif is_triangle(A, B, D): 9 | print("S") 10 | elif is_triangle(A, C, D): 11 | print("S") 12 | elif is_triangle(B, C, D): 13 | print("S") 14 | else: 15 | print("N") -------------------------------------------------------------------------------- /1400- 1599/1547.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | for i in range(loops): 3 | data1 = input().split() 4 | data2 = input().split() 5 | dif = [] 6 | for j in data2: 7 | dif.append(abs(int(j) - int(data1[1]))) # pega a diferença de todos os valores qnd comparados ao valor certo 8 | print(dif.index(min(dif)) + 1) # Retorna a posição do valor mais próximo ao correto(+ 1 pois o index começa no 0) -------------------------------------------------------------------------------- /2000- 3000/2023.py: -------------------------------------------------------------------------------- 1 | # Muito ineficiente mas é aceito, revisitando esse código eu fiquei com vergonha, tem um jeito MT + simples de fazê-lo 2 | nome = [] 3 | while True: 4 | try: 5 | nomes = input() 6 | except EOFError: 7 | break 8 | nome.append(nomes) 9 | minusculos = [i.lower() for i in nome] 10 | ultimo = minusculos.index(max(minusculos)) 11 | print(nome[ultimo]) -------------------------------------------------------------------------------- /2000- 3000/2029.py: -------------------------------------------------------------------------------- 1 | # É só procurar pela fórmula para area de base e altura de cilindros 2 | while True: 3 | try: 4 | volume = float(input()) 5 | raio = float(input()) / 2 6 | except EOFError: 7 | break 8 | area_base = 3.14 * raio * raio 9 | print("ALTURA = {}".format(format(volume / area_base, ".2f"))) 10 | print("AREA = {}".format(format(area_base, ".2f"))) -------------------------------------------------------------------------------- /1101- 1200/1115.py: -------------------------------------------------------------------------------- 1 | while True: 2 | x, y = map(int, input().split()) 3 | if any(nulo == 0 for nulo in [x, y]): 4 | break 5 | elif all(positivo > 0 for positivo in [x, y]): 6 | print("primeiro") 7 | elif all(negativo < 0 for negativo in [x, y]): 8 | print("terceiro") 9 | elif x > 0: 10 | print("quarto") 11 | else: 12 | print("segundo") 13 | -------------------------------------------------------------------------------- /2000- 3000/2670.py: -------------------------------------------------------------------------------- 1 | andares = [] 2 | for i in range(3): 3 | data = int(input()) 4 | andares.append(data) 5 | # calcula o tempo que será gasto dependendo de que posição a máquina está 6 | primeiro = 2 * andares[1] + 4 * andares[2] 7 | segundo = 2 * andares[0] + 2 * andares[2] 8 | terceiro = 4 * andares[0] + 2 * andares[1] 9 | 10 | print(min(primeiro, segundo, terceiro)) # imprime o menor dos valores -------------------------------------------------------------------------------- /1400- 1599/1541.py: -------------------------------------------------------------------------------- 1 | import math 2 | while True: 3 | '''tive q por tudo em uma variável por causa da condição de fechamento 4 | se eu dividisse em 3 variáveis antes iria dar erro no último input''' 5 | data = list(map(int, input().split())) 6 | if data[0] == 0: 7 | break 8 | a = data[0] 9 | b = data[1] 10 | c = data[2] 11 | print(math.floor(math.sqrt((a * b * 100) / c))) -------------------------------------------------------------------------------- /1600- 1999/1943.py: -------------------------------------------------------------------------------- 1 | data = int(input()) 2 | if data == 1: 3 | print("Top 1") 4 | elif data in range(2, 4): 5 | print("Top 3") 6 | elif data in range(4, 6): 7 | print("Top 5") 8 | elif data in range(6, 11): 9 | print("Top 10") 10 | elif data in range(11, 26): 11 | print("Top 25") 12 | elif data in range(26, 51): 13 | print("Top 50") 14 | elif data in range(51, 101): 15 | print("Top 100") -------------------------------------------------------------------------------- /1400- 1599/1581.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | lista_ling = [] 3 | for j in range(int(input())): 4 | ling = input() 5 | lista_ling.append(ling) 6 | # set remove os repetidos, se tiver mais de 1 língua sempre será inglês 7 | if len(set(lista_ling)) > 1: 8 | print("ingles") 9 | else: 10 | print(lista_ling[0]) # Se tiver só uma língua falada a resposta sempre será ela -------------------------------------------------------------------------------- /2000- 3000/2547.py: -------------------------------------------------------------------------------- 1 | while True: 2 | try: 3 | loops, menor, maior = list(map(int, input().split())) 4 | except EOFError: 5 | break 6 | qnt = 0 7 | for i in range(loops): 8 | tamanho = int(input()) 9 | if tamanho in range(menor, maior + 1): # +1 para incluir o próprio número 10 | qnt += 1 # conta a qnt de pessoas que estão no range de altura 11 | print(qnt) -------------------------------------------------------------------------------- /2000- 3000/2557.py: -------------------------------------------------------------------------------- 1 | while True: 2 | try: 3 | data = input().replace("=", "+").split("+") # Remove os símbolos 4 | except EOFError: 5 | break 6 | numeros = [] 7 | for i in data: 8 | if i.isdigit(): 9 | numeros.append(i) 10 | if data[-1] == "J": 11 | print(int(numeros[0]) + int(numeros[1])) 12 | else: 13 | print(int(numeros[1]) - int(numeros[0])) -------------------------------------------------------------------------------- /1101- 1200/1161.py: -------------------------------------------------------------------------------- 1 | # Da para fazer a fórmula fatorial sem usar o built in também, e é relativamente fácil 2 | # Smp q tiver 1 exercício q diz q o último valor é valor vazio(n confundir com 0 ou "") ou valor EOF use esse método 3 | import math 4 | while True: 5 | try: 6 | data = input().split() 7 | except EOFError: 8 | break 9 | print(math.factorial(int(data[0])) + math.factorial(int(data[1]))) 10 | -------------------------------------------------------------------------------- /2000- 3000/2140.py: -------------------------------------------------------------------------------- 1 | # Coloquei todos as combinações possíveis para duas notas em uma lista 2 | troco = [200, 150, 120, 110, 105, 102, 100, 70, 60, 55, 52, 40, 30, 25, 22, 20, 15, 12, 10, 7, 4] 3 | while True: 4 | data = input().split() 5 | if int(data[0]) + int(data[1]) == 0: 6 | break 7 | if int(data[1]) - int(data[0]) in troco: 8 | print("possible") 9 | else: 10 | print("impossible") -------------------------------------------------------------------------------- /2000- 3000/2653.py: -------------------------------------------------------------------------------- 1 | # Outro método seria incluir todas as jóias, mesmo as repetidas, na lista e imprimir set(len(lista_joias)) 2 | lista_joias = [] 3 | while True: 4 | try: 5 | joia = input() 6 | except EOFError: 7 | break 8 | if joia not in lista_joias: # Se for uma jóia nova, ira entrar aqui 9 | lista_joias.append(joia) 10 | print(len(lista_joias)) # Conta a quantidade de jóias distintas -------------------------------------------------------------------------------- /1101- 1200/1134.py: -------------------------------------------------------------------------------- 1 | tabela_combustivel, comando = {"1": 0, "2": 0, "3": 0}, 0 2 | while comando != "4": 3 | comando = input() 4 | if comando in tabela_combustivel.keys(): 5 | tabela_combustivel[comando] += 1 6 | print("MUITO OBRIGADO\nAlcool: {}\nGasolina: {}\nDiesel: {}".format(tabela_combustivel["1"], tabela_combustivel["2"], 7 | tabela_combustivel["3"])) 8 | -------------------------------------------------------------------------------- /1201- 1299/1240.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | a, b = input().split() 3 | if len(b) > len(a): # se for maior não encaixa isso elimina rapidamente vários casos 4 | print("nao encaixa") 5 | # se o final do "numero" a for igual a b encaixa 6 | elif b == a[-len(b):]: # a[-len(b):], pega o final da string a seguindo o tamanho da string b 7 | print("encaixa") 8 | else: 9 | print("nao encaixa") -------------------------------------------------------------------------------- /1400- 1599/1436.py: -------------------------------------------------------------------------------- 1 | import math 2 | loops = int(input()) 3 | for i in range(loops): 4 | data = input().split() 5 | quantidade = int(data[0]) # Pega a quantidade de valores, é nescessário para ver o número do meio 6 | metade = math.ceil(quantidade / 2) # math.ceil ja retorna o valor arredondado pra cima em int 7 | print("Case " + str(i + 1) + ":", data[metade]) # Seu IDE vai dar warning , ignore, math.ceil smp retorna val int 8 | -------------------------------------------------------------------------------- /2000- 3000/2543.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 2 | while True: 3 | videos = 0 4 | try: 5 | loops_id = input().split() 6 | except EOFError: 7 | break 8 | for i in range(int(loops_id[0])): 9 | data = input().split() 10 | if data[0] == loops_id[1] and int(data[1]) == 0: 11 | videos += 1 12 | print(videos) -------------------------------------------------------------------------------- /1101- 1200/1181.py: -------------------------------------------------------------------------------- 1 | data = int(input()) 2 | op = input() 3 | soma = 0 4 | for horizontal in range(12): 5 | for vertical in range(12): 6 | valor = float(input()) # Pega os valores pela ordem horizontal 7 | if horizontal == data: # Pega só os valores da linha escolhida para a operação 8 | soma += valor 9 | if op == 'S': 10 | print(format(soma, ".1f")) 11 | else: 12 | print(format(soma / 12.0, ".1f")) -------------------------------------------------------------------------------- /1101- 1200/1182.py: -------------------------------------------------------------------------------- 1 | data = int(input()) 2 | op = input() 3 | soma = 0 4 | for horizontal in range(12): 5 | for vertical in range(12): 6 | valor = float(input()) # Pega os valores pela ordem horizontal 7 | if vertical == data: # Pega só os valores da coluna escolhida para a operação 8 | soma += valor 9 | if op == 'S': 10 | print(format(soma, ".1f")) 11 | else: 12 | print(format(soma / 12.0, ".1f")) -------------------------------------------------------------------------------- /2000- 3000/2157.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | for i in range(loops): 3 | data = input().split() 4 | final = "" 5 | for j in range(int(data[0]), int(data[1]) + 1): # +1 para incluir o próprio número, o mesmo no for: da linha 7 6 | final += str(j) 7 | for k in range(int(data[1]), int(data[0]) - 1, - 1): 8 | final += str(k)[::-1] # Imprime invertido e na ordem decrescente para fazer uma string espelhada 9 | print(final) -------------------------------------------------------------------------------- /2000- 3000/2650.py: -------------------------------------------------------------------------------- 1 | data = input().split() 2 | for i in range(int(data[0])): 3 | titan = input().split() 4 | name = titan[:-1] # só pega o nome do titan 5 | size = int(titan[-1]) # pega o tamanho e tranforma em int 6 | final = "" 7 | if size > int(data[1]): 8 | for j in name: 9 | final += j + " " # retorna o nome do titan separando por espaços 10 | print(final[:-1]) # retira o último espaço -------------------------------------------------------------------------------- /2000- 3000/2682.py: -------------------------------------------------------------------------------- 1 | # Outro método seria incluir todas os números numa lista, e imprimir max(lista) + 1 2 | maior = 0 # só funciona com 0 porque todos os números são positivos 3 | while True: 4 | try: 5 | numero = int(input()) 6 | except EOFError: 7 | break 8 | if numero > maior: # Sempre que vier um número maior vai mudar a variavel 9 | maior = numero 10 | else: 11 | break 12 | print(maior + 1) -------------------------------------------------------------------------------- /2000- 3000/2062.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | data = input().split() 3 | final = "" 4 | for j in data: 5 | if j[:2] in ["OB", "UR"] and len(j) == 3: # vê se começa com OB ou UR e se tem 3 de tamanho 6 | final += j[:2] + "I" + " " # tiver elimina a outra letra e substitui por i (separando cada 1 por espaços) 7 | else: 8 | final += j + " " # se não for mantêm a palavra, separando por espaços 9 | print(final[:-1]) # remove o último espaço -------------------------------------------------------------------------------- /1001- 1100/1021.py: -------------------------------------------------------------------------------- 1 | quantia = float(input()) * 1000 2 | notas = [100000, 50000, 20000, 10000, 5000, 2000] 3 | moedas = [1000, 500, 250, 100, 50, 10] 4 | print("NOTAS:") 5 | for i in notas: 6 | print("{} nota(s) de R$ {}".format(int((quantia) // i), format(i / 1000, ".2f"))) 7 | quantia %= i 8 | print("MOEDAS:") 9 | for j in moedas: 10 | print("{} moeda(s) de R$ {}".format(int(quantia // j), format(j / 1000, ".2f"))) 11 | quantia %= j 12 | -------------------------------------------------------------------------------- /2000- 3000/2479.py: -------------------------------------------------------------------------------- 1 | lista_nomes = [] 2 | bons = 0 3 | ruins = 0 4 | for i in range(int(input())): 5 | comportamento, nomes = input().split() 6 | lista_nomes.append(nomes) 7 | if comportamento == "+": 8 | bons += 1 9 | else: 10 | ruins += 1 11 | print("\n".join(sorted(lista_nomes))) # Põe a lista do nomes em ordem e separa cada um deles por linha 12 | print("Se comportaram: {} | Nao se comportaram: {}".format(bons, ruins)) -------------------------------------------------------------------------------- /1001- 1100/1012.py: -------------------------------------------------------------------------------- 1 | data = input().split() 2 | A = float(data[0]) 3 | B = float(data[1]) 4 | C = float(data[2]) 5 | pi = 3.14159 6 | tri = (A * C) / 2 7 | cir = (pi * C * C) 8 | tra = (C * (A + B)) / 2 9 | ret = A * B 10 | qua = B * B 11 | print("TRIANGULO:", format(tri, ".3f")) 12 | print("CIRCULO:", format(cir, ".3f")) 13 | print("TRAPEZIO:", format(tra, ".3f")) 14 | print("QUADRADO:", format(qua, ".3f")) 15 | print("RETANGULO:", format(ret, ".3f")) 16 | -------------------------------------------------------------------------------- /2000- 3000/2551.py: -------------------------------------------------------------------------------- 1 | while True: 2 | try: 3 | dias = int(input()) 4 | except EOFError: 5 | break 6 | maior = 0 7 | for i in range(dias): 8 | duracao, distancia = list(map(int, input().split())) 9 | if distancia / duracao > maior: 10 | print(i + 1) # Imprime todos os dias em que o recorde foi batido 11 | maior = distancia / duracao # Toda vez que o recorde for batido troca o valor de maior -------------------------------------------------------------------------------- /2000- 3000/2702.py: -------------------------------------------------------------------------------- 1 | # pega a diferença entre as refeições disponíveis e pedidas e soma todas os pedidos não completos 2 | refeicoes = list(map(int, input().split())) 3 | pedidos = list(map(int, input().split())) 4 | total = 0 5 | if refeicoes[0] < pedidos[0]: 6 | total += abs(refeicoes[0] - pedidos[0]) 7 | if refeicoes[1] < pedidos[1]: 8 | total += abs(refeicoes[1] - pedidos[1]) 9 | if refeicoes[2] < pedidos[2]: 10 | total += abs(refeicoes[2] - pedidos[2]) 11 | print(total) -------------------------------------------------------------------------------- /1001- 1100/1041.py: -------------------------------------------------------------------------------- 1 | data = input().split() 2 | posicaox = float(data[0]) 3 | posicaoy = float(data[1]) 4 | if posicaox == 0 and posicaoy == 0: 5 | print("Origem") 6 | elif posicaox == 0: 7 | print("Eixo Y") 8 | elif posicaoy == 0: 9 | print("Eixo X") 10 | elif posicaox > 0: 11 | if posicaoy > 0: 12 | print("Q1") 13 | else: 14 | print("Q4") 15 | else: 16 | if posicaoy > 0: 17 | print("Q2") 18 | else: 19 | print("Q3") 20 | -------------------------------------------------------------------------------- /1101- 1200/1160.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | anos = 0 3 | populacao1, populacao2, crescimento1, crescimento2 = map(float, input().split()) 4 | while populacao2 >= populacao1: 5 | if anos > 99: 6 | print("Mais de 1 seculo.") 7 | break 8 | populacao1 += int(populacao1 * crescimento1 / 100) 9 | populacao2 += int(populacao2 * crescimento2 / 100) 10 | anos += 1 11 | else: 12 | print(anos, "anos.") 13 | -------------------------------------------------------------------------------- /1300- 1399/1397.py: -------------------------------------------------------------------------------- 1 | while True: 2 | loops = int(input()) 3 | if loops == 0: 4 | break 5 | jogador1 = 0 6 | jogador2 = 0 7 | for i in range(loops): 8 | data = list(map(int, input().split())) # transforma os input em int() e põe numa lista 9 | if data[0] > data[1]: # O maior número recebe 1 ponto 10 | jogador1 += 1 11 | elif data[1] > data[0]: 12 | jogador2 += 1 13 | print("{} {}".format(jogador1, jogador2)) -------------------------------------------------------------------------------- /1101- 1200/1176.py: -------------------------------------------------------------------------------- 1 | def fib(n, d): 2 | a, b = 0, 1 3 | fibo = [0] 4 | for j in range(n): 5 | a, b = b, a + b 6 | fibo.append(a) 7 | return fibo[d] # pega o valor da posição requerida do input na lista de fibonacci 8 | 9 | 10 | loops = int(input()) # Vê a qntd de casos testes 11 | for i in range(loops): 12 | data = int(input()) 13 | print("Fib(" + str(data) + ") = " + str(fib(60, data))) # transformei em str, para formatar o print + facilmente 14 | -------------------------------------------------------------------------------- /1400- 1599/1542.py: -------------------------------------------------------------------------------- 1 | while True: 2 | '''tive q por tudo em uma variável por causa da condição de fechamento 3 | se eu dividisse em 3 variáveis antes iria dar erro no último input''' 4 | data = list(map(int, input().split())) 5 | if data[0] == 0: 6 | break 7 | x = int((data[0] * data[1]) / (data[2] - data[0]) * data[2]) 8 | if x == 1: 9 | print("{} pagina".format(x)) # print(x, "pagina") seria mais rápido 10 | else: 11 | print("{} paginas".format(x)) -------------------------------------------------------------------------------- /1600- 1999/1983.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | maior = 0 3 | aprovados = {} 4 | for i in range(loops): 5 | data = input().split() 6 | if float(data[1]) >= 8: # coloca os aprovados e suas notas em um dicionário 7 | aprovados[data[0]] = float(data[1]) 8 | 9 | if len(aprovados) > 0: 10 | print(max(aprovados, key=aprovados.get)) # Pega a maior nota dos aprovados e imprime o dono dessa nota 11 | else: # Se n tiver aprovados entra aqui 12 | print("Minimum note not reached") 13 | -------------------------------------------------------------------------------- /1001- 1100/1066.py: -------------------------------------------------------------------------------- 1 | pares = 0 2 | impares = 0 3 | positivos = 0 4 | negativos = 0 5 | for i in range(5): 6 | data = int(input()) 7 | if data % 2 == 0: 8 | pares += 1 9 | else: 10 | impares += 1 11 | if data > 0: 12 | positivos += 1 13 | elif data < 0: 14 | negativos += 1 15 | print(pares, "valor(es) par(es)") 16 | print(impares, "valor(es) impar(es)") 17 | print(positivos, "valor(es) positivo(s)") 18 | print(negativos, "valor(es) negativo(s)") 19 | -------------------------------------------------------------------------------- /1400- 1599/1548.py: -------------------------------------------------------------------------------- 1 | for i in range(int(input())): 2 | alunos = int(input()) 3 | notas = list(map(int, input().split())) # pega as notas e põe em uma lista desordenada 4 | notas_ordenadas = sorted(notas, reverse=True) # ordena as notas da maior para menor 5 | total = 0 6 | for j in range(alunos): 7 | # Se a nota do aluno estiver na mesma posição em que ele chegou aumenta o resultado em 1 8 | if notas[j] == notas_ordenadas[j]: 9 | total += 1 10 | print(total) -------------------------------------------------------------------------------- /1101- 1200/1171.py: -------------------------------------------------------------------------------- 1 | quantidade = {} 2 | for i in range(int(input())): 3 | data = int(input()) 4 | # Toda vez que for contar a frequencia de todas as letras ou números usar esse método 5 | quantidade.setdefault(data, 0) # se o item não estiver no dict coloca ela como chave e atribui o valor 0 6 | quantidade[data] = quantidade[data] + 1 # Cada vez q ele aperecer adiciona 1 ao valor 7 | ordenado = sorted(quantidade.keys()) 8 | for j in ordenado: 9 | print("{} aparece {} vez(es)".format(j, quantidade[j])) -------------------------------------------------------------------------------- /2000- 3000/2523.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 2 | while True: 3 | try: 4 | lampadas = input() # Letras das lampadas 5 | inutil = int(input()) # valor descartado nesse método 6 | data = input().split() # Posições da lampada 7 | except EOFError: 8 | break 9 | frase = "" 10 | for i in data: 11 | frase += lampadas[int(i) - 1] # -1, porque o index começa a contar no 0 12 | print(frase) -------------------------------------------------------------------------------- /1101- 1200/1120.py: -------------------------------------------------------------------------------- 1 | while True: 2 | data = input().split() 3 | errado = data[0] 4 | numero = data[1] 5 | if int(errado) + int(numero) == 0: # Condição de parada do loop 6 | break 7 | novo_numero = numero.replace(errado, "") # substitui o errado por um vazio 8 | if novo_numero == "": # Se não sobrar nada entra aqui, se não tivesso isso daria erro na conversão para int 9 | print(0) 10 | else: 11 | print(int(novo_numero)) # Converte para int, para dar o output esperado 12 | -------------------------------------------------------------------------------- /2000- 3000/2152.py: -------------------------------------------------------------------------------- 1 | # Esse exercício era mais interpretação de texto q um exercício de programação 2 | loops = int(input()) 3 | for i in range(loops): 4 | data = input().split() 5 | horas, minutos, porta = data 6 | if int(horas) < 10: 7 | horas = "0" + str(horas) 8 | if int(minutos) < 10: 9 | minutos = "0" + str(minutos) 10 | if porta == "1": 11 | print("{}:{} - A porta abriu!".format(horas, minutos)) 12 | else: 13 | print("{}:{} - A porta fechou!".format(horas, minutos)) -------------------------------------------------------------------------------- /1201- 1299/1272.py: -------------------------------------------------------------------------------- 1 | # Entrada 2 | n = int(input()) 3 | for i in range(n): 4 | a = input().replace("·", " ") # Troca os pontos por um espaço vazio 5 | a = a.split() # Separa as palavras que estão divididas usando o parametro 6 | texto = "" # Texto inicial 7 | # Processo 8 | for p in a: # Divide a lista ou string por item(nesse caso cada palavra é um item por causa do split) 9 | texto += p[0] # Pega a primeira letra de cada palavra e acumula no texto 10 | # Saída 11 | print(texto) # Imprime a resposta 12 | -------------------------------------------------------------------------------- /1001- 1100/1043.py: -------------------------------------------------------------------------------- 1 | data = input().split() 2 | ordenado_data = sorted(map(float, data)) # converte os itens do input para float e ordena, fica mais legível o código 3 | lado1 = ordenado_data[2] # O maior lado fica aqui 4 | lado2 = ordenado_data[1] 5 | lado3 = ordenado_data[0] # O menor aqui 6 | if lado1 >= lado2 + lado3: # Eu ordenei para ficar mais consiso aqui 7 | print("Area =", format((float(data[0]) + float(data[1])) * float(data[2]) / 2, ".1f")) 8 | else: 9 | print("Perimetro =", format((lado1 + lado2 + lado3), ".1f")) 10 | -------------------------------------------------------------------------------- /1101- 1200/1180.py: -------------------------------------------------------------------------------- 1 | # Esse val deve ser para facilitar p qm vai fazer o ex pelo método de iteração, mas no meu método esse valor é inutil 2 | inutil = int(input()) 3 | data = input().split() # Separa os valores e tranformam em itens de uma lista(serão valores str) 4 | menor = min(map(int, data)) # Usa o map para converter os itens para int o usa o min para pegar o menor 5 | print("Menor valor:", menor) 6 | print("Posicao:", data.index(str(menor))) 7 | # O método index pega a posição do item str dentro dos (), só é possível pois os valores são todos distintos 8 | -------------------------------------------------------------------------------- /1400- 1599/1555.py: -------------------------------------------------------------------------------- 1 | # Essa questão era só traduzir para python as fórmulas de cada 1 2 | loops = int(input()) # Vê a qntd de casos testes 3 | for i in range(loops): 4 | data = input().split() 5 | x, y = int(data[0]), int(data[1]) 6 | raf = (3 * x) * (3 * x) + (y * y) 7 | bet = 2 * (x * x) + (5 * y) * (5 * y) 8 | car = -100 * x + (y * y * y) 9 | if raf > bet and raf > car: 10 | print("Rafael ganhou") 11 | elif car > bet and car > raf: 12 | print("Carlos ganhou") 13 | else: 14 | print("Beto ganhou") 15 | -------------------------------------------------------------------------------- /2000- 3000/2031.py: -------------------------------------------------------------------------------- 1 | valor = {"ataque": 3, "pedra": 2, "papel": 1 } 2 | for i in range(int(input())): 3 | jog1 = valor[input()] # converte para o valor correspondente do dicionário automaticamente 4 | jog2 = valor[input()] 5 | if jog1 == jog2: 6 | if jog1 == 1: 7 | print("Ambos venceram") 8 | elif jog1 == 2: 9 | print("Sem ganhador") 10 | else: 11 | print("Aniquilacao mutua") 12 | elif jog1 > jog2: 13 | print("Jogador 1 venceu") 14 | else: 15 | print("Jogador 2 venceu") -------------------------------------------------------------------------------- /1600- 1999/1960.py: -------------------------------------------------------------------------------- 1 | # Dava para fazer com o método de dicionário, mas assim funciona tb 2 | def num_romanos(restando): 3 | numeros = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1) 4 | romanos = ('M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I') 5 | result = "" 6 | for i in range(13): # 13 valores chave 7 | count = restando // numeros[i] 8 | result += romanos[i] * count 9 | restando -= numeros[i] * count 10 | return result 11 | 12 | 13 | pagina = int(input()) 14 | print(num_romanos(pagina)) 15 | -------------------------------------------------------------------------------- /2000- 3000/2540.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 2 | while True: 3 | try: 4 | data = int(input()) # Número de votantes 5 | except EOFError: 6 | break 7 | dois_tercos = data * 2 / 3 # Identifica quanto é 2/3 de todos os votos 8 | votos = input().split() 9 | total = sum(map(int, votos)) # Transforma os itens da list em int e retorna e soma de todos 10 | if total >= dois_tercos: 11 | print("impeachment") 12 | else: 13 | print("acusacao arquivada") -------------------------------------------------------------------------------- /1101- 1200/1118.py: -------------------------------------------------------------------------------- 1 | encerramento = 0 2 | while encerramento != 2: 3 | corretas, total_notas = 0, 0 4 | while corretas < 2: 5 | nota = float(input()) 6 | if nota < 0 or nota > 10: 7 | print("nota invalida") 8 | else: 9 | corretas += 1 10 | total_notas += nota 11 | print("media = {}".format(format(total_notas / 2, ".2f"))) 12 | encerramento = int(input("novo calculo (1-sim 2-nao)\n")) 13 | while encerramento not in [1, 2]: 14 | encerramento = int(input("novo calculo (1-sim 2-nao)\n")) 15 | -------------------------------------------------------------------------------- /1600- 1999/1985.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) # Vê a qntd de casos testes 2 | total = 0 3 | for i in range(loops): 4 | data = input().split() 5 | if data[0] == "1001": # Data[0] é o item, Data[1] a qntd 6 | total += 1.5 * int(data[1]) 7 | elif data[0] == "1002": 8 | total += 2.5 * int(data[1]) 9 | elif data[0] == "1003": 10 | total += 3.5 * int(data[1]) 11 | elif data[0] == "1004": 12 | total += 4.5 * int(data[1]) 13 | elif data[0] == "1005": 14 | total += 5.5 * int(data[1]) 15 | print(format(total, ".2f")) 16 | -------------------------------------------------------------------------------- /2000- 3000/2059.py: -------------------------------------------------------------------------------- 1 | # O valor de r e a são prioridade, só é preciso checar o valor de par ou ímpar se eles forem 0 2 | p, j1, j2, r, a = map(int, input().split()) 3 | total = (j1 + j2) % 2 4 | if r == 0: 5 | if a == 0: 6 | if (total == 0 and p == 1) \ 7 | or (total == 1 and p == 0): 8 | print("Jogador 1 ganha!") 9 | else: 10 | print("Jogador 2 ganha!") 11 | else: 12 | print("Jogador 1 ganha!") 13 | elif r == 1: 14 | if a == 0: 15 | print("Jogador 1 ganha!") 16 | else: 17 | print("Jogador 2 ganha!") -------------------------------------------------------------------------------- /2000- 3000/2137.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é fim de arquivo ou valor EOF use esse método 2 | while True: 3 | try: 4 | loops = int(input()) # Vê a qntd de casos testes 5 | except EOFError: 6 | break 7 | lista = [] # Junta todos os números aqui como strings(não converter para int, senão os 0 iniciais iriam sumir) 8 | for i in range(loops): 9 | data = input() 10 | lista.append(data) 11 | lista_ordenada = sorted(lista) # Ordena a lista 12 | for j in lista_ordenada: 13 | print(j) # Imprime na ordem crescente 14 | -------------------------------------------------------------------------------- /2000- 3000/2060.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | data = input().split() 3 | dois = 0 4 | tres = 0 5 | quatro = 0 6 | cinco = 0 7 | for j in map(int, data): # transforma os valores da lista data em int 8 | # E checa a qntd de divisiveis de 2, 3, 4, 5 nessa lista 9 | if j % 2 == 0: 10 | dois += 1 11 | if j % 4 == 0: 12 | quatro += 1 13 | if j % 3 == 0: 14 | tres += 1 15 | if j % 5 == 0: 16 | cinco += 1 17 | print(dois, "Multiplo(s) de 2") 18 | print(tres, "Multiplo(s) de 3") 19 | print(quatro, "Multiplo(s) de 4") 20 | print(cinco, "Multiplo(s) de 5") 21 | -------------------------------------------------------------------------------- /1600- 1999/1914.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | for i in range(loops): 3 | data = input().split() 4 | numeros = input().split() 5 | if (int(numeros[0]) + int(numeros[1])) % 2 == 0: # Checa se a soma é par 6 | if data[1] == "PAR": # se a 1° pessoa escolheu par imprime o nome dela 7 | print(data[0]) 8 | else: # se não, imprime o nome da segunda pessoa 9 | print(data[2]) 10 | else: # Se for ímpar é só fazer a mesmo método, mudando as condições 11 | if data[1] == "IMPAR": 12 | print(data[0]) 13 | else: 14 | print(data[2]) 15 | -------------------------------------------------------------------------------- /2000- 3000/2692.py: -------------------------------------------------------------------------------- 1 | # põe os valores que serão trocados em um dicionário, troca esse valores por iteração e põe tudo na variável final 2 | loops = list(map(int, input().split())) 3 | trocas = {} 4 | for i in range(loops[0]): 5 | letras = input() 6 | trocas[letras[0]] = letras[2] 7 | trocas[letras[2]] = letras[0] 8 | for j in range(loops[1]): 9 | frase = input() 10 | final = "" 11 | for k in frase: 12 | if k in trocas.keys(): 13 | final += trocas[k] 14 | else: # se não for uma das chaves do dicionário mantem a letra 15 | final += k 16 | print(final) -------------------------------------------------------------------------------- /1101- 1200/1199.py: -------------------------------------------------------------------------------- 1 | while True: 2 | data = input() # negativos fecham o programa, poderia converter para int primeiro mas esse método é mais eficiente 3 | if data.startswith("-"): 4 | break 5 | if data.startswith("0x"): # 0x idetifica numeros hexadecimais 6 | print(int(data, 16)) # esse método ignora automaticament o 0x 7 | else: 8 | """ hex converte para hexadecimal incluindo 0x, mas em letras minúsculas 9 | o exercício pede em letra máisculas(tirando o X de 0x), por isso o 10 | método upper e replace""" 11 | print(hex(int(data)).upper().replace("X", "x")) -------------------------------------------------------------------------------- /2000- 3000/2108.py: -------------------------------------------------------------------------------- 1 | maior = 0 2 | maior_palavra = "" 3 | while True: 4 | data = input().split() 5 | tamanho = [] 6 | if data[0] == "0": 7 | break 8 | for i in data: 9 | tamanho.append(len(i)) # põe o tamanho de todas as palavras em uma lista 10 | if len(i) >= maior: # Sempre troca a variável maior_palavra se a palavra atual é maior que a maior antes dela 11 | maior = len(i) 12 | maior_palavra = i 13 | print("-".join(map(str, tamanho))) # transforma a lista de tamanhos em string e separa os itens por "-" 14 | print() 15 | print("The biggest word:", maior_palavra) -------------------------------------------------------------------------------- /2000- 3000/2534.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 2 | while True: 3 | try: 4 | loops = input().split() 5 | except EOFError: 6 | break 7 | notas = [] 8 | for i in range(int(loops[0])): 9 | data = int(input()) 10 | notas.append(data) # põe todas as notas em uma lista 11 | for j in range(int(loops[1])): 12 | posicao = int(input()) 13 | # põe a lista de notas em ordem decrescente e pega a pos pedida(-1 pois as listas são contadas a partir do 0) 14 | print(sorted(notas, reverse=True)[posicao - 1]) -------------------------------------------------------------------------------- /2000- 3000/2544.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 2 | while True: 3 | try: 4 | numero = int(input()) 5 | except EOFError: 6 | break 7 | conta = 0 8 | double = 1 # Inicial é 1 pois é uma multiplicação 9 | if double == numero: # Se já começa no número desejado não é necessaria nenhuma ação 10 | print(0) 11 | else: 12 | while double != numero: # Quando chegar ao número desejado vai parar 13 | conta += 1 # Conta as ações 14 | double *= 2 # Dobra a cada iteração 15 | print(conta) -------------------------------------------------------------------------------- /1201- 1299/1273.py: -------------------------------------------------------------------------------- 1 | count = 0 2 | while True: 3 | loops = int(input()) 4 | if loops == 0: 5 | break 6 | names = [] 7 | tamanhos = [] 8 | for i in range(loops): 9 | data = input() 10 | names.append(data) # pega todas as palavras e põe em uma lista 11 | tamanhos.append(len(data)) # junta o tamanho das palavras em uma lista 12 | if count: # para não dar PE... 13 | print() 14 | count += 1 15 | for j in names: 16 | # pega o tamanho da maior palavra e coloca esse tamanho como margem final pras outras usando rjust 17 | print(j.rjust(max(tamanhos))) -------------------------------------------------------------------------------- /1600- 1999/1789.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é valor vazio(n confundir com 0 ou "") ou valor EOF use esse método 2 | while True: 3 | try: 4 | tamanho = int(input()) # Valor inútil usando esse método 5 | data = input().split() # Separa as velocidades em itens de uma lista(eles serão em str) 6 | except EOFError: 7 | break 8 | maior = max(map(int, data)) # Tranforma os valores da lista em int usando map, e pega o maior usando o max 9 | if maior < 10: 10 | print(1) 11 | elif maior in range(10, 20): 12 | print(2) 13 | else: 14 | print(3) 15 | -------------------------------------------------------------------------------- /1001- 1100/1047.py: -------------------------------------------------------------------------------- 1 | hora_inicial, minuto_inicial, hora_final, minuto_final = map(int, input().split()) 2 | if hora_final == hora_inicial == minuto_inicial == minuto_final: 3 | horas, minutos = 24, 0 4 | else: 5 | if minuto_final >= minuto_inicial: 6 | minutos = minuto_final - minuto_inicial 7 | else: 8 | minutos = 60 - abs(minuto_final - minuto_inicial) 9 | hora_final -= 1 10 | if hora_final >= hora_inicial: 11 | horas = hora_final - hora_inicial 12 | else: 13 | horas = 24 - abs(hora_final - hora_inicial) 14 | print("O JOGO DUROU {} HORA(S) E {} MINUTO(S)".format(horas, minutos)) 15 | -------------------------------------------------------------------------------- /1101- 1200/1168.py: -------------------------------------------------------------------------------- 1 | leds = {1: 2, 2: 5, 3: 5, 4: 4, 5: 5, 6: 6, 7: 3, 8: 7, 9: 6, 0: 6} # quantidade de leds dependendo do número 2 | loops = int(input()) # Quantidade de loops 3 | for i in range(loops): 4 | soma = 0 5 | valor = list(input()) # Pega o valor e separa cada número dentro de uma lista 6 | for v in valor: # Pega 1 item da lista 7 | for d in leds: # Pega os valores do dicionário leds 8 | if int(v) == d: # Se o valor coincidir(sempre irá) entra aqui 9 | soma += leds[d] # acumula o total de leds aqui, encontra o v no {leds} e retorna o valor correspondente 10 | print(soma, "leds") 11 | -------------------------------------------------------------------------------- /1001- 1100/1018.py: -------------------------------------------------------------------------------- 1 | dinheiro = int(input()) 2 | cem = dinheiro // 100 3 | sobra = dinheiro % 100 4 | cinquenta = sobra // 50 5 | sobra = sobra % 50 6 | vinte = sobra // 20 7 | sobra = sobra % 20 8 | dez = sobra // 10 9 | sobra = sobra % 10 10 | cinco = sobra // 5 11 | sobra = sobra % 5 12 | dois = sobra // 2 13 | sobra = sobra % 2 14 | um = sobra 15 | print(dinheiro) 16 | print(cem, "nota(s) de R$ 100,00") 17 | print(cinquenta, "nota(s) de R$ 50,00") 18 | print(vinte, "nota(s) de R$ 20,00") 19 | print(dez, "nota(s) de R$ 10,00") 20 | print(cinco, "nota(s) de R$ 5,00") 21 | print(dois, "nota(s) de R$ 2,00") 22 | print(um, "nota(s) de R$ 1,00") 23 | -------------------------------------------------------------------------------- /1001- 1100/1048.py: -------------------------------------------------------------------------------- 1 | salario = float(input()) 2 | aumentos = [0.15, 0.12, 0.1, 0.07, 0.04] 3 | if salario <= 400: 4 | posicao = 0 5 | elif salario <= 800: 6 | posicao = 1 7 | elif salario <= 1200: 8 | posicao = 2 9 | elif salario <= 2000: 10 | posicao = 3 11 | else: 12 | posicao = 4 13 | print("Novo salario: {}\nReajuste ganho: {}\nEm percentual: {} %".format(format(salario + salario * aumentos[posicao], ".2f"), 14 | format(salario * aumentos[posicao], ".2f"), 15 | int(aumentos[posicao] * 100))) 16 | -------------------------------------------------------------------------------- /1300- 1399/1332.py: -------------------------------------------------------------------------------- 1 | def checando_numero(palavra): 2 | if len(palavra) == 5: # 1 e 2 tem 3 de tamanho em inglês, isso já elimina 1/3 dos casos rapidamente 3 | print(3) 4 | else: 5 | val = 0 6 | o = 'one' 7 | for x in range(len(palavra)): 8 | if palavra[x] == o[x]: # valores equivalentes a one 9 | val += 1 10 | if val == 2 or val == 3: # se tiver dois ou 3 equivalentes é 1 11 | print(1) 12 | else: 13 | print(2) 14 | 15 | 16 | loops = int(input()) # Vê a qntd de casos testes 17 | for i in range(loops): 18 | data = input() 19 | checando_numero(data) -------------------------------------------------------------------------------- /1001- 1100/1045.py: -------------------------------------------------------------------------------- 1 | lado3, lado2, lado1 = sorted(map(float, input().split())) 2 | if lado1 >= lado2 + lado3: 3 | print("NAO FORMA TRIANGULO") 4 | else: 5 | if lado1 * lado1 == lado2 * lado2 + lado3 * lado3: 6 | print("TRIANGULO RETANGULO") 7 | elif lado1 * lado1 > lado2 * lado2 + lado3 * lado3: 8 | print("TRIANGULO OBTUSANGULO") 9 | elif lado1 * lado1 < lado2 * lado2 + lado3 * lado3: 10 | print("TRIANGULO ACUTANGULO") 11 | if lado1 == lado2 == lado3: 12 | print("TRIANGULO EQUILATERO") 13 | if lado1 == lado2 != lado3 or lado1 == lado3 != lado2 or lado2 == lado3 != lado1: 14 | print("TRIANGULO ISOSCELES") 15 | -------------------------------------------------------------------------------- /1101- 1200/1131.py: -------------------------------------------------------------------------------- 1 | qntd, inter, gremio, empates, encerramento = 0, 0, 0, 0, 0 2 | while encerramento != 2: 3 | gols_inter, gols_gremio = map(int, input().split()) 4 | qntd += 1 5 | if gols_inter == gols_gremio: 6 | empates += 1 7 | elif gols_inter > gols_gremio: 8 | inter += 1 9 | else: 10 | gremio += 1 11 | encerramento = int(input("Novo grenal (1-sim 2-nao)\n")) 12 | 13 | print("{} grenais\nInter:{}\nGremio:{}\nEmpates:{}".format(qntd, inter, gremio, empates)) 14 | if inter > gremio: 15 | print("Inter venceu mais") 16 | elif gremio > inter: 17 | print("Gremio venceu mais") 18 | else: 19 | print("Nao houve vencedor") -------------------------------------------------------------------------------- /1001- 1100/1094.py: -------------------------------------------------------------------------------- 1 | tabela_qntd = {"total": 0} 2 | for i in range(int(input())): 3 | qntd, tipo = input().split() 4 | tabela_qntd.setdefault(tipo, 0) 5 | tabela_qntd[tipo] += int(qntd) 6 | tabela_qntd["total"] += int(qntd) 7 | 8 | coelho, rato, sapo, total = tabela_qntd["C"], tabela_qntd["R"], tabela_qntd["S"], tabela_qntd["total"] 9 | print("Total: {} cobaias\nTotal de coelhos: {}\nTotal de ratos: {}\nTotal de sapos: {}\n" 10 | "Percentual de coelhos: {} %\nPercentual de ratos: {} %\nPercentual de sapos: {} %".format(total, coelho, rato, 11 | sapo, format(coelho / total * 100, ".2f"), format(rato / total * 100, ".2f"), format(sapo / total * 100, ".2f"))) 12 | -------------------------------------------------------------------------------- /1400- 1599/1478.py: -------------------------------------------------------------------------------- 1 | while True: 2 | data = int(input()) 3 | if data == 0: 4 | break 5 | final = [] 6 | for i in range(1, (data + 1)): 7 | borda = [] 8 | count = i 9 | for j in range(data): 10 | borda.append(abs(count)) 11 | if count == 1: 12 | count -= 3 13 | else: 14 | count -= 1 15 | final.append(borda) 16 | for k in range(data): 17 | tx = '' 18 | for j in range(data): 19 | # essa linha da muito trabalho quanto a PE no site(n use format() nesse caso) 20 | tx += " %3d" % final[k][j] 21 | print(tx[1:]) 22 | print() -------------------------------------------------------------------------------- /1001- 1100/1040.py: -------------------------------------------------------------------------------- 1 | notas = input().split() # separa os dados de uma mesma linha 2 | n1 = float(notas[0]) * 2 3 | n2 = float(notas[1]) * 3 4 | n3 = float(notas[2]) * 4 5 | n4 = float(notas[3]) 6 | media = (n1 + n2 + n3 + n4) / 10 7 | print("Media:", format(media, ".1f")) 8 | if media >= 7: 9 | print("Aluno aprovado.") 10 | elif 5 <= media < 7: 11 | print("Aluno em exame.") 12 | ne = float(input()) 13 | print("Nota do exame:", format(ne, ".1f")) 14 | if (ne + media) / 2 >= 5: 15 | print("Aluno aprovado.") 16 | else: 17 | print("Aluno reprovado.") 18 | print("Media final:", format((ne + media) / 2, ".1f")) 19 | else: 20 | print("Aluno reprovado.") 21 | -------------------------------------------------------------------------------- /1101- 1200/1183.py: -------------------------------------------------------------------------------- 1 | soma_media = input() 2 | total = 0 3 | fora = 1 4 | dentro = 11 5 | numeros = 0 6 | inicial_fora = fora 7 | inicial_dentro = dentro 8 | for i in range(144): 9 | data = float(input()) 10 | if inicial_fora + inicial_dentro == 0: 11 | fora += 1 12 | dentro -= 1 13 | inicial_fora = fora 14 | inicial_dentro = dentro 15 | if inicial_fora > 0: 16 | inicial_fora -= 1 17 | continue 18 | if inicial_dentro > 0: 19 | inicial_dentro -= 1 20 | total += data 21 | numeros += 1 22 | continue 23 | if soma_media == 'S': 24 | print(format(total, ".1f")) 25 | else: 26 | print(format((total / numeros), ".1f")) -------------------------------------------------------------------------------- /1101- 1200/1184.py: -------------------------------------------------------------------------------- 1 | soma_media = input() 2 | total = 0 3 | fora = 12 4 | dentro = 0 5 | numeros = 0 6 | inicial_fora = fora 7 | inicial_dentro = dentro 8 | for i in range(144): 9 | data = float(input()) 10 | if inicial_fora + inicial_dentro == 0: 11 | fora -= 1 12 | dentro += 1 13 | inicial_fora = fora 14 | inicial_dentro = dentro 15 | if inicial_dentro > 0: 16 | inicial_dentro -= 1 17 | total += data 18 | numeros += 1 19 | continue 20 | if inicial_fora > 0: 21 | inicial_fora -= 1 22 | continue 23 | if soma_media == 'S': 24 | print(format(total, ".1f")) 25 | else: 26 | print(format((total / numeros), ".1f")) -------------------------------------------------------------------------------- /1101- 1200/1185.py: -------------------------------------------------------------------------------- 1 | soma_media = input() 2 | total = 0 3 | fora = 0 4 | dentro = 11 5 | numeros = 0 6 | inicial_fora = fora 7 | inicial_dentro = dentro 8 | for i in range(144): 9 | data = float(input()) 10 | if inicial_dentro > 0: 11 | inicial_dentro -= 1 12 | total += data 13 | numeros += 1 14 | continue 15 | if inicial_fora > 0: 16 | inicial_fora -= 1 17 | continue 18 | if inicial_fora + inicial_dentro == 0: 19 | fora += 1 20 | dentro -= 1 21 | inicial_fora = fora 22 | inicial_dentro = dentro 23 | if soma_media == 'S': 24 | print(format(total, ".1f")) 25 | else: 26 | print(format((total / numeros), ".1f")) -------------------------------------------------------------------------------- /1101- 1200/1187.py: -------------------------------------------------------------------------------- 1 | soma_media = input() 2 | total = 0 3 | fora = 1 4 | dentro = 10 5 | numeros = 0 6 | inicial_fora = fora 7 | inicial_dentro = dentro 8 | for i in range(144): 9 | data = float(input()) 10 | if inicial_fora + inicial_dentro == 0: 11 | fora += 2 12 | dentro -= 2 13 | inicial_fora = fora 14 | inicial_dentro = dentro 15 | if inicial_fora > 0: 16 | inicial_fora -= 1 17 | continue 18 | if inicial_dentro > 0: 19 | inicial_dentro -= 1 20 | total += data 21 | numeros += 1 22 | continue 23 | 24 | if soma_media == 'S': 25 | print(format(total, ".1f")) 26 | else: 27 | print(format((total / numeros), ".1f")) -------------------------------------------------------------------------------- /1201- 1299/1237.py: -------------------------------------------------------------------------------- 1 | def longest_common_substr_length(s1, s2): 2 | # Processo 3 | substr_len = min(map(len, (s1, s2))) 4 | if len(s1) > len(s2): 5 | s1, s2 = s2, s1 6 | for length in range(substr_len, 0, -1): 7 | for index in range(0, len(s1)-length+1): 8 | if s1[index:index+length] in s2: 9 | return length 10 | return 0 11 | 12 | 13 | a = "bla" 14 | b = "bla" 15 | while a != "" and b != "": 16 | # Entrada 17 | try: 18 | a = input() 19 | b = input() 20 | # Saída 21 | if a and b: 22 | print(longest_common_substr_length(a, b)) 23 | else: 24 | break 25 | except EOFError: 26 | break 27 | -------------------------------------------------------------------------------- /2000- 3000/2633.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 2 | while True: 3 | try: 4 | loops = int(input()) 5 | except EOFError: 6 | break 7 | valores = {} 8 | for i in range(loops): 9 | data = input().split() 10 | valores[data[0]] = int(data[1]) # põe os valores correspondentes para cada item no dicionário 11 | ordenado = sorted(valores, key=valores.get) # põe os valores em ordem e retorna as chaves correspondentes 12 | final = "" 13 | for j in ordenado: 14 | final += j + " " # separa os valores com um espaço (usar " ".join() é bem mais eficiente) 15 | print(final[:-1]) # retira o último espaço -------------------------------------------------------------------------------- /2000- 3000/2694.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) # Não deve ser o método mais eficiente, mas é bom mesmo assim 2 | for i in range(loops): 3 | data = input() 4 | num_str = "" 5 | for j in data: 6 | if j.isdigit(): 7 | num_str += j # Manda os números como strings para a variável 8 | else: 9 | num_str += " " # Transforma as letras em espaços, eu incluí para separar os números 10 | print(sum(map(int, num_str.split()))) 11 | ''' 12 | split(), separa os números pelos espaços, e os tranforma em itens de uma lista 13 | map(int, lista), transforma todas as strings em números inteiros ex: "123" --- 123 14 | sum(lista), soma todos os valores de uma lista 15 | ''' 16 | -------------------------------------------------------------------------------- /1201- 1299/1238.py: -------------------------------------------------------------------------------- 1 | loops = int(input()) 2 | for i in range(loops): 3 | str_final = "" 4 | data = input().split() # separas as palavras e elimina os espaços 5 | for j in range(min(len(data[0]), len(data[1]))): 6 | str_final += data[0][j] + data[1][j] # pela diferença de tamanho ela itercala as letras das 2 palavras 7 | # Depois checa qual das 2 palavras é a maior é completa a palavra final com o que sobrou 8 | if len(data[0]) > len(data[1]): 9 | print(str_final + data[0][len(data[1]):len(data[0])]) 10 | elif len(data[1]) > len(data[0]): 11 | print(str_final + data[1][len(data[0]):len(data[1])]) 12 | else: # se forem iguais já está completo e entra aqui 13 | print(str_final) -------------------------------------------------------------------------------- /1400- 1599/1534.py: -------------------------------------------------------------------------------- 1 | while True: 2 | try: 3 | data = int(input()) 4 | except EOFError: 5 | break 6 | final = [] 7 | coluna = data - 1 8 | for i in range(data): 9 | principal = [] 10 | for j in range(data): 11 | if j == coluna: 12 | principal.append(2) 13 | coluna -= 1 14 | else: 15 | if i == j: 16 | principal.append(1) 17 | else: 18 | principal.append(3) 19 | final.append(principal) 20 | for k in range(data): 21 | matriz = '' 22 | for l in range(data): 23 | matriz += str(final[k][l]) 24 | print(matriz) -------------------------------------------------------------------------------- /2000- 3000/2149.py: -------------------------------------------------------------------------------- 1 | # É a lista da fib, so que em de ser só soma, intercala soma e multiplicação 2 | def fib(n): 3 | list_phil = [0, 1] 4 | a, b = 0, 1 5 | for i in range(n - 1): 6 | if i % 2 == 0: # Intercala entre + e * 7 | a, b = b, a + b 8 | else: 9 | a, b = b, a * b 10 | list_phil.append(a) 11 | return list_phil[-1] # Retorna o último valor 12 | 13 | 14 | while True: 15 | try: 16 | data = int(input()) 17 | except EOFError: 18 | break 19 | # Se não tivesse isso daria errado qnd data fosse 1, pois a lista inicial da função começa com 2 valores 20 | if data == 1: 21 | print(0) 22 | else: 23 | print(fib(data)) 24 | -------------------------------------------------------------------------------- /2000- 3000/2313.py: -------------------------------------------------------------------------------- 1 | # Se você souber as regras dos tipos de triangulo não é um exercício difícil, esse código pode ser simplificado tb 2 | lados = list(map(int, input().split())) 3 | A = lados[0] 4 | B = lados[1] 5 | C = lados[2] 6 | if A + B > C and A + C > B and B + C > A: 7 | if A == B == C: 8 | print("Valido-Equilatero") 9 | elif A == B or B == C or C == A: 10 | print("Valido-Isoceles") 11 | elif A not in [B, C] or B not in [A, C] or B not in [A, C]: 12 | print("Valido-Escaleno") 13 | if A ** 2 == B ** 2 + C ** 2 or B ** 2 == A ** 2 + C ** 2 or C ** 2 == A ** 2 + B ** 2: 14 | print("Retangulo: S") 15 | else: 16 | print("Retangulo: N") 17 | else: 18 | print("Invalido") 19 | -------------------------------------------------------------------------------- /1101- 1200/1110.py: -------------------------------------------------------------------------------- 1 | # deve ter uma formula matematica para deixar isso bem + rápido e também seria + rapido usar deque em vez de listas 2 | while True: 3 | qnt = int(input()) 4 | if qnt == 0: 5 | break 6 | inicial = [] 7 | for i in range(1, qnt + 1): 8 | inicial.append(i) 9 | descartado = [] 10 | while len(inicial) > 1: 11 | # descarta o 1° item da lista inicial e põe na pilha de descartados 12 | descartado.append(inicial.pop(0)) 13 | # faz o mesmo q a linha acima e modifica a lista inicial de acordo com o enunciado 14 | inicial.insert(len(inicial)-1, inicial.pop(0)) 15 | print("Discarded cards:", ", ".join(map(str, descartado))) 16 | print("Remaining card:", str(inicial[0])) -------------------------------------------------------------------------------- /2000- 3000/2150.py: -------------------------------------------------------------------------------- 1 | while True: 2 | # Entrada 3 | vogais_a = input() # Pega as vogais aliens já q tds as palavras e vogais são min, n preciso usar lower() ou upper() 4 | if vogais_a == "": # Se estiver vazio fecha o programa 5 | break # O while roda s parar qnd a cond for True, então só será interrompido qnd o break aparecer 6 | frase = input() # Pega a frase a ser avaliada 7 | conta = 0 # Valor inicial para a contagem de vogais aliens na frase 8 | # Processo 9 | for i in frase: # Itera a frase letra por letra 10 | if i in vogais_a: # Vê se a letra é uma das vogais aliens 11 | conta += 1 # Se for aumenta o contador em 1 12 | # Saída 13 | print(conta) # Imprime a qntd de vogais alien na palavra 14 | -------------------------------------------------------------------------------- /1001- 1100/1068.py: -------------------------------------------------------------------------------- 1 | # Essa é a mais eficiente resposta do site em python3, 1° lugar isolado!!! 2 | # Não é totalmente eficiente, mas funciona para todos os casos teste do site 3 | # Smp q tiver 1 exercício q diz q o último valor é valor vazio(n confundir com 0 ou "") ou valor EOF use esse método 4 | while True: 5 | try: 6 | data = input() 7 | except EOFError: 8 | break 9 | if data[0] == ")" or data[-1] == "(": # Se o 1° simbolo da expressao for ) ou a ultima for (, esta incorreto 10 | print("incorrect") 11 | elif (data.count("(") + data.count(")")) % 2 == 0: # conta os pares de (), se a soma for par está correto 12 | print("correct") 13 | else: # Se não for está incorreto 14 | print("incorrect") 15 | -------------------------------------------------------------------------------- /1101- 1200/1186.py: -------------------------------------------------------------------------------- 1 | soma_media = input() 2 | total = 0 3 | fora = 10 4 | dentro = 1 5 | numeros = 0 6 | inicial_fora = fora 7 | inicial_dentro = dentro 8 | for i in range(144): 9 | data = float(input()) 10 | if i < 23: 11 | continue 12 | if inicial_fora + inicial_dentro == 0: 13 | fora -= 1 14 | dentro += 1 15 | inicial_fora = fora 16 | inicial_dentro = dentro 17 | if inicial_dentro > 0: 18 | inicial_dentro -= 1 19 | total += data 20 | numeros += 1 21 | continue 22 | if inicial_fora > 0: 23 | inicial_fora -= 1 24 | continue 25 | 26 | if soma_media == 'S': 27 | print(format(total, ".1f")) 28 | else: 29 | print(format((total / numeros), ".1f")) -------------------------------------------------------------------------------- /1101- 1200/1188.py: -------------------------------------------------------------------------------- 1 | soma_media = input() 2 | total = 0 3 | fora = 9 4 | dentro = 2 5 | numeros = 0 6 | inicial_fora = fora 7 | inicial_dentro = dentro 8 | for i in range(144): 9 | data = float(input()) 10 | if i < 89: 11 | continue 12 | if inicial_fora + inicial_dentro == 0: 13 | fora -= 2 14 | dentro += 2 15 | inicial_fora = fora 16 | inicial_dentro = dentro 17 | if inicial_dentro > 0: 18 | inicial_dentro -= 1 19 | total += data 20 | numeros += 1 21 | continue 22 | if inicial_fora > 0: 23 | inicial_fora -= 1 24 | continue 25 | 26 | if soma_media == 'S': 27 | print(format(total, ".1f")) 28 | else: 29 | print(format((total / numeros), ".1f")) -------------------------------------------------------------------------------- /2000- 3000/2712.py: -------------------------------------------------------------------------------- 1 | import re 2 | loops = int(input()) 3 | for i in range(loops): 4 | data = input() 5 | placa = re.compile('([A-Z]{3})-([0-9]{4})') # vê se segue o formato AAA-9999 6 | # Tem que checar o tamanho pois placas como AAA-9999x também são aceitas pelo regex 7 | if placa.match(data) and len(data) == 8: 8 | ultimo = data[-1] 9 | if ultimo in ["1", "2"]: 10 | print("MONDAY") 11 | elif ultimo in ["3", "4"]: 12 | print("TUESDAY") 13 | elif ultimo in ["5", "6"]: 14 | print("WEDNESDAY") 15 | elif ultimo in ["7", "8"]: 16 | print("THURSDAY") 17 | elif ultimo in ["0", "9"]: 18 | print("FRIDAY") 19 | else: 20 | print("FAILURE") -------------------------------------------------------------------------------- /2000- 3000/2028.py: -------------------------------------------------------------------------------- 1 | caso = 0 2 | while True: 3 | try: 4 | data = int(input()) 5 | except EOFError: 6 | break 7 | caso += 1 8 | lista_numero = ["0"] # O meu método excluí o 0, então eu tive que por ele direto na lista inicial 9 | if data == 0: 10 | print("Caso {}: 1 numero\n0".format(caso)) 11 | else: 12 | for i in range(data + 1): 13 | for j in range(i): # põe todos os números na lista, eles se repetem de acordo com seu valor numérico 14 | lista_numero.append(str(i)) 15 | # Converti para str para poder usar o método .join(que é bem superior em desempenho a usar loops) 16 | print("Caso {}: {} numeros\n{}".format(caso, len(lista_numero), " ".join(lista_numero))) 17 | print() -------------------------------------------------------------------------------- /1400- 1599/1467.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 2 | while True: 3 | try: 4 | data = input() 5 | except EOFError: 6 | break 7 | for i in data: 8 | if data.count(i) == 1: # acha o valor isolado usando método de exaustão (pouco eficiente) 9 | if data.index(i) == 0: # confere a posição do valor isolado 10 | print("A") 11 | break 12 | elif data.index(i) == 2: 13 | print("B") 14 | break 15 | else: 16 | print("C") 17 | break 18 | else: # Se forem todos iguais não vai quebrar o loop anterior e vai entrar aqui(método só possível em python) 19 | print("*") -------------------------------------------------------------------------------- /2000- 3000/2486.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 2 | c_vit = {"suco": 120, "morango": 85, "mamao": 85, "goiaba": 70, "manga": 56, "laranja": 50, "brocolis": 34} 3 | while True: 4 | loops = int(input()) 5 | if loops == 0: 6 | break 7 | total = 0 8 | for i in range(loops): # Vê a qntd de casos testes 9 | data = input().split() 10 | # Vê o nome e retorna o valor corrrespondente no dicionário, depois multiplica esse valor pela qnt 11 | total += c_vit[data[1]] * int(data[0]) 12 | if total in range(110, 131): 13 | print(total, "mg") 14 | elif total in range(0, 110): 15 | print("Mais", 110 - total, "mg") 16 | else: 17 | print("Menos", total - 130, "mg") 18 | -------------------------------------------------------------------------------- /1101- 1200/1103.py: -------------------------------------------------------------------------------- 1 | while True: 2 | data = input().split() 3 | h1 = int(data[0]) 4 | m1 = int(data[1]) 5 | h2 = int(data[2]) 6 | m2 = int(data[3]) 7 | if h1 + h2 + m1 + m2 == 0: 8 | break 9 | minutos_atuais = (h1 * 60) + m1 # Total de minutos no dia quando ela foi dormir 10 | minutos_finais = (h2 * 60) + m2 # Total de minutos no dia quando ela for acordar 11 | if minutos_atuais < minutos_finais: # Se o dia for o mesmo(que ela dormir e acordar) entra aqui 12 | print(abs(minutos_atuais - minutos_finais)) # abs para converter pra positivo(o resultado sempre será negativo) 13 | else: 14 | # Se o dia for outro vai se substrair 1440 minutos(representando 1 dia) assim mostrando o valor certo 15 | print(abs(minutos_atuais - minutos_finais - 1440)) 16 | -------------------------------------------------------------------------------- /1600- 1999/1867.py: -------------------------------------------------------------------------------- 1 | while True: 2 | n1, n2 = input().split() 3 | if int(n1) + int(n2) == 0: 4 | break 5 | while True: 6 | total_1 = 0 7 | total_2 = 0 8 | for i in n1: 9 | total_1 += int(i) # soma todos os digitos 10 | n1 = str(total_1) 11 | # converte para string para poder iterar da mesma maneira novamente(caso não tenha apenas 1 digito) 12 | for j in n2: 13 | total_2 += int(j) 14 | n2 = str(total_2) 15 | if len(n1) == 1 and len(n2) == 1: # só vai parar de iterar qnd tiver apenas 1 digito em cada 1 dos inputs 16 | break 17 | if int(total_1) > int(total_2): 18 | print(1) 19 | elif int(total_2) > int(total_1): 20 | print(2) 21 | else: 22 | print(0) -------------------------------------------------------------------------------- /1600- 1999/1873.py: -------------------------------------------------------------------------------- 1 | def raj_win(i, j): 2 | if i == "tesoura": 3 | if j == "papel" or j == "lagarto": 4 | return True 5 | elif i == "papel": 6 | if j == "pedra" or j == "spock": 7 | return True 8 | elif i == "pedra": 9 | if j == "tesoura" or j == "lagarto": 10 | return True 11 | elif i == "lagarto": 12 | if j == "spock" or j == "papel": 13 | return True 14 | else: 15 | if j == "tesoura" or j == "pedra": 16 | return True 17 | loops = int(input()) 18 | for i in range(loops): 19 | data = input().split() 20 | raj = data[0].lower() 21 | shel = data[1].lower() 22 | if raj == shel: 23 | print("empate") 24 | elif raj_win(raj, shel): 25 | print("rajesh") 26 | else: 27 | print("sheldon") 28 | -------------------------------------------------------------------------------- /2000- 3000/2674.py: -------------------------------------------------------------------------------- 1 | # Infelizmente sympy.isprime não funciona no site pois é um módulo de terceiros 2 | def is_prime(n): 3 | if n in range(0, 2): 4 | return False 5 | for i in range(2, int(n ** 0.5) + 1): 6 | if n % i == 0: 7 | return False 8 | return True 9 | 10 | 11 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 12 | while True: 13 | try: 14 | data = input() 15 | except EOFError: 16 | break 17 | if is_prime(int(data)): 18 | for j in data: 19 | if j not in "2357": 20 | # usando esse método é melhor que chamar a função de novo(funciona pois só tem apenas 1 digito) 21 | print("Primo") 22 | break 23 | else: 24 | print("Super") 25 | else: 26 | print("Nada") -------------------------------------------------------------------------------- /1400- 1599/1557.py: -------------------------------------------------------------------------------- 1 | # convertido da resposta de Matheus Glauber 2 | while True: 3 | matriz = [] 4 | col = 0 5 | qtd = int(input()) 6 | if qtd == 0: 7 | break 8 | elif qtd > 1: 9 | valor = 1 10 | for i in range(qtd): 11 | linha = [] 12 | for l in range(qtd): 13 | linha.append(valor) 14 | valor *= 2 15 | matriz.append(linha) 16 | valor = matriz[col][1] 17 | col += 1 18 | tamanho = len(str(matriz[-1][-1])) 19 | if qtd == 1: 20 | print(qtd) 21 | else: 22 | for linha in matriz: 23 | for elemento in range(qtd): 24 | if elemento < qtd - 1: 25 | print('{:{}}'.format(linha[elemento], tamanho), end=' ') 26 | else: 27 | print('{:{}}'.format(linha[elemento], tamanho)) 28 | print() -------------------------------------------------------------------------------- /1201- 1299/1253.py: -------------------------------------------------------------------------------- 1 | # Entrada 2 | loops = int(input()) # Qnt de iterações 3 | for j in range(loops): 4 | texto = input() # Todos os testes são maiusculos portanto não preciso converter usando upper() 5 | codigo = int(input()) # A quantidade a ser movida 6 | palavra = "" 7 | # Processo 8 | if codigo == 0: # Se for zero não terá modificações na palavra 9 | palavra += texto # E retornará igual 10 | else: 11 | for i in texto: 12 | hop = ord(i) - codigo # Pega o cod e checa o valor do símbolo covertido em ascii 13 | if hop < ord("A"): # Se não corresponder à um símbolo dentro do alfabeto maiúsculo, vai entrar aqui 14 | hop += 26 # E dar a volta para correponder a uma letra correta seguindo as regras do exercício 15 | palavra += chr(hop) # adiciona à variável palavra as letras convertidas seguindo o código ascii 16 | # Saída 17 | print(palavra) 18 | -------------------------------------------------------------------------------- /1001- 1100/1049.py: -------------------------------------------------------------------------------- 1 | # Com toda a certeza tem maneiras mais eficientes de fazer esse código 2 | osso = input()[0] # coloquei o index em todos os inputs pra não precisar digitar tudo 3 | if osso == "v": 4 | classe = input()[0] 5 | if classe == "a": 6 | comida = input()[0] 7 | if comida == "c": 8 | print("aguia") 9 | else: 10 | print("pomba") 11 | else: 12 | comida = input()[0] 13 | if comida == "o": 14 | print("homem") 15 | else: 16 | print("vaca") 17 | else: 18 | classe = input()[0] 19 | if classe == "i": 20 | comida = input()[2] 21 | if comida == "m": 22 | print("pulga") 23 | else: 24 | print("lagarta") 25 | else: 26 | comida = input()[0] 27 | if comida == "h": 28 | print("sanguessuga") 29 | else: 30 | print("minhoca") 31 | -------------------------------------------------------------------------------- /2000- 3000/2310.py: -------------------------------------------------------------------------------- 1 | # O a adicional nas variaveis representa os acertos, é nescessário saber o total e os acertos para calcular a % 2 | loops = int(input()) 3 | totals = 0 4 | totalb = 0 5 | totala = 0 6 | totalsa = 0 7 | totalba = 0 8 | totalaa = 0 9 | for i in range(loops): 10 | nome = input() 11 | data = input().split() 12 | saque, block, attack = int(data[0]), int(data[1]), int(data[2]) 13 | data2 = input().split() 14 | saquea, blocka, attacka = int(data2[0]), int(data2[1]), int(data2[2]) 15 | totals += saque 16 | totalb += block 17 | totala += attack 18 | totalsa += saquea 19 | totalba += blocka 20 | totalaa += attacka 21 | print("Pontos de Saque:", format(totalsa / totals * 100, ".2f"), "%.") # format(valor, ".2f) arredonda em 2 casas dec 22 | print("Pontos de Bloqueio:", format(totalba / totalb * 100, ".2f"), "%.") 23 | print("Pontos de Ataque:", format(totalaa / totala * 100, ".2f"), "%.") 24 | -------------------------------------------------------------------------------- /1600- 1999/1848.py: -------------------------------------------------------------------------------- 1 | # Converte os símbolos para decimal 2 | valores = {"---": 0, "--*": 1, "-*-": 2, "*--": 4, "-**": 3, "*-*": 5, 3 | "**-": 6, "***": 7} 4 | count = 0 5 | while count != 3: # Cada caw caw aumenta o valor em 1 e para no terceiro 6 | total = [] # Acumula todos os valores 7 | while True: 8 | data = input() 9 | total.append(data) 10 | if data == "caw caw": 11 | count += 1 12 | break 13 | # O caw caw também sempre entra na lista então se tiver 2 caw caw consecutivos vai entrar aqui e o valor será 0 14 | if len(set(total)) == 1: 15 | print(0) 16 | else: 17 | final = [] 18 | # Sempre terá 1 caw caw no fim da lista então ele tem que ser removido 19 | total.remove("caw caw") 20 | for i in total: 21 | final.append(valores[i]) # junta os valores convertidos dos símbolos em uma lista 22 | print(sum(final)) # Soma todos os valores da lista -------------------------------------------------------------------------------- /1101- 1200/1179.py: -------------------------------------------------------------------------------- 1 | # Não acredito que seja a forma mais eficiente de fazer isso, pois tem muitas iterações 2 | par = [] 3 | impar = [] 4 | for i in range(15): 5 | valor = int(input()) 6 | if valor % 2 == 0: 7 | par.append(valor) 8 | else: 9 | impar.append(valor) 10 | 11 | if len(par) == 5: 12 | posicao = 0 13 | for j in par: 14 | print("par[{}] = {}".format(posicao, j)) 15 | posicao += 1 16 | par = [] 17 | if len(impar) == 5: 18 | posicao = 0 19 | for k in impar: 20 | print("impar[{}] = {}".format(posicao, k)) 21 | posicao += 1 22 | impar = [] 23 | 24 | if len(impar) > 0: 25 | posicao = 0 26 | for l in impar: 27 | print("impar[{}] = {}".format(posicao, l)) 28 | posicao += 1 29 | 30 | if len(par) > 0: 31 | posicao = 0 32 | for m in par: 33 | print("par[{}] = {}".format(posicao, m)) 34 | posicao += 1 -------------------------------------------------------------------------------- /1201- 1299/1234.py: -------------------------------------------------------------------------------- 1 | while True: 2 | try: 3 | s = input() 4 | except EOFError: # Tive que incluir isso pois o site tava dando esse erro 5 | break 6 | p = 0 7 | for c in s: # Itera pela frase, cada loop é um letra(ou espaço) 8 | if c == ' ': 9 | print(c, end="") # Se for um espaço não afeta a intercalação entre maiúscula e minúscula 10 | elif p == 0: # Começa como maíuscula e intercala a cada letra(não considerando os espaços) 11 | print(c.upper(), end="") # Converte a letra pra maiúscula e junta tudo na mesma linha 12 | p += 1 # Muda o valor de p, fazendo intercalar entre as condições de if e else 13 | else: 14 | print(c.lower(), end="") # Converte a letra pra minúscula e junta todos os prints na mesma linha 15 | p -= 1 # Muda o valor de p, fazendo intercalar entre as condições de if e else 16 | print() # Tive que adicionar o espaço final pois estava dando erro 17 | -------------------------------------------------------------------------------- /2000- 3000/2630.py: -------------------------------------------------------------------------------- 1 | import math 2 | loops = int(input()) 3 | caso = 0 4 | for i in range(loops): 5 | tipo = input() 6 | data = input().split() 7 | caso += 1 8 | if tipo == "min": 9 | # tranforma os valores em int, põe em uma lista e pega o menor 10 | print("Caso #{}:".format(caso), min(map(int, data))) 11 | elif tipo == "mean": 12 | # tranforma os val em int, põe em uma lista e pega a média arrendondando o valor para baixo 13 | print("Caso #{}:".format(caso), math.floor(sum(map(int, data)) // 3)) # talvez math.floor n fosse preciso aqui 14 | elif tipo == "max": 15 | # tranforma os valores em int, põe em uma lista e pega o maior 16 | print("Caso #{}:".format(caso), max(map(int, data))) 17 | else: 18 | # tranforma os val em int, põe em uma lista faz a fórmula do enunciado arrendondando o valor para baixo 19 | print("Caso #{}:".format(caso), math.floor((int(data[0]) * 0.3 + int(data[1]) * 0.59 + int(data[2]) * 0.11))) -------------------------------------------------------------------------------- /2000- 3000/2690.py: -------------------------------------------------------------------------------- 1 | # retorna o valor correspondente na tabela do enunciado e só retorna os primeiros 12 números 2 | loops = int(input()) 3 | for i in range(loops): 4 | final = "" 5 | data = input() 6 | for j in data: 7 | if j in ["G", "Q", "a", "k", "u"]: 8 | final += "0" 9 | elif j in ["I", "S", "b", "l", "v"]: 10 | final += "1" 11 | elif j in ["E", "O", "Y", "c", "m", "w"]: 12 | final += "2" 13 | elif j in ["F", "P", "Z", "d", "n", "x"]: 14 | final += "3" 15 | elif j in ["J", "T", "e", "o", "y"]: 16 | final += "4" 17 | elif j in ["D", "N", "X", "f", "p", "z"]: 18 | final += "5" 19 | elif j in ["A", "K", "U", "g", "q"]: 20 | final += "6" 21 | elif j in ["C", "M", "W", "h", "r"]: 22 | final += "7" 23 | elif j in ["B", "L", "V", "i", "s"]: 24 | final += "8" 25 | elif j in ["H", "R", "j", "t"]: 26 | final += "9" 27 | print(final[:12]) -------------------------------------------------------------------------------- /1201- 1299/1249.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é um arquivo final ou valor EOF use esse método 2 | while True: 3 | try: 4 | data = input() 5 | except EOFError: 6 | break 7 | final = "" 8 | for i in data: 9 | if i.isalpha(): # se for uma letra entra aqui 10 | character = ord(i) + 13 # ord retorna o código numérico ASCII de um simbolo 11 | if i.isupper(): # Se a letra for maiúscula entra qui 12 | if character > 90: # Se sair do alfabeto maiúsculo ASCII... 13 | character -= 26 # ...vai dar a volta e entrar de novo no alfabeto 14 | final += chr(character) # chr retorna o símbolo equivalente a um código numérico de acordo com ASCII 15 | else: # Faz a mesma coisa que antes só q agora com as minúsculas 16 | if character > 122: 17 | character -= 26 18 | final += chr(character) 19 | else: # Se for um símbolo ou número não ocorre alterações 20 | final += i 21 | print(final) -------------------------------------------------------------------------------- /1101- 1200/1124.py: -------------------------------------------------------------------------------- 1 | def f(l1, l2, r1, r2): 2 | # Processo 3 | dx = l1 - r1 - r2 4 | dy = l2 - r1 - r2 5 | if dx < 0 or dy < 0: 6 | return False # Se a soma dos raios for maior que um dos lados retorna falso, elimina vários casos 7 | return dx * dx + dy * dy >= (r1 + r2) * (r1 + r2) and min(l1, l2) >= 2 * max(r1, r2) 8 | # Valor bool, se couber volta True se não couber volta False 9 | 10 | 11 | def main(): 12 | while True: 13 | # Entrada 14 | data = input().split() # recebe o valor e separa 15 | l1 = int(data[0]) 16 | l2 = int(data[1]) 17 | r1 = int(data[2]) 18 | r2 = int(data[3]) 19 | if not (l1 + l2 + r1 + r2) > 0: # Se todos os valores forem 0, o programa fecha(seguindo as instruções) 20 | break 21 | # Saída 22 | if f(l1, l2, r1, r2): # Chama e retorna o valor da função anterior, se for True entra aqui e imprime S 23 | print("S") 24 | else: # Se for False entra aqui 25 | print("N") 26 | return 0 27 | 28 | 29 | main() # Chama e retorna o valor da função main 30 | 31 | -------------------------------------------------------------------------------- /1400- 1599/1435.py: -------------------------------------------------------------------------------- 1 | while True: 2 | data = int(input()) 3 | if data == 0: 4 | break 5 | matriz_final = [] 6 | for i in range(data): 7 | um = [] 8 | for j in range(data): 9 | um.append(1) 10 | matriz_final.append(um) 11 | valor = 1 12 | topo = 0 13 | lado1 = 0 14 | bot = data - 1 15 | lado2 = data - 1 16 | if data % 2 == 0: 17 | meio = data / 2 18 | else: 19 | meio = data + 1 / 2 20 | while valor <= meio: 21 | i = lado1 22 | while i <= lado2: 23 | matriz_final[topo][i] = valor 24 | matriz_final[bot][i] = valor 25 | i += 1 26 | i = (topo + 1) 27 | while i < bot: 28 | matriz_final[i][lado1] = valor 29 | matriz_final[i][lado2] = valor 30 | i += 1 31 | valor += 1 32 | topo += 1 33 | bot -= 1 34 | lado1 += 1 35 | lado2 -= 1 36 | for i in range(data): 37 | tx = '' 38 | for j in range(data): 39 | if j == data - 1: 40 | # essa linha da muito trabalho quanto a PE no site(n use format() nesse caso) 41 | tx += " %3d".format(matriz_final[i][j]) 42 | print(tx[1:]) 43 | print() -------------------------------------------------------------------------------- /1400- 1599/1536.py: -------------------------------------------------------------------------------- 1 | # é o mais eficiente do site em python, eu elimino a maioria dos casos nas 2 primeiras condições aumentando a eficiencia 2 | # Mesmo assim, não é um código bom para leitura pois as vaiáveis podem confundir 3 | for i in range(int(input())): 4 | """ 5 | Recebe o input, remove o x (que entraria na lista causando um erro)converte para 6 | int põe em uma lista e depois atribui os valores às variaveis""" 7 | time1_casa, time2_visitante = list(map(int, input().replace("x", "").split())) 8 | time2_casa, time1_visitante = list(map(int, input().replace("x", "").split())) 9 | if time1_casa > time2_visitante and time1_visitante > time2_casa: 10 | print("Time 1") 11 | elif time2_casa > time1_visitante and time2_visitante > time1_casa: 12 | print("Time 2") 13 | else: 14 | # essa variável reduz a necessidade de várias outras condições que deixariam o código mais devagar 15 | saldo = time1_casa + time1_visitante - time2_visitante - time2_casa 16 | if saldo > 0: 17 | print("Time 1") 18 | elif saldo < 0: 19 | print("Time 2") 20 | elif time1_visitante > time2_visitante: 21 | print("Time 1") 22 | elif time2_visitante > time1_visitante: 23 | print("Time 2") 24 | else: 25 | print("Penaltis") -------------------------------------------------------------------------------- /1001- 1100/1024.py: -------------------------------------------------------------------------------- 1 | # Entrada 2 | loops = int(input()) # Recebe o número de mensagens que o programa vai receber 3 | for l in range(loops): # Faz iteração por determinado número de vezes(o número que estiver no loops) 4 | palavra = input() # Recebe a mensagem a ser criptografada 5 | palavra1 = "" # Armazena em uma variável a mensagem depois de primeira etapa da criptografia 6 | # Processo 7 | for letter in palavra: # Itera a entrada inicial (cada iteração é uma letra) 8 | if letter.isalpha(): # Se for letra vai ser True(se não for letra vai ser false) 9 | palavra1 += chr(ord(letter) + 3) # chr(ord(letter), identifica o valor ASCII da letra e retorna 3 a frente 10 | else: 11 | palavra1 += letter # Se for símbolo ou número irá se manter nessa etapa 12 | palavra_inversa = palavra1[::-1] # [::-1] Inverte a palavra concluindo a primeira etapa da criptografia 13 | metade_truncada = len(palavra1) // 2 # Identifica quando chega na metade truncada da palavra 14 | palavra_final = palavra_inversa[:metade_truncada] # Pega o início até a metade da palavra q deve permanecer igual 15 | for letter in palavra_inversa[metade_truncada:]: # Pega da metade até o final para modificar 16 | palavra_final += chr(ord(letter) - 1) # chr(ord(letter), ident o val ASCII do simb/letra e passa ele 1 pra tras 17 | # Saída 18 | print(palavra_final) # imprime o valor final 19 | -------------------------------------------------------------------------------- /1101- 1200/1189.py: -------------------------------------------------------------------------------- 1 | soma_media = input() 2 | total = 0 3 | fora = 12 4 | dentro = 0 5 | numeros = 0 6 | flag = False 7 | inicial_fora = fora 8 | inicial_dentro = dentro 9 | for i in range(144): 10 | data = float(input()) 11 | if flag is False: 12 | if inicial_fora + inicial_dentro == 0: 13 | fora -= 1 14 | dentro += 1 15 | inicial_fora = fora 16 | inicial_dentro = dentro 17 | if inicial_dentro > 0: 18 | if inicial_dentro == 6: 19 | flag = True 20 | inicial_fora += 1 21 | inicial_dentro -= 1 22 | fora += 1 23 | dentro -= 1 24 | inicial_dentro -= 1 25 | total += data 26 | numeros += 1 27 | continue 28 | if inicial_fora > 0: 29 | inicial_fora -= 1 30 | continue 31 | else: 32 | if inicial_fora + inicial_dentro == 0: 33 | fora += 1 34 | dentro -= 1 35 | inicial_fora = fora 36 | inicial_dentro = dentro 37 | if inicial_dentro > 0: 38 | inicial_dentro -= 1 39 | total += data 40 | numeros += 1 41 | continue 42 | if inicial_fora > 0: 43 | inicial_fora -= 1 44 | continue 45 | 46 | if soma_media == 'S': 47 | print(format(total, ".1f")) 48 | else: 49 | print(format((total / numeros), ".1f")) -------------------------------------------------------------------------------- /2000- 3000/2253.py: -------------------------------------------------------------------------------- 1 | # Smp q tiver 1 exercício q diz q o último valor é valor vazio(n confundir com 0 ou "") ou valor EOF use esse método 2 | while True: 3 | try: 4 | senha = input() 5 | except EOFError: 6 | break 7 | if len(senha) not in range(6, 33): # Eliminando casos erroneos(deixa o programa mais rápido) 8 | print("Senha invalida.") 9 | else: 10 | maiuscula = 0 11 | minuscula = 0 12 | numeral = 0 13 | for i in senha: # Pega letra por letra (não é um método mto eficiente, mas faz o trabalho) 14 | if i.isupper(): # Se for maiúscula entra aqui e acrescenta a quantidade na variável 15 | maiuscula += 1 16 | elif i.islower(): # Se for minúscula entra aqui e acrescenta a quantidade na variável 17 | minuscula += 1 18 | elif i.isdecimal(): # Se for numeral entra aqui e acrescenta a quantidade na variável 19 | numeral += 1 20 | else: # for um espaço ou símbolo entre aqui e fecha 21 | print("Senha invalida.") 22 | break 23 | else: # Se o loop não for quebrado pelo break entra aqui(método exclusivo do python for - else) 24 | if minuscula == 0 or maiuscula == 0 or numeral == 0: # se não ter tds desses tipos na senha ela é inválida 25 | print("Senha invalida.") 26 | else: # Se cumpriu com todos os requesitos, entra aqui 27 | print("Senha valida.") 28 | -------------------------------------------------------------------------------- /1001- 1100/1022.py: -------------------------------------------------------------------------------- 1 | def main(): 2 | n = int(input()) 3 | for x in range(0, n): 4 | line = str(input("")) 5 | split = line.split(" ") 6 | n1 = int(split[0]) 7 | d1 = int(split[2]) 8 | op = split[3] 9 | n2 = int(split[4]) 10 | d2 = int(split[6]) 11 | 12 | if op == '+': 13 | n3 = (n1*d2 + n2*d1) 14 | d3 = (d1*d2) 15 | mdc = int(euclides(max(n3, d3), min(n3, d3))) 16 | print(str(n3) + "/" + str(d3) + " = " + str(int(n3/mdc)) + "/" + str(int(d3/mdc))) 17 | elif op == '-': 18 | n3 = (n1*d2 - n2*d1) 19 | d3 = (d1*d2) 20 | mdc = abs(int(euclides(max(n3, d3), min(n3, d3)))) 21 | print(str(n3) + "/" + str(d3) + " = " + str(int(n3/mdc)) + "/" + str(int(d3/mdc))) 22 | elif op == '*': 23 | n3 = (n1*n2) 24 | d3 = (d1*d2) 25 | mdc = int(euclides(max(n3, d3), min(n3, d3))) 26 | print(str(n3) + "/" + str(d3) + " = " + str(int(n3/mdc)) + "/" + str(int(d3/mdc))) 27 | elif op == '/': 28 | n3 = (n1*d2) 29 | d3 = (n2*d1) 30 | mdc = int(euclides(max(n3, d3), min(n3, d3))) 31 | print(str(n3) + "/" + str(d3) + " = " + str(int(n3/mdc)) + "/" + str(int(d3/mdc))) 32 | 33 | 34 | def euclides(x, y): 35 | r = x % y 36 | if r == 0: 37 | return y 38 | else: 39 | return euclides(y, r) 40 | 41 | 42 | if __name__ == "__main__": 43 | main() 44 | -------------------------------------------------------------------------------- /1101- 1200/1190.py: -------------------------------------------------------------------------------- 1 | soma_media = input() 2 | total = 0 3 | fora = 10 4 | dentro = 1 5 | numeros = 0 6 | flag = False 7 | inicial_fora = fora 8 | inicial_dentro = dentro 9 | for i in range(144): 10 | data = float(input()) 11 | if i < 23: 12 | continue 13 | if flag is False: 14 | if inicial_fora + inicial_dentro == 0: 15 | fora -= 1 16 | dentro += 1 17 | inicial_fora = fora 18 | inicial_dentro = dentro 19 | if inicial_dentro > 0: 20 | if inicial_dentro == 5: 21 | flag = True 22 | fora = 7 23 | dentro = 5 24 | inicial_fora = fora 25 | inicial_dentro -= 1 26 | total += data 27 | numeros += 1 28 | continue 29 | if inicial_fora > 0: 30 | inicial_fora -= 1 31 | continue 32 | else: 33 | if inicial_fora + inicial_dentro == 0: 34 | fora += 1 35 | dentro -= 1 36 | if i == 79: 37 | dentro = 5 38 | inicial_fora = fora 39 | inicial_dentro = dentro 40 | if inicial_dentro > 0: 41 | inicial_dentro -= 1 42 | total += data 43 | numeros += 1 44 | continue 45 | if inicial_fora > 0: 46 | inicial_fora -= 1 47 | continue 48 | 49 | if soma_media == 'S': 50 | print(format(total, ".1f")) 51 | else: 52 | print(format((total / numeros), ".1f")) -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | *.egg-info/ 24 | .installed.cfg 25 | *.egg 26 | 27 | # PyInstaller 28 | # Usually these files are written by a python script from a template 29 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 30 | *.manifest 31 | *.spec 32 | 33 | # Installer logs 34 | pip-log.txt 35 | pip-delete-this-directory.txt 36 | 37 | # Unit test / coverage reports 38 | htmlcov/ 39 | .tox/ 40 | .coverage 41 | .coverage.* 42 | .cache 43 | nosetests.xml 44 | coverage.xml 45 | *.cover 46 | .hypothesis/ 47 | 48 | # Translations 49 | *.mo 50 | *.pot 51 | 52 | # Django stuff: 53 | *.log 54 | local_settings.py 55 | 56 | # Flask stuff: 57 | instance/ 58 | .webassets-cache 59 | 60 | # Scrapy stuff: 61 | .scrapy 62 | 63 | # Sphinx documentation 64 | docs/_build/ 65 | 66 | # PyBuilder 67 | target/ 68 | 69 | # Jupyter Notebook 70 | .ipynb_checkpoints 71 | 72 | # pyenv 73 | .python-version 74 | 75 | # celery beat schedule file 76 | celerybeat-schedule 77 | 78 | # SageMath parsed files 79 | *.sage.py 80 | 81 | # Environments 82 | .env 83 | .venv 84 | env/ 85 | venv/ 86 | ENV/ 87 | 88 | # Spyder project settings 89 | .spyderproject 90 | .spyproject 91 | 92 | # Rope project settings 93 | .ropeproject 94 | 95 | # mkdocs documentation 96 | /site 97 | 98 | # mypy 99 | .mypy_cache/ 100 | -------------------------------------------------------------------------------- /1101- 1200/1193.py: -------------------------------------------------------------------------------- 1 | t = int(input()) # Pega o número de casos - teste 2 | case = 1 # Apenas para apresentação 3 | for i in range(t): # Itera por uma quantidade de vezes determinada pelo input t 4 | numeros = input().split() # Pega os casos - teste e os separa em números e tipo 5 | numero = numeros[0] # Pega o número a ser convertido 6 | tipo = numeros[1] # Pega o tipo do número a ser convertido 7 | print("Case " + str(case) + ":") # Imprime qual é o case 8 | if tipo == "dec": # Se o tipo for decimal entra aqui 9 | print("{:x} hex".format(int(numero))) # Pega 1 n int e volta como str o val hex desse número decimal usando{:x} 10 | print("{:b} bin".format(int(numero))) # Pega 1 n int e volta como str o val bin desse número decimal usando{:b} 11 | case += 1 # Quando terminar adiciona 1 apenas para apresentação 12 | print() # Pula uma linha apenas para apresentação 13 | elif tipo == "bin": # Se o tipo for binário entra aqui 14 | dec = int(numero, 2) # Pega o numero binário e converte para decimal usando esse método 15 | print(dec, "dec") # Imprime o valor decimal desse binário 16 | print("{:x} hex".format(dec)) # Pega 1 n int e volta o val hex desse num dec(convertido anteriormente)usando{:x} 17 | case += 1 # Quando terminar adiciona 1 apenas para apresentação 18 | print() # Pula uma linha apenas para apresentação 19 | else: # Se o tipo for hexadecimal entra aqui 20 | dec = int(numero, 16) # Pega o numero hexadecimal e converte para decimal usando esse método 21 | print(dec, "dec") # Imprime o valor decimal desse hexadecimal 22 | print("{:b} bin".format(dec)) # Pega 1 n int e volta o val bin desse n dec(convertido anteriormente)usando{:b} 23 | case += 1 # Quando terminar adiciona 1 apenas para apresentação 24 | print() # Pula uma linha apenas para apresentação 25 | --------------------------------------------------------------------------------