[HADOOP] 스파크 및 스칼라에서 양수와 음수가 혼합 된 값 목록의 사이클 수

스파크 및 스칼라에서 양수와 음수가 혼합 된 값 목록의 사이클 수

값 목록이 포함 된 RDD에 양수와 음수가 혼합되어 있습니다. 이 데이터에서 사이클 수를 계산해야합니다.

예를 들어

val 범위 = 목록 -1010)

위 목록의 각 값 사이의 간격은 1 초입니다. 즉, 2020 및 2030은 1 초 간격으로 기록됩니다.

몇 번이고 네거티브에서 포지티브로 바뀌고> = 2 초 동안 포지티브로 유지됩니다. > = 2 초이면 사이클입니다.

사이클 수 : 논리 예 1 : 목록 (1,2,3,4,5,6, -15, -66) 사이클 수는 1입니다. 이유 : 목록의 첫 번째 요소에서 6 번째 요소로 이동할 때 5 초 간격으로 5 초를 의미합니다. 그래서 한주 기. 리스트의 6 번째 요소로 이동함에 따라 음수입니다. 6 번째 요소부터 7 번째 요소로 계산을 시작합니다. 음수 값은 2이고 간격은 1입니다. 따라서 주기로 계산되지 않습니다. 예 2 : 리스트 (11,22,33, -25, -36, -43,20,25,28) 사이클 수는 3입니다. 이유 : 목록의 첫 번째 요소에서 세 번째 요소로 이동할 때 간격이 2 초로 2 초입니다. 따라서 한 사이클리스트의 4 번째 요소로 이동하면 음의 값이됩니다. 그래서 우리는 4 번째 원소부터 계산을 시작하고 5 번째, 6 번째 원소로 이동합니다. 우리는 2 초 간격으로 2 초를 가졌습니다. 따라서 한 사이클리스트의 7 번째 요소로 이동할 때 양수 값입니다. 그래서 우리는 7 번째 요소부터 8 번째, 9 번째 요소로 계산을 시작합니다. 우리는 2 초 간격으로 2 초를 가졌습니다. 그래서 한주 기.

범위는 사용 사례에서 RDD입니다. 마치 스칼라> 범위 범위 : Seq [com.Range] = 목록 (XtreamRange (858,890,899,920, StartEngage, -758, -790, -890, -720,920,940,950))

해결법

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

   1."음에서 양으로 바뀌고> = 2 초 동안 양을 유지하는 횟수를이 코드로 인코딩 할 수 있습니다.> = 2 초이면 사이클입니다." 가드와 패턴 일치에 거의 직접. if (h <0 && ht> 0 && hht> 0) 식은주기를 확인하고 결과에 1을 더한 다음 나머지리스트를 계속합니다.

   "음에서 양으로 바뀌고> = 2 초 동안 양을 유지하는 횟수를이 코드로 인코딩 할 수 있습니다.> = 2 초이면 사이클입니다." 가드와 패턴 일치에 거의 직접. if (h <0 && ht> 0 && hht> 0) 식은주기를 확인하고 결과에 1을 더한 다음 나머지리스트를 계속합니다.

   def countCycles(xs: List[Int]): Int = xs match {
    case Nil => 0
    case h::ht::hht::t if(h < 0 && ht > 0 && hht > 0) => 1 + countCycles(t)
    case h::t => countCycles(t)
   }
   
   scala> countCycles(range)
   res7: Int = 1
   

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

   2.하나의 라이너

   하나의 라이너

   range.sliding(3).count{case f::s::t::Nil => f < 0 && s > 0 && t > 0}
   

   이것은 길이 3의 모든 하위 시퀀스를 생성하고 -ve, + ve, + ve 수를 계산합니다.

   일반화주기 길이

   def countCycles(n:Int, xs:List[Int]) = xs.sliding(n+1)
                                            .count(ys => ys.head < 0 && ys.tail.forall(_ > 0))
   

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

   3.아래 코드는 쿼리를 해결하는 데 도움이됩니다.

   아래 코드는 쿼리를 해결하는 데 도움이됩니다.

   object CycleCheck {
      def main(args: Array[String]) {
        var data3 = List(1, 4, 82, -2, -12, "startingpoint", -9, 32, 76,45, -98, 76, "Endpoint", -24)
        var data2 = data3.map(x => getInteger(x)).filter(_ != "unknown").map(_.toString.toInt)
        println(data2)
        var nCycle = findNCycle(data2)
        println(nCycle)
      }
   
      def getInteger(obj: Any) = obj match {
        case n: Int => obj
        case _     => "unknown"
   
      }
   def findNCycle(obj: List[Int]) : Int = {
    var cycleCount =0
    var sign = ""
    var signCheck="+"
    var size = obj.size - 1
    var numberOfCycles=0
    var i=0
    for( x <- obj){
      if (x < 0){
        sign="-"
      }
      else if (x > 0){
        sign="+"
       }
   
     if(signCheck.equals(sign))
           cycleCount=cycleCount+1
   
     if(!signCheck.equals(sign) && cycleCount>1){
          cycleCount = 1
          numberOfCycles=numberOfCycles+1
     }    
     if(size==i && cycleCount>1)
         numberOfCycles= numberOfCycles+1
   
   
    if(cycleCount==1)
         signCheck = sign;
   
     i=i+1
    }
   
     return numberOfCycles  
   

   } }

from https://stackoverflow.com/questions/39219085/number-of-cycles-from-list-of-values-which-are-mix-of-positives-and-negatives-i by cc-by-sa and MIT license