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.
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.
hycnara95 rev l = last l : (rev $ init l)john_jiabin_zha1 It will cause an error when getting
last []orinit [].har33sh - rev l = (last l) : (rev (init l)) *
works !
Easy way
rev l = reverse l
rudaliszka In Clojure: (fn [lst] (reduce conj '() lst))
Ekwy_ Haskell :
rev [] = []rev l = last l : rev (init l)Is this efficient?
Yes or no, I woud like to know what makes efficient / inefficient and what concept could help me make it better
mertalptaytak Scala:
def f(arr:List[Int]):List[Int] = arr.zipWithIndex.sortWith(_._2 > _._2).map(_._1)
weozUA Scala solution
def f(arr:List[Int]):List[Int] = (for (i <- arr.size-1 to 0 by -1) yield arr(i)).toList
ddenisovdanila Erlang solution:
L = fun F(Acc) -> case io:fread("", "~d") of eof -> Acc; {ok, [N]} -> F([N | Acc]) end end, [io:fwrite("~p~n", [X]) || X <- L([])].
Sort 52 Discussions, By:
Please Login in order to post a comment