#python #maratona

maratona-2022.md

• Maratona 2022 - Resoluções
  • A - Medição Climática
  • B - Asteróides
  • C - Divisão
  • D - Expedição
  • E - Números primos
  • F - Jogo de Sinuca
  • H - Evento
  • I - Conversão de Bases
  • J - Sequência de bits

Maratona 2022 - Resoluções

A - Medição Climática

from functools import reduce

dias, porDia = map(lambda n: int(n), input().split())

medicoes = [None] * dias

for i in range(dias):
  medicoes[i] = list(map(lambda n: float(n), input().split()))

# print(medicoes)

def calcularMediaDeCadaDia(acc, cur):
  sum = reduce(lambda iacc, icur: iacc + icur, cur) / porDia
  acc.append(sum)
  return acc

mediaDeCadaDia = reduce(calcularMediaDeCadaDia, medicoes, [])
print("-Media das medicoes dos dias-")
for i, media in enumerate(mediaDeCadaDia):
  print("Dia " + str(i) + ": " + "{:.2f}".format(media))

def calcularMediaDeCadaMedicao(medicaoIndex):
  cadaMedicao = list(map(
    lambda diaIndex: medicoes[diaIndex][medicaoIndex],
    list(range(dias))
  ))
  mediaDeCadaMedicao = reduce(lambda acc, cur: acc + cur, cadaMedicao) / dias
  return mediaDeCadaMedicao

mediaDeCadaMedicao = list(map(calcularMediaDeCadaMedicao, list(range(porDia))))
print("-Media de cada medicao diaria -")
for i, media in enumerate(mediaDeCadaMedicao):
  print("Medicao " + str(i) + ": " + "{:.2f}".format(media))

B - Asteróides

# returns the index of the first element in an array that
# satisfies the provided testing function
def findIndex(l, fn, start = 0):
    for i, el in list(enumerate(l))[start:]:
        if fn(el):
            return i
    
    return -1

n = int(input()) # quantidade de asteroides
L = [ int(asteroide) for asteroide in input().split() ]

# acha o asteroide negativo mais perto do começo
fn = lambda start = 0: findIndex(L, lambda n: n < 0, start)

# seleciona asteroide negativo mais perto do começo
cur = fn() # current asteroide index

while cur != -1:

  # percorre os elementos anteriores ao curi da esquerda p/ direita
  while cur > 0:

    # asteroides negativos vão ficar no começo da lista; ao encontrar um
    # asteroide negativo, todos os asteroides anteriores são negativos
    if L[cur - 1] < 0:
      cur += 1
      break

    if abs(L[cur]) > L[cur - 1]:
      L[cur - 1] = L[cur]
      del L[cur]
      cur -= 1
    elif abs(L[cur]) < L[cur - 1]:
      del L[cur]
      # mantém valor de cur
      break
    else: # abs(L[cur]) == L[cur - i]
      del L[cur]
      del L[cur - 1]
      cur -= 1
      break

  cur = fn(cur)

for asteroide in L:
  print(asteroide)

C - Divisão

dividendo, divisor = [ int(n) for n in input().split() ]

i = 0
while (dividendo >= divisor):
  dividendo -= divisor
  i += 1

  if (dividendo >= divisor):
    print(dividendo)

print(dividendo)
print(i)

D - Expedição

from functools import reduce

total = int(input()) # quantidade de baús

# capacidade de cada baú
capacidades = [ int(capacidade) for capacidade in input().split() ]

# quantidade atual dentro de cada baú
quantidades = [ int(quantidade) for quantidade in input().split() ]

adicionais = int(input()) # fósseis a serem armazenados

# baús que faltam menos fósseis aparecem primeiro
baus = sorted(
  [
    {
      'capacidade': capacidades[i],
      'quantidade': quantidades[i]
    } for i in range(total)
  ],
  key=lambda t: t['capacidade'] - t['quantidade']
)

for bau in baus:
  if adicionais == 0:
    break

  espaco_vazio = bau['capacidade'] - bau['quantidade']

  if espaco_vazio == 0:
    continue

  if adicionais >= espaco_vazio:
    bau['quantidade'] += espaco_vazio
    adicionais -= espaco_vazio
  else: # adicionais < espaco_vazio
    bau['quantidade'] += adicionais
    adicionais = 0

baus_cheios = list(filter(
  lambda bau: bau['capacidade'] == bau['quantidade'], baus
  ))

print(len(baus_cheios))

E - Números primos

import math

# n prime number starting from x double
n, x = [ int(n) for n in input().split() ]
x *= 2

def isPrime(n):
  if n != 2 and n % 2 == 0:
    return False

  for i in range(3, int(math.sqrt(n) + 1), 2):
    if n % i == 0:
      return False

  return True

primes = []

while (len(primes) != n):
  if (isPrime(x)):
    primes.append(x)

  x += 1

for prime in primes:
  print(prime)

F - Jogo de Sinuca

n = int(input()) # quantidade de bolas p/ cada jogador
bolas = [ int(bola) for bola in input().split() ]
ultimo_jogador = input() # o jogador que encaçapou a bola 8

bolas_s = list(filter(lambda bola: bola < 8, bolas)) # bolas do jogador S
bolas_z = list(filter(lambda bola: bola > 8, bolas)) # bolas do jogador Z

if len(bolas_s) < n and len(bolas_z) < n:
    # caso falso, quer dizer que um ou ambos acertaram todas as bolas
    print('Z' if ultimo_jogador == 'S' else 'S')
elif len(bolas_s) == n and len(bolas_z) == n:
    print(ultimo_jogador)
elif len(bolas_s) == n:
    print('S')
else: # len(bolas_z) == n
    print('Z')

H - Evento

from math import ceil

n = int(input()) # quantidade de alunos

professores = ceil(n / 10)
total = n + professores
onibus = int(total / 44)
total -= onibus * 44
vans = ceil(total / 14)
disponiveis = 14 - (total % 14) # vagas disponíveis na última van
motoristas = onibus + vans

print('Onibus:', onibus)
print('Vans:', vans)
print('Vagas disponiveis:', disponiveis)
print('Motoristas:', motoristas)
print('Docentes:', professores)

I - Conversão de Bases

n = int(input())

binario = ""

while (n != 1):
  if n % 2 == 0:
    binario += "0"
  else:
    binario += "1"    
    n -= 1

  n /= 2

binario += "1";

print(binario[::-1])

J - Sequência de bits

# inputs = input().split()
# binario = inputs[0]
# deslocamento, quantidade = list(map(lambda n: int(n), inputs[1::]))
#
# equivalent to:
binario, deslocamento, quantidade = [
  inp if i == 0 else int(inp)
  for i, inp in enumerate(input().split())
]

binario = binario.rjust(8, "0")

if (deslocamento == 0):
  binario = binario.ljust(8 + quantidade, "0")[quantidade::]
else:
  binario = binario.rjust(8 + quantidade, "0")[:-quantidade:]

for letra in binario:
  print(letra)