Sort 42 Discussions, By:

gmrodgers 3 years ago+ 1 comment

f arr = map abs arr

tongda 3 years ago+ 0 comments

actually you could omit arr as follow:

f = map abs

PaGrom 2 years ago+ 0 comments

Clojure:

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

balintant 3 years ago+ 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 7 months ago+ 0 comments

Here's kind of a funny solution:

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

Jack_Lee1_ 2 years ago+ 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 2 years ago+ 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 1 year ago+ 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 1 year ago+ 0 comments

or just

arr.map(Math.abs)

MartinRosenberg 1 year ago+ 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 1 year ago+ 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 9 months ago+ 0 comments

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

pratyoosh_sharma 3 years ago+ 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 3 years ago+ 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 3 years ago+ 0 comments

even better with arr.map(math.abs)

baranoob 3 years ago+ 1 comment

How about arr.map(_.abs)?

leongfeng 3 years ago+ 0 comments

I think this is a good solution.

numerocinquo 2 years ago+ 1 comment

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

patrick_ce 2 weeks ago+ 0 comments

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

elmadioune 2 weeks ago+ 0 comments

f# matching function

let ToPositif value =
match value with
| v when v < 0 -> -v
| v -> v

let f arr = List.map(ToPositif) arr

emrepun 2 months ago+ 0 comments

Scala recursive solution with pattern matching and list concatenation:

def f(arr:List[Int]):List[Int] = {
  def newArrayThing(oldOne:List[Int], newOne:List[Int]): List[Int] = oldOne match {
    case x::xs => 
        if (x < 0) newArrayThing(xs, newOne:+(-x)) 
        else newArrayThing(xs, newOne:+x)
    case Nil => newOne
  }
  newArrayThing(arr, List())
}

thnd23 4 months ago+ 0 comments

racket scheme solution

lang racket

(define (func) (let ((read-val (read))) (when (not (eof-object? read-val))
(write (abs read-val)) (newline) (func)))) (func)

sunilsparkscala 4 months ago+ 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

Load more conversations