__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.
chesschingis Thanks! I forgot h was supposed to be a list.
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]
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))
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
CylonSam Another clojure solution:
(fn [lst] (rseq (vec lst)))
chukwudumiebi With Scala, i tried
arr.inits.toList.init.map(_.last)
Seems rather inefficient with all the transformations but looks cool.
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.
sunilsparkscala Scala solution
def f(arr:List[Int]):List[Int] = (
for(i<- arr.length-1 to 0 by -1 ) yield arr(i)).toList
Sort 56 Discussions, By:
Please Login in order to post a comment