字符串基础：读进来、切开、比对

// ★★ 这一章的开场白：`cin >> w` 之后直接 getline，读到的是**空行**
//
// 为什么：`cin >> w` 只把单词那几个字符取走，**行尾那个换行符还留在输入里**。
// 下一句 `getline` 一上来就撞见它，于是「读到了一行，内容是空的」——
// 程序不报错、不崩溃，只是后面全错。J 组最常见的一个坑，而且最难自己看出来。
//
// 这一份把两种写法**并排跑给你看**：同一份输入，只差一句 getline。
// ⚠ 实现上它先把整个输入读进内存，再用两个 stringstream 各演一遍 ——
//   这样两种写法吃的是**同一份字节**，对比才算数。
//
// ⇒ 三种活得下去的写法（正文第 3 步有表）：
//   ① `cin >> w;` 之后**先来一句 getline 吃掉换行**，再 getline 正文（本章正解用的就是它）；
//   ② 全程 getline，自己从第一行里把单词取出来；
//   ③ `cin >> ws` 跳过所有空白再 getline —— ⚠ 但它会把**正文开头的空格**也吃掉。

#include <bits/stdc++.h>
using namespace std;

int main() {
    string all((istreambuf_iterator<char>(cin)), istreambuf_iterator<char>());

    {
        stringstream ss(all);
        string w, t;
        ss >> w;
        getline(ss, t);                      // ⚠ 少了一句，读到的是上一行剩下的换行
        printf("① 不吃换行：  w = [%s]   t = [%s]   (t 的长度 %zu)\n", w.c_str(), t.c_str(), t.size());
    }
    {
        stringstream ss(all);
        string w, t;
        ss >> w;
        getline(ss, t);                      // 这一句专门用来吃掉换行，读到的东西直接扔掉
        getline(ss, t);
        printf("② 先吃换行：  w = [%s]   t = [%s]   (t 的长度 %zu)\n", w.c_str(), t.c_str(), t.size());
    }
    {
        stringstream ss(all);
        string w, t;
        ss >> w >> ws;                       // ws 跳过所有空白（换行也算）
        getline(ss, t);
        printf("③ 用 cin >> ws：w = [%s]   t = [%s]   (t 的长度 %zu)\n", w.c_str(), t.c_str(), t.size());
    }

    printf("\n★ ① 那一行的 t 是空的 —— 程序不报错，只是后面全算错。\n");
    printf("⚠ ③ 看着最省事，但它连**正文开头的空格**也一起吃掉了；正文开头有空格的题会栽在这儿。\n");
    return 0;
}

// 第三件事：字符就是整数（第 46 章那句话在字符串上的样子）
//
// `char` 存的本来就是一个整数（它的 ASCII 编码）。这一章要用到的三条：
//   ① `'a' - 'A' == 32`，而 32 = 2⁵ ⇒ **大小写只差第 5 位**（第 46 章的 flip）；
//   ② 数字字符转数字要减 `'0'`；
//   ③ 判断字母 / 数字用 `isalpha` / `isdigit`，⚠ 参数要先转成 `unsigned char`。
//
// ⚠ ③ 那个 `unsigned char` 不是讲究：`char` 在 x86 上是**有符号**的，
//   遇到中文这类字节会变成负数，而 `tolower(负数)` 是未定义行为。

#include <bits/stdc++.h>
using namespace std;

int main() {
    printf("① 大小写差多少\n");
    printf("   'a' = %d   'A' = %d   差 %d = 2^5\n", 'a', 'A', 'a' - 'A');
    printf("   'a' ^ 32 = %c        ← 翻转第 5 位就换了大小写（第 46 章那个 flip）\n", 'a' ^ 32);
    printf("   'Q' ^ 32 = %c\n", 'Q' ^ 32);
    printf("   ⚠ 但考场上请写 tolower / toupper：^ 32 只对字母成立，对别的字符是乱来的\n");
    printf("   '1' ^ 32 = %d   ← 变成了一个不可打印的控制字符，不是别的数字\n", '1' ^ 32);

    printf("\n② 数字字符转数字\n");
    string num = "2026";
    int v = 0;
    for (char c : num) v = v * 10 + (c - '0');
    printf("   \"%s\" 逐位减 '0' 再累加 = %d\n", num.c_str(), v);
    printf("   ⚠ 反过来：数字转字符是 + '0'，比如 7 -> %c\n", (char)(7 + '0'));

    printf("\n③ 判字母 / 数字\n");
    const char* samples = "aZ3 _";
    for (const char* p = samples; *p; p++)
        printf("   '%c'：isalpha %d  isdigit %d  isspace %d\n",
               *p, isalpha((unsigned char)*p) ? 1 : 0,
               isdigit((unsigned char)*p) ? 1 : 0, isspace((unsigned char)*p) ? 1 : 0);
    printf("   ⚠ 参数要先转成 unsigned char —— char 在 x86 上是有符号的，\n");
    printf("     遇到非 ASCII 字节会变成负数，而这几个函数吃到负数是未定义行为。\n");
    return 0;
}

