设s、t 为两个字符串，两个字符串分为两行输出，判断t 是否为s 的子串。如果是，输出子串所在位置（第一个字符，字符串的起始位置从0开始），否则输出-1

### 回答1：
可以使用字符串的 find() 方法来判断 t 是否为 s 的子串，如果是，则返回子串在 s 中的起始位置，否则返回 -1。

具体实现可以参考以下代码：

s = input() # 输入字符串 s
t = input() # 输入字符串 t

pos = s.find(t) # 在 s 中查找 t

if pos == -1:
print(-1) # t 不是 s 的子串，输出 -1
else:
print(pos) # t 是 s 的子串，输出子串在 s 中的起始位置

### 回答2：
这个问题可以通过遍历整个字符串s，寻找和t字符串中第一个字符相等的字符，然后从这个字符开始和t字符串进行逐字符比较，判断是否是子串。

具体算法如下：

1.定义变量i，表示开始比较的位置，初始化为0。

2.循环遍历字符串s，从i位置开始，如果找到s中的一个字符等于t的第一个字符，进入第3步，否则继续往后面遍历。

3.定义变量j，表示t中已经匹配的字符个数，初始化为1，因为第一个字符已经匹配。

4.循环比较s[i+j]和t[j]的值，如果相等，将j加1，继续比较下一个字符，直到匹配了整个t字符串，输出i的值，表示t是s的子串。

5.如果没有匹配成功，将i加1，重新从下一个字符开始比较，重复执行步骤2到步骤4，直到找到子串或者s字符串遍历结束。

6.如果整个s字符串遍历完成，都没有找到子串，则t不是s的子串，输出-1。

以下为实现此算法的Python代码：

def find_substring(s, t):
    n = len(s)
    m = len(t)
    for i in range(n-m+1):
        j = 0
        while j < m and s[i+j] == t[j]:
            j += 1
        if j == m:
            return i
    return -1

s = "hello world"
t = "wor"
pos = find_substring(s, t)
if pos == -1:
    print("t不是s的子串")
else:
    print("t是s的子串，开始位置是：", pos)
print("s：", s)
print("t：", t)

输出结果为：

t是s的子串，开始位置是： 6
s： hello world
t： wor

可以看到，数字6表示子串t在s中的起始位置。如果t字符串在s中不存在，则输出-1表示不是子串。

### 回答3：
题目中要求判断字符串t是否为字符串s的子串，并输出子串在字符串s中的位置。那么我们如何来判断呢？

首先，我们可以确定一个比较朴素的做法：枚举s中的每一个字符，看看它是否与t的第一个字符相等，如果相等，则比较后面的字符。如果后面的字符也都相等，那么就说明t是s的子串，同时输出子串在s中的位置。这种做法的时间复杂度为O(n*m)，n和m分别为s和t的长度，毫无疑问，它是普适性最强的一种方法。

但是，此时我们就可以思考几个问题：是否可以针对特定情况，设计更加高效的算法？是否有更优秀的数据结构可以解决这个问题？

对于第一个问题，当然是可以的。比如说，我们可以采用“KMP算法”。这种算法的基本思想是假设字符串s有一个长度为i的前缀和后缀相同，其中i为从1开始的最大的数。然后，在匹配的时候，如果出现了不匹配的情况，就回溯到i-1的位置继续匹配。这种算法的时间复杂度为O(m+n)，是一种比较高效的字符串匹配算法。

对于第二个问题，我们可以考虑使用哈希表。因为哈希表的查找时间复杂度为O(1)，所以我们可以把t中的每一个子串都映射到哈希表上，然后在s中枚举每一个长度为t的子串，看看它是否在哈希表上。这种算法的时间复杂度为O(n+m)，比起暴力枚举子串的时间复杂度要低。当然，这种算法需要解决哈希冲突和哈希函数等问题。

综上所述，我们有多种方法来解决这个问题，每种方法都有其特点和优缺点。我们需要根据具体的情况来选择适合的算法和数据结构。