FlavioFernandes4 Scala:
arr.foldLeft(List[Int]())((acc,v) => v::acc)
suryakalyanr Is there anyway I can get a detailed explanation of how this works? This is fascinating.
petrpoliak9 Scala api and
::is concatenation
alesasnouski List[Int] is accumulator, () near List[Int] means that it's an empty List at the beginning; (acc, v) => v:acc is a function that receives accumulator and value from left and than adds this into List - :: operation. try in console: 5::4::3::2::1::Nil
xavier_guihot [deleted]
__spartax rev [] = [] rev (h:t) = rev t ++ [h]
asaka So sexy!
onecrane Thanks much, that's exactly what I needed - that ++ concatentation operator. I was following examples too quickly and didn't realize that : is only for prepending.
petrpoliak9 using accumulator
rev l = rev' l []
rev'::[a]->[a]->[a]
rev' [] l = l
rev' (x:xs) l = rev' xs (x:l)suryakalyanr I m sorry, but what language is this?
petrpoliak9 Haskell
Kaan_Aydinay yo !
bayalla_abdelka1 this is sorcery!
ajs520 This is pretty inefficient haskell, as you have to traverse the entire list and make a copy of it each time you use the ++ operator. A more efficient solution is
rev = foldl (\acc x -> x : acc) []. this way, you avoid the expense of using the ++ operator
eloyekunle Or, with
flip:rev = foldl (flip (:)) []
Although, this is pretty advanced since we're making use of higher order functions already. Deriving the 'inefficient' solution first, before learning why it's inefficient is the way to go.
M_F_H yet I read on haskell.org/prelude, "Also note that if you want an efficient left-fold, you probably want to use
foldl'instead offoldl." So maybe this isn't that efficient? Can you say a word about this? (I'm a complete newbie... :-))
chesschingis Thanks! I forgot h was supposed to be a list.
luizpericolo My Scala solution:
def f(arr:List[Int]):List[Int] = { def revList(orig: List[Int], rev: List[Int]): List[Int] = { orig match { case Nil => rev case x::xs => revList(xs, x :: rev) } } revList(arr, Nil) }
xavier_guihot [deleted]
MartinRosenberg If you're going to use tail recursion in Scala, you need to annotate the helper function with @tailrec.
rudaliszka In Clojure: (fn [lst] (reduce conj '() lst))
chrissphinx Not enough Elixir love:
IO.stream(:stdio, :line) |> Enum.map(&String.trim/1) |> Enum.reduce([], &([&1 | &2])) |> Enum.each(&IO.puts/1)
luislhsc Elixir using recursion and pattern matching
def filter([]), do: nil def filter([x | tail] = _numbers) do filter(tail) IO.puts x end
reis_vitore Haskell:
rev l = [ l !! (i-1) | i <- [length l, length l - 1 .. 1]]
[length l, length l - 1 .. 1] -- generates a list of decreasing indexes
l !! (i-1) -- accesses the (i-1)th element of l
all within a list comprehension.
ZakBibi Scala:
def f(arr:List[Int]):List[Int] = { arr match{ case head :: Nil => List(head) case head :: tail => f(tail) :+ head } }
Sort 67 Discussions, By:
Please Login in order to post a comment