J'ai commencé AtCoder il y a juste une semaine, et à ce moment-là, j'ai essayé AtCoder Beginners Selection. Depuis que je suis nouveau dans la programmation compétitive, j'ai commencé par apprendre à taper. J'ai résumé les réponses et ce que j'ai pensé de moi.
PracticeA - Welcome to AtCoder
a = int(input())
b, c = map(int, input().split())
s = input()
print('{} {}'.format(a+b+c,s))
Tests liés aux entrées / sorties int(input()) map(int, input().split()) Plus tard, en résolvant d'autres concours, j'ai appris que j'utiliserais beaucoup ces deux-là.
ABC086A - Product
strings = ['Even','Odd']
a, b = map(int, input().split())
print(strings[(a*b)%2])
La question de répondre à une situation étrange.
ABC081A - Placing Marbles
#Placing Marbles
S = list(input())
print(S.count('1'))
Le problème de trouver le nombre de chiffres qui est 1 à partir de la valeur numérique d'entrée. Je l'ai entré sous forme de chaîne de caractères et j'ai jugé le nombre.
ABC081B - Shift only
#Shift only
import numpy as np
N = int(input())
A = np.array(list(map(int, input().split())))
count = 0
check = A%2
while np.count_nonzero(check)==0 :
count += 1
A = A/2
check = A%2
print(count)
La question de savoir combien de fois le tableau d'entrée est divisible par 2. Dans le tableau numpy, l'opérateur est appliqué à chaque élément, de sorte que l'entrée est reçue par numpy et répondue. Quand j'y pense maintenant, je ne pense pas avoir à me soucier de la vérification des variables ...
ABC087B - Coins
#Coins
A = int(input())
B = int(input())
C = int(input())
X = int(input())
count=0
for i in range(A+1):
yo = X-i*500
if(yo>=0):
for j in range(B+1):
yoi = yo-j*100
if(yoi>=0):
for k in range(C+1):
yoii = yoi-k*50
if(yoii==0):
count +=1
print(count)
Le nombre de combinaisons qui font X yens à partir de balles A 500 yens, B balles 100 yens et balles C 50 yens.
La politique de réponse est Une boucle de balle de 100 yens avec une balle de 500 yens fixée à 0 feuille. Dans la boucle de balle de 100 yens, il est fixé à 0 balles de 100 yens et une boucle de balle de 50 yens. Si X yen peut être généré avec C ou moins de 50 boules de yens, revenez à la boucle supérieure de 100 yens et utilisez une boule de 100 yens comme une ... Puisque l'instruction for est multiplexée, je voulais la rendre plus facile, mais c'était la limite.
ABC083B - Some Sums
#Some Sums
N, A, B = list(map(int, input().split()))
count = 0
for j in range(N):
S = str(j+1)
numN = 0
for i in range(len(S)):
numN += int(S[i])
if A <= numN <= B:
count += j+1
print(count)
La somme de tous les nombres entiers x où 1 <= x <= N et A <= somme de chaque chiffre <= B. J'ai changé le nombre en str, reçu chaque chiffre avec int et calculé la somme avec l'instruction for.
Réflexions Il n'était pas nécessaire qu'il s'agisse d'une liste car il reçoit 3 entrées dans 3 variables. J'ai pu calculer N à partir de 1 avec une plage (1, N + 1). J'ai pu utiliser la méthode de la somme (?)
ABC088B - Card Game for Two
#Card Game for Two
N = int(input())
a = sorted(map(int, input().split()))
count = 0
for i in range(N):
count += a[-i-1] * (-1)**i
print(count)
Alice et Bob acquièrent alternativement N cartes avec des nombres arbitraires écrits dessus afin que le score maximum soit atteint. Enfin, le problème de trouver la différence de score entre Alice et Bob.
Triez les N cartes par ordre décroissant, en passant la cote à Alice et les égales à Bob. ↓ Afin d'obtenir enfin la différence de score, il est conseillé d'ajouter les nombres impairs et de soustraire les nombres pairs. J'ai pensé et répondu de cette façon.
ABC085B - Kagami Mochi
import numpy as np
N = int(input())
d = np.zeros(N)
for i in range(N):
d[i] = int(input())
sorted_d = np.unique(d)
print(len(sorted_d))
Compte tenu des diamètres de N disques, la question est de savoir combien d'étages peuvent être empilés lorsqu'ils sont empilés par ordre décroissant de haut en bas.
Les disques de même diamètre ne peuvent pas être empilés. ↓ Vous pouvez obtenir un tableau unique en utilisant la fonction de Numpy qui renvoie un tableau unique. Trouvez le nombre d'éléments. J'ai finalement réfléchi et répondu.
ABC085C - Otoshidama
#Otoshidama
N, Y = list(map(int, input().split()))
y_man = Y
flag = False
out = [-1,-1,-1]
for i in range(N+1):
y_gsen = y_man
for j in range(N-i+1):
n_sen = int(y_gsen/1000)
if N-i-j == n_sen:
out = [i,j,n_sen]
flag = True
break
y_gsen -= 5000
if flag:
break
y_man -= 10000
print('{} {} {}'.format(out[0],out[1],out[2]))
# print(out[0]*10000+out[1]*5000+out[2]*1000)
Si les billets de 10 000 yens, les billets de 5 000 yens et les billets de 1 000 yens peuvent être combinés en N et Y yens. Répondez à la combinaison si possible (-1 -1 -1 si pas possible)
J'ai trouvé un moyen de sortir de l'instruction inférieure pour lorsque je suis sortie de l'instruction supérieure pour, mais c'était difficile à comprendre et je l'ai remplacée en définissant une variable appelée flag.
#Hakuchumu
S = input()
m = ['dream','dreamer','erase','eraser']
for i in range(len(m)):
m[i] = m[i][::-1]
lenS = len(S)
revS = S[::-1]
Header = 0
flag = True
Ans = 'YES'
while Header < lenS-1 :
flag = True
if Header + 6 < lenS:
# print('6t')
if revS[Header:Header+7]==m[1]:
Header += 7
flag = False
# print('6tt')
if Header + 5 < lenS:
# print('5t')
if revS[Header:Header+6]==m[3]:
Header += 6
flag = False
# print('5tt')
if Header + 4 < lenS:
# print('4t')
if revS[Header:Header+5]==m[0] or revS[Header:Header+5]==m[2]:
Header += 5
flag = False
# print('4tt')
if flag:
Ans = 'NO'
# print('out')
break
print(Ans)
Le problème de déterminer si la chaîne de caractères S peut être complétée en arrangeant arbitrairement 4 de «rêver», «rêveur», «effacer» et «effacer».
J'ai pensé à une méthode pour juger depuis le début de la chaîne de caractères et déplacer l'en-tête par le nombre de caractères s'ils correspondent, mais j'ai été vaincu par le branchement conditionnel de la chaîne de caractères, qui est compliqué à diviser comme la dreamerase. La réponse est basée sur l'indication qu'il n'y a pas de correspondance lorsque la chaîne de caractères est inversée.
ABC086C - Traveling
#Traveling
import numpy as np
N = int(input())
Plan = np.zeros((N+1,3))
for i in range(N):
Plan[i+1] = list(map(int, input().split()))
able = 'Yes'
for j in range(N):
t, x, y = Plan[j]
t_next, x_next, y_next = Plan[j+1]
distance = abs(x-x_next) + abs(y-y_next)
delta = t_next - t
amari = delta - distance
# print(distance,delta,amari)
if amari < 0 or amari%2 == 1:
able = 'No'
break
print(able)
La question est de savoir s'il est possible d'avoir une combinaison de x_n et y_n au temps t_n lors du déplacement vers un point de grille de l'un quelconque des haut, bas, gauche et droite à la fois.
Tout d'abord, déterminez que la prochaine distance x, y est inférieure à t. Et, étant donné que ça bouge toujours, c'est faisable quand trop de fois le sont. S'il s'agit d'un nombre impair, il est déterminé qu'il est inaccessible car il doit se déplacer.
En regardant en arrière maintenant, il y a eu diverses améliorations. Dédié au prochain concours ...
Recommended Posts