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 46 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 + 1 comment

    Here's kind of a funny solution:

    main = interact $ filter (/= '-')
    • nitinpatel278 + 0 comments

      Genius!

  • 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 + 1 comment

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

      • patrick_ce + 0 comments

        My favorite :D Although my first answer was with "if (x<0) ..."

  • sandez_jorge + 0 comments

    Scala

    import scala.math._

    def f(arr:List[Int]):List[Int] = arr.map(abs(_))

  • sebbelundin + 0 comments
    f (x:xs) 
    | x < 0 = x * (-1) : f xs
    | otherwise = x : f xs

  • julianolf + 0 comments

    Elixir

    defmodule Solution do
  def main do
    IO.read(:stdio, :all)
      |> String.split("\n", trim: true)
      |> Enum.each(&(IO.puts abs(String.to_integer(&1))))
  end
end

Solution.main

  • A_M_C + 0 comments

    Haskell.

    import Data.Maybe (mapMaybe)
import Text.Read (readMaybe)

f :: Num a => [a] -> [a]
f = map abs

main :: IO ()
main = interact (unlines . map show . f . mapMaybe readMaybe . lines)

    import Data.Maybe (mapMaybe)
import Text.Read (readMaybe)

main :: IO ()
main = interact (unlines . map (show . abs) . mapMaybe readMaybe . lines)
Load more conversations