Bonjour, je m'appelle Mana. Lorsqu'une personne apprend un nouveau langage de programmation, il est naturel qu'elle l'absorbe à la lumière des connaissances qu'elle a acquises jusqu'à présent. Est-ce quelque chose comme "cette fonction de cette langue, en d'autres termes, c'est à quoi elle ressemble dans cette langue"? Je ressens une grande valeur à cette méthode d'explication paraphrasante et je me demande si elle peut être expliquée dans n'importe quelle langue. Donc, dans cet article, pour ceux qui sont "Je suis tellement habitué à Python, mais que dois-je faire quand je veux faire ça avec Rust?", J'ai laissé une marque comme un marquage avec une casserole déchirée. C'est un article à lire. Cette fois-ci, je voudrais parler de la façon d'organiser une séquence lors du passage d'une séquence, ce qui est souvent le cas dans la programmation compétitive.
L'environnement à utiliser est Windows. Je n'en parle pas de manière critique, vous n'avez donc pas à vous en soucier trop.
PS C:\> cargo --version
cargo 1.43.0 (3532cf738 2020-03-17)
PS C:\> python --version
Python 3.8.2
L'entrée supposée cette fois est la suivante. Considérez une liste contenant la colonne numérique a.
n #Nombre de nombres
a1 a2... an #Séquence numérique
Par exemple
4
5 9 10 6
Le sujet de la réflexion à la Python est énorme, mais la meilleure façon d'y penser est d'abord de supprimer le nombre n, d'appliquer une division à la chaîne de nombres, de la convertir en int et de les collecter avec une carte. Est-ce facile?
input()
n = list(map(int, input().split()))
print(n)
Si vous ne pensez pas aux macros d'entrée standard et que vous les stockez sous forme de fonctions,
fn main(){
input();
let n: Vec<i32> = (&input()).split(" ").map(|s| s.parse().unwrap()).collect();
println!("{:?}", n);
}
fn input() -> String{
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).unwrap();
buf.trim_end().to_string()
}
Si vous l'écrivez comme ci-dessus, vous pouvez facilement le comprendre sans aucune difficulté.
En parlant de ce que je fais, je jette n, j'apporte une chaîne de nombres en tant que type & str, je la divise, puis je l'analyse (Rust est intelligent, donc j'interprète bien l'affichage du type sur le côté gauche. Cela le rendra i32), ignorez le cas où l'entrée est étrange avec unwrap, collectez les valeurs avec map et faites-en une collection appropriée avec collect.
Pour la fonction d'entrée, voir Mes articles passés (l'exemple ci-dessus est différent de trim).
Et si: Ignorez l'alphabet et stockez a et b dans une liste à deux dimensions.
n #Le nombre de données
x1 a1 b1 # x:Alphabet
x2 a2 b2 # a:Nombres
... # b:Nombres
xn an bn
Par exemple
2
a 2 3
b 8 6
Est-ce une idée générale de sauvegarder n comme nombre de boucles, de frapper le premier caractère lors de la saisie d'une ligne de données et de lire le deuxième caractère et les suivants?
n = int(input())
l = []
for _ in range(n):
l.append([int(e) for e in input().split()[1:]])
print(l)
fn main(){
let raw = input();
let n: i32 = raw.parse().unwrap();
let mut v: Vec<Vec<i32>> = Vec::new();
for _ in 0..n {
let raw = input();
let s: Vec<&str> = raw.split(" ").collect();
v.push([1, 2].iter().map(|i| s[*i as usize].parse::<i32>().unwrap()).collect());
}
println!("{:?}", v);
}
fn input() -> String{
let mut buf = String::new();
std::io::stdin().read_line(&mut buf).unwrap();
buf.trim_end().to_string()
}
Si vous écrivez let raw = input ();, vous pouvez lier la valeur d'entrée standard à raw, ce qui facilite la gestion des prêts et emprunts spécifiques à ce langage.
Je voudrais que vous voyiez autour de [1, 2] .iter (). Map (). Collect ();, et il sera beaucoup plus facile d'écrire de cette façon pour une entrée de type avec une largeur fixe. Je vais.
Utiliser un tableau de longueur fixe avec [] et le verser dans la carte via iter facilite le contrôle de l'ordre et de l'emplacement d'accès aux éléments. Dans cet exemple, il semble que vous puissiez utiliser get ou quelque chose, mais je vais laisser une déclaration de défaite indiquant que cela a fonctionné.
** Carte maîtresse! ** ** ** N'oubliez pas de collecter et de déballer! ** **
Cette fois, c'était comme si une personne qui ne pouvait pas changer d'avis était foirée dans un autre monde. J'espère que je pourrai continuer à laisser ce genre de conscience dans Qiita ... juste au cas où je l'oublierais. Le titre est comme une série, mais je ne sais pas s'il y en a une suivante car je dois passer par le processus d'apprentissage de Rust-> l'utiliser avec atCoder-> le donner à Qiita. Veuillez attendre avec impatience le prochain travail de M. Mana. '' Merci d'avoir lu jusqu'ici. J'espère que cela aide.