Mémos privés utilisés pour les opérations de liste et la programmation de concours

Si vous le remarquez, vous pouvez ajouter ou mettre à jour l'article ici. http://qiita.com/clarinet758/items/5135a8075001a3b6782b est en ruine.

Chaînes dans l'ordre inverse

a='abcdef'
a[::-1]
'fedcba'

Programmé pour les listes, les décors, les cartes, etc.

liste

Faites beaucoup de listes vides l=[[] for x in xrange(n)]

Tournez verticalement et horizontalement. Par exemple, chaîne de caractères d'origine 8 verticale 8 8 horizontale abcdefgh ijklmlop qrstuvwx yzABCDEF GHIJKLMN OPQRSTUV WXYZ1234 567890!?

tateyoko.py


#Dans ce cas, un,b vaut 8 pour les deux
(a,b)=map(int, raw_input().split())
x=[sys.stdin.readline().strip() for x in range(a)]
print x
#['abcdefgh', 'ijklmlop', 'qrstuvwx', 'yzABCDEF', 'GHIJKLMN', 'OPQRSTUV', 'WXYZ1234', '567890!?']

chikan=[[] for i in range(8)]
#X dans la liste d'origine[0]Lire de
for a in range(8):
#Initialiser la liste du stockage temporaire
    tate=[]
#Léchez le bth élément de la colonne a
    for b in range(8):
        tate.append(x[b][a])
#Combinez les différents personnages un par un et mettez-les dans la liste pour le stockage officiel
    tate1=''.join(tate)
    chikan[a]=tate1
print chikan
#['aiqyGOW5', 'bjrzHPX6', 'cksAIQY7', 'dltBJRZ8', 'emuCKS19', 'flvDLT20', 'gowEMU3!', 'hpxFNV4?']

Aller et venir entre les chaînes et les listes

Opération de liste


#Pour les cordes
orig = "hello"
li   = list(orig)   #Chaîne=>liste
text = "".join(li)  #liste=>Chaîne
print li    # ['h', 'e', 'l', 'l', 'o']
print text  # hello


#Pour un tableau de nombres
nums = [1,2,3,4,5]
text = "".join(map(str, nums))  #liste=>Chaîne
li   = list(map(int, text))     #Chaîne=>liste
print li    # [1, 2, 3, 4, 5]
print text  # 12345

#Il semble qu'il soit plus rapide d'utiliser la notation d'inclusion pour la liste à partir de la chaîne de caractères
#Reflétez les commentaires que vous avez reçus et vérifiez comment les utiliser
text='12345'
li = [int(i) for i in text]
#[1, 2, 3, 4, 5]

Trier la liste

sort.py


#Trier par ordre croissant()Est utilisé.
>>> m = [1, 18, 2, 117, 205]
>>> m.sort()
# x = m.sort()Même si vous écrivez, laissez la liste originale,
#x ne peut pas être une liste triée.
>>> m
[1, 2, 18, 117, 205]


#Par ordre décroissant, trier une fois()Puis inverser()Est utilisé.
>>> n = [1, 18, 2, 117, 205]
>>> n.reverse()
>>> n
[205, 117, 2, 18, 1]
# reverse()Faites-le simplement pour inverser la liste d'origine.
#Alors triez par ordre croissant, puis inversez.
>>> n.sort()
>>> n.reverse()
>>> n
[205, 117, 18, 2, 1]

Liste y=Soyez prudent lors de la manipulation avec x


>>> x=[1,6,3,8,4]
>>> y=x
>>> y
[1, 6, 3, 8, 4]
>>> x
[1, 6, 3, 8, 4]
>>> y.sort()
>>> y
[1, 3, 4, 6, 8]
>>> x
[1, 3, 4, 6, 8]
>>> y[1]=y[1]+1
>>> y
[1, 4, 4, 6, 8]
>>> x
[1, 4, 4, 6, 8]

