We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
Loading...
  1. Practice
  2. Functional Programming
  3. Introduction
  4. Reverse a List
  5. Discussions

Reverse a List

Sort 43 Discussions, By:

votes

  • FF
    FlavioFernandes4 + 2 comments

    Scala:

    arr.foldLeft(List[Int]())((acc,v) => v::acc)
    • SR
      suryakalyanr + 3 comments

      Is there anyway I can get a detailed explanation of how this works? This is fascinating.

      • P
        petrpoliak9 + 0 comments

        Scala api and :: is concatenation

      • alesasnouski + 0 comments

        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

      • L
        LuisLC + 0 comments

        Check: https://commitlogs.com/2016/09/10/scala-fold-foldleft-and-foldright/

    • xavier_guihot + 0 comments
      [deleted]

  • __spartax + 6 comments
    rev [] = []
rev (h:t) = rev t ++ [h]
    • asaka + 0 comments

      So sexy!

    • SS
      onecrane + 0 comments

      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.

    • P
      petrpoliak9 + 0 comments

      using accumulator
      rev l = rev' l []
      rev'::[a]->[a]->[a]
      rev' [] l = l
      rev' (x:xs) l = rev' xs (x:l)

    • SR
      suryakalyanr + 1 comment

      I m sorry, but what language is this?

      • P
        petrpoliak9 + 0 comments

        Haskell

    • Kaan_Aydinay + 0 comments

      yo !

    • BA
      bayalla_abdelka1 + 0 comments

      this is sorcery!

  • AH
    hycnara95 + 1 comment
    rev l = last l : (rev $ init l)
    • JZ
      john_jiabin_zha1 + 1 comment

      It will cause an error when getting last [] or init [].

      • HK
        har33sh + 0 comments
        • rev l = (last l) : (rev (init l)) *

        works !

        Easy way

        rev l = reverse l

  • luizpericolo + 2 comments

    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 + 0 comments
      [deleted]
    • MartinRosenberg + 0 comments

      If you're going to use tail recursion in Scala, you need to annotate the helper function with @tailrec.

  • HW
    causality + 1 comment

    rev l = foldl (flip (:)) [] l

    • J
      jinwuzhao + 0 comments

      this is great!

  • rudaliszka + 0 comments

    In Clojure: (fn [lst] (reduce conj '() lst))

  • TH
    thonagan + 0 comments

    I'm new to Scala having learned Python first, so a lot of my algorithms are pretty brute force since I'm still new. I try applying my logic in scala the same way I woud in Python so bear with me. Here's my solution:

    def f(arr:List[Int]):List[Int] = {
    var lst = List[Int]()
    for (i<- 0 to arr.length-1){
        lst = arr(i)::lst
    }
    return lst
}

  • pwalessi1 + 0 comments
    def f(arr:List[Int]):List[Int] = {
    var retval= List[Int]()
    for (elem<-arr){
        retval=elem::retval
    }
    retval
}

  • FM
    fedor_malyshkin + 0 comments

    Additional solution:

    def f(arr:List[Int]):List[Int] = {
    var index = arr.length
    List.fill(index)({
        index = index-1
        arr(index)
        })
}

  • TT
    Tohnmeister + 0 comments
    def f(arr:List[Int]):List[Int] = {
    import scala.annotation.tailrec
    @tailrec def loop(arr: List[Int], acc: List[Int]): List[Int] = arr match {
        case x :: xs => loop(xs, x :: acc)
        case _ => acc
    }

    loop(arr, Nil)
}
Load more conversations