D'abord, je ne voudrais pas réinventer la roue ... la méthode max est déjà définie dans RichInt
, de sorte que vous pouvez écrire a max b
, pour a
et b
entiers.
Alsó,
slice
est dépréciée, donc au lieu de
lst.slice(0, num)
j'utiliser lst.take(num)
. Les méthodes obsolètes disparaîtront probablement lorsque Scala 2.8 sera lancé.
EDIT: En effet, comme Daniel a souligné, slice(Int, Int)
n'est pas dépréciée. J'étais tout à fait pressé quand j'ai commencé à écrire cela, et je pensais à slice(Int)
, ce qui équivaut à drop(Int)
. Je trouve toujours lst.take(num)
pour être plus clair que lst.slice(0, num)
:).
(nitpick) Votre dernière ligne ne compile pas non plus puisque vous avez oublié d'ajouter Nil
à la fin de votre séquence de cons. 1::2::3::4
, finirait par appeler ::
sur un Int
, qui n'a pas cette méthode. C'est pourquoi vous devez ajouter Nil
à la fin (invoquer ::
sur Nil
).
De plus, l'algorithme que vous avez utilisé n'est pas évident au premier coup d'œil. La façon dont je voudrais écrire est la suivante:
val numbers = /*"--the string of numbers--"*/.map(_.asDigit).toList
def sliding[A](xs: List[A], w: Int): List[List[A]] = {
for(n <- List.range(0, xs.size - w))
yield xs drop n take w
}
def product(xs: List[Int]): Int = (1 /: xs) (_ * _)
sliding(numbers, 5).map(product).sort(_ > _).head
Je pense que la dernière ligne explique très bien ce que l'algorithme est censé faire - prendre une fenêtre glissante de la liste, calculer le produit dans cette fenêtre coulissante et alors obtenir le maximum des produits calculés (j'ai implémenté la fonction maximum comme sort(_ > _).head
par paresse, j'aurais pu faire quelque chose O (n) plutôt que O (n log (n)) si la performance était critique ... ça marche toujours sous une seconde si).
Notez que la fonction de glissement sera dans la bibliothèque Scala 2.8 (voir Daniel's post, d'où j'ai été inspiré en écrivant cette définition de glissement).
EDIT: Oups ...désolé pour le /:
. J'aime juste la concision et le fait que l'élément initial du pli arrive avant la liste. Vous pouvez écrire product
comme équivalente ci-après, pour être plus explicite:
def product(xs: List[Int]): Int = xs.foldLeft(1)(_ * _)
-- Flaviu Cipcigan
Merci Flaviu, c'est la réponse que j'espérais. Il m'a fallu 5 minutes pour comprendre votre solution, principalement à cause de la syntaxe très concise, que vous utilisez. Je ne connais pas encore les opérateurs, donc quelque chose comme '1 /: xs' est complètement cryptique à première vue. –
Content de pouvoir aider. J'ai édité le poste pour fournir la définition moins cryptique du produit;). –
Est-ce que 'slice' est déprécié? Je ne vois aucun avertissement sur 2.8 ou 2.7.4. –