# How to check whether a number is perfect number or not in a list of integers using scala higher order function

`Question:-` Can anyone please help me to solve the below problem?

`ListMapHigherOrder` takes an array of string inputs `args` from command line. First convert the array of strings `args` to `intList` i.e a list of integers. Write a function `isPerfectNumber` which takes `integer input` and returns `String output` . It finds if a number is perfect and returns `true` if perfect else return `false` . A perfect number is a number whose sum factors(except for the number itself) is itself (like 6 = 1+2+3). Now write a higher order function `myHigherOrderFunction` which takes `isPerfectNumber` and `intList` as input and returns a List of Strings which contains the output if the number is perfect or not using `map` .

Code snippet:-

object ListMapHigherOrder{ def main(args :Array[String])

{

val intList :List[Int] = //write code to convert args to list of integers

def isPerfectNumber //write code to find is a number is perfect or not

}

def myHigherOrderFunction //complete the higher order function

}

println(myHigherOrderFunction(isPerfectNumber, intList))

}

}

Compile the program using:

`scalac ListMapHigherOrder.scala`

Execute the program to print the outputs:

`scala ListMapHigherOrder.scala 3 6 7`

`Output will be: List(false, true, false)`

Hi,

I think the reason no one responded is that this very much smells like a homework problem, and people donâ€™t want to solve other peopleâ€™s homework for them.

You will most likely have more luck if you focus on one particular issue you are having trouble with and write a question in your own words.

2 Likes

I have tried to solve the problem as below. Here, i am getting the output as-
List(false)List(true)List(false).
But, the desired output is- List(false,true,false) [where, the input list is- List(3,6,7)]

Can anyone please look into the below code and help me to get the desired output i.e. List(false,true,false)?-

Object ListMapHigherOrder{

def main(args:Array[String])

{

val a=args(0).toInt

val b=args(1).toInt

val c=args(2).toInt

val intList:List[Int]=List(a,b,c)

def isPerfectNumber(num:Int):Boolean={

def perfect(n:Int):Boolean={

if(n<=0)

false

else

{

If((for(i<-2 to n/2 if n%i==0)yield i).sum+1==n)

true

else

false

}

}

perfect(num)

}

def myHigherOrderFunction(perfect: (Int)=>Boolean,intList:List[Int])={

val a:List[Boolean]=List();

intList.foreach((x:Int)=>print(List.concat(a,List(perfect(x)))))

}

myHigherOrderFunction(isPerfectNumber,intList)

}

}

Can someone please assist me to get the output in desired format i.e. List(false,true,false) for input list List(3,6,7)?
In the above code, i am getting the output as- List(false)List(true)List(false).

You have a list: List[Int], and you need a List[Boolean], and you have a function isPerfectNumber: (Int) => Booleanâ€¦ I think you should be able to put this together: â€ślist.map(isPerfectNumber)â€ť.

Brian Maso

1 Like

object ListMapHigherOrder{
def main(args:Array[String])
{
//val input = Array(args(0).toString, args(1).toString, args(2).toString)
//val spString= ipstring.split(" ").toList
//val intList: List[Int] = spString.map(_.toString.toInt)

//working one
val intRes = args.toList
val intList: List[Int] = intRes.map(_.toInt).toList

//val ipstring = args(0).toString
//val spString= ipstring.split(" ").toList
//val intList = spString.map(_.toString.toInt)

def isPerfectNumber(ipnumber:Int):String={
var sum: Int = 0
for (i <- 1 to (ipnumber -1)){
val rem = ipnumber % i
if (rem == 0){sum = sum + i}
}
if (sum == ipnumber) {
//println(â€śEntered Number is perfect numberâ€ť)
val res: String = â€śtrueâ€ť
return res}
else {
val res: String = â€śfalseâ€ť
return res}
}

def myHigherOrderFunction(argFn: Int => String, argVal:List[Int]): List[String]={
val res = argVal.map(argFn)
return res
}
println(myHigherOrderFunction(isPerfectNumber, intList))
}
}

1 Like

//val perfect = intList.map(isPerfectNumber)
output as List(false,true,false) but
not using map function

object ListMapHigherOrder{
def main(args :Array[String]){

val intList :List[Int] = args.map(_.toInt).toList

def isPerfectNumber(n: Int) :String = {
if ( (for (x <- 2 to n/2 if n % x == 0) yield x).sum + 1 == n )
return â€śtrueâ€ť
else
return â€śfalseâ€ť
}

def myHigherOrderFunction(f: (Int) => String, argList :List[Int]) :List[String] = {
return argList.map(f)

}

println(myHigherOrderFunction(isPerfectNumber, intList))
}
}

This is also throwing errorâ€¦ As per my understanding, it has been asked to avoid loop and use map.

if ( (for (x <- 2 to n/2 if n % x == 0) yield x).sum + 1 == n )

