cin and cout

cin: đọc từng mẩu từ dải chữ

Trình chấm đưa dữ liệu vào chương trình như một dải chữ liền nhau, giống như có người gõ bàn phím mà không ai nhìn màn hình. cin là luồng đầu vào chuẩn, và cin >> x lấy một giá trị từ dải chữ đó bỏ vào biến x. Mũi tên chỉ hướng đi của dữ liệu: cin >> x đi từ cin vào x, ngược với cout << x đi từ x ra cout. Viết ngược thành cin << x hay cout >> x là lỗi biên dịch.

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

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

    int a, b, c;
    cin >> a >> b >> c;
    cout << a * b + c << '\n';
}

Input12 7
30

Output114

'\n' (nháy đơn, một ký tự) làm đúng việc của "\n" ở B0, và từ đây ta viết nháy đơn. Gõ nhầm thành '/n' thì g++ chỉ cảnh báo, rồi chương trình in ra một số lạ thay vì xuống dòng.

cin nhớ nó đã đọc tới đâu. Mỗi lần >> bỏ qua mọi khoảng trắng đứng trước (dấu cách, xuống dòng, tab), rồi lấy ra một mẩu chữ liền nhau và đổi thành giá trị theo kiểu của biến. Ở trên a nhận 12, b nhận 7, c nhận 30 dù nó nằm ở dòng khác, và kết quả là $12 \cdot 7 + 30 = 114$.

Hai hệ quả dùng hằng ngày. Dữ liệu nằm trên một dòng hay nhiều dòng, câu lệnh đọc vẫn y hệt; chỉ thứ tự là quan trọng. Và thứ tự đọc là thứ tự trong đề: đề ghi “một dòng chứa $n$ và $k$” thì đọc cin >> n >> k. Đọc ngược là hoán đổi giá trị hai biến, và bài sai dù mọi phép tính phía sau đều đúng.

Chương trình không có người ngồi trước màn hình, nên đừng in lời nhắc kiểu Nhap a:: mọi chữ thừa trong output đều bị tính là sai. Cũng vì thế, in đúng khuôn của đề: “trên cùng một dòng” thì chèn ' ' giữa các giá trị, “mỗi giá trị một dòng” thì chèn '\n'.

Khi chạy thử trên máy mình, cin đọc từ bàn phím, và chương trình đứng yên không phải là treo: nó đang chờ bạn gõ số rồi nhấn Enter. Muốn khỏi gõ lại mỗi lần, ghi dữ liệu mẫu vào tệp input.txt rồi chạy ./main < input.txt (Linux, macOS) hoặc main.exe < input.txt (Command Prompt của Windows; PowerShell không nhận dấu <). Dấu < đưa nội dung tệp vào làm đầu vào chuẩn, đúng như trình chấm làm.

Đến đây ta hiểu được hai dòng đầu main của khung. Mặc định cin và cout làm thêm hai việc để phục vụ người ngồi gõ phím: giữ đúng thứ tự khi chương trình dùng lẫn lệnh đọc ghi kiểu cũ của ngôn ngữ C (scanf, printf), và in hết chữ đang chờ ra màn hình trước mỗi lần đọc để lời nhắc kịp hiện lên. Trình chấm không cần hai việc đó, mà chúng làm chậm: ios::sync_with_stdio(false); tắt việc thứ nhất, cin.tie(0); tắt việc thứ hai. Đề thi viết số lớn bằng lũy thừa của 10: $10^6$ là số 1 theo sau 6 chữ số 0, tức một triệu, còn $10^9$ là một tỷ. Đọc $10^6$ số mà thiếu hai dòng này thì chương trình có thể chậm hơn vài lần, đủ để vượt giới hạn một giây. Đã có dòng thứ nhất thì không dùng lẫn cin, cout với scanf, printf nữa.

Cùng lý do đó, endl in xuống dòng và xả bộ đệm ngay, nên in $10^6$ dòng bằng endl có thể chậm hơn '\n' hàng chục lần. Ngoại lệ duy nhất là bài tương tác (bài 28), nơi phải xả sau mỗi câu hỏi.

Một số kỳ thi đọc ghi qua tệp, tên tệp ghi trong đề. Khi đó thêm hai dòng freopen ở đầu main; chúng nối stdin, stdout vào tệp, còn cin, cout giữ nguyên:

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

int main() {
    freopen("bai.inp", "r", stdin);
    freopen("bai.out", "w", stdout);
    ios::sync_with_stdio(false);
    cin.tie(0);

    int a, b;
    cin >> a >> b;
    cout << a + b << '\n';
}

