Por ejemplo, tengo una lista (1 2 3 4 5 6 7 8 9 10 11)
, y quiero endurecerla por 3 elementos (u otra longitud) para obtener ((1 2 3) (4 5 6) (7 8 9) (10 11))
. ¿Qué bonito código podría usar para esto? Gracias.¿Cómo áspera (en lugar de aplanar) una lista en un estilo funcional?
Respuesta
def split[A](list : List[A], n : Int) : List[List[A]] = list match {
case List() => List()
case _ => (list take n) :: split(list drop n, n)
}
List(1,2,3,4,5,6,7,8,9,10,11) grouped 3 toList
res0: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6),
List(7, 8, 9), List(10, 11))
+1 ¡Agradable! ...... – Dario
¡Bien! ¿Tienes algún código de Clojure? – user342304
En Scala 2.8, Lista de Mezclas en IterableLike que tiene el método agrupados que devuelve un iterador [Lista [T]], que a su vez se puede convertir a la lista [Lista [T]].
List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11).grouped(3).toList
res3: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9), List(10, 11))
Si desea un método roughen en la Lista puede utilizar una conversión implícita, algo así como:
scala> class RList[T](val l: List[T]) {def roughen(n: Int) = l.grouped(n).toList}
defined class RList
scala> implicit def list2rlist[T](l: List[T]) = new RList(l)
list2rlist: [T](l: List[T])RList[T]
scala> List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11) roughen 3
res5: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9), List(10, 11))
Vaya, no vi la respuesta de Thomas. –
¡Todas las respuestas son muy buenas! pero el nombre agrupado es malo, el rough es más general, como contra flatten: P, tal vez áspero recibir una función que aspereza por él, tal longitud, regex ..., será mejor – user342304
Pero rough implicaría (para mí al menos) que las listas no tenían la misma longitud, como una matriz irregular. Creo que la partición se usa en otros idiomas/bibliotecas para la misma operación. – pdbartlett
Esto es lo mejor que se le ocurrió:
def roughen(l:List[_],s:Int):List[_] ={
if (l.isEmpty) return Nil
val l2 = l.splitAt(s)
l2._1 :: roughen(l2._2,s)
}
val l = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
roughen(l,3)
//returns: List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9), List(10))
Desde usted usa la etiqueta Clojure también ...
Hay una función incorporada para hacer eso en Clojure 1.2, también disponible en 1.1 en cloj ure.contrib.seq-utils.
(partition-all 3 [1 2 3 4 5 6 7 8 9 10 11])
; => ((1 2 3) (4 5 6) (7 8 9) (10 11))
Ver también partition
y partition-by
. También tenga en cuenta que partition
y partition-all
aceptan algunos argumentos opcionales si necesita algo ligeramente diferente, consulte p. Ej. (doc partition)
en REPL.
Con frecuencia me sorprende la amplitud de la funcionalidad de las bibliotecas de Clojure ... ¡pero desearía que hubiera una manera inteligente de encontrar las que desea rápidamente! (por supuesto, pedirle a las superestrellas sobre stackoverflow siempre es una opción :-)) – mikera
Ver http://clojure.org/cheatsheet - la partición está ahí en "Sects anidados". –
Aquí hay una aplicación compatible con Clojure 1.0 de roughen:
(defn roughen
"Roughen sequence s by sub-grouping every n elements.
e.gn (roughen '(a b c d) 2) -> ((a b) (c d))"
[s n]
(loop [result() s s]
(cond (empty? s)
result
(< (count s) n)
(concat result (list s))
:default
(recur (concat result (list (take n s))) (drop n s)))))
user=> (roughen '(a b c d e f g) 2)
((a b) (c d) (e f) (g))
user=> (roughen '(a b c d e f) 2)
((a b) (c d) (e f))
user=> (roughen '(a b c d e f) 4)
((a b c d) (e f))
user=>
Y otra versión clojure, escrito en clojure más idiomática.
(defn roughen
[n coll]
(lazy-seq
(when-let [s (seq coll)]
(let [[l r] (split-at n s)]
(cons l (roughen n r))))))
Nota, que split-at
atraviesa la secuencia de entrada dos veces. Para que pueda reemplazar la versión estándar con lo siguiente:
(defn split-at
[n coll]
(loop [n n, s coll, l []]
(if-not (zero? n)
(if-let [s (seq s)]
(recur (dec n) (rest s) (conj l (first s)))
[l nil])
[l s])))
(. Por supuesto, se podría usar partition
y amigos como ya se mencionó anteriormente)
- 1. Aplanar una lista de listas
- 2. ¿Modelo de objeto en estilo funcional?
- 3. Cómo mantenerme fiel al estilo funcional en Scala para expresiones
- 4. ¿Qué es un estilo sin puntos en la programación funcional?
- 5. Aplanar una lista de listas anidadas en Erlang
- 6. Programación funcional en C++ 11, estilo F #
- 7. ¿Cómo influye la programación funcional en su estilo de codificación?
- 8. Aplanar confirmaciones en una rama
- 9. Lista doblemente enlazada en un lenguaje de programación puramente funcional
- 10. Ruby: ¿cómo empalmar una matriz en una lista estilo Lisp?
- 11. Acerca de la programación de estilo funcional
- 12. cómo aplanar un WPF TreeView
- 13. Mejor enfoque funcional para Y a través de una lista
- 14. ¿Cómo separar estilos en un estilo de lista anidada?
- 15. aplanar una trama de datos
- 16. Depuración Código F # y estilo funcional
- 17. Pregunta sobre el estilo OOP funcional en JavaScript
- 18. C++ en lugar de C-estilo arroja
- 19. Scala Rendimiento: estilo imperativo vs funcional
- 20. gama Aplanar en PowerShell
- 21. Aplanar tupla como una bolsa
- 22. ¿Cómo restar elementos específicos en una lista usando programación funcional en Mathematica?
- 23. ¿Cómo puedo combinar interfaces fluidas con un estilo funcional en Scala?
- 24. ¿Cómo 'aplanar' múltiples UIImageViews en UNO?
- 25. ¿Cómo usar un usuario autenticado en una prueba funcional Symfony2?
- 26. Aplanar jerarquía de lista de adyacencia a una lista de todas las rutas
- 27. programación de juego scala: posición de avance del objeto en un estilo funcional
- 28. ¿Cómo estructurar una aplicación escrita en un lenguaje funcional?
- 29. Cómo aplanar IO [[String]]?
- 30. Clojure: Semi-Aplanar una secuencia anidada
-1 para el estilo. Difícil de averiguar la pregunta real – Dario
"Roughen"? Personalmente me referiría a eso como "agrupado", como también lo hace Scala. :-) –