Expérience de sélection des débutants AtCoder (2e fois)

Expérience de sélection des débutants AtCoder (2e fois)

Le code dans AtCoder Beginners Selection Experience ne fonctionne plus dans Python 2, j'ai donc essayé de le résoudre à nouveau pour voir à quel point il s'était amélioré.

PracticeA - Welcome to AtCoder

8 minutes → 2 minutes La chaîne de caractères séparés par des espaces a été générée par%, mais elle a changé quand j'ai réalisé que si je la transmettais à une impression séparée par des virgules, elle serait séparée par des espaces.

a = int(raw_input())
b, c = [int(e) for e in raw_input().split()]
s = raw_input()
print "%d %s" % (a + b + c, s)

a = int(input())
b, c = map(int, input().split())
s = input()

print(a + b + c, s)

ABC086A - Product

2 minutes → 1 minute L'ordre impair et pair a été inversé.

a, b = [int(e) for e in raw_input().split()]
if a * b % 2 == 0:
  print 'Even'
else:
  print 'Odd'

a, b = map(int, input().split())

if a * b % 2 == 1:
    print('Odd')
else:
    print('Even')

ABC081A - Placing Marbles

4 minutes → 30 secondes Il semble que je ne savais pas compter à ce moment-là.

print len([c for c in raw_input() if c == '1'])

s = input()

print(s.count('1'))

ABC081B - Shift only

9 minutes → 3 minutes et demie. Lecture en une fois par open (0) .read (). La politique est très différente de traiter un par un et de répéter le contrôle pour voir si tous se cassent une fois.

n = int(raw_input())
a = [int(e) for e in raw_input().split()]
i = 0
while True:
  if any(e % 2 == 1 for e in a):
    break
  i += 1
  a = [e / 2 for e in a]
print i

N, *A = map(int, open(0).read().split())

result = float('inf')
for a in A:
    t = 0
    while a % 2 == 0:
        t += 1
        a //= 2
    result = min(result, t)
print(result)

ABC087B - Coins

4 minutes → 2 minutes Tournoi à la ronde, il n'y a pas de grande différence.

a = int(raw_input())
b = int(raw_input())
c = int(raw_input())
x = int(raw_input())
result = 0
for i in range(a + 1):
  for j in range(b + 1):
    for k in range(c + 1):
      if i * 500 + j * 100 + k * 50 == x:
        result += 1
print result

A, B, C, X = map(int, open(0).read().split())

result = 0
for a in range(A + 1):
    for b in range(B + 1):
        for c in range(C + 1):
            if X == 500 * a + 100 * b + 50 * c:
                result += 1
print(result)

ABC083B - Some Sums

6 minutes → 3 minutes La politique était différente, qu'il s'agisse de calculer la somme de chaque chiffre directement ou de la convertir en chaîne de caractères.

n, a, b = [int(e) for e in raw_input().split()]
result = 0
for i in range(1, n + 1):
  if a <= sum(int(e) for e in str(i)) <= b:
    result += i
print result

N, A, B = map(int, input().split())

result = 0
for i in range(1, N + 1):
    c = 0
    t = i
    while t != 0:
        c += t % 10
        t //= 10
    if A <= c <= B:
        result += i
print(result)

ABC088B - Card Game for Two

7 minutes → 1 minute et demie La politique est presque la même, mais il semble qu'il ne connaissait pas l'option inverse du tri à ce moment-là.

n = int(raw_input())
a = [int(e) for e in raw_input().split()]
a.sort()
a.reverse()
print sum(a[::2]) - sum(a[1::2])

N, *a = map(int, open(0).read().split())

a.sort(reverse=True)
print(sum(a[::2]) - sum(a[1::2]))

ABC085B - Kagami Mochi

3 minutes → 1 minute et demie, je m'en souviens.

n = int(raw_input())
d = [int(raw_input()) for i in range(n)]
print len(set(d))

N, *d = map(int, open(0).read().split())

print(len(set(d)))

ABC085C - Otoshidama

7 minutes → 3 minutes. Eh bien, c'est un tour de rôle, il n'y a donc pas de grande différence de politique. Seule l'utilisation de l'impression a changé.

import sys
n, y = [int(e) for e in raw_input().split()]
for i in range(n + 1):
  for j in range(n + 1 - i):
    k = n - i - j
    if 10000 * i + 5000 * j + 1000 * k == y:
      print "%d %d %d" % (i, j, k)
      sys.exit()
print "-1 -1 -1"

N, Y = map(int, input().split())

for i in range(N + 1):
    for j in range(N + 1 - i):
        k = N - i - j
        if 10000 * i + 5000 * j + 1000 * k == Y:
            print(i, j, k)
            exit()
print(-1, -1, -1)

ABC049C --Daydream

Environ 1 heure → 12 minutes. Je me suis souvenu que je devais le retourner. Cependant, a-t-il été vissé vers l'avant avec l'algorithme * O * (* N * 2 </ sup>) la dernière fois? La vitesse est passée de 1223 ms à 41 ms.

import sys
s = raw_input()
ts = ['']
while True:
  nts= []
  for t in ts:
    for w in ['dreamer', 'eraser', 'dream', 'erase']:
      if s == t + w:
        print 'YES'
        sys.exit()
      if s.startswith(t + w):
        nts.append(t + w)
  if len(nts) == 0:
    print 'NO'
    sys.exit()
  ts = nts

S = input()

S = S[::-1]
candidates = [s[::-1] for s in ['dream', 'dreamer', 'erase', 'eraser']]

i = 0
while i < len(S):
    for c in candidates:
        if S.startswith(c, i):
            i += len(c)
            break
    else:
        print('NO')
        exit()
print('YES')

ABC086C - Traveling

Environ 40 minutes → 8 minutes et demie. Je suis passé à IO tamponné, donc 337ms → 131ms. C'est presque la même chose, mais le code a beaucoup changé car il est différent que l'entrée soit traitée ensemble ou non au début.

import sys
n = int(raw_input())
data = [map(int, raw_input().split()) for i in range(n)]
t = 0
x = 0
y = 0
for d in data:
  duration = d[0] - t
  distance = abs(x - d[1]) + abs(y - d[2])
  if (distance > duration) or ((duration - distance) % 2 == 1):
    print 'No'
    sys.exit()
  t = d[0]
  x = d[1]
  y = d[2]
print 'Yes'

from sys import stdin
readline = stdin.readline

N = int(readline())

pt, px, py = 0, 0, 0
for _ in range(N):
    t, x, y = map(int, readline().split())
    d = abs(x - px) + abs(y - py)
    if d > t - pt:
        print('No')
        break
    if (t - pt - d) % 2 == 1:
        print('No')
        break
    pt, px, py = t, x, y
else:
    print('Yes')

Recommended Posts

Expérience de sélection des débutants AtCoder (2e fois)
Mémorandum de sélection pour débutants AtCoder
Réponse à la sélection des débutants d'AtCoder par Python3
[Exemple de réponse (python3)] ABS (AtCoder Beginners Selection) de atcoder