>>> x=[1,2,3,4,5]
>>> y=x[:]
>>> x
[1, 2, 3, 4, 5]
>>> y
[1, 2, 3, 4, 5]
>>> y[1]+=3
>>> y
[1, 5, 3, 4, 5]
>>> x
[1, 2, 3, 4, 5]

La liste d'origine n'est pas laissée pour sort () et reverse (). .. Si vous avez besoin de la liste originale

Trier la partie 2


#Soit x la liste d'origine et y la destination du tri
>>> x=[3,55,6,3,71,8,1]
>>> y=sorted(x)
>>> y
[1, 3, 3, 6, 8, 55, 71]
>>> y=reversed(x)
>>> y
<listreverseiterator object at 0x109144c10>
>>> y=x[::-1]
>>> y
[1, 8, 71, 3, 6, 55, 3]
>>> y=reversed(x)
>>> y[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'listreverseiterator' object is not subscriptable
>>> for i in y:
...   print i
... 
1
8
71
3
6
55
3

Il semble que vous deviez être prudent car inversé () est un comportement mystérieux.

Quels sont les éléments de la liste de c?

Comptez le nombre et définissez le maximum / minimum


#1 en c,2,3,Comptez le nombre de 4(p)Compter par
#Ajouter à la liste vide l avec append.
#max(l),min(l)Pour les valeurs maximales et minimales
l,p=[],1
c=[1, 2, 3, 4, 1, 2, 3]
for i in xrange(4):
    l.append(int(c.count(p)))
    p+=1
print max(l),min(l)

#Il semble que la notation d'inclusion soit bonne pour le nombre d'éléments, alors réimprimez-la
c = [1, 2, 3, 4, 1, 2, 3]
l = [c.count(i) for i in xrange(4)]
print max(l), min(l)

Quel dictionnaire pour les éléments de la liste


i=['A','A','C','C','A','B']
h={"A":4,"B":3,"C":2,"D":1,"F":0}
for x in enumerate(i): f+=h[x[1]]

↑ Un code soigné que je ne comprends pas pourquoi j'ai passé. Il compte toujours les scores attribués à ABC dans la liste de i.

Différences entre les éléments de liste? prendre

Différence de liste


a=['a','b','c','d',1,2,'3','4']
b=['c','d','1',2,3]
#Liste des personnes à quitter-Liste des candidats à effacer, liste des inscrits-Liste des migrants=Comme le dernier inscrit
#L'ordre de la liste est cassé.
l=set(a)-set(b)
l
set(['a', 1, '3', 'b', '4'])
sabun=list(l)
sabun
['a', 1, '3', 'b', '4']

Joindre une liste


a=[1,2,3]
b=['4','5','6']
c=a+b
#Il semble qu'il n'y ait pas de problème même si le type str et le type int sont mélangés

Répertorier les opérations en double

Pour la déduplication, le type d'ensemble est plus rapide que le type de liste et des expressions logiques peuvent être utilisées, ce qui est pratique. Utilisons le type set.

définir le type

Un objet set est une collection d'objets hachables non ordonnés. Les utilisations courantes incluent le test d'appartenance, la suppression des doublons d'une séquence de nombres et le calcul d'opérations mathématiques telles que des produits logiques, des sommes de valeurs, des ensembles de différences et des différences symétriques. Il semble.

Fonctionnement de l'ensemble que j'ai essayé ou semble utiliser


{raw_input()}
123
#set(['123'])

{int(raw_input())}
345
#set([345])

#Séparé par des blancs
set(raw_input().split())
#Je peux, mais

set(int, raw_input().split())
set(input().split())
#N'est pas bon

Divers éléments qui se chevauchent des deux listes


#Lors de l'utilisation de set
a=[1,2,3,1,2,3]
b=[1,4,5]

set(x)&set(y)
#set([1])
#a,Il semble que seuls les éléments dupliqués en b soient extraits
#La duplication en a et b semble disparaître

set(x)|set(y)
#set([1, 2, 3, 4, 5])
#La duplication en a et b disparaît et tous les éléments ne font plus qu'un

set(x)^set(y)
#set([2, 3, 4, 5])
#La duplication en a et b semble disparaître
#C'était seulement en a, c'était seulement en b, mais ça rejoint

#Le nombre d'éléments est len(set(x)&set(y))Etc. peut être pris en utilisant len.

#Les doublons de l'ensemble disparaissent lorsque le type d'ensemble est utilisé.
#Il semble que l'existence d'éléments en double dans l'ensemble soit effacée. ensemble(raw_input())
23432
# set(['3', '2', '4'])
set(raw_input())
asdfgfdsa
# set(['a', 's', 'd', 'g', 'f'])
#Notation qui était possible
#set(raw_input().split())Tous les contenus sont des str, séparés par des blancs

#Lors de l'utilisation de group by
#la prochaine fois

Si le jeu ne peut pas être utilisé


#Est-il possible de créer une chaîne de caractères de ligne inférieure en utilisant les caractères de ligne supérieure un par un? Quand
Instead of dogging Your footsteps it disappears but you dont notice anything
Your dog is upstears

s=list(raw_input())+[' ']*200
try: 
  map(s.remove,raw_input())
  print 'YES'
except:
  print 'NO'

Effacer les éléments de la liste

・ Spécifiez la position et l'ordre de la liste risuto=['a','b','c'] del risuto[i] Le i-ème de risuto disparaît

・ Précisez par élément risuto=['haru','natsu','aki',huyu'] risuto.remove('huyu') Cela fera disparaître huyu

・ Effacer la fin risuto=['haru','natsu','aki',huyu'] risuto.pop() Cela supprimera le huyu final

Inclusion de liste pour déclaration tt = [ x+y for x in "abxy" for y in "abxy" ]

Compter une chaîne spécifique

count.py


>>> x = 'aaaabbaaabaaa'
>>> x
'aaaabbaaabaaa'
>>> x.count('aa')
4
# 1,Le deuxième caractère est'aa'2 si compté comme,3ème caractère'aa'Est
#Il semble que cela ne soit pas compté.

>>> x.count('a')
10

Comptez le nombre de correspondances

count.py


>>> import re

>>> x = 'aaaabbaaabaaaba'
>>> i = 0
# +Compte un ou plusieurs caractères consécutifs immédiatement avant.
>>> for m in re.finditer('a+', x):
...    i += 1
... 
>>> i
4

>>> re.findall('a+', x)
['aaaa', 'aaa', 'aaa', 'a']
#Les parties correspondantes sont extraites au format liste
# len(re.findall('a+', x))Pour obtenir le nombre d'éléments dans la liste
#Cela semble être synonyme d'obtenir le nombre de correspondances.

# re.re que trouver tout.finditer semble économiser de la mémoire.
>>> i = 0
>>> for m in re.finditer('a+', x):
...    i += 1
... 
>>> i
4

Site de référence http://lightson.dip.jp/zope/ZWiki 2013/11/14 J'aurais dû connaître les points forts de la syntaxe, donc c'était une omission complète. .. .. Merci pour votre demande de modification.

Recommended Posts

Mémos privés utilisés pour les opérations de liste et la programmation de concours
[Résumé des livres et cours en ligne utilisés pour l'apprentissage de la programmation et de la science des données]
[Programmation de compétition] [Python3] Connaissances nécessaires, pour vous-même
Obtenez toutes les entrées standard utilisées dans la programmation paiza et compétition avec int (python)
Liste des fonctions et méthodes intégrées fréquemment utilisées
[Python / Chrome] Paramètres de base et opérations de scraping
Programme de recherche complète des séquences (pour la programmation du concours)
[Pour les débutants] Comment étudier la programmation Mémo privé
[Python] Construire un environnement pour la programmation de compétition avec Atom (input () peut être utilisé!) [Mac]