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. Update List
  5. Discussions

Update List

Sort 39 Discussions, By:

votes

  • gmrodgers + 1 comment

    f arr = map abs arr

    • tongda + 0 comments

      actually you could omit arr as follow:

      f = map abs

  • PaGrom + 0 comments

    Clojure:

    (fn[lst]
    (map #(Math/abs %) lst))

  • balintant + 0 comments

    Haskell

    -- Enter your code here. Read input from STDIN. Print output to STDOUT

f arr = [abs x | x <- arr]-- Complete this function here

-- This section handles the Input/Output and can be used as it is. Do not modify it.
main = do
   inputdata <- getContents
   mapM_ putStrLn $ map show $ f $ map (read :: String -> Int) $ lines inputdata

  • patrickwherrmann + 0 comments

    Here's kind of a funny solution:

    main = interact $ filter (/= '-')

  • Jack_Lee1_ + 5 comments

    For Scala

    import scala.math._
def f(arr:List[Int]):List[Int] = arr.map((a:Int) => abs(a))

    I feel it was a bit of cop out using the abs() function. Does anyone have a method to solve it using something tail recursive?

    • luizpericolo + 1 comment

      Here you go:

      def f(arr:List[Int]):List[Int] = {
    def absList(absed: List[Int], unabsed: List[Int]): List[Int] = {
        unabsed match {
            case Nil => absed
            case x :: xs => {
                x match {
                    case v if v < 0 => absList(absed :+ v * -1, xs)
                    case v => absList(absed :+ v, xs)
                }
            }
        }
    }
    absList(Nil, arr)
}

      Feel free to ask if you have any doubts.

      • bayalla_abdelka1 + 0 comments
        def fabs(arr:List[Int]):List[Int] = {

  def loop(arr:List[Int],acc:List[Int]):List[Int] = arr match {
    case Nil => Nil
    case h :: tail =>  h.abs :: loop(arr tail,acc)
  }
    
  loop(arr,List()) 
}
    • vestail + 0 comments

      or just

      arr.map(Math.abs)
    • MartinRosenberg + 0 comments

      Generally, I'd avoid cluttering the namespace with a wildcard import, especially given only one member of it is actually being used. Also, for members of scala, you can actually drop scala.:

      def f(arr: List[Int]): List[Int] = arr map math.abs
    • MartinRosenberg + 0 comments

      To avoid using math.abs:

      def f(arr: List[Int]): List[Int] = arr map (x => x * x.signum)

      And if you wanna do that with tail recursion:

      def f(arr: List[Int]): List[Int] = {
  @annotation.tailrec
  def run(i: Int, res: List[Int]): List[Int] = arr.length match {
    case `i` => res
    case _   => run(i + 1, res :+ arr(i) * arr(i).signum)
  }
  run(0, List.empty[Int])
}
    • sao_rahul + 0 comments

      "def f(arr:List[Int]):List[Int] = arr.map(x => if (x < 0 ) -x else x )"

  • pratyoosh_sharma + 2 comments

    Scala noob here, any comments if this is a valid solution scala def abs(x:Int):Int = { if(x<0) x * -1 else x } def f(arr:List[Int]):List[Int] = { arr.map(x=> abs(x)).toList
    }

    • martinez_calvo_1 + 2 comments

      Instead of to declare abs function, you can use Math.abs, and also the .toList is not necessary because the map function returns in this case a List

      Here is my solution

      arr.map(Math.abs(_))

      • fazzdev + 0 comments

        even better with arr.map(math.abs)

      • baranoob + 1 comment

        How about arr.map(_.abs)?

        • leongfeng + 0 comments

          I think this is a good solution.

    • numerocinquo + 0 comments

      def f(arr:List[Int]):List[Int] = for(i <- arr) yield(i.abs)

  • sunilsparkscala + 0 comments

    Sunil scala solution

    import scala.math.{abs, max} def f(arr:List[Int]):List[Int] = (for(i<-0 to arr.length-1)yield(abs(arr(i)))).toList

  • apeksha_career + 0 comments

    for Scala : arr.map(_.abs)

  • AndresReyMaz + 0 comments

    Common Lisp (SBCL):

    (defun f (l)
  (map 'list #'abs l))

  • rpatrelle + 0 comments

    My clojure proposal: (fn[lst](map #(. Math abs %) lst))

Load more conversations