Il est facile de voir que le bouton A N </ sub> est enfoncé dans l'ordre inverse du bouton A 1 </ sub>. A i </ sub> est B i < Un multiple de / sub> signifie A i </ sub> mod B i </ sub> = 0, donc A i </ sub> mod B Lorsque i </ sub> n'est pas 0, appuyez sur B i </ sub> --A i </ sub> mod B i </ sub> fois. Au fait, d'ici là Notez que A i </ sub> augmente du nombre de fois que vous appuyez dessus. Sur la base de ce qui précède, j'ai écrit le code suivant pour demander une réponse.
N = int(input())
A = [None] * N
B = [None] * N
for i in range(N):
A[i], B[i] = map(int, input().split())
result = 0
for i in range(N - 1, -1, -1):
t = (A[i] + result) % B[i]
if t != 0:
result += B[i] - t
print(result)
Le bus part lorsque la limite de temps de la première personne qui attend arrive maintenant ou que la personne qui attend devient des personnes C. Donc, mettez la limite de temps de la première personne et le nombre actuel de personnes en attente dans les variables. Il suffit de tourner la boucle. Notez que le temps T i </ sub> n'augmente pas de façon monotone, même s'il s'agit du i-ème passager.
N, C, K = map(int, input().split())
T = [int(input()) for _ in range(N)]
T.sort()
c = 0
l = float('inf')
result = 0
for i in range(N):
t = T[i]
if t > l:
result += 1
l = float('inf')
c = 0
if c == 0:
l = t + K
c += 1
if c == C:
result += 1
l = float('inf')
c = 0
if c != 0:
result += 1
print(result)
C'est facile pour les humains à faire à la main, mais je gémissais que c'était ennuyeux à mettre en œuvre, mais j'ai juste oublié que je ne pouvais aller que vers la droite (rires). La priorité est donnée à celui avec le but à droite. Si vous ne pouvez pas le déplacer, déplacez l'autre, et si vous ne pouvez pas déplacer les deux, affichez Non, c'est tout.
N, A, B, C, D = map(int, input().split())
S = input()
def move_snuke():
global A, B
if B == D:
return False
if S[B + 1] == '.' and A != B + 1:
B += 1
return True
if S[B + 2] == '.' and A != B + 2:
B += 2
return True
return False
def move_fnuke():
global A, B
if A == C:
return False
if S[A + 1] == '.' and B != A + 1:
A += 1
return True
if S[A + 2] == '.' and B != A + 2:
A += 2
return True
return False
S = '#' + S
while True:
if C < D:
if not move_snuke():
if not move_fnuke():
print('No')
break
else:
if not move_fnuke():
if not move_snuke():
print('No')
break
if A == C and B == D:
print('Yes')
break
Si le premier est a et le second est b, le troisième est un xor b, le quatrième est a, le cinquième est b et seuls trois types de nombres apparaissent. Donc, a i < S'il y a 4 types ou plus de nombres / sub>, vous pouvez définir Non à ce stade. S'il y a 3 types, il n'y a que 9 types dans les 2 premiers et même si vous simulez toutes les combinaisons, N ≤ 10 5 </ sup > De au maximum O (9 × 10 5 </ sup>), AC est possible.
from itertools import product
N = int(input())
a = list(map(int, input().split()))
c = {}
for e in a:
c.setdefault(e, 0)
c[e] += 1
if len(set(c)) > 3:
print('No')
exit()
t = {}
for x, y in product(set(c), repeat=2):
i = x
j = y
t[i] = 1
if t[i] > c[i]:
continue
t.setdefault(j, 0)
t[j] += 1
if t[j] > c[j]:
continue
for _ in range(N - 2):
k = i ^ j
t.setdefault(k, 0)
t[k] += 1
c.setdefault(k, 0)
if t[k] > c[k]:
j = -1
break
i, j = j, k
if j ^ x == y:
print('Yes')
exit()
print('No')
Puisque L est divisible par N et M, il est un multiple du multiple commun minimum de N et M. Lorsque L / N * i == L / M * j, il doit être S [i] == T [j], Même si L devient L * a, la paire de i et j à comparer ne change pas car elle n'est multipliée par a que des deux côtés. Puisque la réponse est la plus courte, L est le multiple commun minimum de N et M. Devenir.
from fractions import gcd
def lcm(x, y):
return x // gcd(x, y) * y
N, M = map(int, input().split())
S = input()
T = input()
for i in range(N):
if M * i % N == 0 and S[i] != T[M * i // N]:
print(-1)
exit()
print(lcm(N, M))
Le prochain mot coloré est
Sera.
Après tout, il s'agit d'une chaîne de caractères d'une longueur maximale de 26, donc il n'y a aucun problème à l'ajouter ou à l'ajouter, donc la mise en œuvre n'est pas si difficile.
def next_diverse_word(s):
alphabets = set(chr(ord('a') + i) for i in range(26))
if s == 'zyxwvutsrqponmlkjihgfedcba':
return -1
r = alphabets - set(s)
if len(r) != 0:
return s + sorted(r)[0]
s = list(s)
r = [s[-1]]
s = s[:-1]
while True:
k = s[-1]
r.append(s[-1])
s = s[:-1]
t = [c for c in r if c > k]
if len(t) != 0:
s.append(sorted(t)[0])
return ''.join(s)
S = input()
print(next_diverse_word(S))
Recommended Posts