Chỉ thêm khi đề yêu cầu: gửi lên LQDOJ mà còn freopen thì chương trình đi tìm tệp không tồn tại và không đọc được dữ liệu của trình chấm.

Ví dụHai số đảo chỗ

Đề. Một dòng chứa hai số nguyên $a$ và $b$ ($-1000 \le a, b \le 1000$). In $b$ rồi đến $a$ trên cùng một dòng.

Lời giải. Đọc đúng thứ tự đề cho, cin >> a >> b, rồi đảo thứ tự lúc in; không cần đổi giá trị hai biến. Giữa hai số phải có ' ', thiếu nó thì máy in 83 thay vì 8 3. Số âm không cần xử lý gì thêm: cin đọc cả dấu -.

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

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

    int a, b;
    cin >> a >> b;
    cout << b << ' ' << a << '\n';
}

Input3 8

Output8 3

Kiểu của biến: số, ký tự, xâu

Kiểu của biến quyết định cin lấy bao nhiêu chữ. Với biến số, cin không lấy trọn mẩu chữ mà chỉ lấy phần đầu còn đúng dạng số của kiểu đó (có thể mở đầu bằng - hoặc +), và dừng ở ký tự đầu tiên không hợp. Đọc 3.5 vào biến int chỉ lấy được 3; phần .5 nằm lại chờ lần đọc sau. Lần đọc sau gặp dấu chấm, không thể bắt đầu một số nguyên, nên cin rơi vào trạng thái lỗi: biến đang đọc nhận 0, và mọi lệnh cin về sau không làm gì nữa.

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

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

    int a = -5, b = -5, c = -5;
    cin >> a >> b >> c;
    cout << a << ' ' << b << ' ' << c << '\n';
}

Input3.5 7 8

Output3 0 -5

Ba biến được gán sẵn $-5$ để thấy biến nào không được đọc. a lấy 3, b hỏng ở chỗ .5 nên nhận 0, còn c giữ nguyên $-5$: số 7 và 8 không bao giờ được đọc. Số quá lớn so với kiểu cũng làm cin hỏng: đọc 3000000000 vào int cho 2147483647 rồi cũng vào trạng thái lỗi. Nghĩa là đề cho giá trị tới $10^{10}$ mà khai báo int thì chương trình sai ngay lúc đọc, trước cả khi có phép tính nào tràn. Thấy những số 0 hay 2147483647 không ngờ tới, hãy in lại các biến ngay sau lệnh cin để xem dữ liệu có vào đúng không.

Với chữ, >> vẫn bỏ qua khoảng trắng rồi lấy một mẩu. Biến string (xâu) nhận cả mẩu liền nhau, còn biến char chỉ nhận đúng một ký tự không phải khoảng trắng.

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

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

    string a, b;
    char c;
    cin >> a >> b >> c;
    cout << a << '|' << b << '|' << c << '\n';
}

InputNguyen Van An

OutputNguyen|Van|A

Ba biến nhận Nguyen, Van và A; chữ n cuối còn nằm đó chưa ai đọc. Vì >> dừng ở khoảng trắng, nó không đọc nổi một dòng có dấu cách bên trong như họ tên hay một câu văn. Để đọc trọn một dòng ta dùng getline(cin, s): nó lấy mọi ký tự tới hết dòng, kể cả dấu cách, và bỏ dấu xuống dòng đi.

Chỗ hay vấp là getline đứng ngay sau một lệnh >>. Lệnh >> đọc xong số thì dừng sát sau số, nên ký tự xuống dòng vẫn nằm trong dải chữ, và getline đọc được ngay một dòng rỗng. Chèn cin.ignore(); vào giữa để bỏ ký tự xuống dòng đó:

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

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

    int n;
    string name;
    cin >> n;
    cin.ignore();
    getline(cin, name);
    cout << n << ": " << name << '\n';
}

Input3
Nguyen Van An

Output3: Nguyen Van An

Xóa dòng cin.ignore(); thì chương trình chỉ in 3:, vì name nhận dòng rỗng. ignore() chỉ bỏ đúng một ký tự, nên nếu sau số còn dấu cách thừa, hay dòng kết thúc bằng cặp \r\n của Windows, thì nó bỏ chưa đủ. Khi đó viết cin.ignore(1000, '\n');: bỏ đi tới hết dòng chứa số (tối đa 1000 ký tự, thừa sức cho một dòng như vậy).

