[PYTHON] AtCoder Beginner Contest 059 Revue des questions précédentes

Questions passées résolues pour la première fois

Temps requis

Problème A

Fonction supérieure pour capitaliser

answerA.py

s1,s2,s3=input().split()
s=s1[0]+s2[0]+s3[0]
print(s.upper())

Problème B

Comparez simplement

answerB.py

a=int(input())
b=int(input())
if a>b:
    print("GREATER")
elif a<b:
    print("LESS")
else:
    print("EQUAL")

Problème C

Il est préférable de faire ce ** problème qui vaut pour tout i et que i + 1 et plus dépendent de i ** (Est-ce vrai? Je peux le montrer si je fais de mon mieux avec la méthode de l'absurdité). Vous pouvez faire en sorte que chaque terme ait un signe différent, et soit le terme impair est positif et le terme pair est négatif, soit le terme impair est négatif et le terme pair est positif. De plus, lorsque l'on considère chacun de ces deux modèles, si chaque terme ne satisfait pas le modèle, il est nécessaire d'utiliser des codes différents, et le nombre minimum de fois requis pour changer le terme est fixé à -1 ou 1. Vous pouvez voir que cela peut être réalisé. Aussi, à ce stade, il est facile de montrer qu'il n'est pas nécessaire de passer à -2 ou 2, etc. si vous pensez au cas d'un tel changement (je l'omettrai ici, mais veuillez commenter si nécessaire) Faire.). Une fois que vous savez cela, vous pouvez trouver la réponse en réfléchissant dans l'ordre à partir de la section précédente. (Puisque nous considérons la somme, nous avons d'abord calculé la somme cumulée.)

answerC.py

import copy
n=int(input())
a1=[int(i) for i in input().split()]
a2=copy.deepcopy(a1)
#Recherche de somme cumulée
for i in range(1,n):
    a1[i]+=a1[i-1]
for i in range(1,n):
    a2[i]+=a2[i-1]

#pm à ce moment+Ou-Enregistrez ce que vous faites et c enregistrez le nombre de fois
#Pour 1 le terme pair est positif, pour 2 le terme impair est positif(0 origine)
pm1,c1=0,0
pm2,c2=0,0

for i in range(n):
    a1[i]+=pm1
    if i%2==1:
        if a1[i]>=0:
            pm1-=(a1[i]+1)
            c1+=(a1[i]+1)
    else:
        if a1[i]<=0:
            pm1+=(-a1[i]+1)
            c1+=(-a1[i]+1)

for i in range(n):
    a2[i]+=pm2
    if i%2==0:
        if a2[i]>=0:
            pm2-=(a2[i]+1)
            c2+=(a2[i]+1)
    else:
        if a2[i]<=0:
            pm2+=(-a2[i]+1)
            c2+=(-a2[i]+1)

print(min(c1,c2))

Problème D

Je veux être en mesure de résoudre ce genre de problème, qui est incroyablement frustrant. Tout d'abord, nous devons garder à l'esprit que ces ** problèmes de jeu sont souvent plus faciles lorsque vous pensez à la forme finale **. Cependant, j'ai pensé au cas d'une mauvaise lecture de l'énoncé du problème et ** agissant de manière optimale ** comme toujours en la maximisant (le code de answerD_wrong.py), mais ce n'est pas du tout optimal. fait. À ce stade, j'ai eu l'idée que les deux montagnes devraient être aussi proches que possible, mais je n'étais pas sûr parce que j'essayais de le simuler. Cependant, si vous creusez le plus près possible, il est facile de voir que certaines personnes ne peuvent même pas essayer de se rapprocher. En d'autres termes, si la différence entre les deux montagnes est de 1 ou moins, vous devez faire ** 2 ou plus à partir de la condition que ** i est 1 ou plus (d'une à deux pierres à l'autre montagne. Même si vous en ajoutez une, la différence entre les pierres changera de trois). À l'inverse, l'autre personne reçoit la différence entre les deux pics lorsqu'elle est de 2 ou plus, donc en l'ajustant de manière appropriée, elle peut être transmise lorsque la différence entre les deux pics est de 1 ou moins. En d'autres termes, on peut voir que la composition de ** personnes avec une différence entre deux montagnes de 1 ou moins ** et de ** personnes avec une différence entre deux montagnes de 2 ou plus ** ne s'effondrera en aucun cas. Par conséquent, il est seulement nécessaire de considérer quelle sera la différence entre les deux pics dans l'état initial. Cette hypothèse peut également être étayée par ** la forme finale de la perte . En effet, la forme finale de perte est (0,0), (0,1), (1,0), (1,1), donc la différence entre les deux pics est inférieure ou égale à 1. En d'autres termes, une personne qui reçoit une différence entre deux montagnes de 2 ou plus aura certainement la montagne de l'adversaire sous la forme d'une défaite en faisant la différence entre les deux montagnes 1 ou moins ( optimal ). Je sais que je peux y aller. D'après la considération ci-dessus, si la différence entre les deux montagnes est de 2 ou plus dans l'état initial, Alice gagne, et si elle est de 1 ou moins, Brown gagne. ( L'expérience est importante! **)

answerD_right.py

x,y=map(int,input().split())
print("Alice" if abs(x-y)>1 else "Brown")

answerD_wrong.py

def next_tup(x,y):
    if x==0 or x==1:#x toujours grand
        x,y=y,x
    k=x//2
    x-=2*k
    y+=k
    return (x,y)

def defeat(tup):
    return tup==(1,1) or tup==(0,1) or tup==(1,0) or tup==(0,0)

X,Y=map(int,input().split())
if defeat((X,Y)):
    print("Brown")
else:
    ans=[]
    x_sub1,y_sub1=X,Y
    f1=0
    while True:
        z=next_tup(x_sub1,y_sub1)
        if defeat(z):
            break
        else:
            x_sub1,y_sub1=z
            if f1==0:
                f1=1
            else:
                f1=0
    ans.append(f1)
    x_sub2,y_sub2=Y,X
    f2=0
    while True:
        z=next_tup(x_sub2,y_sub2)
        if defeat(z):
            break
        else:
            x_sub2,y_sub2=z
            if f2==0:
                f2=1
            else:
                f2=0
    ans.append(f2)
    if 0 in ans:
        print("Alice")
    else:
        print("Brown")