En raison de diverses circonstances, je vais essayer de résoudre le problème APG4b publié par Atcoder en utilisant Python. Dans le chapitre 1, j'ai essayé de résoudre ce que les volontaires ont publié, donc à partir du chapitre 2, je vais essayer de résoudre le problème EX après l'avoir lu moi-même. Je suis un débutant qui n'a touché Python que pendant environ six mois à l'université, alors j'apprécierais que vous puissiez m'apprendre s'il y a quelque chose qui peut être raccourci (ou plus efficacement). Le but est de créer un code qui "résout efficacement les problèmes". De plus, en raison de contraintes de temps, si AC apparaît dans le test EX, je lirai simplement brièvement la réponse du modèle et ne la réécrirai pas.
** Comment écrire une boucle ** exemple
a = int(input())
data = list(map(int,input().split()))
answer = 0
for i in range(len(data)):
if data[i] == a:
answer += 1
print(answer)
** Plage de relevé ** exemple
a = [1,3,2,5]
for i in a:
print(i)
À la tête de la famille, il y avait une déclaration selon laquelle "pour les déclarations peuvent être utilisées même avec un type de conteneur", mais je me demandais "qu'est-ce qu'un type de conteneur ...?", Alors j'ai cherché. Je me demande si le type qui stocke chaque élément tel que list et dict ensemble est le type de conteneur ...? Est-ce quelque chose comme appeler int ou str un type de données? Dans cet esprit, je vais le laisser ici.
** Histoire détaillée ** À propos de l'utilisation correcte des boucles
--Lorsque vous souhaitez traiter tous les éléments du tableau → Plage pour instruction -Lors du traitement répété un certain nombre de fois autre que les conditions de ↑ → pour instruction --Autres cas → Instruction While
La première chose que j'ai pensé était "Quand utilisez-vous la phrase While ...?" Quand je l'ai utilisé à l'université, j'utilisais une instruction Wheel avec une variable de type booléen comme indicateur, mais cette méthode est-elle réellement utilisée? Je me demandais et je flottais.
** Cas où l'instruction While convient **
n = int(input())
count = 0
while n > 0:
if n % 2 > 0:
break
n /= 2
count+=1
print(count)
Utile "uniquement si certains éléments remplissent les conditions". Quand j'y ai pensé, je l'ai utilisé comme ça à l'université (traité comme un drapeau).
data = list(map(int,input().split()))
keep=0
flag=False
for i in data:
if keep==i:
flag=True
break
keep=i
if flag==True:
print("YES")
else:
print("NO")
** Boucle multiple ** Boucle à l'intérieur de la boucle. J'ai entendu dire que ce n'était pas une manière très complimentée, mais je suis désolé de ne pas me souvenir de la source. J'ai eu la chance de voir le code écrit par d'autres personnes avant, mais quand il a été bouclé plusieurs fois, il a parfois fallu beaucoup de temps pour lire "Quelle est cette intention ...?". Principalement à cause de mon manque de capacité! Hey! !!
for i in range(3):
for j in range(3):
print("i:{},j:{}".format(i,j))
** Exemple "Déterminez si deux tableaux A et B de 3 éléments contiennent le même élément" **
A = list(map(int,input().split()))
B = list(map(int,input().split()))
answer = False
for i in range(3):
for j in range(3):
if A[i]==B[j]:
answer = True
if answer == True:
print("YES")
else:
print("NO")
Certes, vous pouvez voir des éléments de tableau en double sans boucles multiples. D'un point de vue lisible, je l'écris avec la mort cérébrale, pensant que c'est plus facile à comprendre.
** Saut de boucle multiple / continue **
C'est tout ce qu'on peut en dire. Dans la boucle multiple de l'exemple, cela signifie "Si vous interrompez / continuez à" for j ~ ", vous irez à" for i ~ "". C'est un peu difficile à comprendre, mais c'est difficile à comprendre. Concernant cette partie, il y a un exemple facile à comprendre dans la famille principale.
** Erreur d'indice ** A ce propos, si vous pensez "Il est important de décider du nom de la variable ...", je pense que c'est conforme à l'intention du créateur. «Je» et «j» ne sont pas faciles à comprendre, n'est-ce pas? Cependant, je l'utilise toujours lorsque je tourne des phrases, toujours. D'ailleurs, au cours de ma première année, j'ai l'impression qu'on m'a appris à l'université à «arrêter les variables à une seule lettre». De plus, il semble qu'il y avait plusieurs questions à soumettre. Excusez-moi, professeur ...
N,S = map(int,input().split())
A = list(map(int,input().split()))
P = list(map(int,input().split()))
count = 0
total = 0
for ap_price in A:
for pin_price in P:
total = ap_price + pin_price
if total == S:
count+=1
else:
total = 0
print(count)
** Un tableau à deux dimensions ** Je suis désolé, je suis complètement ignorant sur C ++, donc quand j'ai lu la maison d'origine, je ne pouvais que penser "Pourquoi écrirais-je autant de code simplement en créant un tableau?" Quand j'ai touché au langage C (pas ++) il y a longtemps, le mot «allouer de la mémoire» est sorti, donc je pense que je prends diverses mesures pour sécuriser la capacité du tableau. Non, je ne comprends pas vraiment. Revenez à Python.
exemple
data = []
for i in range(3):
data.append(list(map(int,input().split())))
count = 0
for i in range(3):
for j in range(4):
if data[i][j] == 0:
count+=1
print(count)
** Déclaration ** Dans l'exemple ci-dessus, c'est la pièce.
data = []
for i in range(3):
data.append(list(map(int,input().split())))
Ajoutez simplement la ligne d'entrée standard convertie en liste aux données de variable de type liste déclarées à l'avance. Est-il correct de le déclarer?
accès En termes de données du tableau bidimensionnel créé ci-dessus
data[Quel numéro du haut][Numéro de gauche]
** Taille d'apprentissage ** Étant donné que "l'apprentissage de la taille" indiqué à la famille principale était (longueur verticale, longueur horizontale) J'écrirai comment importer et vérifier numpy. Si c'est facile à comprendre, vous ne pouvez que le comprendre ...
import numpy as np
#Créer un tableau à deux dimensions
data = []
for i in range(3):
data.append(list(map(int,input().split())))
#Faites-en un tableau NumPy.forme
data = np.array(data)
print(data.shape)
** Concept de tableau 2D ** Le chef de famille est très facile à comprendre. Cependant, cela dit aussi que ce n'est pas nécessaire en Python ... Je n'en ai pas envie, mais c'est une connaissance qui doit être utilisée dans la première moitié de la deuxième année d'une certaine université, il vaut donc mieux la lire. Un jour, j'ai entendu de mes aînés: "Si vous touchez plusieurs langues, vous pouvez comprendre la langue que vous touchez pour la première fois dans l'atmosphère", n'est-ce pas nécessaire pour Python? Il est important de lire ce que vous pensez comme des connaissances et rêvez d'un jour utile un jour. C'est important! !! !! !! !! !! !!
** Tableau multidimensionnel **
exemple Je suis désolé de ne pas avoir pu réécrire ... </ font> L'entrée de ce problème est de multiples problèmes au format 3 × 3 ○ ×, mais la ligne vide entre les problèmes ○ × est inévitablement incluse dans le tableau multidimensionnel, et la dernière ligne ne peut pas être lue. C'est emballé ... Par habitude, je trébuche dans des endroits comme celui-ci et passe un temps infini, donc une fois que je serai calme, je recommencerai. Je veux dire, pour qui vous excusez-vous?
après ça Je n'ai pas résolu le problème ci-dessus, je le ferai donc plus tard.
n,m = map(int,input().split())
lists = []
for i in range(m):
lists.append(list(map(int,input().split())))
result = []
results = []
for i in range(n):
for j in range(n):
result.append("-")
results.append(result)
result = []
for i in lists:
win = i[0]
lose = i[1]
results[win-1][lose-1] = "o"
results[lose-1][win-1] = "x"
for i in results:
j=" ".join(i)
print(j)
C'est une écriture absolument mauvaise. Bref, je l'ai écrit improvisé pour arracher la climatisation. Nous le corrigerons à une date ultérieure avec les exercices ci-dessus.
référence
Se référer à une autre variable d'une variable. Cela peut-il être fait avec Python? Après une recherche rapide, j'ai trouvé les concepts «immuable» et «mutable». «Immuable» fait référence aux chaînes, aux nombres, etc., et les objets appartenant à ce concept ne peuvent pas changer les nombres d'une variable en une autre comme la famille d'origine. Au contraire, les objets tels que les dictionnaires et les listes qui appartiennent à "mutable" peuvent être réécrits d'une variable à une autre comme la famille principale. Vraiment.
a = 3
b = a
#Le numéro 3 de a est sorti
print(b)
b = 4
#Dans le cas de la famille principale, la valeur numérique de a est remplacée et 4 est sortie.
#Cependant, comme l'objet numérique est immuable, 3 est sorti sans remplacement.
print(a)
a_list=[1,2,3]
b = a_list
b[0] = 4
#Si cela devient la rue principale, un_Le 0e élément de la liste a été réécrit[4,2,3]devenir
#L'objet de liste est mutable, remplacez-le[4,2,3]Est sortie
print(a_list)
Y avait-il un tel mécanisme? Je ne savais pas…… Je me suis demandé si tous les objets étaient mutables en C ++, mais quand j'ai touché C (pas ++) il y a longtemps, le langage C gère les variables en mémoire. J'ai l'impression d'avoir entendu l'histoire. Non, j'étudiais Haskell en même temps à ce moment-là ... Je suis désolé de ne pas m'en souvenir un instant et ma mémoire est trouble, donc je retourne à Python.
** Après ça ** C'est plus facile à comprendre si vous lisez l'original (et il semble être différent de Python) …… Mais le mécanisme ici est-il le même que Python et C ++? Python est un langage d'interprétation et C ++ est un langage de compilation, n'est-ce pas? Je sais seulement si je dois compiler ou non au moment de l'exécution, mais la différence entre les deux est que le comportement de base est le même, seule la méthode d'exécution est différente ...? J'enquêterai moi-même plus tard plus tard. Je ne sais pas.
A = []
for i in range(9):
line = list(map(int,input().split()))
A.append(line)
correct_count = 0
wrong_count = 0
def saiten(A,correct_count,wrong_count):
for i in range(9):
for j in range(9):
if A[i][j] == (i+1)*(j+1):
correct_count+=1
else:
wrong_count+=1
A[i][j]=(i+1)*(j+1)
return A,correct_count,wrong_count
A,correct_count,wrong_count = saiten(A,correct_count,wrong_count)
for i in range(9):
line =[str(a) for a in A[i]]
line=' '.join(line)
print(line)
print(correct_count)
print(wrong_count)
Puisque "correct_count" et "mauvais_count", qui indiquent le nombre de réponses correctes et incorrectes, sont des objets immuables, ils ne peuvent pas être remplacés dans la fonction "saiten ()" qui effectue la notation. Je renvoie donc le résultat avec retour. Puisque "A" dans le tableau bidimensionnel qui stocke le résultat du calcul est un objet mutable, il peut être remplacé dans la fonction. Donc je ne l'ai pas rendu.
Jusqu'à présent, j'ai utilisé des mots qui semblent immuables, mutables et d'autres termes techniques, mais si tout cela est faux, ce serait assez ridicule. Il semble que si vous comprenez mal la signification de "waroshi" dans les textes anciens comme "très intéressante" et que vous l'utilisez beaucoup devant un professeur de japonais, vous serez désapprouvé. Faites-le une fois dans votre vie.
J'ai appris cela au cours de ma première année, mais je ne me souviens pas avoir utilisé la récidive depuis. Il semble que ce soit une catégorie difficile à la tête de la famille, et il a été écrit que "Si vous ne comprenez pas après avoir lu l'explication, vous pouvez la sauter." e? Est-ce celui que vous n'utilisez pas beaucoup?
Je m'en souviens seulement un peu, alors je vais écrire le code de l'exercice et m'en souvenir.
def sum(n):
if n == 0:
return 0
s = sum(n - 1)
return s + n
print(sum(2)) # 0 + 1 + 2 = 3
print(sum(3)) # 0 + 1 + 2 + 3 = 6
print(sum(10)) # 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55
Je ne sais pas comment le mettre en mots.
sum (n) est conçu pour renvoyer return 0, c'est-à-dire 0 quand ʻif n == 0. L'opération récursive est effectuée avec le suivant s = sum (n -1)`.
Le nombre obtenu en soustrayant 1 de n est poussé dans l'appel récursif, et lorsque n devient 0, le récursif est terminé et le calcul est effectué ...?
Je comprends le sentiment de cette fonction, mais il est difficile de l'écrire. Faisons une balle.
** Pour sum (2) **
[1ère boucle] ** n = 2 **, donc l'instruction if est un chemin. s = somme (n -1) devient s = somme (1). Récursivité ici.
⬇︎
[2nd loop] ** n = 1 **, donc si les minutes sont une passe. s = somme (n -1) devient s = somme (0). Récursivité ici.
⬇︎
[Troisième boucle] Aller à l'instruction if avec ** n = 0 **. 0 retourne au retour.
⬇︎
[2nd loop] s = sum (n -1) est la valeur renvoyée dans la troisième boucle ** s = 0 **. Puisque ** n = 1 **, return s + n est effectué et 1 est renvoyé.
⬇︎
[1ère boucle] s = somme (n -1) est la valeur renvoyée dans la 2ème boucle ** s = 1 **. Puisque ** n = 2 **, faites return s + n et renvoyez 3. la fin.
Voilà ce que c'est. C'est mon sentiment. Non, c'est difficile à voir pour la première fois. Cela semble amusant de résoudre de tels problèmes, mais est-il acceptable de le lire lorsqu'il est utilisé dans des batailles réelles? À mon niveau, c'est difficile à moins que je ne l'énumère, mais si vous êtes une personne expérimentée, pouvez-vous le dire en un coup d'œil? Je dois me consacrer ...
** Après ça ** Lisons la famille principale. D'accord (pas). J'étais un peu difficile. Cependant, en termes de contenu, j'ai fait un peu dans la classe d'algorithmes dans la première moitié de la deuxième année. Pour être honnête, il peut être préférable de lire le contenu de la famille principale comme un manuel plutôt que comme une véritable bataille. Il vaut peut-être mieux lire dans une atmosphère du genre "Il y a une telle façon". Mais si je devais le faire, je mettrais juste des déclarations et des drapeaux ... Je ne peux pas du tout y penser.
n = int(input())
read_line = list(map(int,input().split()))
p = []
for i in range(n):
if i == 0:
p.append(-1)
continue
p.append(read_line[i-1])
key = list(dict.fromkeys(p))
children={}
for i in key:
value_list = []
for j in range(n):
if i == p[j]:
value_list.append(j)
children[i]=[]
for k in value_list:
children[i].append(k)
def count_report_num(chlidren,x):
if children.get(x)==None:
return 1
sum = 0
for i in children[x]:
sum += count_report_num(chlidren,i)
sum+=1
return sum
for i in range(n):
print(count_report_num(children,i))
Je ne pouvais pas comprendre le comportement de la récurrence, alors j'ai fait référence à la réponse modèle ... De plus, il semble que vous puissiez ajouter des éléments enfants au tableau avec c ++, mais je ne savais pas comment le faire en Python, j'ai donc décidé de l'exécuter avec le type dict. C'était difficile.
--À propos de "** méthode de commande **" qui estime le montant du calcul du programme
Lisez attentivement l'explication du chef de famille. C'était très facile à comprendre. C'est aussi le contenu à faire dans la première moitié de la deuxième année d'une certaine université, j'ai donc pensé que ce serait utile.
J'ai une réponse à cela, et je n'ai pas à la réécrire (juste commenter), alors je me demande si je n'ai pas à l'écrire.
Recommended Posts