Voici quelques opérations simples de map `` `` filter reduction``` qui sont souvent utilisées dans les opérations de liste dans chaque langue.
Java est redondant, n'est-ce pas? Ruby et Haskell sont très concis.
Cependant, comme j'utilise Java dans mon travail quotidien, je ne connais pas grand-chose aux autres langages, donc
Il existe peut-être une manière plus concise de l'écrire.
Voici un exemple simple de.
D'ailleurs, il semble qu'il n'est pas souvent fixé d'initialiser la liste dans les affaires. Normalement, les données de liste sont générées par la méthode d'usine et référencées. Cependant, j'effectue parfois l'initialisation suivante en tant que données de test dans les tests.
Java
List<Integer> xs = Arrays.asList(1, 2, 3, 4, 5);
//Ou@S'il s'agit de Java 10 ou version ultérieure, comme enseigné par saka1029
var xs = List.of(1, 2, 3, 4, 5);
//Il existe également un moyen d'utiliser une telle liste infinie. Ne faites-vous pas cela en affaires?
//Valeur de départ de l'extérieur, fonction,Vous pouvez le faire en entrant la valeur limite.
xs = Stream.iterate(1, i -> i + 1).limit(5).collect(toList())
Ruby
xs = [1, 2, 3, 4, 5]
#En fait, ce qui précède semble être un mauvais exemple,
# @Les suivants enseignés par scivola sont bons pour l'initialisation.
xs = [*1..5]
Python
xs = [1, 2, 3, 4, 5]
Haskell
xs = [1, 2, 3, 4, 5]
--Ou
xs = [1..5]
Clojure
(def xs '(1 2 3 4 5))
;Ou@Comment Lagenorhynque a commenté
(def xs (range 1 (inc 5)))
On suppose que cette liste a déjà été créée ci-dessous.
Le résultat pour chaque langue est `` [2, 4, 6, 8, 10] ''. La fonction d'impression est omise.
Java
xs.stream().map(i -> i * 2).collect(toList());
Ruby
xs.map {|i| i * 2}
Python
list(map(lambda i: i * 2, xs))
#Il est peut-être normal d'utiliser la notation d'inclusion de liste en Python pour donner cette réponse.
[i * 2 for i in xs]
Haskell
map (*2) xs
Clojure
(map (fn [n](* n 2)) xs)
;Ou@Ce que m'a dit lagenorhynque. Celui-ci est simple et sympa!
(map #(* % 2) xs)
Le résultat est `` [2, 4] ''.
Java
xs.stream().filter(n -> n % 2 == 0).collect(toList());
Ruby
xs.select(&:even?)
Python
list(filter(lambda n: n % 2 == 0, xs))
#Ce sera peut-être une notation d'inclusion de liste sans écrire comme ci-dessus.
[n for n in xs if n % 2 == 0]
Haskell
filter even xs
Clojure
(filter even? xs)
Le résultat est `` 15 ''.
Java
xs.stream().reduce(Integer::sum).orElse(0);
Ruby
xs.reduce(:+)
#Ou l.inject(:+)
#Lorsque vous n'utilisez pas, réduisez
xs.sum
Python n'était pas convivial car il n'y avait aucune importation de @shiracamus, alors je l'ai écrit.
Python
from functools import reduce
from operator import add
reduce(lambda a, b: a + b, xs)
#Lorsque vous n'utilisez pas, réduisez
sum(xs)
#Ou@J'ai appris de shiracamus,
reduce(add, xs)
Haskell
foldl (+) 0 xs
--Lorsque vous n'utilisez pas le pli
sum xs
Clojure
(reduce + xs)
;@Enseigné par lagenorhynque
(apply + xs)
;Le même résultat peut être obtenu en écrivant. Ce qui est fait en interne(+ 1 2 3 4 5)
;réduire est(+ (+ (+ (+ 1 2) 3) 4) 5)
c'est tout.
J'ai écrit pour une langue que j'ai étudiée jusqu'à présent, mais j'ai personnellement écrit Ruby, Clojure, que j'ai trouvé confortable </ b>. Je sens que le sentiment est similaire. (Parce que les deux auteurs aiment lisp?) Haskell est trop terrible et désagréable! Je pense (dans le bon sens) </ b>, mais est-ce amusant! </ B> Ruby, Clojure? Je ne sais pas pourquoi. De plus, Haskell a une façon de penser complètement différente des autres langues, il est donc difficile d'étudier.
Recommended Posts