Ví dụGhép hai chữ số

Đề. Một dòng chứa chữ số hàng chục $a$ ($1 \le a \le 9$) và chữ số hàng đơn vị $b$ ($0 \le b \le 9$). In số có hai chữ số này.

Lời giải. Số cần in, viết ra giấy, chính là chữ số $a$ đứng liền trước chữ số $b$. Đọc hai chữ số vào hai biến char: mỗi >> bỏ dấu cách rồi lấy đúng một ký tự. In hai ký tự liền nhau, không chèn gì, là ra số cần tìm; vì $a \ge 1$ nên không có chữ số 0 thừa ở đầu. Cách số học là đọc vào int rồi in 10 * a + b, đúng kiểu ghép của mục sau.

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

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

    char a, b;
    cin >> a >> b;
    cout << a << b << '\n';
}

Input4 2

Output42

Thương và phần dư: tách, ghép và quay vòng

B0 đã cho biết / giữa hai số nguyên là thương và % là phần dư. Với dữ liệu đọc vào, hai phép này là bộ công cụ chính của các bài nhập môn, vì chúng chia một số thành các phần. Đây chính là phép chia có dư: số bị chia bằng thương nhân số chia cộng số dư, và số dư luôn nhỏ hơn số chia. Viết bằng C++, với $n \ge 0$ và $k \ge 1$:

Ba cách dùng thường gặp:

• Đổi đơn vị. Đổi $m$ phút ra giờ và phút: m / 60 là số giờ trọn, m % 60 là số phút lẻ. Chẳng hạn $200 = 3 \cdot 60 + 20$ cho 3 giờ 20 phút.
• Tách và ghép chữ số. Trong hệ thập phân, n % 10 là chữ số cuối và n / 10 là phần còn lại sau khi bỏ chữ số cuối. Ngược lại, 10 * n + d gắn thêm chữ số $d$ vào cuối $n$.
• Quay vòng. Đồng hồ chỉ 22 giờ, 30 giờ nữa là mấy giờ? Cộng thẳng ra 52, nhưng một ngày chỉ có 24 giờ: 52 % 24 = 4 là giờ trên đồng hồ, còn 52 / 24 = 2 là số vòng đã đi trọn.

Với số âm, % cho phần dư âm (-7 % 5 ra -2); khi cần phần dư nằm trong $[0, k)$, viết (x % k + k) % k.

Ví dụTổng ba chữ số

Đề. Cho số nguyên $n$ có đúng ba chữ số ($100 \le n \le 999$). In tổng ba chữ số của $n$.

Lời giải. Mỗi chữ số lấy ra bằng một biểu thức. Chia cho 10 thì số dư là chữ số hàng đơn vị: n % 10. Thương n / 10 là $n$ bỏ đi chữ số cuối, nên chữ số cuối của thương, n / 10 % 10, là chữ số hàng chục. Chia cho 100 bỏ đi hai chữ số cuối, còn lại chữ số hàng trăm: n / 100. Biểu thức n / 10 % 10 tính từ trái sang phải, tức (n / 10) % 10.

Với $n = 307$: 307 / 100 = 3, 307 / 10 = 30 nên 307 / 10 % 10 = 0, 307 % 10 = 7, tổng là 10. Số nhiều chữ số hơn thì lặp lại cặp % 10, / 10 bằng vòng lặp, việc của bài B3.

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

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

    int n;
    cin >> n;
    cout << n / 100 + n / 10 % 10 + n % 10 << '\n';
}

Input307

Output10

Ví dụVị trí trên vòng

Đề. Một vòng tròn có $k$ vị trí đánh số từ $0$ đến $k - 1$; sau vị trí $k - 1$ là vị trí $0$. Bắt đầu ở vị trí $p$, đi $s$ bước theo chiều tăng số. In vị trí cuối cùng. Giới hạn: $1 \le k \le 100$, $0 \le p < k$, $0 \le s \le 1000$.

Lời giải. Nếu vòng được duỗi thẳng thì ta dừng ở $p + s$. Mỗi $k$ bước là đi trọn một vòng và quay về chỗ cũ, nên chỉ phần dư của $p + s$ khi chia cho $k$ quyết định vị trí: đáp án là (p + s) % k. Với ví dụ $k = 7$, $p = 5$, $s = 4$: $5 + 4 = 9 = 1 \cdot 7 + 2$, dừng ở vị trí 2. Đây đúng là bài đồng hồ ở trên với $k = 24$.

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

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

    int k, p, s;
    cin >> k >> p >> s;
    cout << (p + s) % k << '\n';
}

