Искра - Найти диапазон всех недель в году между 2 неделями

Question

Мне нужно найти все недели года между указанными неделями.

201824 - это пример годовой недели.Это означает 24-ю неделю года 2018.

Предполагая, что в году 52 недели, недели 2018 года начинаются с 201801 и заканчиваются 201852. После этого они продолжаются с 201901.

Мне удалось найти диапазон между неделями года между двумя неделями, если начальная и конечная недели совпадают, как показано ниже

val range = udf((i: Int, j: Int) => (i to j).toArray)

Приведенный выше код работает, только когда начальная неделяи конечная неделя относится к одному и тому же году, например, 201912 - 201917

Как заставить ее работать, если начальная и конечная недели относятся к разным годам.

Example: 201849 - 201903

The above weeks should give the output as: 
201849,201850,201851,201852,201901,201902,201903

Answer 1

Вот решение с UDF, которое использует java.time API:

def weeksBetween = udf{ (startWk: Int, endWk: Int) =>
  import java.time.LocalDate
  import java.time.format.DateTimeFormatter
  import scala.util.{Try, Success, Failure}

  def formatYW(yw: Int): String = {
    val pattern = "(\\d{4})(\\d+)".r
    s"$yw" match { case pattern(y, w) => s"$y-$w-1"}
  }

  val formatter = DateTimeFormatter.ofPattern("YYYY-w-e")  // week-based year

  Try(
    Iterator.iterate(LocalDate.parse(formatYW(startWk), formatter))(_.plusWeeks(1)).
      takeWhile(_.isBefore(LocalDate.parse(formatYW(endWk), formatter))).
      map{ s =>
        val a = s.format(formatter).split("-")
        (a(0) + f"${a(1).toInt}%02d").toInt
      }.
      toList.tail
  ) match {
    case Success(ls) => ls
    case Failure(_) => List.empty[Int]  // return an empty list
  }
}

Тестирование UDF:

val df = Seq(
  (1, 201849, 201903), (2, 201908, 201916), (3, 201950, 201955)
).toDF("id", "start_wk", "end_wk")

df.withColumn("weeks_between", weeksBetween($"start_wk", $"end_wk")).show(false)
// +---+--------+------+--------------------------------------------------------+
// |id |start_wk|end_wk|weeks_between                                           |
// +---+--------+------+--------------------------------------------------------+
// |1  |201849  |201903|[201850, 201851, 201852, 201901, 201902]                |
// |2  |201908  |201916|[201909, 201910, 201911, 201912, 201913, 201914, 201915]|
// |3  |201950  |201955|[]                                                      |
// +---+--------+------+--------------------------------------------------------+

Answer 2

Ну, есть еще много оптимизаций, но для общего направления вы можете использовать:
Я использую org.joda.time.format здесь, но java.time также должно соответствовать.

 def rangeOfYearWeeks(weeksRange: String): Array[String] = {
  try {
    val left =  weeksRange.split("-")(0).trim
    val right = weeksRange.split("-")(1).trim

    val leftPattern  = s"${left.substring(0, 4)}-${left.substring(4)}"
    val rightPattern = s"${right.substring(0, 4)}-${right.substring(4)}"

    val fmt = DateTimeFormat.forPattern("yyyy-w")

    val leftDate  = fmt.parseDateTime(leftPattern)
    val rightDate = fmt.parseDateTime(rightPattern)
    //if (leftDate.isAfter(rightDate))
    val weeksBetween = Weeks.weeksBetween(leftDate, rightDate).getWeeks
    val dates = for (one <- 0 to weeksBetween) yield {
      leftDate.plusWeeks(one)
    }

    val result: Array[String] = dates.map(date => fmt.print(date)).map(_.replaceAll("-", "")).toArray
    result
  } catch {
    case e: Exception => Array.empty
  }
}

Пример:

val dates = Seq("201849 - 201903", "201912 - 201917").toDF("col")

val weeks = udf((d: String) => rangeOfYearWeeks(d))

dates.select(weeks($"col")).show(false)

+-----------------------------------------------------+
|UDF(col)                                             |
+-----------------------------------------------------+
|[201849, 201850, 201851, 201852, 20181, 20192, 20193]|
|[201912, 201913, 201914, 201915, 201916, 201917]     |
+-----------------------------------------------------+