// 错法一：直接拿 find 数「子串」
//
// 一眼看上去这道题就是「数子串出现几次」，于是顺手写了个 find 循环。
// ★ 可题目要的是**完整单词**：`the` 不该在 `theme`、`theatre` 里被数到。
//
// ⇒ 靠什么现形：文章里要有**把目标词包在里面的更长的词**。
//   ⚠ 而「顺手写的生成器」只会随机拼几个不相干的词，撞上这种情况的概率很低 ——
//   本章 gen.cpp 的档位 1 就是专门造它的。
//
// ★ 这也是这道题最经典的一个 WA：样例往往过得去（样例里正好没有那种词），测试点过不去。

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string w, t;
    cin >> w;
    getline(cin, t);
    getline(cin, t);

    for (char& c : w) c = (char)tolower((unsigned char)c);
    for (char& c : t) c = (char)tolower((unsigned char)c);

    int cnt = 0, first = -1;
    size_t pos = t.find(w);
    while (pos != string::npos) {                 // ⚠ 错在这里：数的是子串，不是完整单词
        cnt++;
        if (first < 0) first = (int)pos;
        pos = t.find(w, pos + 1);
    }

    if (cnt == 0) cout << -1 << '\n';
    else cout << cnt << ' ' << first << '\n';
    return 0;
}

// 正解：手写扫描，自己切单词 —— O(n)，一遍过
//
// 这道题真正难的地方不是算法（它只有一个循环），是**三件很容易写错的小事**：
//   ① 读入：第一行是一个单词，第二行是**一整行**（含空格）—— 必须用 getline，
//      而且 `cin >> w` 之后要先把残留的换行吃掉（见 readTrap.cpp）；
//   ② 大小写：题目说不区分，所以两边都要先统一（字符就是整数，见 charInt.cpp）；
//   ③ ★ **「完整单词」不是「子串」**：`the` 不该在 `theme` 里被数到。
//      逐词切分之后这一条是免费的 —— 因为切出来的每一段本来就是完整单词。
//
// ⚠ 位置的口径：**第一次出现的那个单词，它首字母在整行里的下标（从 0 开始）**。
//   不是「第几个单词」（那是 wrongPos.cpp 的错法）。

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string w, t;
    cin >> w;
    getline(cin, t);            // ← 先把 w 那一行剩下的换行吃掉，否则下面读到的是空行
    getline(cin, t);

    for (char& c : w) c = (char)tolower((unsigned char)c);
    for (char& c : t) c = (char)tolower((unsigned char)c);

    int cnt = 0, first = -1;
    int n = (int)t.size();
    int i = 0;
    while (i < n) {
        while (i < n && t[i] == ' ') i++;            // 跳过空格
        if (i >= n) break;
        int j = i;
        while (j < n && t[j] != ' ') j++;            // [i, j) 是一个完整单词
        if ((int)w.size() == j - i && t.compare(i, j - i, w) == 0) {
            cnt++;
            if (first < 0) first = i;
        }
        i = j;
    }

    if (cnt == 0) cout << -1 << '\n';
    else cout << cnt << ' ' << first << '\n';
    return 0;
}