Can anyone help write the same program but instead of for loop use map ?
saraswat

I think you need to use a fold. If the collection isnâ€™t too large, use a collect first. To make things like this understandable, I usually create a number of one-statement methods. That will (hopefully) make the operation understandable.

At that point, you can recombine the code and/or leave parts of it in the methods. The only reason to break it into methods is to aid in understanding the code. Once thatâ€™s transparent, reconstructing it is easy.

And shoot the original programmer. When I am the original programmer, I just hit my head against the desk for a minute. It helps remind me not to write this kind of thing in the future.

Any suggestion how it can be used in below for loop logic ?

object ListMapHigherOrder{
def main(args :Array[String]){

val intList :List[Int] = args.map(_.toInt).toList

def isPerfectNumber(n: Int) :String = {
if ( (for (x <- 2 to n/2 if n % x == 0) yield x).sum + 1 == n ) // can you please provide the logic
return â€śtrueâ€ť
else
return â€śfalseâ€ť
}

def myHigherOrderFunction(f: (Int) => String, argList :List[Int]) :List[String] = {
return argList.map(f)

}

println(myHigherOrderFunction(isPerfectNumber, intList))
}
}

Hi All,

Is there any suggesstion on this ?

what is your question, exactly, at this point? what aspect of this are you stuck on?

Here is the Problem Statement :

ListMapHigherOrder takes an array of string inputs args from the command line. Convert the array of strings args to intList, a list of integers. Write a function isPerfectNumber which takes integer input and returns String output. It finds if a number is perfect, and returns true if perfect, else returns false. A perfect number is a number whose sum factors (except for the number itself) is itself (example, 6 = 1+2+3). Write a higher order function myHigherOrderFunction which takes isPerfectNumber and intList as input, and returns a List of Strings which contain the output if the number is perfect or not using map.

Output will be: List(false, true, false)

Here is the Code snipped :

object ListMapHigherOrder{
def main(args :Array[String]){

val intList :List[Int] = args.map(_.toInt).toList

def isPerfectNumber(n: Int) :String = {
if ( (for (x <- 2 to n/2 if n % x == 0) yield x).sum + 1 == n ) // can you please provide the logic
return â€śtrueâ€ť
else
return â€śfalseâ€ť
}

def myHigherOrderFunction(f: (Int) => String, argList :List[Int]) :List[String] = {
return argList.map(f)

}

println(myHigherOrderFunction(isPerfectNumber, intList))
}
}

I am getting correct output using this logic. But in the problem statement is asking to write MAP function to get perfect number. In this above logic, I assume the below part is considered as not completed because it is being asked to use MAP function to do this for loop and condition check logic.

if ( (for (x <- 2 to n/2 if n % x == 0) yield x).sum + 1 == n )

can you please let me know how using MAP we can do the same task ? ( for loop , then condition check and summation)

The `for` loop here is just searching for factors of your target number. You could if desired build the numbers `2..n/2` as a list and filter it (which is a higherOrderedFunction) but without getting silly the `for` loop is your quickest way to solve what it is solving (i.e, finding factors, summing + 1, seeing if it matches your input and thus your input is a perfect number).

The problem statement is asking you to use `map` on your List[Int] with your isPerfectNumber function. Not to use `map` in isPerfectNumber.

Any issue with below code

``````object ListMapHigherOrder{
def main(args:Array[String])
{

val intRes = args.toList
val intList: List[Int] = intRes.map(_.toInt).toList

def isPerfectNumber(input: Int) :String  =
{
var check_sum = ( (2 to math.sqrt(input).toInt).collect  { case x if input % x == 0 => x + input / x}  ).sum
if ( check_sum == input - 1 )
return "true"
else
return "false"
}

def myHigherOrderFunction(argFn: Int => String, argVal:List[Int]): List[String] = { argVal.map(argFn) }

println(myHigherOrderFunction(isPerfectNumber, intList))

}
}
``````

Please let us know what issue with

object ListMapHigherOrder{
def main(args:Array[String])
{

val intRes = args.toList
val intList: List[Int] = intRes.map(_.toInt).toList

def isPerfectNumber(input: Int) :String =
{
var check_sum = ( (2 to math.sqrt(input).toInt).collect { case x if input % x == 0 => x + input / x} ).sum
if ( check_sum == input - 1 )
return â€śtrueâ€ť
else
return â€śfalseâ€ť
}

def myHigherOrderFunction(argFn: Int => String, argVal:List[Int]): List[String] = { argVal.map(argFn) }

println(myHigherOrderFunction(isPerfectNumber, intList))

}
}

getting required result but cannot pass exam

how to wrote code without var n returnâ€¦ seems after that code will work

Try changing `var` to `val` and simply omitting `return` (itâ€™s rarely needed in Scala, if ever). Does anything go wrong? If so, what?

As an aside, `Boolean` would be a better than `String` as a return type for `isPerfectNumber`.