从逗号分隔的整数字符串数组映射的连续天数

Question

我收到了多个逗号分隔的字符串整数作为输入，例如，以下字符串：

1. “5,6,0”
2. “0,1,2”
3. “1,2,3,4”

这些整数中的每一个都表示一周中的某一天

• 0=星期日1=星期一2=星期二3=星期三4=星期四5=星期五6=星期六

在第一个字符串的情况下，这将意味着星期四到星期日第二个字符串将从星期日到星期二有效第三个字符串将从星期一到星期四有效

目前，我正在使用以下内容

  private fun mapOfDays(validDays: String): LinkedHashMap<Int, String>
    {
        if (!validDays.isBlank())
        {
            val daysArray = validDays.split("\\s*,\\s*") as Array<String>
            var mapDays = LinkedHashMap<Int, String>()
            var mapDay = LinkedHashMap<Int, String>()
            mapDays[0] = "SUNDAY"
            mapDays[1] = "MONDAY"
            mapDays[2] = "TUESDAY"
            mapDays[3] = "WEDNESDAY"
            mapDays[4] = "THURSDAY"
            mapDays[5] = "FRIDAY"
            mapDays[6] = "SATURDAY"

            for (day in daysArray)
            {
                if (mapDays.containsKey(day.toInt()))
                {
                    mapDay[day.toInt()] = mapDays[day.toInt()]!!
                }
            }
            return mapDay
        }
        return LinkedHashMap()
    }

    private fun mappedDays(mapOfDays: LinkedHashMap<Int, String>?): String
    {
        if (!mapOfDays.isNullOrEmpty())
        {
            val mapSize = mapOfDays.size

            if (mapSize > 6) return "All Day"
            if (mapSize > 5) return sixDayString(mapOfDays)
            if (mapSize > 4) return fiveDayString(mapOfDays)
            if (mapSize > 3) return fourDayString(mapOfDays)
            if (mapSize > 2) return threeDayString(mapOfDays)
            if (mapSize > 1) return twoDayString(mapOfDays)
            if (mapSize > 0) return oneDayString(mapOfDays)
        }
        return ""
    }

    private fun twoDayString(mapOfDays: LinkedHashMap<Int, String>): String
    {
        val firstPosition: Int = mapOfDays.keys.toIntArray()[0]
        val lastPosition: Int = mapOfDays.keys.toIntArray()[1]

        val lastDay = Days.values()[lastPosition]
        val firstDay = Days.values()[firstPosition]

        return "$firstDay and $lastDay"
    }

    private fun oneDayString(mapOfDays: LinkedHashMap<Int, String>): String
    {
        var firstPosition: Int = mapOfDays.keys.toIntArray()[0]
        val firstDay = Days.values()[firstPosition]
        return "$firstDay"
    }

    private fun threeDayString(mapOfDays: LinkedHashMap<Int, String>): String
    {
        val firstPosition: Int = mapOfDays.keys.toIntArray()[0]
        val secondPosition: Int = mapOfDays.keys.toIntArray()[1]
        val thirdPosition: Int = mapOfDays.keys.toIntArray()[2]

        val firstDay = Days.values()[firstPosition]
        val secondDay = Days.values()[secondPosition]
        val lastDay = Days.values()[thirdPosition]
        return "$firstDay, $secondDay and $lastDay"
    }

    private fun fourDayString(mapOfDays: LinkedHashMap<Int, String>): String
    {
        val firstPosition: Int = mapOfDays.keys.toIntArray()[0]
        val secondPosition: Int = mapOfDays.keys.toIntArray()[1]
        val thirdPosition: Int = mapOfDays.keys.toIntArray()[2]
        val fourthPosition: Int = mapOfDays.keys.toIntArray()[3]

        val firstDay = Days.values()[firstPosition]
        val secondDay = Days.values()[secondPosition]
        val thirdDay = Days.values()[thirdPosition]
        val lastDay = Days.values()[fourthPosition]
        return "$firstDay, $secondDay, $thirdDay and $lastDay"
    }

    private fun fiveDayString(mapOfDays: LinkedHashMap<Int, String>): String
    {
        val firstPosition: Int = mapOfDays.keys.toIntArray()[0]
        val secondPosition: Int = mapOfDays.keys.toIntArray()[1]
        val thirdPosition: Int = mapOfDays.keys.toIntArray()[2]
        val fourthPosition: Int = mapOfDays.keys.toIntArray()[3]
        val fifthPosition: Int = mapOfDays.keys.toIntArray()[4]

        val firstDay = Days.values()[firstPosition]
        val secondDay = Days.values()[secondPosition]
        val thirdDay = Days.values()[thirdPosition]
        val fourthDay = Days.values()[fourthPosition]
        val lastDay = Days.values()[fifthPosition]
        return "$firstDay, $secondDay, $thirdDay, $fourthDay and $lastDay"
    }

    private fun sixDayString(mapOfDays: LinkedHashMap<Int, String>): String
    {
        var firstPosition: Int = mapOfDays.keys.toIntArray()[0]
        var lastPosition: Int = 0

        for (day in mapOfDays.keys)
        {
            lastPosition = day
        }

        val lastDay = Days.values()[lastPosition]
        val firstDay = Days.values()[firstPosition]

        return "$firstDay to $lastDay"
    }

}

