lc for kotlin

       // 哈希集合，记录每个字符是否出现过
        val occ: HashSet<Char> = HashSet()
        val n = s.length
        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
        var rk = -1
        var ans = 0
        for (i in 0 until n) {
            if (i != 0) {
                // 左指针向右移动一格，移除一个字符
                occ.remove(s[i - 1])
            }
            while (rk + 1 < n && !occ.contains(s[rk + 1])) {
                // 不断地移动右指针
                occ.add(s[rk + 1])
                ++rk
            }
            // 第 i 到 rk 个字符是一个极长的无重复字符子串
            ans = Math.max(ans, rk - i + 1)
        }
        return ans

leetcode 第一题 

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

 

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

 

    @JvmStatic
    fun main(args: Array<String>) {
        //
        val nums = intArrayOf(3,2,4)
        val target = 6

        twoSum2(nums,target)

    }
    fun twoSum2(nums: IntArray, target: Int): IntArray? {
        val back = intArrayOf(0, 0)
        for (i in nums.indices) {
            for (j in   i+1 until nums.size) {
                if (nums[i] + nums[j] == target) {
                    back[0] = i
                    back[1] = j
                    print("找到了${i}和${j}")
                    return back
                }

            }
        }
        return back
    }

    fun twoSum(nums: IntArray, target: Int): IntArray {
        var hashMap = hashMapOf<Int,Int>()
        for((i,num) in nums.withIndex()){   
            val remain = target - num
            val j:Int? = hashMap.get(remain)
            j.let{
                if(hashMap.containsKey(remain)){
                    return intArrayOf(j!!,i)
                }
            }
            hashMap[num]= i
        }
        return intArrayOf()  
    }

 

第二种用 hashmap 来算，空间换时间，减去之后 contains 方法找索引。

 

 

leetcode 第二题 

链表就是类里有个自己的类

 

 

leetcode 第3题   窗口滑动的思想

    fun addTwoNumbers(l1: ListNode?, l2: ListNode?): ListNode? {
        //  要返回的数字 从 0 开始创建一个头
        val dummyHead = ListNode(0)
        var p = l1
        var q = l2
        var curr: ListNode? = dummyHead
        var carry = 0
        //
        while (p != null || q != null) {
            val x = p?.`val` ?: 0
            val y = q?.`val` ?: 0
            val sum = carry + x + y
            //除 10 看看是否超过了 10
            carry = sum / 10
            //下一数字 的初始值 需要 carry 的进一制
            curr!!.next = ListNode(sum % 10)
            //替换三个值,继续计算
            curr = curr.next
            if (p != null) p = p.next
            if (q != null) q = q.next
        }
        if (carry > 0) {
            curr!!.next = ListNode(carry)
        }
        println(dummyHead.toString())
        //返回的是去掉了 0
        return dummyHead.next
    }