class OddList<T>(private val originalList: List<T>) : List<T> {
    override val size: Int
        get() = originalList.count() / 2

    override fun contains(element: T): Boolean {
        for (index in 1 until originalList.count() step 2) {
            if (originalList[index] == element)
                return true
        }
        return false
    }

    override fun containsAll(elements: Collection<T>): Boolean {
        outer@ for (element in elements) {
            for (index in 1 until originalList.count() step 2) {
                if (originalList[index] == element)
                    continue@outer
            }
            return false
        }
        return true
    }

    override fun get(index: Int): T = originalList[2 * index + 1]

    override fun indexOf(element: T): Int {
        for (index in 1 until originalList.count() step 2) {
            if (originalList[index] == element)
                return (index - 1) / 2
        }
        return -1
    }

    override fun isEmpty(): Boolean = size == 0

    override fun iterator(): Iterator<T> = listIterator()

    override fun lastIndexOf(element: T): Int {
        val start = originalList.count() - originalList.count() % 2 - 1
        for (index in start downTo 0 step 2) {
            if (originalList[index] == element)
                return (index - 1) / 2
        }
        return -1
    }

    override fun listIterator(): ListIterator<T> = listIterator(0)

    override fun listIterator(index: Int): ListIterator<T> = object : ListIterator<T> {
        var indexOddList = index

        override fun hasNext(): Boolean = indexOddList < size - 1

        override fun hasPrevious(): Boolean = indexOddList > 0

        override fun next(): T {
            indexOddList += 1
            return originalList[2 * indexOddList + 1]
        }

        override fun nextIndex(): Int = indexOddList + 1

        override fun previous(): T {
            indexOddList -= 1
            return originalList[2 * indexOddList + 1]
        }

        override fun previousIndex(): Int = indexOddList - 1
    }

    override fun subList(fromIndex: Int, toIndex: Int): List<T> = originalList.subList(fromIndex * 2 + 1, toIndex * 2 + 1).filterIndexed {
        index, _ -> index % 2 == 0
    }

    override fun equals(other: Any?): Boolean {
        if (other !is List<*> || other.count() != size) return false
        for (index in 1 until originalList.count() step 2) {
            if (originalList[index] != other[(index - 1) / 2])
                return false
        }
        return true
    }

    override fun hashCode(): Int = originalList.asSequence().filterIndexed {
        index, _ -> index % 2 == 1
    }.hashCode()
}

fun main() {
    val originalList = listOf(0, 1, 2, 3, 4, 5)
    val oddList = OddList(originalList)
    println(oddList.joinToString())
}