enum class Days()
{
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

然而，我当前的实现是能够告诉我哪些天包括在内，而不能映射出一组天，例如：

如果我得到“0,1,3,4,5,6”，我希望得到的最终字符串输出如下：星期三到星期一

或

“0,1,3,4,5”将导致以下结果：星期日,星期一,星期三到星期五。

Answer 1

package days

import java.lang.IllegalArgumentException


class DaysFactory {
    fun dayFromInt(index: Int): Day {
        return when (index) {
            0 -> Day.Sunday
            1 -> Day.Monday
            2 -> Day.Tuesday
            3 -> Day.Wednesday
            4 -> Day.Thursday
            5 -> Day.Friday
            6 -> Day.Saturday
            else -> throw IllegalArgumentException("illigal index :$index")
        }
    }

    enum class Day(val index: Int) {
        Sunday(0), Monday(1), Tuesday(2), Wednesday(3), Thursday(4), Friday(5), Saturday(6)
    }
}


class DaysRange(val seed: String) {

    var stringFormat = ""

    private fun getTomorrow(dayIndex: Int): Int {
        if (dayIndex != 6) return dayIndex + 1
        return 0
    }

    override fun toString(): String =stringFormat


    init {
        if (isValidInput(seed)) {
            val dayFactory = DaysFactory()
            val indexes = seed.split(",").map { it.toInt() }
            val days = indexes.map { dayFactory.dayFromInt(it) }
            val ranges = splitIndexesToRanges(indexes)
            ranges.forEach { range ->
                if (range.size > 2) {
                    stringFormat += "${dayFactory.dayFromInt(range.first())} to ${dayFactory.dayFromInt(range.last())},"
                } else
                    range.forEach {
                        stringFormat += "${dayFactory.dayFromInt(it)},"
                    }
            }
            stringFormat = stringFormat.dropLast(1)
        }
    }

    private fun splitIndexesToRanges(daysRange: List<Int>): ArrayList<List<Int>> {
        val result = ArrayList<List<Int>>()
        val slicePoint = ArrayList<Int>()
        for (i in 0 until daysRange.size - 1) {
            if (getTomorrow(daysRange[i]) != daysRange[i + 1]) {
                slicePoint.add(i)
            }
        }

        var start = 0
        slicePoint.forEach {
            result.add(daysRange.slice(start..it))
            start = it + 1
        }
        result.add(daysRange.slice(start until daysRange.size))
        return result

    }

}

private fun isValidInput(seed: String): Boolean = true


fun main(args: Array<String>) {

    val input = listOf(
        "0,1,2,4,5,6",
        "5,6,0",
        "1,2,3,4"
    )

    input.forEach {
        val dr = DaysRange(it)
        println(dr)
    }
}

输出示例：

星期天到星期二，星期四到星期六

星期五至星期日

星期一至星期四