Ceci est un article de synthèse pour les débutants des professionnels de la compétition.
La solution que j'écris ici est écrite en regardant les commentaires et les soumissions d'autres personnes. Ce n'est peut-être pas ce que vous avez réellement soumis.
La question est de répondre s'il y a deux nombres égaux sur les trois nombres donnés.
Vous pouvez simplement les comparer. Ce problème peut être reformulé comme étant demandé "Y a-t-il deux types d'éléments?" Il semble pratique d'utiliser un objet de type set pour supprimer les éléments en double dans un tableau.
A = list(map(int, input().split()))
if len(set(A)) == 2:
print('Yes')
else: print('No')
La question est de savoir si les éléments d'un tableau donné remplissent la condition que «si pair, il est divisible par 3 ou 5».
Examinez tous les éléments et rejetez s'ils sont pairs mais non divisibles par l'un ou l'autre.
N = int(input())
A = list(map(int, input().split()))
for a in A:
if a%2 == 0 and not (a%3 == 0 or a%5 == 0):
print('DENIED')
break
else:
print('APPROVED')
Étant donné que plusieurs chaînes de caractères sont données, il est difficile de sortir la chaîne de caractères avec le plus grand nombre d'occurrences (si le nombre est le même, le tout dans l'ordre du dictionnaire).
Stockez la chaîne de caractères dans un tableau. Agréger en utilisant collections.Counter. Prenez la valeur maximale avec max () et mettez uniquement la chaîne de caractères avec le nombre maximum d'occurrences dans un tableau. J'ai réorganisé cela avec sorted () et l'ai sorti.
import collections
N = int(input())
S = [input() for _ in range(N)]
count = collections.Counter(S)
maxV = max(count.values())
c = [k for k, v in count.items() if v == maxV]
print('\n'.join(sorted(c)))
Lorsque tous les produits de paires constitués d'un tableau donné sont classés dans l'ordre, la question est de savoir quelle est la K-ième plus petite valeur.
Je ne sais pas. J'ai abandonné. Reportez-vous à d'autres réponses.
Le code suivant est écrit pour vous faciliter la compréhension, faisant référence à la plupart des autres réponses. J'ai expliqué autant que possible dans les commentaires, mais honnêtement, il y a de nombreuses parties que je ne comprends pas bien. Je ne sais pas si le commentaire est correct (en particulier la partie avec?).
import numpy as np
N, K = map(int, input().split())
A = np.array(list(map(int, input().split())))
A = np.sort(A)
G = A[A > 0]
Z = A[A == 0]
L = A[A < 0]
l, r = 10**18, -10**18
while l-r > 1:
#Cochez "le nombre de paires dont le produit est inférieur ou égal à m".
m = (l+r) // 2
# A[A > 0]Nombre d'articles qui remplissent les conditions?
Pk = np.searchsorted(A, m//G, side="right").sum()
# A[A < 0]Nombre d'articles qui remplissent les conditions?
Nk = (N - np.searchsorted(A, (-m-1)//(-L), side="right")).sum()
# A[0]Nombre d'articles qui remplissent les conditions?
Zk = 0
if m >= 0:
Zk += len(Z) * N
#Le produit des mêmes éléments ne peut pas être sélectionné, donc réduisez-le si les conditions sont remplies.
duplicate = np.count_nonzero(A*A <= m)
#Faites correspondre le nombre d'éléments qui remplissent les conditions
k = Pk + Nk + Zk - duplicate
#Tous les éléments sont doublés. Supprimer les éléments en double
k //= 2
#Si le nombre d'éléments k qui satisfont à la condition est K ou plus, m est abaissé, et s'il est inférieur à K, m est élevé.
if k >= K:
l = m
else:
r = m
#Si l et r correspondent, m est déterminé de manière unique
print(l)
Je suis passé par là.
Je ne comprends pas du tout la partie suivante. Je me demandais pourquoi je pouvais trouver le numéro qui remplissait les conditions, mais j'ai abandonné.
# A[A > 0]Nombre d'articles qui remplissent les conditions?
Pk = np.searchsorted(A, m//G, side="right").sum()
# A[A < 0]Nombre d'articles qui remplissent les conditions?
Nk = (N - np.searchsorted(A, (-m-1)//(-L), side="right")).sum()
C'est un problème de réfléchir à la façon de payer l'argent pour que le «total du nombre de feuilles à sortir et du nombre de changements» soit le plus petit. Cependant, il n'y a que des billets de 10 $ ^ n $ en espèces dans ce monde.
Comptons par le bas. Si le nombre de feuilles à payer est de 5 ou moins, il est plus efficace de payer tel quel, et s'il est de 6 ou plus, il est plus efficace de passer au chiffre suivant et de recevoir la monnaie.
Mauvais garçon.py
N = list(map(int, input()))
N = N[::-1] + [0]
count = 0
for i, n in enumerate(N):
if n <= 5:
count += n
elif n > 5:
count += 10 - n
N[i+1] += 1
print(count)
C'est WA. Avec le code ci-dessus, il y a quelques omissions, par exemple, si vous voulez payer 95 $ yens, il est plus efficace de payer 100 $ yens et de recevoir la monnaie (6 cartes au total). À ce tarif, j'ai payé 105 $ pour un total de 7 cartes.
La condition ne se branche davantage que lorsque 5 est émis. Si le chiffre suivant est égal ou supérieur à 5, vous pouvez réduire le changement de un en remontant.
Celui qui est passé.py
N = list(map(int, input()))
N = N[::-1] + [0]
count = 0
for i, n in enumerate(N):
if n < 5:
count += n
elif n > 5:
count += 10 - n
N[i+1] += 1
elif n == 5:
if N[i+1] >= 5:
N[i+1] += 1
count += 5
print(count)
En regardant l'explication, la solution était différente.
Nous vérifierons le nombre de feuilles dans l'ordre du haut. Vous pouvez calculer le report en demandant le montant «quand vous payez exactement» et «quand vous en payez un de plus».
J'écrirai selon l'explication.py
N = list(map(int, input()))
m = 0 #Nombre minimum de feuilles
m_ = 1 #Sécurisez le nombre de feuilles au moment du report, en pensant toujours que n est un de plus
for n in N:
m, m_ = min(m + n, m_ + 10-n), min(m + (n+1), m_ + 10-(n+1))
print(m)
Est-ce simple d'écrire?
C'est tout pour cet article.
Recommended Posts