Input7 5 4

Output2

Số thực và số lớn: double, long long

Khi dữ liệu hay kết quả có phần thập phân ta dùng double; cin đọc và cout in nó như số nguyên. Mặc định cout in số thực với 6 chữ số có nghĩa, và số lớn bị đổi sang dạng khoa học. Muốn đúng $k$ chữ số sau dấu phẩy, thêm fixed << setprecision(k) trước giá trị.

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

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

    double x;
    cin >> x;
    cout << x << '\n';
    cout << fixed << setprecision(2) << x << '\n';
}

Input1234567.891

Output1.23457e+06
1234567.89

fixed << setprecision(k) làm tròn chứ không cắt, và ở lại với cout tới hết chương trình; nó chỉ ảnh hưởng số thực. double chỉ lưu gần đúng, được chừng 15 đến 16 chữ số có nghĩa, nên số nguyên lớn thì giữ bằng long long chứ đừng đưa vào double.

Chỗ sai hay gặp nhất với double là phép chia. Kiểu của một phép tính do các toán hạng quyết định, không do biến nhận kết quả: a / b với hai int là chia nguyên, tính xong rồi mới đổi sang double, lúc đó phần lẻ đã mất.

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

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

    int a = 7, b = 2;
    double x = a / b;
    double y = 1.0 * a / b;
    cout << x << ' ' << y << '\n';
}

Output3 3.5

x nhận 7 / 2 = 3 rồi mới thành 3.0. Ở y, 1.0 * a ra 7.0 trước, nên phép chia sau đó là chia thực; viết (double)a / b cũng được.

Số nguyên cũng có giới hạn. int chỉ chứa tới 2147483647 (C++ đặt sẵn tên INT_MAX), còn long long tới khoảng $9{,}2 \cdot 10^{18}$ (LLONG_MAX, số có 19 chữ số). Khi kết quả một phép tính vượt phạm vi của kiểu, số bị tràn (overflow). Tràn số thì C++ không báo lỗi, cũng không hứa kết quả nào: thường là một số sai, nhiều khi là số âm. Đây là lý do một bài đúng thuật toán vẫn trượt vài test lớn.

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

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

    cout << INT_MAX << ' ' << LLONG_MAX << '\n';
    int a = 100000, b = 100000;
    cout << 1LL * a * b << '\n';
}

Output2147483647 9223372036854775807
10000000000

Trước khi gõ code, dùng giới hạn của đề để ước lượng giá trị lớn nhất của dữ liệu, của từng phép tính trung gian và của đáp án. Hai số $10^5$ nhân nhau cho $10^{10}$; ba số $10^9$ cộng nhau cho $3 \cdot 10^9$; tổng $1 + 2 + \dots + n$ với $n = 10^5$ cỡ $5 \cdot 10^9$. Cả ba đều vượt int dù từng số đọc vào vẫn vừa int. Cái gì có thể vượt khoảng $2 \cdot 10^9$ thì khai báo long long ngay từ đầu; nghi ngờ thì cứ chọn nó. Biến long long đọc bằng cin và in bằng cout y hệt int.

Quy tắc toán hạng ở trên áp dụng cả ở đây: với a, b là int, câu lệnh long long c = a * b; vẫn sai, vì tích đã tính xong bằng int (và tràn) rồi mới được gán vào c. Cách chữa là hằng 1LL, số 1 kiểu long long, đặt ở đầu chuỗi nhân như trong chương trình trên: phép nhân đầu tiên đã chạy bằng long long, và các phép sau cũng vậy vì chuỗi nhân tính từ trái sang phải. Gọn nhất vẫn là khai báo a, b là long long từ đầu.

Ví dụTích lớn

Đề. Cho hai số nguyên không âm $a, b \le 10^9$. In tích $a \times b$.

Lời giải. Mỗi số còn vừa int, nhưng tích lớn nhất là $10^{18}$: vượt xa $2{,}1 \cdot 10^9$ và vẫn nhỏ hơn $9{,}2 \cdot 10^{18}$, tức vừa long long. Khai báo a, b là long long, đọc, nhân, in. Để int cả hai và nhân thẳng thì ngay test ví dụ $10^5 \cdot 10^5$ đã in ra một con số sai mà không có cảnh báo nào.

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

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

    long long a, b;
    cin >> a >> b;
    cout << a * b << '\n';
}

Input100000 100000

Output10000000000