// 做法二：交给 stringstream 逐词切分
//
// `stringstream` 把一行字符串当成输入流，`ss >> word` 就自动按空格切词 ——
// 三行就写完了，比手写扫描短得多。
//
// ⚠ 但它有两个代价，正文第 7 步会实测：
//   ① **它不是免费的**：每读一个词都要走一遍流的那套机制，比手写扫描慢几倍；
//   ② ★ **它不告诉你位置** —— 切出来的是单词本身，不是它在原串里的下标。
//      所以要回答「第一次出现在第几个字符」，还得自己一边切一边累加长度，
//      而那一步**很容易差一格**（词与词之间那个空格算谁的）。
//
// ⇒ 结论：只要问「有没有 / 有几个」，`stringstream` 很好用；一旦问**位置**，手写扫描更稳。

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string w, t;
    cin >> w;
    getline(cin, t);
    getline(cin, t);

    for (char& c : w) c = (char)tolower((unsigned char)c);
    for (char& c : t) c = (char)tolower((unsigned char)c);

    stringstream ss(t);
    string word;
    int cnt = 0, first = -1, pos = 0;
    while (ss >> word) {
        // ⚠ 这一句是「切词」之外多出来的活：从 pos 起找到这个词真正的起点
        pos = (int)t.find(word, pos);
        if (word == w) { cnt++; if (first < 0) first = pos; }
        pos += (int)word.size();
    }

    if (cnt == 0) cout << -1 << '\n';
    else cout << cnt << ' ' << first << '\n';
    return 0;
}

// 换一把尺子：stringstream 到底比手写扫描慢多少
//
// 两种做法答案完全一样（对拍验过 300 轮），所以秒表是这里唯一看得见差别的东西 ——
// 第 36 章那个第四盲区：**只影响常数、不影响答案的差别，对拍原理上看不见。**
//
// ⚠ 为了量的是「切词」本身而不是读入，这一份**自己造文章**（不吃 stdin），
//   两种做法跑的是同一个字符串（第 29、34 章那条「量之前先确认你量的就是它」）。
//
// 用法：./race [单词数，默认 200000] [csv]

#include <bits/stdc++.h>
#include <chrono>
using namespace std;
using namespace std::chrono;

static volatile long long sink = 0;

int main(int argc, char** argv) {
    int n = (argc > 1) ? atoi(argv[1]) : 200000;
    bool csv = (argc > 2 && string(argv[2]) == "csv");
    if (n < 1) n = 1;

    mt19937 rng(20260825u);
    string t;
    t.reserve((size_t)n * 6);
    for (int i = 0; i < n; i++) {
        if (i) t += ' ';
        if (rng() % 20 == 0) t += "the";
        else { int len = 2 + (int)(rng() % 7); for (int k = 0; k < len; k++) t += (char)('a' + rng() % 26); }
    }
    const string w = "the";

    /* ① 手写扫描 */
    auto t0 = steady_clock::now();
    long long c1 = 0;
    {
        int m = (int)t.size(), i = 0;
        while (i < m) {
            while (i < m && t[i] == ' ') i++;
            if (i >= m) break;
            int j = i;
            while (j < m && t[j] != ' ') j++;
            if ((int)w.size() == j - i && t.compare(i, j - i, w) == 0) c1++;
            i = j;
        }
    }
    double ms1 = duration<double, milli>(steady_clock::now() - t0).count();

    /* ② stringstream */
    t0 = steady_clock::now();
    long long c2 = 0;
    {
        stringstream ss(t);
        string word;
        while (ss >> word) if (word == w) c2++;
    }
    double ms2 = duration<double, milli>(steady_clock::now() - t0).count();

    sink += c1 + c2;

    if (csv) {
        printf("scan,%.3f\nstream,%.3f\nsame,%d\ncount,%lld\n", ms1, ms2, c1 == c2 ? 1 : 0, c1);
        return 0;
    }
    printf("%d 个单词、%zu 个字符，找 \"the\"（本机实测）\n\n", n, t.size());
    printf("  手写扫描      %8.1f 毫秒\n", ms1);
    printf("  stringstream  %8.1f 毫秒   慢 %.1f 倍\n", ms2, ms2 / ms1);
    printf("\n两种做法数出来的都是 %lld 个%s\n", c1, c1 == c2 ? "（一致 ✓）" : "（居然不一样，有 bug）");
    printf("★ 答案一样，差别只在秒表上 —— 这正是对拍看不见的那一类差别（第 36 章第四盲区）。\n");
    printf("⚠ 秒数换台机器就变，**倍数**才是要记住的东西。\n");
    return 0;
}

