훈남규

def getMaxArrayMulti(numbers:Array[Int]) : BigInt = {
  var mMultiply:BigInt = 1
  val minData = numbers.min
  val minIdx = numbers.indexOf(minData)

  numbers(minIdx) += 1

  for(num<- numbers) {
    mMultiply *= num
  }

  mMultiply
}

Q3 답

답안

def inviteParty2(first:Array[String], second:Array[String]) : Int = {
  var mMap = new mutable.HashMap[String, Int]()

  for(i<-first.length) {
    mMap.put(first(i),0)
    mMap.put(second(i),0)
  }

  for(i<-first.length) {
    mMap(first(i)) = mMap.getOrElse(first(i),0)+1
    mMap(second(i)) = mMap.getOrElse(second(i),0)+1
  }
  
  var ans = 0
  
  for(key<-mMap.keySet){
    ans = Math.max(ans, mMap.getOrElse(key,0))
  }
  
  ans
}

자바식으로 그대로 스칼라로 바꾼 것

좋은 답은 아닌거 같다

def inviteParty(first:Array[String], second:Array[String]) : Int = {
  var mResultCnt = 1

  var mFirstMap = mutable.Map[String, Int]()
  var mSecondMap = mutable.Map[String, Int]()

  for (num <- first.indices) {
    if(mFirstMap.contains(first(num)) || mSecondMap.contains(first(num))
      || mFirstMap.contains(second(num)) || mSecondMap.contains(second(num))){
      mResultCnt+=1
    }
    mFirstMap.put(first(num), 1)
    mSecondMap.put(second(num), 1)
  }

  mResultCnt
}

 답!

if 문은 적게 쓸수록 좋다 그거는 프로그래머라면 다들 알고 있는 상식!!

이건 내가 한 것이 아니다...

def thePouring2(capapcities:Array[Int], bottles:Array[Int], fromId:Array[Int], toId:Array[Int]) : Array[Int] = {

  for(nl <- fromId.indices ) {
    val sum = bottles(fromId(nl)) + bottles(toId(nl))
    bottles(toId(nl)) = Math.min(sum, capapcities(toId(nl)))
    bottles(fromId(nl)) = sum - bottles(toId(nl))

  }

  bottles
}

결국은 수학적 사고 방식이 필요 한 것인가...

때론 단순한게 좋지만...

Input이 크지 않는 데이터라면 속도 차이는 거의 없다고 봐도 무방하지만

Input이 커질수록 if문이 있고 없고의 차이는 크다...

하지만 무엇이 딱 옳다고 말 할 수는 없는 것 같다.

코드는 줄일 수 있다면 좋지만 그 만큼 가독성이 떨어지기도 하니 말이다..

더 좋은 방법이 있을 것 같은데 더 공부를 해봐야 할 것 같다.

[Hun]

무언가 좀 더 깔삼한 방법이 있을 것 같지만...

일단 우선 적으로 만든 것(Scala)

def thePouring(capapcities:Array[Int], bottles:Array[Int], fromId:Array[Int], toId:Array[Int]) : Array[Int] = {

  for(nl <- 0 until fromId.length ) {
    val fromNum = fromId(nl)      //시작 넘버
    val toNum = toId(nl)          //to 넘버

    val addJuice = bottles(toNum) + bottles(fromNum)

    if(capapcities(toNum) - addJuice <0) {
      bottles(toNum) = capapcities(toNum)
      bottles(fromNum) = addJuice - capapcities(toNum)
    } else {
      bottles(fromNum) = 0
      bottles(toNum) = addJuice
    }
  }

  bottles
}