Problem:
Score : 200 points

Problem Statement

Given are two strings S and T.

Let us change some of the characters in S so that T will be a substring of S.

At least how many characters do we need to change?

Here, a substring is a consecutive subsequence. For example, xxx is a substring of yxxxy, but not a substring of xxyxx.

Constraints

The lengths of S and T are each at least 1 and at most 1000.

The length of T is at most that of S.

S and T consist of lowercase English letters.

Input

Input is given from Standard Input in the following format:

S
T

Output

Print the minimum number of characters in S that need to be changed.

Sample Input 1

cabacc
abc

Sample Output 1

1

For example, changing the fourth character a in S to c will match the second through fourth characters in S to T.

Since S itself does not have T as its substring, this number of changes - one - is the minimum needed.

Sample Input 2

codeforces
atcoder

Sample Output 2

6

Solution in Kotlin (1.3.71) (judge verdict: Wrong Answer)

import java.util.*

fun main() {
    val sc = Scanner(System.`in`)
    val s = sc.next()
    val t = sc.next()
    val cnt = calc(s, t)
    println(t.length - cnt)
}

fun calc(s: String, t: String): Int {
    var oldCnt = 0
    var newCnt = 0
    s.forEachIndexed { index, c ->
        val index2 = getIndex(index, t.length)
        (0..index2).forEach { tindex ->
            if (c == t[tindex]) {
                val lastIndex = getLastIndex(s, t, index)
                newCnt = check(s, t, index, tindex, lastIndex)
                return@forEach
            }
        }
        if (oldCnt < newCnt) oldCnt = newCnt
        newCnt = 0

    }
    if (oldCnt < newCnt) oldCnt = newCnt
    return oldCnt
}

fun check(s: String, t: String, index: Int, index2: Int, lastIndex: Int): Int {
    var sindex = index
    if(s.length - sindex - 1 < t.length - index2 - 1) return 0
    var cnt = 1
    (index2 + 1..lastIndex).forEach {
        sindex++
        if(sindex >= s.length) return@forEach
        if (s[sindex] == t[it]) cnt += 1 else return@forEach
    }
    return cnt
}

fun getIndex(index: Int, length: Int): Int {
    return if (index > length - 1) length - 1 else index
}

fun getLastIndex(s: String, t: String, sIndex: Int): Int {
    return if (s.length - 1 - sIndex < t.length) s.length - 1 - sIndex else t.length - 1
}