[SCALA] 의 경우의 프로그램 무리에 스칼라 방법

의 경우의 프로그램 무리에 스칼라 방법

i'am 스칼라로 밖으로 시작하고, 여기에 기능적인 방법을 적용하려고하지만, 알아보기 힘들 느릅 나무 경우 \ 다른 구조를 중첩의 내가 무리와 함께 나온, 그리고 난 궁금해 프로그램 같은 것들에 더 좋은 방법이있다? 예를 들어 내가 수행 괄호 균형 것을, 스크립트를 작성했습니다

def balance(chars: List[Char]): Boolean = {
    def checkParentesys(chars: List[Char], parentesis: List[Char]): Boolean =
      if (chars.isEmpty && parentesis.isEmpty)
        true
      else
        if (chars.head == '(')
            checkParentesys(chars.tail, '(' :: parentesis)
        else
            if (parentesis.isEmpty)
                false
            else
                checkParentesys(chars.tail, parentesis.tail)

    checkParentesys(chars.filter(s => s == '(' || s == ')'), List())
  }

당신은 내가 좋아하는 것이 더 많은 기능과 더 스칼라을 쓸 수있는 방법, 제안 할 수 있습니다?

해결법

1. ==============================

   1.배로 작성하는 더 좋은 수 있습니다 :

   배로 작성하는 더 좋은 수 있습니다 :

   def balance(chars: List[Char]): Boolean = chars.foldLeft(0){
     case (0, ')') => return false
     case (x, ')') => x - 1
     case (x, '(') => x + 1
     case (x, _  ) => x
   } == 0
   

2. ==============================

   2.나는 당신이 그것을 통과하기 전에 목록을 필터링 할 이유가 있다고 생각하지 않습니다. 당신이 목록을 통과으로 당신은 비 괄호를 무시할 수 있습니다. 나는 또한 두 번째 목록을 구축 할 필요가 없다 생각합니다. 당신이 정말로 알고 싶은 모든 여는 괄호의 수는 결코 부정적이다 :

   나는 당신이 그것을 통과하기 전에 목록을 필터링 할 이유가 있다고 생각하지 않습니다. 당신이 목록을 통과으로 당신은 비 괄호를 무시할 수 있습니다. 나는 또한 두 번째 목록을 구축 할 필요가 없다 생각합니다. 당신이 정말로 알고 싶은 모든 여는 괄호의 수는 결코 부정적이다 :

   def balance(chars: List[Char]): Boolean = {
     @tailrec
     def _balance(chars: List[Char], count: Int) : Boolean = 
       chars match {
           case Nil => count == 0   // end of the string did we close every open?
           case '(' :: xs => _balance(xs, count+1)  
           case ')' :: xs => (count > 0) && _balance(xs, count-1) 
           case _ => _balance(chars.tail, count) // uninteresting char, skip it
       }
   
     _balance(chars, 0)
   }
   

3. ==============================

   3.잘:

   잘:

   그것과 같을 것이다 그래서 :

   def balance(chars: List[Char]): Boolean = {
     @tailrec
     def checkParentesys(chars: List[Char], parentesis: List[Char]): Boolean =
       if (chars.isEmpty && parentesis.isEmpty)
         true
       else if (chars.head == '(')
         checkParentesys(chars.tail, '(' :: parentesis)
       else if (chars.isEmpty || parentesis.isEmpty)
         false
       else
         checkParentesys(chars.tail, parentesis.tail)
   
     checkParentesys(chars.filter(Set('(', ')')), List())
   }
   

   당신은 또한 단지 패턴 일치로 전체를 돌 수 있었다 :

   def balance(chars: List[Char]): Boolean = {
     @tailrec
     def checkParentesys(chars: List[Char], parentesis: List[Char]): Boolean =
       (chars, parentesis) match {
         case (Nil, Nil) => true
         case ('(' :: charsTail, _) => checkParentesys(charsTail, '(' :: parentesis)
         case (Nil, _) => false
         case (_, Nil) => false
         case (')' :: charsTail, '(' :: parentesisTail) => checkParentesys(charsTail, parentesisTail)
       }
     checkParentesys(chars.filter(Set('(', ')')), List())
   }
   

4. ==============================

   4.

   var parens :List[Char] =  Nil
   def matcher(chrs: List[Char]): Boolean = {
        if (chrs.isEmpty) {
           return parens.isEmpty
        }
        else {
            chrs.head match {
              case '(' =>  parens = '(' :: parens ;matcher(chrs.tail)
              case ')' =>  if (parens.isEmpty) return false 
                               else if (parens.apply(0) ==  '(') parens = parens.drop(1) 
                               else return false;  
                               matcher(chrs.tail);
              case _ => matcher(chrs.tail)
            }
        }
   }
   

   당신은 () () 계수가 작동하지 않습니다 때문에이 수를 사용하지 않은 볼 수 있듯이

from https://stackoverflow.com/questions/12523788/scala-way-to-program-bunch-of-ifs by cc-by-sa and MIT license