// ★★ 第二个坑：`s.size()` 是**无符号**的
//
// `string::size()` 返回的是 `size_t`（64 位无符号）。于是空串上：
//         s.size() - 1   不是 -1，是 18446744073709551615
// 而 `for (int i = 0; i < s.size() - 1; i++)` 这种写法，在空串上会试图跑 1.8×10¹⁹ 次 ——
// 表现是「程序卡死」或者「乱七八糟的越界」，而**数据里只要有一组空串就会中招**。
//
// ⚠ 更阴的是：`i` 是 int、`s.size()` 是无符号，比较时 **int 会被转成无符号** ——
//   所以哪怕 i 是负数，比较结果也可能和你想的相反。
//
// ⇒ 三种活得下去的写法：
//   ① `for (size_t i = 0; i + 1 < s.size(); i++)`   —— 把减法换成加法，永远不下溢；
//   ② `for (int i = 0; i + 1 < (int)s.size(); i++)` —— 显式转成有符号；
//   ③ 干脆 `if (s.empty()) return ...;` 先把空串挡在外面。
//
// 本章 wrongSize.cpp 犯的就是这个错，而**只有「空文章」那一档数据能把它照出来**。

#include <bits/stdc++.h>
using namespace std;

int main() {
    string s = "";
    printf("空串：s.size() = %zu\n", s.size());
    printf("★     s.size() - 1 = %zu   ← 不是 -1\n", s.size() - 1);
    printf("      也就是 %.1f × 10^19 次循环 —— 看起来就是「卡死」\n", (double)(s.size() - 1) / 1e19);

    printf("\n当场就能看见的一个后果：\n");
    try {
        string bad = s.substr(s.size() - 1);
        printf("  substr 居然没抛异常？拿到 [%s]\n", bad.c_str());
    } catch (const std::out_of_range& e) {
        printf("  s.substr(s.size() - 1) 抛了 out_of_range：%s\n", e.what());
    }

    printf("\n两种写法在空串上的差别：\n");
    int a = 0, b = 0;
    for (size_t i = 0; i + 1 < s.size(); i++) a++;              // ✓ 加法，不下溢
    for (int i = 0; i + 1 < (int)s.size(); i++) b++;            // ✓ 显式转成有符号
    printf("  i + 1 < s.size()        跑了 %d 次\n", a);
    printf("  i + 1 < (int)s.size()   跑了 %d 次\n", b);
    printf("  i < s.size() - 1        会跑 %zu 次 —— 就不真跑给你看了\n", s.size() - 1);

    string t = "abc";
    printf("\n非空串上它们没有任何差别（所以你的样例永远发现不了）：\n");
    a = b = 0;
    for (size_t i = 0; i + 1 < t.size(); i++) a++;
    for (size_t i = 0; i < t.size() - 1; i++) b++;
    printf("  \"abc\"：两种写法都跑 %d / %d 次\n", a, b);
    return 0;
}

// 正解：手写扫描，自己切单词 —— O(n)，一遍过
//
// 这道题真正难的地方不是算法（它只有一个循环），是**三件很容易写错的小事**：
//   ① 读入：第一行是一个单词，第二行是**一整行**（含空格）—— 必须用 getline，
//      而且 `cin >> w` 之后要先把残留的换行吃掉（见 readTrap.cpp）；
//   ② 大小写：题目说不区分，所以两边都要先统一（字符就是整数，见 charInt.cpp）；
//   ③ ★ **「完整单词」不是「子串」**：`the` 不该在 `theme` 里被数到。
//      逐词切分之后这一条是免费的 —— 因为切出来的每一段本来就是完整单词。
//
// ⚠ 位置的口径：**第一次出现的那个单词，它首字母在整行里的下标（从 0 开始）**。
//   不是「第几个单词」（那是 wrongPos.cpp 的错法）。

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string w, t;
    cin >> w;
    getline(cin, t);            // ← 先把 w 那一行剩下的换行吃掉，否则下面读到的是空行
    getline(cin, t);

    for (char& c : w) c = (char)tolower((unsigned char)c);
    for (char& c : t) c = (char)tolower((unsigned char)c);

    int cnt = 0, first = -1;
    int n = (int)t.size();
    int i = 0;
    while (i < n) {
        while (i < n && t[i] == ' ') i++;            // 跳过空格
        if (i >= n) break;
        int j = i;
        while (j < n && t[j] != ' ') j++;            // [i, j) 是一个完整单词
        if ((int)w.size() == j - i && t.compare(i, j - i, w) == 0) {
            cnt++;
            if (first < 0) first = i;
        }
        i = j;
    }

    if (cnt == 0) cout << -1 << '\n';
    else cout << cnt << ' ' << first << '\n';
    return 0;
}