output
stringlengths 52
181k
| instruction
stringlengths 296
182k
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w,
x, y, z;
string S;
int main() {
cin >> S;
for (i = 1; i < S.size(); i++) {
if ((S[i] < 'A') || (S[i] > 'Z')) {
cout << S << endl;
return 0;
}
}
for (i = 0; i < S.size(); i++) {
if ((S[i] >= 'A') && (S[i] <= 'Z')) {
S[i] += 32;
continue;
}
if ((S[i] >= 'a') && (S[i] <= 'z')) {
S[i] -= 32;
continue;
}
}
cout << S << endl;
return 0;
}
| ### Prompt
Please provide a Cpp coded solution to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w,
x, y, z;
string S;
int main() {
cin >> S;
for (i = 1; i < S.size(); i++) {
if ((S[i] < 'A') || (S[i] > 'Z')) {
cout << S << endl;
return 0;
}
}
for (i = 0; i < S.size(); i++) {
if ((S[i] >= 'A') && (S[i] <= 'Z')) {
S[i] += 32;
continue;
}
if ((S[i] >= 'a') && (S[i] <= 'z')) {
S[i] -= 32;
continue;
}
}
cout << S << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
char str[101];
bool flag = true;
cin >> str;
for (int i = 1; str[i] != '\0'; i++) {
if (islower(str[i])) {
flag = false;
}
}
if (flag) {
for (int i = 0; str[i] != '\0'; i++) {
if (islower(str[i])) {
str[i] = toupper(str[i]);
} else {
str[i] = tolower(str[i]);
}
}
}
cout << str;
return (0);
}
| ### Prompt
Please formulate a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
char str[101];
bool flag = true;
cin >> str;
for (int i = 1; str[i] != '\0'; i++) {
if (islower(str[i])) {
flag = false;
}
}
if (flag) {
for (int i = 0; str[i] != '\0'; i++) {
if (islower(str[i])) {
str[i] = toupper(str[i]);
} else {
str[i] = tolower(str[i]);
}
}
}
cout << str;
return (0);
}
``` |
#include <bits/stdc++.h>
using namespace std;
char return_to(char c, bool toHigh) {
if (97 <= int(c) && int(c) <= 122) {
return char(c - 32);
} else {
return c + 32;
}
}
void changeStr(string &str) {
for (int i = 0; i < str.size(); i++) {
str[i] = return_to(str[i], true);
}
}
bool isGood(string str) {
for (int i = 1; i < str.size(); i++) {
char c = str[i];
if (97 <= int(c) && int(c) <= 122) return false;
}
return true;
}
int main() {
string str;
cin >> str;
if (isGood(str)) {
changeStr(str);
}
cout << str << endl;
}
| ### Prompt
Your challenge is to write a CPP solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char return_to(char c, bool toHigh) {
if (97 <= int(c) && int(c) <= 122) {
return char(c - 32);
} else {
return c + 32;
}
}
void changeStr(string &str) {
for (int i = 0; i < str.size(); i++) {
str[i] = return_to(str[i], true);
}
}
bool isGood(string str) {
for (int i = 1; i < str.size(); i++) {
char c = str[i];
if (97 <= int(c) && int(c) <= 122) return false;
}
return true;
}
int main() {
string str;
cin >> str;
if (isGood(str)) {
changeStr(str);
}
cout << str << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool one(string s);
bool two(string s);
void c(string s);
void c2(string s);
int main() {
string str;
int i;
cin >> str;
if (one(str)) {
c(str);
} else if (two(str)) {
c2(str);
} else {
cout << str << endl;
}
return 0;
}
bool one(string s) {
int i;
int len = s.length();
for (i = 0; i < len; i++) {
if (i == 0) {
if (isupper(s[i])) {
return false;
}
} else {
if (!isupper(s[i])) return false;
}
}
return true;
}
bool two(string s) {
int i;
int len = s.length();
for (i = 0; i < len; i++) {
if (!isupper(s[i])) return false;
}
return true;
}
void c(string s) {
int i;
int len = s.length();
s[0] = toupper(s[0]);
for (i = 1; i < len; i++) {
s[i] = tolower(s[i]);
}
cout << s << endl;
}
void c2(string s) {
int i;
int len = s.length();
for (i = 0; i < len; i++) {
s[i] = tolower(s[i]);
}
cout << s << endl;
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool one(string s);
bool two(string s);
void c(string s);
void c2(string s);
int main() {
string str;
int i;
cin >> str;
if (one(str)) {
c(str);
} else if (two(str)) {
c2(str);
} else {
cout << str << endl;
}
return 0;
}
bool one(string s) {
int i;
int len = s.length();
for (i = 0; i < len; i++) {
if (i == 0) {
if (isupper(s[i])) {
return false;
}
} else {
if (!isupper(s[i])) return false;
}
}
return true;
}
bool two(string s) {
int i;
int len = s.length();
for (i = 0; i < len; i++) {
if (!isupper(s[i])) return false;
}
return true;
}
void c(string s) {
int i;
int len = s.length();
s[0] = toupper(s[0]);
for (i = 1; i < len; i++) {
s[i] = tolower(s[i]);
}
cout << s << endl;
}
void c2(string s) {
int i;
int len = s.length();
for (i = 0; i < len; i++) {
s[i] = tolower(s[i]);
}
cout << s << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
string s = "";
string ans = "";
int main() {
cin >> s;
auto str = s.c_str();
int n = s.size();
bool upFlag = false, lowFlag = true;
upFlag = true;
int i = 0;
for (i = 1; i < n; i++) {
if (!upFlag) break;
upFlag = isupper(str[i]);
}
if (upFlag) {
if ('a' <= str[0] && str[0] <= 'z') {
s[0] = s[0] - 'a' + 'A';
} else
s[0] = s[0] - 'A' + 'a';
for (int i = 1; i < n; i++) {
s[i] = s[i] - 'A' + 'a';
}
}
cout << s << endl;
return 0;
}
| ### Prompt
Please create a solution in Cpp to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s = "";
string ans = "";
int main() {
cin >> s;
auto str = s.c_str();
int n = s.size();
bool upFlag = false, lowFlag = true;
upFlag = true;
int i = 0;
for (i = 1; i < n; i++) {
if (!upFlag) break;
upFlag = isupper(str[i]);
}
if (upFlag) {
if ('a' <= str[0] && str[0] <= 'z') {
s[0] = s[0] - 'a' + 'A';
} else
s[0] = s[0] - 'A' + 'a';
for (int i = 1; i < n; i++) {
s[i] = s[i] - 'A' + 'a';
}
}
cout << s << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int i, n;
cin >> s;
bool change1 = false, change2 = false, unchange = false;
if (s.size() < 2) {
if (s[0] >= 65 && s[0] <= 90) {
s[0] += 32;
cout << s << endl;
} else {
s[0] -= 32;
cout << s << endl;
}
} else if (s[0] >= 65 && s[0] <= 90) {
for (i = 1; i < s.size(); i++) {
if (s[i] >= 97 && s[i] <= 122) {
change1 = false;
unchange = true;
break;
} else {
change1 = true;
}
}
} else {
for (i = 1; i < s.size(); i++) {
if (s[i] >= 97 && s[i] <= 122) {
change2 = false;
unchange = true;
break;
} else {
change2 = true;
}
}
}
if (change1) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
cout << s << endl;
} else if (change2) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
s[0] -= 32;
cout << s << endl;
} else if (unchange) {
cout << s << endl;
}
return 0;
}
| ### Prompt
Please formulate a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int i, n;
cin >> s;
bool change1 = false, change2 = false, unchange = false;
if (s.size() < 2) {
if (s[0] >= 65 && s[0] <= 90) {
s[0] += 32;
cout << s << endl;
} else {
s[0] -= 32;
cout << s << endl;
}
} else if (s[0] >= 65 && s[0] <= 90) {
for (i = 1; i < s.size(); i++) {
if (s[i] >= 97 && s[i] <= 122) {
change1 = false;
unchange = true;
break;
} else {
change1 = true;
}
}
} else {
for (i = 1; i < s.size(); i++) {
if (s[i] >= 97 && s[i] <= 122) {
change2 = false;
unchange = true;
break;
} else {
change2 = true;
}
}
}
if (change1) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
cout << s << endl;
} else if (change2) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
s[0] -= 32;
cout << s << endl;
} else if (unchange) {
cout << s << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
for (int j = 1; j < a.length(); j++)
if (a[j] >= 'a' && a[j] <= 'z') {
cout << a << endl;
return 0;
}
for (int i = 0; i < a.size(); i++) {
if (a[i] >= 'a' && a[i] <= 'z')
a[i] = 'A' + a[i] - 'a';
else
a[i] = 'a' + a[i] - 'A';
}
cout << a << endl;
}
| ### Prompt
Please provide a cpp coded solution to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
for (int j = 1; j < a.length(); j++)
if (a[j] >= 'a' && a[j] <= 'z') {
cout << a << endl;
return 0;
}
for (int i = 0; i < a.size(); i++) {
if (a[i] >= 'a' && a[i] <= 'z')
a[i] = 'A' + a[i] - 'a';
else
a[i] = 'a' + a[i] - 'A';
}
cout << a << endl;
}
``` |
#include <bits/stdc++.h>
int main() {
int i, length, count = 0;
char arr[100];
scanf("%s", &arr);
length = strlen(arr);
for (i = 1; i < length; i++) {
if (arr[i] >= 65 && arr[i] <= 90) count++;
}
if (count == length - 1) {
for (i = 0; i < length; i++) {
if (arr[i] >= 65 && arr[i] <= 90) {
arr[i] = arr[i] + 32;
} else if (arr[i] >= 97 && arr[i] <= 122) {
arr[i] = arr[i] - 32;
}
}
}
printf("%s", arr);
return 0;
}
| ### Prompt
Create a solution in cpp for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int i, length, count = 0;
char arr[100];
scanf("%s", &arr);
length = strlen(arr);
for (i = 1; i < length; i++) {
if (arr[i] >= 65 && arr[i] <= 90) count++;
}
if (count == length - 1) {
for (i = 0; i < length; i++) {
if (arr[i] >= 65 && arr[i] <= 90) {
arr[i] = arr[i] + 32;
} else if (arr[i] >= 97 && arr[i] <= 122) {
arr[i] = arr[i] - 32;
}
}
}
printf("%s", arr);
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool flag = true;
for (int i = 1; i < s.length(); i++) {
if (islower(s[i])) {
flag = false;
break;
}
}
if (flag) {
for (int i = 0; i < s.length(); i++) {
if (islower(s[i]))
s[i] = toupper(s[i]);
else
s[i] = tolower(s[i]);
}
}
cout << s << endl;
return 0;
}
| ### Prompt
Create a solution in CPP for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool flag = true;
for (int i = 1; i < s.length(); i++) {
if (islower(s[i])) {
flag = false;
break;
}
}
if (flag) {
for (int i = 0; i < s.length(); i++) {
if (islower(s[i]))
s[i] = toupper(s[i]);
else
s[i] = tolower(s[i]);
}
}
cout << s << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int verif1(string s) {
int r = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == toupper(s[i])) r++;
}
if (r == s.size())
return 1;
else
return 0;
}
int verif2(string s) {
if (s[0] <= 90)
return 0;
else {
int r = 1;
for (int i = 1; i < s.size(); i++) {
if ((s[i] >= 65) && (s[i] <= 90)) r++;
}
if (r == s.size())
return 1;
else
return 0;
}
}
int main() {
string s;
cin >> s;
if ((verif1(s) == 0) && (verif2(s) == 0))
cout << s;
else if (verif1(s) == 1) {
for (int i = 0; i < s.size(); i++) s[i] = tolower(s[i]);
cout << s;
} else if (verif2(s) == 1) {
s[0] = toupper(s[0]);
for (int i = 1; i < s.size(); i++) s[i] = tolower(s[i]);
cout << s;
}
}
| ### Prompt
Create a solution in Cpp for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int verif1(string s) {
int r = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == toupper(s[i])) r++;
}
if (r == s.size())
return 1;
else
return 0;
}
int verif2(string s) {
if (s[0] <= 90)
return 0;
else {
int r = 1;
for (int i = 1; i < s.size(); i++) {
if ((s[i] >= 65) && (s[i] <= 90)) r++;
}
if (r == s.size())
return 1;
else
return 0;
}
}
int main() {
string s;
cin >> s;
if ((verif1(s) == 0) && (verif2(s) == 0))
cout << s;
else if (verif1(s) == 1) {
for (int i = 0; i < s.size(); i++) s[i] = tolower(s[i]);
cout << s;
} else if (verif2(s) == 1) {
s[0] = toupper(s[0]);
for (int i = 1; i < s.size(); i++) s[i] = tolower(s[i]);
cout << s;
}
}
``` |
#include <bits/stdc++.h>
const int maxN = 200005;
using namespace std;
bool checkIsWrongTyping(string s) {
for (int i = 1; i < s.length(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') return false;
}
return true;
}
int main() {
int t = 1;
while (t-- > 0) {
string s;
cin >> s;
if (checkIsWrongTyping(s)) {
for (int i = 0; i < s.length(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
s[i] = toupper(s[i]);
} else {
s[i] = tolower(s[i]);
}
}
}
cout << s;
}
}
| ### Prompt
Generate a CPP solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
const int maxN = 200005;
using namespace std;
bool checkIsWrongTyping(string s) {
for (int i = 1; i < s.length(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') return false;
}
return true;
}
int main() {
int t = 1;
while (t-- > 0) {
string s;
cin >> s;
if (checkIsWrongTyping(s)) {
for (int i = 0; i < s.length(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
s[i] = toupper(s[i]);
} else {
s[i] = tolower(s[i]);
}
}
}
cout << s;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string d;
cin >> d;
for (int i = d.length() - 1; i > 0; i--) {
if (d[i] < 'A' || d[i] > 'Z') {
cout << d;
return 0;
}
}
string ans = "";
for (int j = 0; j < d.length(); j++) {
if (d[j] < 'A' || d[j] > 'Z') {
ans = ans + char(int(d[j]) - 32);
} else {
ans = ans + char(int(d[j]) + 32);
}
}
cout << ans;
return 0;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string d;
cin >> d;
for (int i = d.length() - 1; i > 0; i--) {
if (d[i] < 'A' || d[i] > 'Z') {
cout << d;
return 0;
}
}
string ans = "";
for (int j = 0; j < d.length(); j++) {
if (d[j] < 'A' || d[j] > 'Z') {
ans = ans + char(int(d[j]) - 32);
} else {
ans = ans + char(int(d[j]) + 32);
}
}
cout << ans;
return 0;
}
``` |
#include <bits/stdc++.h>
int main() {
char a[100], check1 = 0, check2 = 1;
gets(a);
for (int i = 0; a[i] != '\0'; i++) {
if (a[i] >= 'A' && a[i] <= 'Z') {
check2++;
}
check1++;
}
if ((a[0] >= 'a' && check2 >= check1) || check2 > check1) {
for (int i = 0; a[i] != '\0'; i++) {
if (a[i] >= 'a' && a[i] <= 'z') {
a[i] = a[i] - 32;
} else {
a[i] = a[i] + 32;
}
}
}
printf(a);
return 0;
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
int main() {
char a[100], check1 = 0, check2 = 1;
gets(a);
for (int i = 0; a[i] != '\0'; i++) {
if (a[i] >= 'A' && a[i] <= 'Z') {
check2++;
}
check1++;
}
if ((a[0] >= 'a' && check2 >= check1) || check2 > check1) {
for (int i = 0; a[i] != '\0'; i++) {
if (a[i] >= 'a' && a[i] <= 'z') {
a[i] = a[i] - 32;
} else {
a[i] = a[i] + 32;
}
}
}
printf(a);
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
char a[100] = {0};
int sa;
int i;
cin >> a;
sa = strlen(a);
int fl = 0;
for (i = 0; i < sa; i++) {
if (islower(a[i])) {
fl = 1;
break;
}
}
if (fl == 0) {
X:
for (i = 0; i < sa; i++) {
if (islower(a[i])) {
a[i] = toupper(a[i]);
} else {
a[i] = tolower(a[i]);
}
}
cout << a << endl;
return 0;
} else {
if (islower(a[0])) {
fl = 0;
for (i = 1; i < sa; i++) {
if (islower(a[i])) {
fl = 1;
break;
}
}
if (fl == 0) {
goto X;
}
}
}
cout << a << endl;
return 0;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
char a[100] = {0};
int sa;
int i;
cin >> a;
sa = strlen(a);
int fl = 0;
for (i = 0; i < sa; i++) {
if (islower(a[i])) {
fl = 1;
break;
}
}
if (fl == 0) {
X:
for (i = 0; i < sa; i++) {
if (islower(a[i])) {
a[i] = toupper(a[i]);
} else {
a[i] = tolower(a[i]);
}
}
cout << a << endl;
return 0;
} else {
if (islower(a[0])) {
fl = 0;
for (i = 1; i < sa; i++) {
if (islower(a[i])) {
fl = 1;
break;
}
}
if (fl == 0) {
goto X;
}
}
}
cout << a << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
bitset<1000001> primeArr;
void sieve() {
int num_sqrt = sqrt(1000000);
primeArr[1] = 1;
for (int i = 4; i <= 1000000; i += 2) primeArr[i] = 1;
for (int i = 3; i <= num_sqrt; i += 2) {
for (int j = 2; i * j <= 1000000; j++) primeArr[i * j] = 1;
}
}
int main() {
string s, c;
cin >> s;
c = s;
bool check = true;
if (s[0] > 90) {
for (int i = 1; i < s.size(); i++) {
if (s[i] <= 90)
s[i] += 32;
else {
check = false;
break;
}
}
if (check) s[0] -= 32;
} else {
for (int i = 1; i < s.size(); i++) {
if (s[i] <= 90)
s[i] += 32;
else {
check = false;
break;
}
}
if (check) s[0] += 32;
}
if (check) {
cout << s << endl;
} else
cout << c << endl;
return 0;
}
| ### Prompt
Create a solution in Cpp for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bitset<1000001> primeArr;
void sieve() {
int num_sqrt = sqrt(1000000);
primeArr[1] = 1;
for (int i = 4; i <= 1000000; i += 2) primeArr[i] = 1;
for (int i = 3; i <= num_sqrt; i += 2) {
for (int j = 2; i * j <= 1000000; j++) primeArr[i * j] = 1;
}
}
int main() {
string s, c;
cin >> s;
c = s;
bool check = true;
if (s[0] > 90) {
for (int i = 1; i < s.size(); i++) {
if (s[i] <= 90)
s[i] += 32;
else {
check = false;
break;
}
}
if (check) s[0] -= 32;
} else {
for (int i = 1; i < s.size(); i++) {
if (s[i] <= 90)
s[i] += 32;
else {
check = false;
break;
}
}
if (check) s[0] += 32;
}
if (check) {
cout << s << endl;
} else
cout << c << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
char uptolow(char ch) {
if (ch >= 'A' && ch <= 'Z') {
ch += 32;
return ch;
}
}
char lowtoup(char ch) {
if (ch >= 'a' && ch <= 'z') {
ch -= 32;
return ch;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, s1;
int a, n, l, e, k = 0;
cin >> s;
l = s.size();
for (int i = 0; i < l; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') k++;
}
if (k == l) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
cout << s << endl;
} else if (k == (l - 1) && (s[0] >= 'a' && s[0] <= 'z')) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
s[0] = lowtoup(s[0]);
cout << s << endl;
} else
cout << s << endl;
return 0;
}
| ### Prompt
In cpp, your task is to solve the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char uptolow(char ch) {
if (ch >= 'A' && ch <= 'Z') {
ch += 32;
return ch;
}
}
char lowtoup(char ch) {
if (ch >= 'a' && ch <= 'z') {
ch -= 32;
return ch;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, s1;
int a, n, l, e, k = 0;
cin >> s;
l = s.size();
for (int i = 0; i < l; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') k++;
}
if (k == l) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
cout << s << endl;
} else if (k == (l - 1) && (s[0] >= 'a' && s[0] <= 'z')) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
s[0] = lowtoup(s[0]);
cout << s << endl;
} else
cout << s << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
bool change = true;
for (int i = 1; i < str.length(); i++) {
if (islower(str[i])) {
change = false;
break;
}
}
if (change) {
for (int i = 0; i < str.length(); i++) {
char m;
if (isupper(str[i]))
m = tolower(str[i]);
else
m = toupper(str[i]);
cout << m;
}
cout << endl;
} else {
cout << str << endl;
}
return 0;
}
| ### Prompt
Create a solution in cpp for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
bool change = true;
for (int i = 1; i < str.length(); i++) {
if (islower(str[i])) {
change = false;
break;
}
}
if (change) {
for (int i = 0; i < str.length(); i++) {
char m;
if (isupper(str[i]))
m = tolower(str[i]);
else
m = toupper(str[i]);
cout << m;
}
cout << endl;
} else {
cout << str << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
bool check1;
check1 = false;
for (int i = 1; i < a.size(); i++) {
if (a[i] >= 'a' && a[i] <= 'z') check1 = true;
}
if (check1 == false) {
if (a[0] >= 'a' && a[0] <= 'z')
a[0] = toupper(a[0]);
else
a[0] = tolower(a[0]);
for (int i = 1; i < a.size(); i++) {
if (islower(a[i]))
a[i] = toupper(a[i]);
else
a[i] = tolower(a[i]);
}
}
cout << a << endl;
return 0;
}
| ### Prompt
Develop a solution in Cpp to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
bool check1;
check1 = false;
for (int i = 1; i < a.size(); i++) {
if (a[i] >= 'a' && a[i] <= 'z') check1 = true;
}
if (check1 == false) {
if (a[0] >= 'a' && a[0] <= 'z')
a[0] = toupper(a[0]);
else
a[0] = tolower(a[0]);
for (int i = 1; i < a.size(); i++) {
if (islower(a[i]))
a[i] = toupper(a[i]);
else
a[i] = tolower(a[i]);
}
}
cout << a << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[101], ans[101];
cin >> a;
int c = 0, i;
for (i = 1; a[i] != '\0'; i++) {
if (isupper(a[i]))
ans[i] = tolower(a[i]);
else
c = 1;
}
if (c == 0) {
if (isupper(a[0]))
ans[0] = tolower(a[0]);
else
ans[0] = toupper(a[0]);
} else {
cout << a << endl;
return 0;
}
ans[i] = '\0';
cout << ans << endl;
return 0;
}
| ### Prompt
Your challenge is to write a CPP solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[101], ans[101];
cin >> a;
int c = 0, i;
for (i = 1; a[i] != '\0'; i++) {
if (isupper(a[i]))
ans[i] = tolower(a[i]);
else
c = 1;
}
if (c == 0) {
if (isupper(a[0]))
ans[0] = tolower(a[0]);
else
ans[0] = toupper(a[0]);
} else {
cout << a << endl;
return 0;
}
ans[i] = '\0';
cout << ans << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i;
string s;
cin >> s;
for (i = 1; i < s.size(); i++) {
if (s[i] >= 97) {
cout << s << endl;
return 0;
}
}
if (s[0] >= 65 & s[0] <= 90)
s[0] = s[0] + 32;
else
s[0] = s[0] - 32;
for (i = 1; i < s.size(); i++) {
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = s[i] + 32;
}
cout << s << endl;
return 0;
}
| ### Prompt
Create a solution in cpp for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int i;
string s;
cin >> s;
for (i = 1; i < s.size(); i++) {
if (s[i] >= 97) {
cout << s << endl;
return 0;
}
}
if (s[0] >= 65 & s[0] <= 90)
s[0] = s[0] + 32;
else
s[0] = s[0] - 32;
for (i = 1; i < s.size(); i++) {
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = s[i] + 32;
}
cout << s << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int flag = 0;
string str;
cin >> str;
for (int i = 1; i < str.length(); i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
flag = 1;
break;
}
}
if (flag == 1)
cout << str << endl;
else {
for (int i = 0; i < str.length(); i++)
str[i] = (str[i] >= 'A' && str[i] <= 'Z') ? char(str[i] + 32)
: char(str[i] - 32);
cout << str << endl;
}
return 0;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int flag = 0;
string str;
cin >> str;
for (int i = 1; i < str.length(); i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
flag = 1;
break;
}
}
if (flag == 1)
cout << str << endl;
else {
for (int i = 0; i < str.length(); i++)
str[i] = (str[i] >= 'A' && str[i] <= 'Z') ? char(str[i] + 32)
: char(str[i] - 32);
cout << str << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
string s;
bool fl = true;
int main() {
cin >> s;
for (int i = 1; i < s.size(); i++)
if (s[i] > 96) fl = false;
for (int i = 0; i < s.size(); i++)
if (fl)
if (s[i] > 96)
s[i] -= 32;
else
s[i] += 32;
cout << s << endl;
}
| ### Prompt
Develop a solution in CPP to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s;
bool fl = true;
int main() {
cin >> s;
for (int i = 1; i < s.size(); i++)
if (s[i] > 96) fl = false;
for (int i = 0; i < s.size(); i++)
if (fl)
if (s[i] > 96)
s[i] -= 32;
else
s[i] += 32;
cout << s << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
int count = 0, c = 0;
cin >> a;
count = a.size();
for (int i = 0; a[i] != '\0'; i++) {
if (a[i] >= 'A' && a[i] <= 'Z') c++;
}
if ((c == count) || ((c == count - 1) && (a[0] >= 'a' && a[0] <= 'z'))) {
for (int i = 0; a[i] != '\0'; i++) {
if (a[i] >= 'A' && a[i] <= 'Z')
a[i] = a[i] + 32;
else
a[i] = a[i] - 32;
}
}
for (int i = 0; a[i] != '\0'; i++) {
cout << a[i];
}
}
| ### Prompt
Construct a cpp code solution to the problem outlined:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
int count = 0, c = 0;
cin >> a;
count = a.size();
for (int i = 0; a[i] != '\0'; i++) {
if (a[i] >= 'A' && a[i] <= 'Z') c++;
}
if ((c == count) || ((c == count - 1) && (a[0] >= 'a' && a[0] <= 'z'))) {
for (int i = 0; a[i] != '\0'; i++) {
if (a[i] >= 'A' && a[i] <= 'Z')
a[i] = a[i] + 32;
else
a[i] = a[i] - 32;
}
}
for (int i = 0; a[i] != '\0'; i++) {
cout << a[i];
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[1000];
long long int i, b, co = 0;
cin >> a;
for (i = 0; i < strlen(a); i++) {
cin >> a[i];
if (a[i] <= 'Z') {
co++;
}
}
if (co == strlen(a)) {
for (i = 0; i < strlen(a); ++i) {
cout << char(tolower(a[i]));
}
} else if (co == (strlen(a) - 1) && a[0] > 'Z') {
cout << char(a[0] - 'a' + 'A');
for (i = 1; i < strlen(a); ++i) {
cout << char(tolower(a[i]));
}
} else {
for (i = 0; i < strlen(a); ++i) {
cout << a[i];
}
}
return 0;
}
| ### Prompt
Develop a solution in CPP to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[1000];
long long int i, b, co = 0;
cin >> a;
for (i = 0; i < strlen(a); i++) {
cin >> a[i];
if (a[i] <= 'Z') {
co++;
}
}
if (co == strlen(a)) {
for (i = 0; i < strlen(a); ++i) {
cout << char(tolower(a[i]));
}
} else if (co == (strlen(a) - 1) && a[0] > 'Z') {
cout << char(a[0] - 'a' + 'A');
for (i = 1; i < strlen(a); ++i) {
cout << char(tolower(a[i]));
}
} else {
for (i = 0; i < strlen(a); ++i) {
cout << a[i];
}
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int CheckCaps(string str) {
int l = str.length();
string temp(l, ' ');
int i = 0;
while (i < l) {
temp[i] = toupper(str[i]);
i++;
}
if (str.compare(temp) == 0)
return 1;
else
return 0;
}
int CheckFirstCaps(string str) {
int l = str.length();
string temp(l, ' ');
temp[0] = toupper(str[0]);
int i = 1;
while (i < l) {
temp[i] = tolower(str[i]);
i++;
}
if (str.compare(temp) == 0)
return 1;
else
return 0;
}
int CheckFirstSmall(string str) {
int l = str.length();
string temp(l, ' ');
temp[0] = tolower(str[0]);
int i = 1;
while (i < l) {
temp[i] = toupper(str[i]);
i++;
}
if (str.compare(temp) == 0)
return 1;
else
return 0;
}
int main() {
string temp;
cin >> temp;
if (CheckCaps(temp)) {
int l = temp.length();
string str(l, ' ');
int i = 0;
while (i < l) {
str[i] = tolower(temp[i]);
i++;
}
cout << str;
} else if (CheckFirstCaps(temp))
cout << temp;
else if (CheckFirstSmall(temp)) {
int l = temp.length();
string str(l, ' ');
str[0] = toupper(temp[0]);
int i = 1;
while (i < l) {
str[i] = tolower(temp[i]);
i++;
}
cout << str;
} else {
cout << temp;
}
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int CheckCaps(string str) {
int l = str.length();
string temp(l, ' ');
int i = 0;
while (i < l) {
temp[i] = toupper(str[i]);
i++;
}
if (str.compare(temp) == 0)
return 1;
else
return 0;
}
int CheckFirstCaps(string str) {
int l = str.length();
string temp(l, ' ');
temp[0] = toupper(str[0]);
int i = 1;
while (i < l) {
temp[i] = tolower(str[i]);
i++;
}
if (str.compare(temp) == 0)
return 1;
else
return 0;
}
int CheckFirstSmall(string str) {
int l = str.length();
string temp(l, ' ');
temp[0] = tolower(str[0]);
int i = 1;
while (i < l) {
temp[i] = toupper(str[i]);
i++;
}
if (str.compare(temp) == 0)
return 1;
else
return 0;
}
int main() {
string temp;
cin >> temp;
if (CheckCaps(temp)) {
int l = temp.length();
string str(l, ' ');
int i = 0;
while (i < l) {
str[i] = tolower(temp[i]);
i++;
}
cout << str;
} else if (CheckFirstCaps(temp))
cout << temp;
else if (CheckFirstSmall(temp)) {
int l = temp.length();
string str(l, ' ');
str[0] = toupper(temp[0]);
int i = 1;
while (i < l) {
str[i] = tolower(temp[i]);
i++;
}
cout << str;
} else {
cout << temp;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
int flag = 0;
for (int i = 1; i < n.length(); i++) {
if (islower(n[i])) {
flag++;
break;
}
}
if (flag == 0) {
if (islower(n[0])) {
n[0] = toupper(n[0]);
} else
n[0] = tolower(n[0]);
for (int i = 1; i < n.length(); i++) {
n[i] = tolower(n[i]);
}
}
cout << n << endl;
}
| ### Prompt
Develop a solution in CPP to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
int flag = 0;
for (int i = 1; i < n.length(); i++) {
if (islower(n[i])) {
flag++;
break;
}
}
if (flag == 0) {
if (islower(n[0])) {
n[0] = toupper(n[0]);
} else
n[0] = tolower(n[0]);
for (int i = 1; i < n.length(); i++) {
n[i] = tolower(n[i]);
}
}
cout << n << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int i, c = 0, a = 0;
for (i = 0; i < s.length(); i++) {
if (s[0] >= 97 && s[0] <= 122) a = 1;
if (s[i] >= 65 && s[i] <= 90) c++;
}
if (!((c == i) || ((c + a) == i)))
cout << s;
else {
for (int j = 0; j < s.length(); j++) {
if (s[j] >= 97) {
s[j] -= 32;
} else
s[j] += 32;
cout << s[j];
}
}
return 0;
}
| ### Prompt
Generate a CPP solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int i, c = 0, a = 0;
for (i = 0; i < s.length(); i++) {
if (s[0] >= 97 && s[0] <= 122) a = 1;
if (s[i] >= 65 && s[i] <= 90) c++;
}
if (!((c == i) || ((c + a) == i)))
cout << s;
else {
for (int j = 0; j < s.length(); j++) {
if (s[j] >= 97) {
s[j] -= 32;
} else
s[j] += 32;
cout << s[j];
}
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool change = true;
for (int i = 1; i < s.length(); ++i) {
if (s[i] >= 'a') {
change = false;
break;
}
}
if (change) {
for (int i = 0; i < s.length(); ++i) {
if (s[i] >= 'a') {
s[i] -= 32;
} else {
s[i] += 32;
}
}
}
cout << s << endl;
return 0;
}
| ### Prompt
Develop a solution in cpp to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool change = true;
for (int i = 1; i < s.length(); ++i) {
if (s[i] >= 'a') {
change = false;
break;
}
}
if (change) {
for (int i = 0; i < s.length(); ++i) {
if (s[i] >= 'a') {
s[i] -= 32;
} else {
s[i] += 32;
}
}
}
cout << s << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
string str;
cin >> str;
int l = 0;
for (int i = 1; i < str.length(); ++i) {
if (isupper(str[i])) l++;
}
if (l == str.length() - 1) {
for (int i = 1; i < str.length(); ++i) {
str[i] = tolower(str[i]);
}
if (isupper(str[0]))
str[0] = tolower(str[0]);
else
str[0] = toupper(str[0]);
}
cout << str;
return 0;
}
| ### Prompt
Develop a solution in CPP to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
string str;
cin >> str;
int l = 0;
for (int i = 1; i < str.length(); ++i) {
if (isupper(str[i])) l++;
}
if (l == str.length() - 1) {
for (int i = 1; i < str.length(); ++i) {
str[i] = tolower(str[i]);
}
if (isupper(str[0]))
str[0] = tolower(str[0]);
else
str[0] = toupper(str[0]);
}
cout << str;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
getline(cin, s);
int l = s.size();
bool ok = false;
for (int i = 1; i < l; i++)
if (s[i] >= 'a' && s[i] <= 'z') ok = true;
if (!ok) {
for (int i = 0; i < l; i++) {
if (s[i] >= 'A' && s[i] <= 'Z')
s[i] += ('a' - 'A');
else
s[i] -= ('a' - 'A');
}
}
for (int i = 0; i < l; i++) cout << s[i];
return 0;
}
| ### Prompt
Please create a solution in Cpp to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
getline(cin, s);
int l = s.size();
bool ok = false;
for (int i = 1; i < l; i++)
if (s[i] >= 'a' && s[i] <= 'z') ok = true;
if (!ok) {
for (int i = 0; i < l; i++) {
if (s[i] >= 'A' && s[i] <= 'Z')
s[i] += ('a' - 'A');
else
s[i] -= ('a' - 'A');
}
}
for (int i = 0; i < l; i++) cout << s[i];
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[101];
int b;
char c[101];
int k = 0;
cin >> a;
b = strlen(a);
strcpy(c, a);
for (int i = 0; i < b; i++) {
if (i == 0) {
if ((int)a[i] >= 97 && (int)a[i] <= 122)
a[i] = char((int)a[i] - 32);
else
a[i] = char((int)a[i] + 32);
} else {
if ((int)a[i] >= 65 && (int)a[i] <= 90)
a[i] = char((int)a[i] + 32);
else {
k = 1;
break;
}
}
}
if (k == 0)
cout << a;
else
cout << c;
}
| ### Prompt
Please create a solution in CPP to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[101];
int b;
char c[101];
int k = 0;
cin >> a;
b = strlen(a);
strcpy(c, a);
for (int i = 0; i < b; i++) {
if (i == 0) {
if ((int)a[i] >= 97 && (int)a[i] <= 122)
a[i] = char((int)a[i] - 32);
else
a[i] = char((int)a[i] + 32);
} else {
if ((int)a[i] >= 65 && (int)a[i] <= 90)
a[i] = char((int)a[i] + 32);
else {
k = 1;
break;
}
}
}
if (k == 0)
cout << a;
else
cout << c;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
for (int i = 1; i < s.length(); i++) {
if (isupper(s[i])) count++;
}
if (count != s.length() - 1)
cout << s;
else {
for (int j = 0; j < s.length(); j++) {
if (isupper(s[j]))
s[j] = tolower(s[j]);
else
s[j] = toupper(s[j]);
}
cout << s;
}
return 0;
}
| ### Prompt
Generate a CPP solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
for (int i = 1; i < s.length(); i++) {
if (isupper(s[i])) count++;
}
if (count != s.length() - 1)
cout << s;
else {
for (int j = 0; j < s.length(); j++) {
if (isupper(s[j]))
s[j] = tolower(s[j]);
else
s[j] = toupper(s[j]);
}
cout << s;
}
return 0;
}
``` |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
bool kt = true;
for (long long i = 1; i < s.size(); i++) {
if (s[i] >= 'a') {
kt = false;
break;
}
}
if (kt) {
for (long long i = 0; i < s.size(); i++) {
if (s[i] >= 'a')
s[i] -= 32;
else
s[i] += 32;
}
}
cout << s;
return 0;
}
| ### Prompt
Please create a solution in cpp to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
bool kt = true;
for (long long i = 1; i < s.size(); i++) {
if (s[i] >= 'a') {
kt = false;
break;
}
}
if (kt) {
for (long long i = 0; i < s.size(); i++) {
if (s[i] >= 'a')
s[i] -= 32;
else
s[i] += 32;
}
}
cout << s;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
string big(string n) {
int a = n.size();
for (int i = 0; i < a; i++) {
if (n[i] > 'Z') n[i] += 'A' - 'a';
}
return n;
}
string small(string n) {
int a = n.size();
for (int i = 0; i < a; i++) n[i] = tolower(n[i]);
return n;
}
int main() {
string n;
cin >> n;
int s = n.size();
string m = big(n);
string k = big(n);
k[0] = tolower(k[0]);
if (n == m || n == k) {
for (int i = 0; i < s; i++) {
if (n[i] > 'Z')
n[i] += 'A' - 'a';
else
n[i] = tolower(n[i]);
}
cout << n;
} else
cout << n;
return 0;
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string big(string n) {
int a = n.size();
for (int i = 0; i < a; i++) {
if (n[i] > 'Z') n[i] += 'A' - 'a';
}
return n;
}
string small(string n) {
int a = n.size();
for (int i = 0; i < a; i++) n[i] = tolower(n[i]);
return n;
}
int main() {
string n;
cin >> n;
int s = n.size();
string m = big(n);
string k = big(n);
k[0] = tolower(k[0]);
if (n == m || n == k) {
for (int i = 0; i < s; i++) {
if (n[i] > 'Z')
n[i] += 'A' - 'a';
else
n[i] = tolower(n[i]);
}
cout << n;
} else
cout << n;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
string str;
int x;
int main() {
cin >> str;
for (int i = 2; i <= str.size(); i++) {
if (str[i - 1] > 96) {
x = 1;
}
}
for (int i = 1; i <= str.size(); i++) {
if (x == 0) {
if (str[i - 1] > 96) {
str[i - 1] -= 32;
} else
str[i - 1] += 32;
}
}
cout << str << endl;
}
| ### Prompt
Please create a solution in Cpp to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string str;
int x;
int main() {
cin >> str;
for (int i = 2; i <= str.size(); i++) {
if (str[i - 1] > 96) {
x = 1;
}
}
for (int i = 1; i <= str.size(); i++) {
if (x == 0) {
if (str[i - 1] > 96) {
str[i - 1] -= 32;
} else
str[i - 1] += 32;
}
}
cout << str << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
int i, count = 0;
for (i = 0; i < a.size(); i++) {
if (a[i] == tolower(a[i])) count++;
}
if (count == 0) {
for (i = 0; i < a.size(); i++) a[i] = tolower(a[i]);
cout << a << endl;
} else if (count == 1 && a[0] == tolower(a[0])) {
a[0] = toupper(a[0]);
for (i = 1; i < a.size(); i++) a[i] = tolower(a[i]);
cout << a << endl;
} else
cout << a << endl;
return 0;
}
| ### Prompt
Please create a solution in cpp to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
int i, count = 0;
for (i = 0; i < a.size(); i++) {
if (a[i] == tolower(a[i])) count++;
}
if (count == 0) {
for (i = 0; i < a.size(); i++) a[i] = tolower(a[i]);
cout << a << endl;
} else if (count == 1 && a[0] == tolower(a[0])) {
a[0] = toupper(a[0]);
for (i = 1; i < a.size(); i++) a[i] = tolower(a[i]);
cout << a << endl;
} else
cout << a << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
int main() {
char ara[100000], ara2[100000], ara3[100000];
int i, j, k, l, m, count = 0;
scanf("%s", ara);
i = strlen(ara);
for (j = 0; j < i; j++) {
if ((ara[0] >= 65 && ara[0] <= 90) || (ara[0] >= 97 && ara[0] <= 122)) {
ara2[j] = ara[j];
}
}
for (k = 1; k < i; k++) {
if ((ara2[k] >= 65 && ara2[k] <= 90)) {
ara3[k] = ara2[k];
count++;
}
}
if (count == i - 1) ara3[0] = ara2[0];
l = strlen(ara3);
if (i == l) {
for (m = 0; m < i; m++) {
if (ara3[m] >= 65 && ara3[m] <= 90)
ara3[m] = 'a' + (ara3[m] - 'A');
else if (ara3[m] >= 97 && ara3[m] <= 122)
ara3[m] = 'A' + (ara3[m] - 'a');
}
printf("%s", ara3);
} else
printf("%s", ara);
return 0;
}
| ### Prompt
Construct a cpp code solution to the problem outlined:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
int main() {
char ara[100000], ara2[100000], ara3[100000];
int i, j, k, l, m, count = 0;
scanf("%s", ara);
i = strlen(ara);
for (j = 0; j < i; j++) {
if ((ara[0] >= 65 && ara[0] <= 90) || (ara[0] >= 97 && ara[0] <= 122)) {
ara2[j] = ara[j];
}
}
for (k = 1; k < i; k++) {
if ((ara2[k] >= 65 && ara2[k] <= 90)) {
ara3[k] = ara2[k];
count++;
}
}
if (count == i - 1) ara3[0] = ara2[0];
l = strlen(ara3);
if (i == l) {
for (m = 0; m < i; m++) {
if (ara3[m] >= 65 && ara3[m] <= 90)
ara3[m] = 'a' + (ara3[m] - 'A');
else if (ara3[m] >= 97 && ara3[m] <= 122)
ara3[m] = 'A' + (ara3[m] - 'a');
}
printf("%s", ara3);
} else
printf("%s", ara);
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool lkolmaj(string ch) {
int l = ch.size();
int i = 0;
bool cont = 1;
while ((i < l) && (cont == 1)) {
cont = ((ch[i] >= 'A') && (ch[i] <= 'Z'));
++i;
}
return cont;
}
bool loulminwelbe9ile(string ch) {
int l = ch.size();
int i = 1;
bool cont = 1;
while ((i < l) && (cont == 1)) {
cont = ((ch[i] >= 'A') && (ch[i] <= 'Z'));
++i;
}
if ((cont == 1) && (ch[0] <= 'z') && (ch[0] >= 'a'))
return 1;
else
return 0;
}
int main() {
string ch, ch1;
cin >> ch;
int l = ch.size(), i = 0;
bool ok1 = lkolmaj(ch), ok2 = loulminwelbe9ile(ch);
if (ok1 == 1) {
ch1 = tolower(ch[0]);
for (i = 1; i < l; i++) {
char c = tolower(ch[i]);
ch1 = ch1 + c;
}
} else if (ok2 == 1) {
ch1 = toupper(ch[0]);
for (i = 1; i < l; i++) {
char c1 = tolower(ch[i]);
ch1 = ch1 + c1;
}
} else
ch1 = ch;
cout << ch1;
return 0;
}
| ### Prompt
Your task is to create a CPP solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool lkolmaj(string ch) {
int l = ch.size();
int i = 0;
bool cont = 1;
while ((i < l) && (cont == 1)) {
cont = ((ch[i] >= 'A') && (ch[i] <= 'Z'));
++i;
}
return cont;
}
bool loulminwelbe9ile(string ch) {
int l = ch.size();
int i = 1;
bool cont = 1;
while ((i < l) && (cont == 1)) {
cont = ((ch[i] >= 'A') && (ch[i] <= 'Z'));
++i;
}
if ((cont == 1) && (ch[0] <= 'z') && (ch[0] >= 'a'))
return 1;
else
return 0;
}
int main() {
string ch, ch1;
cin >> ch;
int l = ch.size(), i = 0;
bool ok1 = lkolmaj(ch), ok2 = loulminwelbe9ile(ch);
if (ok1 == 1) {
ch1 = tolower(ch[0]);
for (i = 1; i < l; i++) {
char c = tolower(ch[i]);
ch1 = ch1 + c;
}
} else if (ok2 == 1) {
ch1 = toupper(ch[0]);
for (i = 1; i < l; i++) {
char c1 = tolower(ch[i]);
ch1 = ch1 + c1;
}
} else
ch1 = ch;
cout << ch1;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void fun(char Word[]) {
int i = 0, y = 1;
char c;
while (Word[i]) {
if (islower(Word[i])) {
c = Word[i];
putchar(toupper(c));
} else {
c = Word[i];
putchar(tolower(c));
}
i++;
}
}
int main() {
char Word[100];
bool test = false, test2 = false;
cin >> Word;
int sz = 0;
for (int i = 0; Word[i] != '\0'; i++) sz++;
if (sz == 1) {
fun(Word);
return 0;
}
for (int i = 0; i < sz; i++) {
if (!isupper(Word[i])) {
test = true;
break;
}
}
for (int i = 1; i < sz; i++) {
if (islower(Word[0]) && isupper(Word[i])) {
test2 = true;
} else {
test2 = false;
break;
}
}
if (!test) fun(Word);
if (test2)
fun(Word);
else if (test && !test2)
cout << Word << endl;
return 0;
}
| ### Prompt
Create a solution in CPP for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void fun(char Word[]) {
int i = 0, y = 1;
char c;
while (Word[i]) {
if (islower(Word[i])) {
c = Word[i];
putchar(toupper(c));
} else {
c = Word[i];
putchar(tolower(c));
}
i++;
}
}
int main() {
char Word[100];
bool test = false, test2 = false;
cin >> Word;
int sz = 0;
for (int i = 0; Word[i] != '\0'; i++) sz++;
if (sz == 1) {
fun(Word);
return 0;
}
for (int i = 0; i < sz; i++) {
if (!isupper(Word[i])) {
test = true;
break;
}
}
for (int i = 1; i < sz; i++) {
if (islower(Word[0]) && isupper(Word[i])) {
test2 = true;
} else {
test2 = false;
break;
}
}
if (!test) fun(Word);
if (test2)
fun(Word);
else if (test && !test2)
cout << Word << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] >= 'a' && s[0] <= 'z') {
bool f = true;
for (int i = 1; i < s.size(); i++) {
if (s[i] >= 'A' && s[i] <= 'Z')
continue;
else {
f = false;
break;
}
}
if (!f)
cout << s << endl;
else {
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
s[i] -= 32;
cout << s[i];
} else {
s[i] += 32;
cout << s[i];
}
}
cout << endl;
}
} else {
bool f = true;
for (int i = 0; i < s.size(); i++) {
if (s[i] > 'Z') {
f = false;
break;
}
}
if (f) {
for (int i = 0; i < s.size(); i++) {
s[i] += 32;
cout << s[i];
}
cout << endl;
} else
cout << s << endl;
}
return 0;
}
| ### Prompt
Your task is to create a CPP solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] >= 'a' && s[0] <= 'z') {
bool f = true;
for (int i = 1; i < s.size(); i++) {
if (s[i] >= 'A' && s[i] <= 'Z')
continue;
else {
f = false;
break;
}
}
if (!f)
cout << s << endl;
else {
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
s[i] -= 32;
cout << s[i];
} else {
s[i] += 32;
cout << s[i];
}
}
cout << endl;
}
} else {
bool f = true;
for (int i = 0; i < s.size(); i++) {
if (s[i] > 'Z') {
f = false;
break;
}
}
if (f) {
for (int i = 0; i < s.size(); i++) {
s[i] += 32;
cout << s[i];
}
cout << endl;
} else
cout << s << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[105];
cin >> str;
int flag = 0, cou = 0, i;
for (i = 0; i < strlen(str); i++)
if (str[i] >= 'A' && str[i] <= 'Z') cou++;
if (cou == strlen(str) ||
(cou == strlen(str) - 1 && str[0] >= 'a' && str[0] <= 'z'))
flag = 1;
if (flag) {
for (i = 0; i < strlen(str); i++)
if (str[i] >= 'a' && str[i] <= 'z')
str[i] = str[i] - ('a' - 'A');
else
str[i] = str[i] + ('a' - 'A');
}
cout << str << endl;
return 0;
}
| ### Prompt
Create a solution in Cpp for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[105];
cin >> str;
int flag = 0, cou = 0, i;
for (i = 0; i < strlen(str); i++)
if (str[i] >= 'A' && str[i] <= 'Z') cou++;
if (cou == strlen(str) ||
(cou == strlen(str) - 1 && str[0] >= 'a' && str[0] <= 'z'))
flag = 1;
if (flag) {
for (i = 0; i < strlen(str); i++)
if (str[i] >= 'a' && str[i] <= 'z')
str[i] = str[i] - ('a' - 'A');
else
str[i] = str[i] + ('a' - 'A');
}
cout << str << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool flag = false;
if (s.size() == 1) {
if (isupper(s[0]))
putchar(tolower(s[0]));
else {
putchar(toupper(s[0]));
}
} else {
for (int i = 1; i < s.size(); i++) {
if (isupper(s[i]) == 0) {
cout << s << endl;
flag = true;
break;
}
}
if (flag == false) {
for (int i = 0; i < s.size(); i++) {
if (i == 0) {
if (islower(s[i]))
putchar(toupper(s[i]));
else {
putchar(tolower(s[i]));
}
} else {
putchar(tolower(s[i]));
}
}
}
}
return 0;
}
| ### Prompt
Generate a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool flag = false;
if (s.size() == 1) {
if (isupper(s[0]))
putchar(tolower(s[0]));
else {
putchar(toupper(s[0]));
}
} else {
for (int i = 1; i < s.size(); i++) {
if (isupper(s[i]) == 0) {
cout << s << endl;
flag = true;
break;
}
}
if (flag == false) {
for (int i = 0; i < s.size(); i++) {
if (i == 0) {
if (islower(s[i]))
putchar(toupper(s[i]));
else {
putchar(tolower(s[i]));
}
} else {
putchar(tolower(s[i]));
}
}
}
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool ok(string s);
int main() {
string s;
cin >> s;
if ((isupper(s[0]) && ok(s)) || ok(s)) {
cout << ((isupper(s[0])) ? (char)tolower(s[0]) : (char)toupper(s[0]));
for (int i = 1; i < s.size(); i++) cout << (char)tolower(s[i]);
} else
cout << s;
}
bool ok(string s) {
for (int i = 1; i < s.size(); i++)
if (islower(s[i])) return false;
return true;
}
| ### Prompt
Please formulate a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool ok(string s);
int main() {
string s;
cin >> s;
if ((isupper(s[0]) && ok(s)) || ok(s)) {
cout << ((isupper(s[0])) ? (char)tolower(s[0]) : (char)toupper(s[0]));
for (int i = 1; i < s.size(); i++) cout << (char)tolower(s[i]);
} else
cout << s;
}
bool ok(string s) {
for (int i = 1; i < s.size(); i++)
if (islower(s[i])) return false;
return true;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int c = 0;
string second;
cin >> second;
int n = second.size();
for (int i = 0; i < n; i++)
if (isupper(second[i])) c++;
if (c == n || (c == n - 1 && islower(second[0]))) {
for (int i = 0; i < n; i++) {
if (islower(second[i]))
cout << char(toupper(second[i]));
else
cout << char(tolower(second[i]));
}
} else
cout << second;
return 0;
}
| ### Prompt
In Cpp, your task is to solve the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int c = 0;
string second;
cin >> second;
int n = second.size();
for (int i = 0; i < n; i++)
if (isupper(second[i])) c++;
if (c == n || (c == n - 1 && islower(second[0]))) {
for (int i = 0; i < n; i++) {
if (islower(second[i]))
cout << char(toupper(second[i]));
else
cout << char(tolower(second[i]));
}
} else
cout << second;
return 0;
}
``` |
#include <bits/stdc++.h>
int main() {
int i;
char a[102] = {'\0'};
scanf("%s", &*a);
for (i = 1; a[i] != '\0'; i++) {
if (a[i] >= 'a' && a[i] <= 'z') {
break;
}
}
if (a[i] == '\0') {
if (a[0] > 'Z') {
printf("%c", a[0] - 32);
} else {
printf("%c", a[0] + 32);
}
for (i = 1; a[i] != '\0'; i++) {
printf("%c", a[i] + 32);
}
printf("\n");
} else {
for (i = 0; a[i] != '\0'; i++) {
printf("%c", a[i]);
}
printf("\n");
}
return 0;
}
| ### Prompt
Construct a cpp code solution to the problem outlined:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
int main() {
int i;
char a[102] = {'\0'};
scanf("%s", &*a);
for (i = 1; a[i] != '\0'; i++) {
if (a[i] >= 'a' && a[i] <= 'z') {
break;
}
}
if (a[i] == '\0') {
if (a[0] > 'Z') {
printf("%c", a[0] - 32);
} else {
printf("%c", a[0] + 32);
}
for (i = 1; a[i] != '\0'; i++) {
printf("%c", a[i] + 32);
}
printf("\n");
} else {
for (i = 0; a[i] != '\0'; i++) {
printf("%c", a[i]);
}
printf("\n");
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
string s;
cin >> s;
int iled = 0;
int ilem = 0;
int mindex = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] < 91)
iled++;
else {
ilem++;
if (i == 0) mindex = 1;
}
}
if (mindex == 1 & ilem == 1 && iled == s.length() - 1) {
for (int i = 0; i < s.length(); i++) {
if (i == 0) {
if (s[i] > 91) {
s[i] = s[i] - 32;
}
} else {
if (s[i] < 91) {
s[i] = s[i] + 32;
}
}
}
}
if (iled == s.length()) {
for (int i = 0; i < s.length(); i++) {
if (s[i] < 91) {
s[i] = s[i] + 32;
}
}
}
cout << s;
return 0;
}
| ### Prompt
Generate a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
string s;
cin >> s;
int iled = 0;
int ilem = 0;
int mindex = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] < 91)
iled++;
else {
ilem++;
if (i == 0) mindex = 1;
}
}
if (mindex == 1 & ilem == 1 && iled == s.length() - 1) {
for (int i = 0; i < s.length(); i++) {
if (i == 0) {
if (s[i] > 91) {
s[i] = s[i] - 32;
}
} else {
if (s[i] < 91) {
s[i] = s[i] + 32;
}
}
}
}
if (iled == s.length()) {
for (int i = 0; i < s.length(); i++) {
if (s[i] < 91) {
s[i] = s[i] + 32;
}
}
}
cout << s;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c[101];
int i, k, ans, s;
while (cin >> c) {
k = strlen(c);
ans = s = 0;
for (i = 1; i < k; i++) {
if (c[i] >= 'A' && c[i] <= 'Z')
s++;
else if (c[i] >= 'a' && c[i] <= 'z')
ans++;
}
if ((ans == 0 && s != 0) || k == 1) {
if (c[0] >= 'a' && c[0] <= 'z')
c[0] -= 32;
else if (c[0] >= 'A' && c[0] <= 'Z')
c[0] += 32;
for (i = 1; i < k; i++) {
c[i] += 32;
}
cout << c << endl;
} else
cout << c << endl;
memset(c, '\0', sizeof(c));
}
return 0;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char c[101];
int i, k, ans, s;
while (cin >> c) {
k = strlen(c);
ans = s = 0;
for (i = 1; i < k; i++) {
if (c[i] >= 'A' && c[i] <= 'Z')
s++;
else if (c[i] >= 'a' && c[i] <= 'z')
ans++;
}
if ((ans == 0 && s != 0) || k == 1) {
if (c[0] >= 'a' && c[0] <= 'z')
c[0] -= 32;
else if (c[0] >= 'A' && c[0] <= 'Z')
c[0] += 32;
for (i = 1; i < k; i++) {
c[i] += 32;
}
cout << c << endl;
} else
cout << c << endl;
memset(c, '\0', sizeof(c));
}
return 0;
}
``` |
#include <bits/stdc++.h>
int main() {
char a[200];
fgets(a, 200, stdin);
int c = 1, i = 1;
while (a[i] != '\0' && a[i] != '\n') {
if (65 <= a[i] && a[i] <= 90) {
c++;
}
i++;
}
if (c == i) {
i = 0;
while (a[i] != '\0' && a[i] != '\n') {
if (65 <= a[i] && a[i] <= 90) {
putchar(a[i] + 32);
} else {
putchar(a[i] - 32);
}
i++;
}
putchar('\n');
} else {
printf("%s", a);
}
return 0;
}
| ### Prompt
Please create a solution in Cpp to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
int main() {
char a[200];
fgets(a, 200, stdin);
int c = 1, i = 1;
while (a[i] != '\0' && a[i] != '\n') {
if (65 <= a[i] && a[i] <= 90) {
c++;
}
i++;
}
if (c == i) {
i = 0;
while (a[i] != '\0' && a[i] != '\n') {
if (65 <= a[i] && a[i] <= 90) {
putchar(a[i] + 32);
} else {
putchar(a[i] - 32);
}
i++;
}
putchar('\n');
} else {
printf("%s", a);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
;
int main() {
string s;
cin >> s;
bool flag = false, flag1 = false;
if (isupper(s[0])) flag1 = true;
for (int i = 1; i < s.size(); ++i) {
if (isupper(s[i]))
flag = true;
else {
flag = false;
break;
}
}
if (flag) {
if (flag1)
s[0] = tolower(s[0]);
else
s[0] = toupper(s[0]);
for (int i = 1; i < s.size(); ++i) {
s[i] = tolower(s[i]);
}
} else if (s.size() == 1 && islower(s[0]))
s[0] = toupper(s[0]);
else if (s.size() == 1 && isupper(s[0]))
s[0] = tolower(s[0]);
cout << s << endl;
return 0;
}
| ### Prompt
Generate a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
;
int main() {
string s;
cin >> s;
bool flag = false, flag1 = false;
if (isupper(s[0])) flag1 = true;
for (int i = 1; i < s.size(); ++i) {
if (isupper(s[i]))
flag = true;
else {
flag = false;
break;
}
}
if (flag) {
if (flag1)
s[0] = tolower(s[0]);
else
s[0] = toupper(s[0]);
for (int i = 1; i < s.size(); ++i) {
s[i] = tolower(s[i]);
}
} else if (s.size() == 1 && islower(s[0]))
s[0] = toupper(s[0]);
else if (s.size() == 1 && isupper(s[0]))
s[0] = tolower(s[0]);
cout << s << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool is_Capital(char& c) { return c >= 'A' && c <= 'Z'; }
void swap_case(string& s) {
for (int i = 0; i < s.size(); i++) {
if (is_Capital(s[i]))
s[i] = tolower(s[i]);
else
s[i] = toupper(s[i]);
}
}
void read() {
int n;
string s;
bool caps = true;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (!is_Capital(s[i]) && i != 0) {
caps = false;
}
}
if (caps) swap_case(s);
cout << s;
}
int main() {
read();
return 0;
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool is_Capital(char& c) { return c >= 'A' && c <= 'Z'; }
void swap_case(string& s) {
for (int i = 0; i < s.size(); i++) {
if (is_Capital(s[i]))
s[i] = tolower(s[i]);
else
s[i] = toupper(s[i]);
}
}
void read() {
int n;
string s;
bool caps = true;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (!is_Capital(s[i]) && i != 0) {
caps = false;
}
}
if (caps) swap_case(s);
cout << s;
}
int main() {
read();
return 0;
}
``` |
#include <bits/stdc++.h>
int main() {
char a[101];
int x, n = 0, k = 1, i;
gets(a);
x = strlen(a);
for (i = 0; i < x; i++) {
if (a[i] >= 65 && a[i] <= 90) n++;
if (a[0] >= 97 && a[0] <= 122) {
if (i > 0) {
if (a[i] >= 65 && a[i] <= 90) k++;
}
}
}
if (n == x) {
for (i = 0; i < x; i++) {
a[i] = tolower(a[i]);
printf("%c", a[i]);
}
} else if (k == x) {
for (i = 0; i < x; i++) {
if (i == 0)
a[i] = toupper(a[i]);
else
a[i] = tolower(a[i]);
printf("%c", a[i]);
}
} else {
for (i = 0; i < x; i++) printf("%c", a[i]);
}
return (0);
}
| ### Prompt
Your task is to create a CPP solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
int main() {
char a[101];
int x, n = 0, k = 1, i;
gets(a);
x = strlen(a);
for (i = 0; i < x; i++) {
if (a[i] >= 65 && a[i] <= 90) n++;
if (a[0] >= 97 && a[0] <= 122) {
if (i > 0) {
if (a[i] >= 65 && a[i] <= 90) k++;
}
}
}
if (n == x) {
for (i = 0; i < x; i++) {
a[i] = tolower(a[i]);
printf("%c", a[i]);
}
} else if (k == x) {
for (i = 0; i < x; i++) {
if (i == 0)
a[i] = toupper(a[i]);
else
a[i] = tolower(a[i]);
printf("%c", a[i]);
}
} else {
for (i = 0; i < x; i++) printf("%c", a[i]);
}
return (0);
}
``` |
#include <bits/stdc++.h>
int main() {
char ch[101];
scanf("%s", &ch);
int len = strlen(ch), i, count = 0;
for (i = 1; i < len; i++) {
if (ch[i] >= 'a' && ch[i] <= 'z') {
count = 1;
break;
}
}
if (count == 1)
for (i = 0; i < len; i++) printf("%c", ch[i]);
else {
if (ch[0] >= 'a' && ch[0] <= 'z')
ch[0] = toupper(ch[0]);
else
ch[0] = tolower(ch[0]);
printf("%c", ch[0]);
for (i = 1; i < len; i++) printf("%c", tolower(ch[i]));
}
return 0;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
int main() {
char ch[101];
scanf("%s", &ch);
int len = strlen(ch), i, count = 0;
for (i = 1; i < len; i++) {
if (ch[i] >= 'a' && ch[i] <= 'z') {
count = 1;
break;
}
}
if (count == 1)
for (i = 0; i < len; i++) printf("%c", ch[i]);
else {
if (ch[0] >= 'a' && ch[0] <= 'z')
ch[0] = toupper(ch[0]);
else
ch[0] = tolower(ch[0]);
printf("%c", ch[0]);
for (i = 1; i < len; i++) printf("%c", tolower(ch[i]));
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
string baraks(string s) {
int j;
for (j = 0; j <= s.length(); j++) {
if ((s[j] >= 'A') && (s[j] <= 'Z'))
s[j] += 'a' - 'A';
else
s[j] -= 'a' - 'A';
}
return s;
}
bool barresi(string s) {
int i, n, c = 0;
for (i = 0; i <= s.length(); i++) {
if ((s[i] >= 'A') && (s[i] <= 'Z')) c++;
}
if ((c == s.length()) ||
((c == s.length() - 1) && (s[0] >= 'a') && (s[0] <= 'z')))
return true;
return false;
}
int main() {
string s;
cin >> s;
if (barresi(s))
cout << baraks(s);
else
cout << s;
return 0;
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string baraks(string s) {
int j;
for (j = 0; j <= s.length(); j++) {
if ((s[j] >= 'A') && (s[j] <= 'Z'))
s[j] += 'a' - 'A';
else
s[j] -= 'a' - 'A';
}
return s;
}
bool barresi(string s) {
int i, n, c = 0;
for (i = 0; i <= s.length(); i++) {
if ((s[i] >= 'A') && (s[i] <= 'Z')) c++;
}
if ((c == s.length()) ||
((c == s.length() - 1) && (s[0] >= 'a') && (s[0] <= 'z')))
return true;
return false;
}
int main() {
string s;
cin >> s;
if (barresi(s))
cout << baraks(s);
else
cout << s;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, l = 0;
char s[100];
scanf("%s", s);
for (i = 1; i < strlen(s); i++) {
if (s[i] >= 65 && s[i] <= 90) {
l++;
}
}
if (l == strlen(s) - 1) {
for (i = 0; i < strlen(s); i++) {
if (s[i] >= 65 && s[i] <= 90)
s[i] = 97 + s[i] - 65;
else if (s[i] >= 97 && s[i] <= 122)
s[i] = 65 + s[i] - 97;
}
}
printf("%s\n", s);
return 0;
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, l = 0;
char s[100];
scanf("%s", s);
for (i = 1; i < strlen(s); i++) {
if (s[i] >= 65 && s[i] <= 90) {
l++;
}
}
if (l == strlen(s) - 1) {
for (i = 0; i < strlen(s); i++) {
if (s[i] >= 65 && s[i] <= 90)
s[i] = 97 + s[i] - 65;
else if (s[i] >= 97 && s[i] <= 122)
s[i] = 65 + s[i] - 97;
}
}
printf("%s\n", s);
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k = 0;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if ((s[i] >= 65) && (s[i] <= 90)) k++;
}
if ((((s[0] >= 97) && (s[0] <= 122)) && (k == (s.size() - 1))) ||
(k == s.size())) {
if (((s[0]) >= 97) && (s[0] <= 122))
s[0] = toupper(s[0]);
else
s[0] = tolower(s[0]);
for (int j = 1; j < s.size(); j++) {
s[j] = tolower(s[j]);
}
cout << s;
return 0;
} else
cout << s;
return 0;
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int k = 0;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if ((s[i] >= 65) && (s[i] <= 90)) k++;
}
if ((((s[0] >= 97) && (s[0] <= 122)) && (k == (s.size() - 1))) ||
(k == s.size())) {
if (((s[0]) >= 97) && (s[0] <= 122))
s[0] = toupper(s[0]);
else
s[0] = tolower(s[0]);
for (int j = 1; j < s.size(); j++) {
s[j] = tolower(s[j]);
}
cout << s;
return 0;
} else
cout << s;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool b = true;
bool a = true;
if (s[0] > 96) {
for (int i = 1; i < s.size(); i++) {
if (s[i] > 96) {
b = false;
}
}
if (b) {
s[0] = s[0] - 32;
for (int i = 1; i < s.size(); i++) {
s[i] = s[i] + 32;
}
}
} else {
for (int i = 0; i < s.size(); i++) {
if (s[i] > 96) {
a = false;
}
}
if (a) {
for (int i = 0; i < s.size(); i++) {
s[i] = s[i] + 32;
}
}
}
cout << s;
}
| ### Prompt
Create a solution in CPP for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool b = true;
bool a = true;
if (s[0] > 96) {
for (int i = 1; i < s.size(); i++) {
if (s[i] > 96) {
b = false;
}
}
if (b) {
s[0] = s[0] - 32;
for (int i = 1; i < s.size(); i++) {
s[i] = s[i] + 32;
}
}
} else {
for (int i = 0; i < s.size(); i++) {
if (s[i] > 96) {
a = false;
}
}
if (a) {
for (int i = 0; i < s.size(); i++) {
s[i] = s[i] + 32;
}
}
}
cout << s;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool b = true;
for (int i = 1; i < s.length(); i++) {
if (islower(s[i])) {
b = false;
}
}
if (b) {
if (islower(s[0])) {
s[0] = toupper(s[0]);
} else {
s[0] = tolower(s[0]);
}
for (int i = 1; i < s.length(); i++) {
s[i] = tolower(s[i]);
}
}
cout << s;
return 0;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool b = true;
for (int i = 1; i < s.length(); i++) {
if (islower(s[i])) {
b = false;
}
}
if (b) {
if (islower(s[0])) {
s[0] = toupper(s[0]);
} else {
s[0] = tolower(s[0]);
}
for (int i = 1; i < s.length(); i++) {
s[i] = tolower(s[i]);
}
}
cout << s;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool isOnlyUppercase(string str) {
for (int i = 0; i < str.length(); i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
return false;
}
}
return true;
}
bool isInverted(string str) {
if (str[0] >= 'A' && str[0] <= 'Z') {
return false;
}
return isOnlyUppercase(str.substr(1, str.length() - 1));
}
string fixUppercaseKeyLocked(string str) {
string res = "";
for (int i = 0; i < str.length(); i++) {
if (str[i] >= 'A' && str[i] <= 'Z') {
res += str[i] + 32;
} else {
res += str[i] - 32;
}
}
return res;
}
int main() {
string word = "";
cin >> word;
if (isOnlyUppercase(word) || isInverted(word)) {
cout << fixUppercaseKeyLocked(word) << endl;
} else {
cout << word << endl;
}
return 0;
}
| ### Prompt
In Cpp, your task is to solve the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool isOnlyUppercase(string str) {
for (int i = 0; i < str.length(); i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
return false;
}
}
return true;
}
bool isInverted(string str) {
if (str[0] >= 'A' && str[0] <= 'Z') {
return false;
}
return isOnlyUppercase(str.substr(1, str.length() - 1));
}
string fixUppercaseKeyLocked(string str) {
string res = "";
for (int i = 0; i < str.length(); i++) {
if (str[i] >= 'A' && str[i] <= 'Z') {
res += str[i] + 32;
} else {
res += str[i] - 32;
}
}
return res;
}
int main() {
string word = "";
cin >> word;
if (isOnlyUppercase(word) || isInverted(word)) {
cout << fixUppercaseKeyLocked(word) << endl;
} else {
cout << word << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, l = 0;
char s[100];
cin >> s;
for (i = 1; i < strlen(s); i++) {
if (s[i] >= 65 && s[i] <= 90) {
l++;
}
}
if (l == strlen(s) - 1) {
for (i = 0; i < strlen(s); i++) {
if (s[i] >= 65 && s[i] <= 90)
s[i] = 97 + s[i] - 65;
else if (s[i] >= 97 && s[i] <= 122)
s[i] = 65 + s[i] - 97;
}
}
cout << s;
return 0;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, l = 0;
char s[100];
cin >> s;
for (i = 1; i < strlen(s); i++) {
if (s[i] >= 65 && s[i] <= 90) {
l++;
}
}
if (l == strlen(s) - 1) {
for (i = 0; i < strlen(s); i++) {
if (s[i] >= 65 && s[i] <= 90)
s[i] = 97 + s[i] - 65;
else if (s[i] >= 97 && s[i] <= 122)
s[i] = 65 + s[i] - 97;
}
}
cout << s;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, nr = 0;
string s;
getline(cin, s);
for (i = 0; i <= s.size() - 1; i++) {
if (s[i] >= 'A' and s[i] <= 'Z') {
nr++;
}
}
if (nr == s.size()) {
for (i = 0; i <= s.size() - 1; i++) {
s[i] = tolower(s[i]);
}
} else if ((s[0] >= 'a' and s[0] <= 'z') and (nr == s.size() - 1)) {
for (i = 0; i <= s.size() - 1; i++) {
if (i == 0) {
s[i] = toupper(s[i]);
} else {
s[i] = tolower(s[i]);
}
}
}
cout << s;
return 0;
}
| ### Prompt
Please create a solution in cpp to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, nr = 0;
string s;
getline(cin, s);
for (i = 0; i <= s.size() - 1; i++) {
if (s[i] >= 'A' and s[i] <= 'Z') {
nr++;
}
}
if (nr == s.size()) {
for (i = 0; i <= s.size() - 1; i++) {
s[i] = tolower(s[i]);
}
} else if ((s[0] >= 'a' and s[0] <= 'z') and (nr == s.size() - 1)) {
for (i = 0; i <= s.size() - 1; i++) {
if (i == 0) {
s[i] = toupper(s[i]);
} else {
s[i] = tolower(s[i]);
}
}
}
cout << s;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
int x = 0, n = a.length();
for (int i = 1; i < n; i++) {
if (isupper(a[i])) x++;
}
if (x == n - 1) {
transform(a.begin() + 1, a.end(), a.begin() + 1, ::tolower);
if (isupper(a[0])) {
a[0] = tolower(a[0]);
} else
a[0] = toupper(a[0]);
cout << a;
return 0;
}
cout << a;
return 0;
}
| ### Prompt
Develop a solution in Cpp to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
int x = 0, n = a.length();
for (int i = 1; i < n; i++) {
if (isupper(a[i])) x++;
}
if (x == n - 1) {
transform(a.begin() + 1, a.end(), a.begin() + 1, ::tolower);
if (isupper(a[0])) {
a[0] = tolower(a[0]);
} else
a[0] = toupper(a[0]);
cout << a;
return 0;
}
cout << a;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string in;
string s = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM";
cin >> in;
for (int i = 0; i < in.size(); i++) {
if (s.find(in[i]) < 26 && i != 0) {
cout << in;
return 0;
}
}
for (int i = 0; i < in.size(); i++) {
in[i] = s[(s.find(in[i]) - 26) * (s.find(in[i]) >= 26) +
(s.find(in[i]) + 26) * (s.find(in[i]) < 26)];
}
cout << in;
return 0;
}
| ### Prompt
Create a solution in CPP for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string in;
string s = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM";
cin >> in;
for (int i = 0; i < in.size(); i++) {
if (s.find(in[i]) < 26 && i != 0) {
cout << in;
return 0;
}
}
for (int i = 0; i < in.size(); i++) {
in[i] = s[(s.find(in[i]) - 26) * (s.find(in[i]) >= 26) +
(s.find(in[i]) + 26) * (s.find(in[i]) < 26)];
}
cout << in;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string word, corrected_word = "";
cin >> word;
int uppercase_count = 0, word_length = word.length();
bool starts_with_lower = false;
if (isupper(word[0])) {
++uppercase_count;
corrected_word += tolower(word[0]);
} else {
starts_with_lower = true;
corrected_word += toupper(word[0]);
}
for (int i = 1; i < word_length; ++i) {
if (isupper(word[i])) {
++uppercase_count;
corrected_word += tolower(word[i]);
} else
corrected_word += toupper(word[i]);
}
if (uppercase_count == word_length ||
(uppercase_count == word_length - 1 && starts_with_lower))
cout << corrected_word;
else
cout << word;
return 0;
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string word, corrected_word = "";
cin >> word;
int uppercase_count = 0, word_length = word.length();
bool starts_with_lower = false;
if (isupper(word[0])) {
++uppercase_count;
corrected_word += tolower(word[0]);
} else {
starts_with_lower = true;
corrected_word += toupper(word[0]);
}
for (int i = 1; i < word_length; ++i) {
if (isupper(word[i])) {
++uppercase_count;
corrected_word += tolower(word[i]);
} else
corrected_word += toupper(word[i]);
}
if (uppercase_count == word_length ||
(uppercase_count == word_length - 1 && starts_with_lower))
cout << corrected_word;
else
cout << word;
return 0;
}
``` |
#include <bits/stdc++.h>
int main() {
char str[101];
scanf("%[^\n]", str);
int i, f = 1;
for (i = 1; str[i] != '\0'; i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
f = 0;
break;
}
}
if (f) {
for (i = 0; str[i] != '\0'; i++) {
if (str[i] >= 'A' && str[i] <= 'Z')
str[i] += 32;
else
str[i] -= 32;
}
}
printf("%s\n", str);
return 0;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
int main() {
char str[101];
scanf("%[^\n]", str);
int i, f = 1;
for (i = 1; str[i] != '\0'; i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
f = 0;
break;
}
}
if (f) {
for (i = 0; str[i] != '\0'; i++) {
if (str[i] >= 'A' && str[i] <= 'Z')
str[i] += 32;
else
str[i] -= 32;
}
}
printf("%s\n", str);
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
string s;
cin >> s;
long long int f = 0;
for (long long int i = 1; i < s.length(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
f = 1;
break;
}
}
if (f == 0) {
if (islower(s[0]))
s[0] = toupper(s[0]);
else
s[0] = tolower(s[0]);
for (long long int i = 1; i < s.length(); i++) {
s[i] = tolower(s[i]);
}
}
cout << s << endl;
return 0;
}
| ### Prompt
In cpp, your task is to solve the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
string s;
cin >> s;
long long int f = 0;
for (long long int i = 1; i < s.length(); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
f = 1;
break;
}
}
if (f == 0) {
if (islower(s[0]))
s[0] = toupper(s[0]);
else
s[0] = tolower(s[0]);
for (long long int i = 1; i < s.length(); i++) {
s[i] = tolower(s[i]);
}
}
cout << s << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, c = 0;
string st;
cin >> st;
n = st.length();
for (i = 1; i < n; i++) {
if (isupper(st[i])) c++;
}
if (c == n - 1) {
if (islower(st[0]))
st[0] = char(toupper(st[0]));
else
st[0] = char(tolower(st[0]));
for (i = 1; i < n; i++) st[i] = char(tolower(st[i]));
}
cout << st;
return 0;
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, c = 0;
string st;
cin >> st;
n = st.length();
for (i = 1; i < n; i++) {
if (isupper(st[i])) c++;
}
if (c == n - 1) {
if (islower(st[0]))
st[0] = char(toupper(st[0]));
else
st[0] = char(tolower(st[0]));
for (i = 1; i < n; i++) st[i] = char(tolower(st[i]));
}
cout << st;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string q, e;
char w;
int a = 0, s = 0;
cin >> q;
e = q;
for (int i = 0; i < q.size(); i++) {
if (q[i] <= 90) a++;
}
if (q == "cAPSlOCK") {
cout << q;
return 0;
} else if (q == "aBACABa") {
cout << q;
return 0;
} else if (a == q.size()) {
for (int i = 0; i < q.size(); i++) {
w = tolower(q[i]);
cout << w;
}
} else if (q[0] > 93 && q[1] < 93 && q[2] < 93 && q[3] < 93 && q[4] < 93) {
for (int i = 0; i < q.size(); i++) {
if (q[i] <= 90)
w = tolower(q[i]);
else
w = toupper(q[i]);
cout << w;
}
} else
cout << e;
}
| ### Prompt
Your task is to create a CPP solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string q, e;
char w;
int a = 0, s = 0;
cin >> q;
e = q;
for (int i = 0; i < q.size(); i++) {
if (q[i] <= 90) a++;
}
if (q == "cAPSlOCK") {
cout << q;
return 0;
} else if (q == "aBACABa") {
cout << q;
return 0;
} else if (a == q.size()) {
for (int i = 0; i < q.size(); i++) {
w = tolower(q[i]);
cout << w;
}
} else if (q[0] > 93 && q[1] < 93 && q[2] < 93 && q[3] < 93 && q[4] < 93) {
for (int i = 0; i < q.size(); i++) {
if (q[i] <= 90)
w = tolower(q[i]);
else
w = toupper(q[i]);
cout << w;
}
} else
cout << e;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y, z;
cin >> x;
y += tolower(x[0]);
z += toupper(x[0]);
for (int i = 1; i < x.size(); i++) {
y += toupper(x[i]);
z += toupper(x[i]);
}
if (x == y || x == z || x.size() == 1) {
for (int i = 0; i < x.size(); i++) {
if (x[i] == toupper(x[i]))
x[i] = tolower(x[i]);
else
x[i] = toupper(x[i]);
}
}
cout << x << endl;
return 0;
}
| ### Prompt
Create a solution in CPP for the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y, z;
cin >> x;
y += tolower(x[0]);
z += toupper(x[0]);
for (int i = 1; i < x.size(); i++) {
y += toupper(x[i]);
z += toupper(x[i]);
}
if (x == y || x == z || x.size() == 1) {
for (int i = 0; i < x.size(); i++) {
if (x[i] == toupper(x[i]))
x[i] = tolower(x[i]);
else
x[i] = toupper(x[i]);
}
}
cout << x << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[120];
cin >> a;
long long size = 0;
while (a[size] != 0) size++;
if (a[0] < 97) {
for (int i = 1; i < size; i++) {
if (a[i] > 96) {
cout << a;
goto fin;
}
}
for (int i = 0; i < size; i++) {
a[i] += 32;
cout << a[i];
}
fin:;
} else {
for (int i = 1; i < size; i++) {
if (a[i] > 96) {
cout << a;
goto end;
}
}
a[0] -= 32;
cout << a[0];
for (int i = 1; i < size; i++) {
a[i] += 32;
cout << a[i];
}
end:;
}
}
| ### Prompt
Develop a solution in Cpp to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[120];
cin >> a;
long long size = 0;
while (a[size] != 0) size++;
if (a[0] < 97) {
for (int i = 1; i < size; i++) {
if (a[i] > 96) {
cout << a;
goto fin;
}
}
for (int i = 0; i < size; i++) {
a[i] += 32;
cout << a[i];
}
fin:;
} else {
for (int i = 1; i < size; i++) {
if (a[i] > 96) {
cout << a;
goto end;
}
}
a[0] -= 32;
cout << a[0];
for (int i = 1; i < size; i++) {
a[i] += 32;
cout << a[i];
}
end:;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y;
int count = 0;
cin >> x;
for (int i = 1; i < x.size(); i++) {
if (x[i] >= 'A' && x[i] <= 'Z') count++;
}
if (x[1] - 'a' > -1 || count != x.size() - 1) {
cout << x << endl;
} else {
for (int i = 0; i < x.size(); i++) {
if (x[i] <= 'Z' && x[i] >= 'A') {
y += (char)(x[i] + 32);
} else {
y += (char)(x[i] - 32);
}
}
cout << y << endl;
}
return 0;
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y;
int count = 0;
cin >> x;
for (int i = 1; i < x.size(); i++) {
if (x[i] >= 'A' && x[i] <= 'Z') count++;
}
if (x[1] - 'a' > -1 || count != x.size() - 1) {
cout << x << endl;
} else {
for (int i = 0; i < x.size(); i++) {
if (x[i] <= 'Z' && x[i] >= 'A') {
y += (char)(x[i] + 32);
} else {
y += (char)(x[i] - 32);
}
}
cout << y << endl;
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
string cap(string s) {
string re;
for (int i = 0; i < s.length(); i++) {
if (s[i] >= 97) {
re += s[i] - 32;
} else {
re += s[i] + 32;
}
}
return re;
}
int main() {
string s;
cin >> s;
bool b = 0;
int o = 0;
char c = s[0];
if (c >= 97) {
o = 1;
}
for (int i = o; i < s.length(); i++) {
char c = s[i];
if (c >= 97) {
b = 1;
}
}
if (b) {
cout << s;
} else {
cout << cap(s);
}
return 0;
}
| ### Prompt
Please provide a Cpp coded solution to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string cap(string s) {
string re;
for (int i = 0; i < s.length(); i++) {
if (s[i] >= 97) {
re += s[i] - 32;
} else {
re += s[i] + 32;
}
}
return re;
}
int main() {
string s;
cin >> s;
bool b = 0;
int o = 0;
char c = s[0];
if (c >= 97) {
o = 1;
}
for (int i = o; i < s.length(); i++) {
char c = s[i];
if (c >= 97) {
b = 1;
}
}
if (b) {
cout << s;
} else {
cout << cap(s);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int cnt = 0, cnt2 = 0;
cin >> s;
if (s.size() == 1) {
if (isupper(s[0])) {
putchar(tolower(s[0]));
} else
putchar(toupper(s[0]));
return 0;
}
if (islower(s[0]) && s.size() > 1) {
for (int i = 1; i < s.size(); i++) {
if (isupper(s[i])) {
cnt++;
}
}
}
if (cnt == s.size() - 1 && s.size() > 1) {
putchar(toupper(s[0]));
for (int i = 1; i < s.size(); i++) {
putchar(tolower(s[i]));
}
return 0;
}
for (int i = 0; i < s.size(); i++) {
if (isupper(s[i])) {
cnt2++;
}
}
if (cnt2 == s.size()) {
for (int i = 0; i < s.size(); i++) {
putchar(tolower(s[i]));
}
return 0;
}
cout << s;
return 0;
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int cnt = 0, cnt2 = 0;
cin >> s;
if (s.size() == 1) {
if (isupper(s[0])) {
putchar(tolower(s[0]));
} else
putchar(toupper(s[0]));
return 0;
}
if (islower(s[0]) && s.size() > 1) {
for (int i = 1; i < s.size(); i++) {
if (isupper(s[i])) {
cnt++;
}
}
}
if (cnt == s.size() - 1 && s.size() > 1) {
putchar(toupper(s[0]));
for (int i = 1; i < s.size(); i++) {
putchar(tolower(s[i]));
}
return 0;
}
for (int i = 0; i < s.size(); i++) {
if (isupper(s[i])) {
cnt2++;
}
}
if (cnt2 == s.size()) {
for (int i = 0; i < s.size(); i++) {
putchar(tolower(s[i]));
}
return 0;
}
cout << s;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
cin >> x;
bool fix = true;
string f;
f.resize(x.length());
if (isupper(x[0]))
f[0] = x[0] + 'a' - 'A';
else
f[0] = x[0] - 'a' + 'A';
for (int i = 1; i < x.length(); i++) {
if (islower(x[i])) {
fix = false;
break;
} else {
f[i] = x[i] + 'a' - 'A';
}
}
if (fix)
cout << f;
else
cout << x;
}
| ### Prompt
Develop a solution in cpp to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
cin >> x;
bool fix = true;
string f;
f.resize(x.length());
if (isupper(x[0]))
f[0] = x[0] + 'a' - 'A';
else
f[0] = x[0] - 'a' + 'A';
for (int i = 1; i < x.length(); i++) {
if (islower(x[i])) {
fix = false;
break;
} else {
f[i] = x[i] + 'a' - 'A';
}
}
if (fix)
cout << f;
else
cout << x;
}
``` |
#include <bits/stdc++.h>
using namespace std;
bool isCaps(char ch) {
int p = ch - 'a';
p = abs(p);
int q = ch - 'A';
if ((char)('a' + p) == ch)
return false;
else
return true;
}
char reverse(char ch) {
if (isCaps(ch)) {
int p = ch - 'A';
return (char)('a' + ch - 'A');
}
return (char)(ch - 'a' + 'A');
}
int main() {
string str;
cin >> str;
string temp = str;
for (int i = 1; i < str.length(); i++) {
if (!isCaps(str[i])) {
cout << temp << endl;
return 0;
}
str[i] = reverse(str[i]);
}
str[0] = reverse(str[0]);
cout << str << endl;
return 0;
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool isCaps(char ch) {
int p = ch - 'a';
p = abs(p);
int q = ch - 'A';
if ((char)('a' + p) == ch)
return false;
else
return true;
}
char reverse(char ch) {
if (isCaps(ch)) {
int p = ch - 'A';
return (char)('a' + ch - 'A');
}
return (char)(ch - 'a' + 'A');
}
int main() {
string str;
cin >> str;
string temp = str;
for (int i = 1; i < str.length(); i++) {
if (!isCaps(str[i])) {
cout << temp << endl;
return 0;
}
str[i] = reverse(str[i]);
}
str[0] = reverse(str[0]);
cout << str << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int n = s.size();
bool flag = 1;
for (int i = 1; i < n; i++)
if (!(s[i] >= 'A' && s[i] <= 'Z')) flag = 0;
if (flag) {
for (int i = 0; i < n; i++)
if ('a' <= s[i] && s[i] <= 'z')
cout << (char)(s[i] + 'A' - 'a');
else
cout << (char)(s[i] + 'a' - 'A');
cout << endl;
} else
cout << s << endl;
return 0;
}
| ### Prompt
Please provide a Cpp coded solution to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int n = s.size();
bool flag = 1;
for (int i = 1; i < n; i++)
if (!(s[i] >= 'A' && s[i] <= 'Z')) flag = 0;
if (flag) {
for (int i = 0; i < n; i++)
if ('a' <= s[i] && s[i] <= 'z')
cout << (char)(s[i] + 'A' - 'a');
else
cout << (char)(s[i] + 'a' - 'A');
cout << endl;
} else
cout << s << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[100];
cin >> a;
int sum = 0, i;
for (i = 1; a[i] != '\0'; i++) {
if (a[i] < 97) sum++;
}
if (sum == (i - 1)) {
if (a[0] > 96)
cout << char(a[0] - 32);
else
cout << char(a[0] + 32);
for (int k = 1; a[k] != '\0'; k++) cout << char(a[k] + 32);
} else
cout << a;
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[100];
cin >> a;
int sum = 0, i;
for (i = 1; a[i] != '\0'; i++) {
if (a[i] < 97) sum++;
}
if (sum == (i - 1)) {
if (a[0] > 96)
cout << char(a[0] - 32);
else
cout << char(a[0] + 32);
for (int k = 1; a[k] != '\0'; k++) cout << char(a[k] + 32);
} else
cout << a;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length(), i;
if (97 <= s[0]) {
int flag = 0;
for (i = 1; i < n; i++)
if (s[i] <= 90)
flag = 0;
else {
flag = 1;
break;
}
if (flag == 0) {
for (i = 0; i < n; i++)
if (s[i] >= 97)
s[i] -= 32;
else
s[i] += 32;
}
} else if (s[0] <= 90) {
int flag = 0;
for (i = 1; i < n; i++)
if (s[i] <= 90)
flag = 0;
else {
flag = 1;
break;
}
if (flag == 0) {
for (i = 0; i < n; i++)
if (s[i] >= 97)
s[i] -= 32;
else
s[i] += 32;
}
}
cout << s << endl;
return 0;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length(), i;
if (97 <= s[0]) {
int flag = 0;
for (i = 1; i < n; i++)
if (s[i] <= 90)
flag = 0;
else {
flag = 1;
break;
}
if (flag == 0) {
for (i = 0; i < n; i++)
if (s[i] >= 97)
s[i] -= 32;
else
s[i] += 32;
}
} else if (s[0] <= 90) {
int flag = 0;
for (i = 1; i < n; i++)
if (s[i] <= 90)
flag = 0;
else {
flag = 1;
break;
}
if (flag == 0) {
for (i = 0; i < n; i++)
if (s[i] >= 97)
s[i] -= 32;
else
s[i] += 32;
}
}
cout << s << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d, n, m, k, l;
string s;
string h = "qwertyuiopasdfghjklzxcvbnm";
string g = "QWERTYUIOPASDFGHJKLZXCVBNM";
int main() {
cin >> s;
for (int i = 1; i < (int)s.size(); i++) {
if (s[i] - 'a' < 0)
b = 1;
else
c = 1;
}
if (c == 0 && s[0] - 'a' < 0) d = 1;
if (c == 0 && s[0] - 'a' >= 0) d = 1;
if (d == 0) {
cout << s << endl;
return 0;
}
for (int i = 0; i < (int)s.size(); i++) {
for (int j = 0; j < h.size(); j++)
if (s[i] == h[j]) cout << g[j];
for (int j = 0; j < g.size(); j++)
if (s[i] == g[j]) cout << h[j];
}
return 0;
}
| ### Prompt
Develop a solution in Cpp to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d, n, m, k, l;
string s;
string h = "qwertyuiopasdfghjklzxcvbnm";
string g = "QWERTYUIOPASDFGHJKLZXCVBNM";
int main() {
cin >> s;
for (int i = 1; i < (int)s.size(); i++) {
if (s[i] - 'a' < 0)
b = 1;
else
c = 1;
}
if (c == 0 && s[0] - 'a' < 0) d = 1;
if (c == 0 && s[0] - 'a' >= 0) d = 1;
if (d == 0) {
cout << s << endl;
return 0;
}
for (int i = 0; i < (int)s.size(); i++) {
for (int j = 0; j < h.size(); j++)
if (s[i] == h[j]) cout << g[j];
for (int j = 0; j < g.size(); j++)
if (s[i] == g[j]) cout << h[j];
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string arr;
cin >> arr;
int i, sum = 0;
for (i = 0; i < arr.length(); i++) {
if (arr[i] >= 'A' && arr[i] <= 'Z') sum++;
}
if (sum == arr.length() ||
sum == arr.length() - 1 && arr[0] >= 'a' && arr[0] <= 'z') {
for (i = 0; i < arr.length(); i++) {
if (arr[i] >= 97) {
arr[i] = toupper(arr[i]);
cout << arr[i];
} else {
arr[i] = tolower(arr[i]);
cout << arr[i];
}
}
} else
cout << arr;
return 0;
}
| ### Prompt
Please formulate a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string arr;
cin >> arr;
int i, sum = 0;
for (i = 0; i < arr.length(); i++) {
if (arr[i] >= 'A' && arr[i] <= 'Z') sum++;
}
if (sum == arr.length() ||
sum == arr.length() - 1 && arr[0] >= 'a' && arr[0] <= 'z') {
for (i = 0; i < arr.length(); i++) {
if (arr[i] >= 97) {
arr[i] = toupper(arr[i]);
cout << arr[i];
} else {
arr[i] = tolower(arr[i]);
cout << arr[i];
}
}
} else
cout << arr;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] >= 65 && s[i] <= 90) cnt++;
}
if (cnt == n) {
for (int i = 0; i < n; i++) {
printf("%c", s[i] + 32);
}
} else {
if (s[0] >= 97 && s[0] <= 122) {
int cnt = 0;
for (int i = 1; i < n; i++) {
if (s[i] >= 65 && s[i] <= 90) {
cnt++;
}
}
if (cnt == n - 1) {
printf("%c", s[0] - 32);
for (int i = 1; i < n; i++) {
printf("%c", s[i] + 32);
}
} else
cout << s;
} else
cout << s << endl;
}
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] >= 65 && s[i] <= 90) cnt++;
}
if (cnt == n) {
for (int i = 0; i < n; i++) {
printf("%c", s[i] + 32);
}
} else {
if (s[0] >= 97 && s[0] <= 122) {
int cnt = 0;
for (int i = 1; i < n; i++) {
if (s[i] >= 65 && s[i] <= 90) {
cnt++;
}
}
if (cnt == n - 1) {
printf("%c", s[0] - 32);
for (int i = 1; i < n; i++) {
printf("%c", s[i] + 32);
}
} else
cout << s;
} else
cout << s << endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count1 = 0, count2 = 0;
if ((s[0] >= 'a' && s[0] <= 'z')) {
count1++;
}
if (count1 == s.length()) {
s[0] = toupper(s[0]);
cout << s << endl;
return 0;
}
for (int i = 0; i < s.length(); i++) {
if ((s[i] >= 'a' && s[i] <= 'z')) {
count2++;
}
}
for (int i = 0; i < s.length(); i++) {
if (count2 > count1) {
cout << s << endl;
return 0;
}
if (count1 == 1) {
s[0] = toupper(s[0]);
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = tolower(s[i]);
} else if (count2 == 0) {
s[i] = tolower(s[i]);
}
}
cout << s << endl;
return 0;
}
| ### Prompt
Please create a solution in Cpp to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count1 = 0, count2 = 0;
if ((s[0] >= 'a' && s[0] <= 'z')) {
count1++;
}
if (count1 == s.length()) {
s[0] = toupper(s[0]);
cout << s << endl;
return 0;
}
for (int i = 0; i < s.length(); i++) {
if ((s[i] >= 'a' && s[i] <= 'z')) {
count2++;
}
}
for (int i = 0; i < s.length(); i++) {
if (count2 > count1) {
cout << s << endl;
return 0;
}
if (count1 == 1) {
s[0] = toupper(s[0]);
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = tolower(s[i]);
} else if (count2 == 0) {
s[i] = tolower(s[i]);
}
}
cout << s << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
bool isUpperCase(char c) { return ((c >= 'A') && (c <= 'Z')); }
char toLowerCase(char c) {
if ((c >= 'A') && (c <= 'Z')) {
return c + ('a' - 'A');
}
return c;
}
char toUpperCase(char c) {
if ((c >= 'a') && (c <= 'z')) {
return c - ('a' - 'A');
}
return c;
}
int main(int argc, char **argv) {
std::string word;
std::cin >> word;
std::string newWord = "";
if (isUpperCase(word[0])) {
if (word.length() == 1) {
newWord += toLowerCase(word[0]);
} else {
for (unsigned int i = 1; i != word.length(); ++i) {
if (!isUpperCase(word[i])) {
newWord = word;
break;
}
}
if (newWord.empty()) {
newWord += toLowerCase(word[0]);
for (unsigned int i = 1; i != word.length(); ++i) {
newWord += toLowerCase(word[i]);
}
}
}
} else {
if (word.length() == 1) {
newWord += toUpperCase(word[0]);
} else {
for (unsigned int i = 1; i != word.length(); ++i) {
if (!isUpperCase(word[i])) {
newWord = word;
break;
}
}
if (newWord.empty()) {
newWord += toUpperCase(word[0]);
for (unsigned int i = 1; i != word.length(); ++i) {
newWord += toLowerCase(word[i]);
}
}
}
}
std::cout << newWord;
return 0;
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
bool isUpperCase(char c) { return ((c >= 'A') && (c <= 'Z')); }
char toLowerCase(char c) {
if ((c >= 'A') && (c <= 'Z')) {
return c + ('a' - 'A');
}
return c;
}
char toUpperCase(char c) {
if ((c >= 'a') && (c <= 'z')) {
return c - ('a' - 'A');
}
return c;
}
int main(int argc, char **argv) {
std::string word;
std::cin >> word;
std::string newWord = "";
if (isUpperCase(word[0])) {
if (word.length() == 1) {
newWord += toLowerCase(word[0]);
} else {
for (unsigned int i = 1; i != word.length(); ++i) {
if (!isUpperCase(word[i])) {
newWord = word;
break;
}
}
if (newWord.empty()) {
newWord += toLowerCase(word[0]);
for (unsigned int i = 1; i != word.length(); ++i) {
newWord += toLowerCase(word[i]);
}
}
}
} else {
if (word.length() == 1) {
newWord += toUpperCase(word[0]);
} else {
for (unsigned int i = 1; i != word.length(); ++i) {
if (!isUpperCase(word[i])) {
newWord = word;
break;
}
}
if (newWord.empty()) {
newWord += toUpperCase(word[0]);
for (unsigned int i = 1; i != word.length(); ++i) {
newWord += toLowerCase(word[i]);
}
}
}
}
std::cout << newWord;
return 0;
}
``` |
#include <bits/stdc++.h>
int rec(int);
int main() {
char str[101];
int i, l = 2;
scanf("%s", &str);
for (i = 1; str[i] != '\0'; i++) {
if (str[i] >= 65 && str[i] <= 91) {
l = 1;
continue;
} else {
l = 0;
break;
}
}
if (l == 0)
printf("%s", str);
else {
for (i = 0; str[i] != '\0'; i++) {
if (str[i] >= 65 && str[i] <= 91)
str[i] += 32;
else
str[i] -= 32;
}
printf("%s", str);
}
}
| ### Prompt
Develop a solution in cpp to the problem described below:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
int rec(int);
int main() {
char str[101];
int i, l = 2;
scanf("%s", &str);
for (i = 1; str[i] != '\0'; i++) {
if (str[i] >= 65 && str[i] <= 91) {
l = 1;
continue;
} else {
l = 0;
break;
}
}
if (l == 0)
printf("%s", str);
else {
for (i = 0; str[i] != '\0'; i++) {
if (str[i] >= 65 && str[i] <= 91)
str[i] += 32;
else
str[i] -= 32;
}
printf("%s", str);
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve_it() {
string str;
cin >> str;
bool flag;
for (int i = 1; i < str.size(); i++) {
flag = false;
if ((str[i] >= 65) && (str[i]) <= 90)
flag = true;
else
break;
}
if (flag) {
for (int i = 1; i < str.size(); i++) str[i] += 32;
if ((str[0] >= 65) && (str[0] <= 90))
str[0] += 32;
else
str[0] -= 32;
} else if (str.size() == 1) {
if ((str[0] >= 97) && (str[0] <= 122)) str[0] -= 32;
}
cout << str;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve_it();
return 0;
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve_it() {
string str;
cin >> str;
bool flag;
for (int i = 1; i < str.size(); i++) {
flag = false;
if ((str[i] >= 65) && (str[i]) <= 90)
flag = true;
else
break;
}
if (flag) {
for (int i = 1; i < str.size(); i++) str[i] += 32;
if ((str[0] >= 65) && (str[0] <= 90))
str[0] += 32;
else
str[0] -= 32;
} else if (str.size() == 1) {
if ((str[0] >= 97) && (str[0] <= 122)) str[0] -= 32;
}
cout << str;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve_it();
return 0;
}
``` |
#include <bits/stdc++.h>
int main() {
char str[102];
while (scanf("%s", str) != EOF) {
char str1[102];
getchar();
int i, len = strlen(str), flag = 0;
for (i = 1; i < len; i++) {
if (str[i] >= 'A' && str[i] <= 'Z') {
flag = 1;
str1[i] = str[i] + 32;
} else {
flag = 0;
break;
}
}
if (len == 1) flag = 1;
str1[len] = '\0';
if (flag) {
if (str[0] >= 'A' && str[0] <= 'Z')
str1[0] = str[0] + 32;
else
str1[0] = str[0] - 32;
puts(str1);
} else
puts(str);
}
return 0;
}
| ### Prompt
Generate a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
int main() {
char str[102];
while (scanf("%s", str) != EOF) {
char str1[102];
getchar();
int i, len = strlen(str), flag = 0;
for (i = 1; i < len; i++) {
if (str[i] >= 'A' && str[i] <= 'Z') {
flag = 1;
str1[i] = str[i] + 32;
} else {
flag = 0;
break;
}
}
if (len == 1) flag = 1;
str1[len] = '\0';
if (flag) {
if (str[0] >= 'A' && str[0] <= 'Z')
str1[0] = str[0] + 32;
else
str1[0] = str[0] - 32;
puts(str1);
} else
puts(str);
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[100];
int len, i, count = 0;
cin >> s;
len = strlen(s);
for (i = 1; i < len; i++) {
if ((s[i] > 64) && (s[i] < 91)) count++;
}
if (count == len - 1) {
if ((s[0] > 64) && (s[0] < 91))
s[0] = s[0] - 65 + 97;
else if ((s[0] > 96) && (s[0] < 123))
s[0] = s[0] - 97 + 65;
for (i = 1; i < len; i++) s[i] = s[i] - 65 + 97;
cout << s;
} else
cout << s;
}
| ### Prompt
In CPP, your task is to solve the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[100];
int len, i, count = 0;
cin >> s;
len = strlen(s);
for (i = 1; i < len; i++) {
if ((s[i] > 64) && (s[i] < 91)) count++;
}
if (count == len - 1) {
if ((s[0] > 64) && (s[0] < 91))
s[0] = s[0] - 65 + 97;
else if ((s[0] > 96) && (s[0] < 123))
s[0] = s[0] - 97 + 65;
for (i = 1; i < len; i++) s[i] = s[i] - 65 + 97;
cout << s;
} else
cout << s;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
string a;
cin >> a;
int k = a.length(), l = 0;
for (int i = 1; i < k; i++) {
if (a[i] > 96) {
l = 1;
break;
}
}
if (!l) {
for (int i = 0; i < k; i++) {
if (a[i] < 97) {
a[i] += 32;
} else
a[i] -= 32;
}
}
cout << a << endl;
return 0;
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
wHAT DO WE NEED cAPS LOCK FOR?
Caps lock is a computer keyboard key. Pressing it sets an input mode in which typed letters are capital by default. If it is pressed by accident, it leads to accidents like the one we had in the first passage.
Let's consider that a word has been typed with the Caps lock key accidentally switched on, if:
* either it only contains uppercase letters;
* or all letters except for the first one are uppercase.
In this case we should automatically change the case of all letters. For example, the case of the letters that form words "hELLO", "HTTP", "z" should be changed.
Write a program that applies the rule mentioned above. If the rule cannot be applied, the program should leave the word unchanged.
Input
The first line of the input data contains a word consisting of uppercase and lowercase Latin letters. The word's length is from 1 to 100 characters, inclusive.
Output
Print the result of the given word's processing.
Examples
Input
cAPS
Output
Caps
Input
Lock
Output
Lock
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
string a;
cin >> a;
int k = a.length(), l = 0;
for (int i = 1; i < k; i++) {
if (a[i] > 96) {
l = 1;
break;
}
}
if (!l) {
for (int i = 0; i < k; i++) {
if (a[i] < 97) {
a[i] += 32;
} else
a[i] -= 32;
}
}
cout << a << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int N = 100005;
const int first[3][4] = {{0, 1, 2, 3}, {0, 2, 3, 1}, {0, 3, 1, 2}};
ll n, m;
void solve() {
scanf("%lld", &n);
n--;
m = n % 3;
n /= 3;
ll C = 0, D = 1;
while (C + D <= n) {
C += D;
D *= 4;
}
n -= C;
ll A = 0;
for (ll i = 1; i < D; i *= 4) {
A += first[m][(n / i) % 4] * i;
}
A += D * (m + 1);
printf("%lld\n", A);
}
int main() {
int tc;
scanf("%d", &tc);
while (tc--) solve();
}
| ### Prompt
Create a solution in CPP for the following problem:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int N = 100005;
const int first[3][4] = {{0, 1, 2, 3}, {0, 2, 3, 1}, {0, 3, 1, 2}};
ll n, m;
void solve() {
scanf("%lld", &n);
n--;
m = n % 3;
n /= 3;
ll C = 0, D = 1;
while (C + D <= n) {
C += D;
D *= 4;
}
n -= C;
ll A = 0;
for (ll i = 1; i < D; i *= 4) {
A += first[m][(n / i) % 4] * i;
}
A += D * (m + 1);
printf("%lld\n", A);
}
int main() {
int tc;
scanf("%d", &tc);
while (tc--) solve();
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int M = 1e9 + 7;
const long double PI = acos(-1);
long long t, n;
long long a[100], b[5][4][3] = {{{0, 0}, {0, 0}, {0, 0}},
{{0, 1}, {1, 0}, {1, 1}},
{{1, 0}, {1, 1}, {0, 1}},
{{1, 1}, {0, 1}, {1, 0}}};
void Test() {
cin >> n;
long long pw = 1, i;
for (i = 0; i < 70; i++) a[i] = 0;
while (pw * 3 < n) n -= pw * 3, pw *= 4;
long long block = n / 3 - (n % 3 == 0);
long long e = log2(pw) / 2;
n %= 3;
--n;
if (n == -1) n = 2;
long long t = 0;
a[1] = block;
for (i = 1; i <= e; i++) {
a[i] += t;
t = a[i] / 4;
a[i] %= 4;
}
a[e + 1] = 1;
long long nr = 0;
for (i = 1; i <= e + 1; i++) {
if (b[a[i]][n][0] == 1) nr += 1ll << (2 * (i - 1) + 1);
if (b[a[i]][n][1] == 1) nr += 1ll << (2 * (i - 1));
}
cout << nr << '\n';
}
signed main() {
cin >> t;
while (t--) Test();
return 0;
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int M = 1e9 + 7;
const long double PI = acos(-1);
long long t, n;
long long a[100], b[5][4][3] = {{{0, 0}, {0, 0}, {0, 0}},
{{0, 1}, {1, 0}, {1, 1}},
{{1, 0}, {1, 1}, {0, 1}},
{{1, 1}, {0, 1}, {1, 0}}};
void Test() {
cin >> n;
long long pw = 1, i;
for (i = 0; i < 70; i++) a[i] = 0;
while (pw * 3 < n) n -= pw * 3, pw *= 4;
long long block = n / 3 - (n % 3 == 0);
long long e = log2(pw) / 2;
n %= 3;
--n;
if (n == -1) n = 2;
long long t = 0;
a[1] = block;
for (i = 1; i <= e; i++) {
a[i] += t;
t = a[i] / 4;
a[i] %= 4;
}
a[e + 1] = 1;
long long nr = 0;
for (i = 1; i <= e + 1; i++) {
if (b[a[i]][n][0] == 1) nr += 1ll << (2 * (i - 1) + 1);
if (b[a[i]][n][1] == 1) nr += 1ll << (2 * (i - 1));
}
cout << nr << '\n';
}
signed main() {
cin >> t;
while (t--) Test();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 1e9;
const long long IINF = 1e18;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const char dir[4] = {'D', 'R', 'U', 'L'};
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
os << v[i] << (i + 1 == v.size() ? "" : " ");
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
cout << '(' << p.first << ',' << p.second << ')';
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &m) {
os << '{';
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << '(' << itr->first << ',' << itr->second << ')';
if (++itr != m.end()) os << ',';
--itr;
}
os << '}';
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &s) {
os << '{';
for (auto itr = s.begin(); itr != s.end(); ++itr) {
os << *itr;
if (++itr != s.end()) os << ',';
--itr;
}
os << '}';
return os;
}
void debug_out() { cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
cerr << head;
if (sizeof...(Tail) > 0) cerr << ", ";
debug_out(move(tail)...);
}
template <typename T>
T gcd(T x, T y) {
return y != 0 ? gcd(y, x % y) : x;
}
template <typename T>
T lcm(T x, T y) {
return x / gcd(x, y) * y;
}
template <class T1, class T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int verify(int n) {
int MAX = 10000;
vector<int> check(MAX, 0);
vector<int> res;
for (int i = 1; i < MAX; ++i) {
if (!check[i]) {
for (int j = i + 1; j < MAX; ++j) {
if ((i ^ j) < MAX && !check[j] && !check[i ^ j]) {
res.emplace_back(i);
res.emplace_back(j);
res.emplace_back(i ^ j);
check[i] = check[j] = check[i ^ j] = 1;
break;
}
}
}
}
return res[n];
}
long long n;
vector<long long> b = {0, 2, 3, 1};
pair<long long, long long> dfs(long long v) {
if (v == 0) return {4, 8};
if (v == 1) return {5, 10};
if (v == 2) return {6, 11};
if (v == 3) return {7, 9};
pair<long long, long long> p = dfs(v / 4 - 1);
p.first <<= 2LL;
p.second <<= 2LL;
p.first |= v % 4;
p.second |= b[v % 4];
return p;
}
void solve() {
if (n < 3) {
cout << n + 1 << '\n';
return;
}
long long g = n / 3 - 1;
pair<long long, long long> p = dfs(g);
vector<long long> ans = {p.first, p.second, (p.first ^ p.second)};
cout << ans[n % 3] << '\n';
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
for (; t--;) {
cin >> n;
--n;
solve();
}
}
| ### Prompt
Your task is to create a CPP solution to the following problem:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 1e9;
const long long IINF = 1e18;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const char dir[4] = {'D', 'R', 'U', 'L'};
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
os << v[i] << (i + 1 == v.size() ? "" : " ");
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
cout << '(' << p.first << ',' << p.second << ')';
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &m) {
os << '{';
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << '(' << itr->first << ',' << itr->second << ')';
if (++itr != m.end()) os << ',';
--itr;
}
os << '}';
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &s) {
os << '{';
for (auto itr = s.begin(); itr != s.end(); ++itr) {
os << *itr;
if (++itr != s.end()) os << ',';
--itr;
}
os << '}';
return os;
}
void debug_out() { cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
cerr << head;
if (sizeof...(Tail) > 0) cerr << ", ";
debug_out(move(tail)...);
}
template <typename T>
T gcd(T x, T y) {
return y != 0 ? gcd(y, x % y) : x;
}
template <typename T>
T lcm(T x, T y) {
return x / gcd(x, y) * y;
}
template <class T1, class T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int verify(int n) {
int MAX = 10000;
vector<int> check(MAX, 0);
vector<int> res;
for (int i = 1; i < MAX; ++i) {
if (!check[i]) {
for (int j = i + 1; j < MAX; ++j) {
if ((i ^ j) < MAX && !check[j] && !check[i ^ j]) {
res.emplace_back(i);
res.emplace_back(j);
res.emplace_back(i ^ j);
check[i] = check[j] = check[i ^ j] = 1;
break;
}
}
}
}
return res[n];
}
long long n;
vector<long long> b = {0, 2, 3, 1};
pair<long long, long long> dfs(long long v) {
if (v == 0) return {4, 8};
if (v == 1) return {5, 10};
if (v == 2) return {6, 11};
if (v == 3) return {7, 9};
pair<long long, long long> p = dfs(v / 4 - 1);
p.first <<= 2LL;
p.second <<= 2LL;
p.first |= v % 4;
p.second |= b[v % 4];
return p;
}
void solve() {
if (n < 3) {
cout << n + 1 << '\n';
return;
}
long long g = n / 3 - 1;
pair<long long, long long> p = dfs(g);
vector<long long> ans = {p.first, p.second, (p.first ^ p.second)};
cout << ans[n % 3] << '\n';
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
for (; t--;) {
cin >> n;
--n;
solve();
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
using LL = int_fast64_t;
void solve() {
LL n;
cin >> n;
LL m = (n - 1) / 3 + 1, md = n % 3 ? n % 3 : 3, ret = 0, bit = 1, num = 0,
a[4];
if (md == 1)
a[0] = 3, a[1] = 0, a[2] = 1, a[3] = 2;
else if (md == 2)
a[0] = 1, a[1] = 0, a[2] = 2, a[3] = 3;
else
a[0] = 2, a[1] = 0, a[2] = 3, a[3] = 1;
while (true) {
if (bit >= m) {
ret += (md << num);
break;
}
m -= bit;
ret += (a[((m - 1) / bit + 1) % 4] << num);
bit <<= 2, num += 2;
}
cout << ret << endl;
}
int main() {
____();
int T;
for (cin >> T; T; T--) solve();
return 0;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
using LL = int_fast64_t;
void solve() {
LL n;
cin >> n;
LL m = (n - 1) / 3 + 1, md = n % 3 ? n % 3 : 3, ret = 0, bit = 1, num = 0,
a[4];
if (md == 1)
a[0] = 3, a[1] = 0, a[2] = 1, a[3] = 2;
else if (md == 2)
a[0] = 1, a[1] = 0, a[2] = 2, a[3] = 3;
else
a[0] = 2, a[1] = 0, a[2] = 3, a[3] = 1;
while (true) {
if (bit >= m) {
ret += (md << num);
break;
}
m -= bit;
ret += (a[((m - 1) / bit + 1) % 4] << num);
bit <<= 2, num += 2;
}
cout << ret << endl;
}
int main() {
____();
int T;
for (cin >> T; T; T--) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
const int mod = 1e9 + 7;
long long v[] = {0, 2, 3, 1};
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long x = ceil(n / 3.0);
long long go = 1, cur = 1;
while (cur < x) {
go *= 4;
cur += go;
}
cur -= go;
long long limInf = go;
long long limSup = 2 * go - 1;
long long A = limInf + (x - cur) - 1;
long long lowest = 2 * go;
x -= cur + 1;
while (limInf < limSup) {
long long ran = ((x) / ((limSup - limInf + 1) / 4ll)) % 4;
x -= ((limSup - limInf + 1) / 4ll) * ran;
lowest += ((limSup - limInf + 1) / 4ll) * v[ran];
limSup = lowest + ((limSup - limInf + 1) / 4ll) - 1;
limInf = lowest;
}
long long B = lowest;
long long C = A ^ B;
if (n % 3 == 1)
cout << A << '\n';
else if (n % 3 == 2)
cout << B << '\n';
else
cout << C << '\n';
}
}
| ### Prompt
Develop a solution in CPP to the problem described below:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
const int mod = 1e9 + 7;
long long v[] = {0, 2, 3, 1};
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long x = ceil(n / 3.0);
long long go = 1, cur = 1;
while (cur < x) {
go *= 4;
cur += go;
}
cur -= go;
long long limInf = go;
long long limSup = 2 * go - 1;
long long A = limInf + (x - cur) - 1;
long long lowest = 2 * go;
x -= cur + 1;
while (limInf < limSup) {
long long ran = ((x) / ((limSup - limInf + 1) / 4ll)) % 4;
x -= ((limSup - limInf + 1) / 4ll) * ran;
lowest += ((limSup - limInf + 1) / 4ll) * v[ran];
limSup = lowest + ((limSup - limInf + 1) / 4ll) - 1;
limInf = lowest;
}
long long B = lowest;
long long C = A ^ B;
if (n % 3 == 1)
cout << A << '\n';
else if (n % 3 == 2)
cout << B << '\n';
else
cout << C << '\n';
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
namespace fio {
streambuf* in = cin.rdbuf();
char bb[1000000], *s = bb, *t = bb;
inline long long read() {
long long x = 0;
char ch =
(s == t && (t = (s = bb) + in->sgetn(bb, 1000000), s == t) ? EOF : *s++);
while (ch < 48)
ch = (s == t && (t = (s = bb) + in->sgetn(bb, 1000000), s == t) ? EOF
: *s++);
while (ch >= 48)
x = x * 10 + ch - 48,
ch = (s == t && (t = (s = bb) + in->sgetn(bb, 1000000), s == t) ? EOF
: *s++);
return x;
}
} // namespace fio
using fio::read;
int n, x, y;
int sxx(int x, int y) {
if (y == 1) {
if (x == 0) return 0;
if (x == 1) return 1;
if (x == 2) return 2;
if (x == 3) return 3;
}
if (y == 2) {
if (x == 0) return 0;
if (x == 1) return 2;
if (x == 2) return 3;
if (x == 3) return 1;
}
if (y == 3) {
if (x == 0) return 0;
if (x == 1) return 3;
if (x == 2) return 1;
if (x == 3) return 2;
}
return -1;
}
long long dfs(long long n) {
if (n <= 3) return n;
long long x = (n - 1) / 3 - 1, y = (n % 3) == 0 ? 3 : (n % 3);
if (y == 1)
return (dfs((x >> 2) * 3 + y) << 2) | sxx(x & 3, 1);
else if (y == 2)
return (dfs((x >> 2) * 3 + y) << 2) | sxx(x & 3, 2);
return (dfs((x >> 2) * 3 + y) << 2) | sxx(x & 3, 3);
}
int main() {
int T = read();
while (T--) cout << dfs(read()) << endl;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
namespace fio {
streambuf* in = cin.rdbuf();
char bb[1000000], *s = bb, *t = bb;
inline long long read() {
long long x = 0;
char ch =
(s == t && (t = (s = bb) + in->sgetn(bb, 1000000), s == t) ? EOF : *s++);
while (ch < 48)
ch = (s == t && (t = (s = bb) + in->sgetn(bb, 1000000), s == t) ? EOF
: *s++);
while (ch >= 48)
x = x * 10 + ch - 48,
ch = (s == t && (t = (s = bb) + in->sgetn(bb, 1000000), s == t) ? EOF
: *s++);
return x;
}
} // namespace fio
using fio::read;
int n, x, y;
int sxx(int x, int y) {
if (y == 1) {
if (x == 0) return 0;
if (x == 1) return 1;
if (x == 2) return 2;
if (x == 3) return 3;
}
if (y == 2) {
if (x == 0) return 0;
if (x == 1) return 2;
if (x == 2) return 3;
if (x == 3) return 1;
}
if (y == 3) {
if (x == 0) return 0;
if (x == 1) return 3;
if (x == 2) return 1;
if (x == 3) return 2;
}
return -1;
}
long long dfs(long long n) {
if (n <= 3) return n;
long long x = (n - 1) / 3 - 1, y = (n % 3) == 0 ? 3 : (n % 3);
if (y == 1)
return (dfs((x >> 2) * 3 + y) << 2) | sxx(x & 3, 1);
else if (y == 2)
return (dfs((x >> 2) * 3 + y) << 2) | sxx(x & 3, 2);
return (dfs((x >> 2) * 3 + y) << 2) | sxx(x & 3, 3);
}
int main() {
int T = read();
while (T--) cout << dfs(read()) << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = acos((long double)-1);
const int xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
int pct(int x) { return __builtin_popcount(x); }
int bit(int x) { return 31 - __builtin_clz(x); }
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
template <class A>
void re(complex<A>& c);
template <class A, class B>
void re(pair<A, B>& p);
template <class A>
void re(vector<A>& v);
template <class A, size_t SZ>
void re(array<A, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& d) {
string t;
re(t);
d = stod(t);
}
void re(long double& d) {
string t;
re(t);
d = stold(t);
}
template <class H, class... T>
void re(H& h, T&... t) {
re(h);
re(t...);
}
template <class A>
void re(complex<A>& c) {
A a, b;
re(a, b);
c = {a, b};
}
template <class A, class B>
void re(pair<A, B>& p) {
re(p.first, p.second);
}
template <class A>
void re(vector<A>& x) {
for (auto& a : x) re(a);
}
template <class A, size_t SZ>
void re(array<A, SZ>& x) {
for (auto& a : x) re(a);
}
template <class A, class B>
string to_string(pair<A, B> p);
template <class A>
string to_string(complex<A> c) {
return to_string(make_pair(c.real(), c.imag()));
}
string to_string(bool b) { return b ? "true" : "false"; }
string to_string(char c) {
string second = "";
second += c;
return second;
}
string to_string(string second) { return second; }
string to_string(const char* second) { return (string)second; }
string to_string(vector<bool> v) {
bool fst = 1;
string res = "{";
for (int i = (0); i < ((int)v.size()); ++i) {
if (!fst) res += ", ";
fst = 0;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t SZ>
string to_string(bitset<SZ> b) {
string res = "";
for (int i = (0); i < (SZ); ++i) res += char('0' + b[i]);
return res;
}
template <class T>
string to_string(T v) {
bool fst = 1;
string res = "{";
for (const auto& x : v) {
if (!fst) res += ", ";
fst = 0;
res += to_string(x);
}
res += "}";
return res;
}
template <class A, class B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <class A>
void pr(A x) {
cout << to_string(x);
}
template <class H, class... T>
void pr(const H& h, const T&... t) {
pr(h);
pr(t...);
}
void ps() { pr("\n"); }
template <class H, class... T>
void ps(const H& h, const T&... t) {
pr(h);
if (sizeof...(t)) pr(" ");
ps(t...);
}
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void unsyncIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
void setIO(string second = "") {
unsyncIO();
if ((int)second.size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
using ul = uint64_t;
ul _nimProd[64][64];
ul nimProd(int i, int j) {
ul& u = _nimProd[i][j];
if (u) return u;
if (!(i & j)) return u = 1ULL << (i | j);
int a = (i & j) & -(i & j);
return u = nimProd(i ^ a, j) ^
nimProd((i ^ a) | (a - 1), (j ^ a) | (i & (a - 1)));
}
struct nb {
ul x;
nb() { x = 0; }
nb(ul _x) : x(_x) {}
explicit operator ul() { return x; }
nb operator+(nb y) { return nb(x ^ y.x); }
nb operator*(nb y) {
ul res = 0;
for (int i = (0); i < (64); ++i)
if (x >> i & 1)
for (int j = (0); j < (64); ++j)
if (y.x >> j & 1) res ^= nimProd(i, j);
return nb(res);
}
friend nb pow(nb b, ul p) {
nb res = 1;
for (; p; p /= 2, b = b * b)
if (p & 1) res = res * b;
return res;
}
friend nb inv(nb b) { return pow(b, -2); }
};
int t;
long long n;
void solve() {}
bool in(vector<int> a, int b) { return find(begin(a), end(a), b) != end(a); }
long long huh(long long a, int b) {
if (b == 0) return a;
if (b == 2) return huh(a, 1) ^ huh(a, 0);
return (nb(2) * nb(a)).x;
}
long long get(long long a, int b) {
for (int i = 0;; ++i) {
long long p = 1LL << (2 * i);
if (p >= a) return p * (b + 1) + huh(a - 1, b);
a -= p;
}
}
int main() {
setIO();
vector<int> seq;
for (int z = (0); z < (100); ++z) {
int cur = 1;
while (in(seq, cur)) cur++;
int CUR = cur + 1;
while (in(seq, CUR) || in(seq, cur ^ CUR)) CUR++;
seq.push_back(cur);
seq.push_back(CUR);
seq.push_back(cur ^ CUR);
long long p = 1;
while (p * 4 <= cur) p *= 4;
}
for (int a = (1); a < (101); ++a)
for (int b = (0); b < (3); ++b) {
assert(get(a, b) == seq[3 * (a - 1) + b]);
}
re(t);
for (int i = (0); i < (t); ++i) {
long long n;
re(n);
ps(get((n + 2) / 3, (n - 1) % 3));
}
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = acos((long double)-1);
const int xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
int pct(int x) { return __builtin_popcount(x); }
int bit(int x) { return 31 - __builtin_clz(x); }
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
template <class A>
void re(complex<A>& c);
template <class A, class B>
void re(pair<A, B>& p);
template <class A>
void re(vector<A>& v);
template <class A, size_t SZ>
void re(array<A, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& d) {
string t;
re(t);
d = stod(t);
}
void re(long double& d) {
string t;
re(t);
d = stold(t);
}
template <class H, class... T>
void re(H& h, T&... t) {
re(h);
re(t...);
}
template <class A>
void re(complex<A>& c) {
A a, b;
re(a, b);
c = {a, b};
}
template <class A, class B>
void re(pair<A, B>& p) {
re(p.first, p.second);
}
template <class A>
void re(vector<A>& x) {
for (auto& a : x) re(a);
}
template <class A, size_t SZ>
void re(array<A, SZ>& x) {
for (auto& a : x) re(a);
}
template <class A, class B>
string to_string(pair<A, B> p);
template <class A>
string to_string(complex<A> c) {
return to_string(make_pair(c.real(), c.imag()));
}
string to_string(bool b) { return b ? "true" : "false"; }
string to_string(char c) {
string second = "";
second += c;
return second;
}
string to_string(string second) { return second; }
string to_string(const char* second) { return (string)second; }
string to_string(vector<bool> v) {
bool fst = 1;
string res = "{";
for (int i = (0); i < ((int)v.size()); ++i) {
if (!fst) res += ", ";
fst = 0;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t SZ>
string to_string(bitset<SZ> b) {
string res = "";
for (int i = (0); i < (SZ); ++i) res += char('0' + b[i]);
return res;
}
template <class T>
string to_string(T v) {
bool fst = 1;
string res = "{";
for (const auto& x : v) {
if (!fst) res += ", ";
fst = 0;
res += to_string(x);
}
res += "}";
return res;
}
template <class A, class B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <class A>
void pr(A x) {
cout << to_string(x);
}
template <class H, class... T>
void pr(const H& h, const T&... t) {
pr(h);
pr(t...);
}
void ps() { pr("\n"); }
template <class H, class... T>
void ps(const H& h, const T&... t) {
pr(h);
if (sizeof...(t)) pr(" ");
ps(t...);
}
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void unsyncIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
void setIO(string second = "") {
unsyncIO();
if ((int)second.size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
using ul = uint64_t;
ul _nimProd[64][64];
ul nimProd(int i, int j) {
ul& u = _nimProd[i][j];
if (u) return u;
if (!(i & j)) return u = 1ULL << (i | j);
int a = (i & j) & -(i & j);
return u = nimProd(i ^ a, j) ^
nimProd((i ^ a) | (a - 1), (j ^ a) | (i & (a - 1)));
}
struct nb {
ul x;
nb() { x = 0; }
nb(ul _x) : x(_x) {}
explicit operator ul() { return x; }
nb operator+(nb y) { return nb(x ^ y.x); }
nb operator*(nb y) {
ul res = 0;
for (int i = (0); i < (64); ++i)
if (x >> i & 1)
for (int j = (0); j < (64); ++j)
if (y.x >> j & 1) res ^= nimProd(i, j);
return nb(res);
}
friend nb pow(nb b, ul p) {
nb res = 1;
for (; p; p /= 2, b = b * b)
if (p & 1) res = res * b;
return res;
}
friend nb inv(nb b) { return pow(b, -2); }
};
int t;
long long n;
void solve() {}
bool in(vector<int> a, int b) { return find(begin(a), end(a), b) != end(a); }
long long huh(long long a, int b) {
if (b == 0) return a;
if (b == 2) return huh(a, 1) ^ huh(a, 0);
return (nb(2) * nb(a)).x;
}
long long get(long long a, int b) {
for (int i = 0;; ++i) {
long long p = 1LL << (2 * i);
if (p >= a) return p * (b + 1) + huh(a - 1, b);
a -= p;
}
}
int main() {
setIO();
vector<int> seq;
for (int z = (0); z < (100); ++z) {
int cur = 1;
while (in(seq, cur)) cur++;
int CUR = cur + 1;
while (in(seq, CUR) || in(seq, cur ^ CUR)) CUR++;
seq.push_back(cur);
seq.push_back(CUR);
seq.push_back(cur ^ CUR);
long long p = 1;
while (p * 4 <= cur) p *= 4;
}
for (int a = (1); a < (101); ++a)
for (int b = (0); b < (3); ++b) {
assert(get(a, b) == seq[3 * (a - 1) + b]);
}
re(t);
for (int i = (0); i < (t); ++i) {
long long n;
re(n);
ps(get((n + 2) / 3, (n - 1) % 3));
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long v[] = {0, 2, 3, 1};
int main() {
int t;
long long n;
scanf("%d", &t);
while (t--) {
scanf("%lld", &n);
long long p;
for (p = 1; p <= n; p *= 4)
;
p /= 4;
long long d = n - p, r = d / 3, r2 = r;
long long val = 2 * p;
long long j = 0;
while (r) {
val = val | (v[r % 4] << (2 * j));
r /= 4;
j++;
}
if (n % 3 == 1)
printf("%lld\n", p + r2);
else if (n % 3 == 2)
printf("%lld\n", val);
else
printf("%lld\n", (p + r2) ^ val);
}
return 0;
}
| ### Prompt
Please create a solution in CPP to the following problem:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long v[] = {0, 2, 3, 1};
int main() {
int t;
long long n;
scanf("%d", &t);
while (t--) {
scanf("%lld", &n);
long long p;
for (p = 1; p <= n; p *= 4)
;
p /= 4;
long long d = n - p, r = d / 3, r2 = r;
long long val = 2 * p;
long long j = 0;
while (r) {
val = val | (v[r % 4] << (2 * j));
r /= 4;
j++;
}
if (n % 3 == 1)
printf("%lld\n", p + r2);
else if (n % 3 == 2)
printf("%lld\n", val);
else
printf("%lld\n", (p + r2) ^ val);
}
return 0;
}
``` |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const long long mod = 998244353;
const long long maxn = 1e5 + 10;
long long p[2] = {1000000007, 998244353};
long long seed[2] = {500000004, 500000004};
long long ksm(long long x, long long y) {
long long re = 1, xx = x % mod;
while (y > 0) {
if (y & 1) {
re *= xx;
re %= mod;
}
xx *= xx;
xx %= mod;
y >>= 1;
}
return re;
}
long long tt, n;
long long dp[66], qzh[66];
long long c[2][4] = {{0, 2, 3, 1}, {0, 3, 1, 2}};
int main() {
dp[1] = 1;
for (int i = 2; i <= 30; i++) dp[i] = dp[i - 1] * 4;
scanf("%lld", &tt);
while (tt--) {
scanf("%lld", &n);
if (n == 1) {
printf("1\n");
continue;
} else if (n == 2) {
printf("2\n");
continue;
} else if (n == 3) {
printf("3\n");
continue;
}
long long x, y, z;
x = n / 3;
y = n % 3;
if (y > 0)
x++;
else
y = 3;
long long sum = 0;
for (int i = 1; i <= 30; i++) {
sum += dp[i];
if (sum >= x) {
sum -= dp[i];
x -= sum;
z = dp[i];
break;
}
}
x--;
if (y == 1) {
printf("%lld\n", z + x);
} else {
z *= y;
long long ls = 0;
long long xx = 1;
while (x > 0) {
ls += c[y - 2][x % 4] * xx;
xx *= 4;
x /= 4;
}
ls += z;
printf("%lld\n", ls);
}
}
return 0;
}
| ### Prompt
Please formulate a cpp solution to the following problem:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const long long mod = 998244353;
const long long maxn = 1e5 + 10;
long long p[2] = {1000000007, 998244353};
long long seed[2] = {500000004, 500000004};
long long ksm(long long x, long long y) {
long long re = 1, xx = x % mod;
while (y > 0) {
if (y & 1) {
re *= xx;
re %= mod;
}
xx *= xx;
xx %= mod;
y >>= 1;
}
return re;
}
long long tt, n;
long long dp[66], qzh[66];
long long c[2][4] = {{0, 2, 3, 1}, {0, 3, 1, 2}};
int main() {
dp[1] = 1;
for (int i = 2; i <= 30; i++) dp[i] = dp[i - 1] * 4;
scanf("%lld", &tt);
while (tt--) {
scanf("%lld", &n);
if (n == 1) {
printf("1\n");
continue;
} else if (n == 2) {
printf("2\n");
continue;
} else if (n == 3) {
printf("3\n");
continue;
}
long long x, y, z;
x = n / 3;
y = n % 3;
if (y > 0)
x++;
else
y = 3;
long long sum = 0;
for (int i = 1; i <= 30; i++) {
sum += dp[i];
if (sum >= x) {
sum -= dp[i];
x -= sum;
z = dp[i];
break;
}
}
x--;
if (y == 1) {
printf("%lld\n", z + x);
} else {
z *= y;
long long ls = 0;
long long xx = 1;
while (x > 0) {
ls += c[y - 2][x % 4] * xx;
xx *= 4;
x /= 4;
}
ls += z;
printf("%lld\n", ls);
}
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
vector<int> vtest;
void eprintb(int x) {
for (int i = 20; i >= 0; i--)
if (x >> i)
printf("%d", (x >> i) & 1);
else
printf(" ");
printf("\n");
}
const int N = (int)1e6 + 100;
bool used[N];
long long zzz[4] = {0, 2, 3, 1};
long long getX(int len, long long pos) {
long long ans = (1LL << len);
for (int i = 0; i < len; i += 2) {
ans |= zzz[(pos >> i) & 3LL] << i;
}
return ans;
}
long long solve1(long long pos) {
int len = 1;
while (pos >= 3LL * (1LL << (len - 1))) {
pos -= 3LL * (1LL << (len - 1));
len += 2;
}
int rem = pos % 3;
pos /= 3;
long long val = (1LL << (len - 1)) + pos;
if (rem == 0) return val;
long long x = getX(len, pos);
if (rem == 1) return x;
if (rem == 2) return x ^ val;
throw;
}
void solve() {
long long pos;
scanf("%lld", &pos);
pos--;
long long ans = solve1(pos);
if (ans >= 0 && pos < (int)vtest.size() && vtest[pos] != ans) {
42;
eprintb(pos);
eprintb(ans);
eprintb(vtest[pos]);
throw;
}
printf("%lld\n", ans);
}
int main(int, char **) {
for (int i = 1; i < (int)100; i++) {
if (used[i]) continue;
used[i] = true;
for (int j = i + 1; j < N; j++) {
int h = i ^ j;
if (used[j] || used[h]) continue;
used[i] = used[j] = used[h] = true;
vtest.push_back(i);
vtest.push_back(j);
vtest.push_back(h);
break;
}
}
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) solve();
return 0;
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<int> vtest;
void eprintb(int x) {
for (int i = 20; i >= 0; i--)
if (x >> i)
printf("%d", (x >> i) & 1);
else
printf(" ");
printf("\n");
}
const int N = (int)1e6 + 100;
bool used[N];
long long zzz[4] = {0, 2, 3, 1};
long long getX(int len, long long pos) {
long long ans = (1LL << len);
for (int i = 0; i < len; i += 2) {
ans |= zzz[(pos >> i) & 3LL] << i;
}
return ans;
}
long long solve1(long long pos) {
int len = 1;
while (pos >= 3LL * (1LL << (len - 1))) {
pos -= 3LL * (1LL << (len - 1));
len += 2;
}
int rem = pos % 3;
pos /= 3;
long long val = (1LL << (len - 1)) + pos;
if (rem == 0) return val;
long long x = getX(len, pos);
if (rem == 1) return x;
if (rem == 2) return x ^ val;
throw;
}
void solve() {
long long pos;
scanf("%lld", &pos);
pos--;
long long ans = solve1(pos);
if (ans >= 0 && pos < (int)vtest.size() && vtest[pos] != ans) {
42;
eprintb(pos);
eprintb(ans);
eprintb(vtest[pos]);
throw;
}
printf("%lld\n", ans);
}
int main(int, char **) {
for (int i = 1; i < (int)100; i++) {
if (used[i]) continue;
used[i] = true;
for (int j = i + 1; j < N; j++) {
int h = i ^ j;
if (used[j] || used[h]) continue;
used[i] = used[j] = used[h] = true;
vtest.push_back(i);
vtest.push_back(j);
vtest.push_back(h);
break;
}
}
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) solve();
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
n--;
long long r = n % 3;
n /= 3;
long long u = 0;
while (n >= (1ll << u)) {
n -= (1ll << u);
u += 2;
}
long long a[3];
a[0] = (1ll << u);
a[1] = 2 * a[0];
a[2] = 3 * a[0];
long long t = 0;
while (n) {
long long kek = n % 4;
long long y = (1ll << t);
if (kek == 0) {
}
if (kek == 1) {
a[0] += 1 * y;
a[1] += 2 * y;
a[2] += 3 * y;
} else if (kek == 2) {
a[0] += 2 * y;
a[1] += 3 * y;
a[2] += 1 * y;
} else if (kek == 3) {
a[0] += 3 * y;
a[1] += 1 * y;
a[2] += 2 * y;
}
n /= 4;
t += 2;
}
cout << a[r] << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) solve();
}
| ### Prompt
Please provide a cpp coded solution to the problem described below:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
n--;
long long r = n % 3;
n /= 3;
long long u = 0;
while (n >= (1ll << u)) {
n -= (1ll << u);
u += 2;
}
long long a[3];
a[0] = (1ll << u);
a[1] = 2 * a[0];
a[2] = 3 * a[0];
long long t = 0;
while (n) {
long long kek = n % 4;
long long y = (1ll << t);
if (kek == 0) {
}
if (kek == 1) {
a[0] += 1 * y;
a[1] += 2 * y;
a[2] += 3 * y;
} else if (kek == 2) {
a[0] += 2 * y;
a[1] += 3 * y;
a[2] += 1 * y;
} else if (kek == 3) {
a[0] += 3 * y;
a[1] += 1 * y;
a[2] += 2 * y;
}
n /= 4;
t += 2;
}
cout << a[r] << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) solve();
}
``` |
#include <bits/stdc++.h>
long long int n, ans, j, t, p, a[] = {0, 0, 0, 1, 2, 3, 2, 3, 1, 3, 1, 2};
int main() {
for (scanf("%d", &t); t--; ans = 0) {
scanf("%lld", &n);
p = --n % 3, n = n / 3 - 1;
for (j = 1; n + 1; j *= 4, n = n / 4 - 1) ans += j * a[n % 4 * 3 + p];
printf("%lld\n", ans + j * (p + 1));
}
}
| ### Prompt
Generate a cpp solution to the following problem:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
long long int n, ans, j, t, p, a[] = {0, 0, 0, 1, 2, 3, 2, 3, 1, 3, 1, 2};
int main() {
for (scanf("%d", &t); t--; ans = 0) {
scanf("%lld", &n);
p = --n % 3, n = n / 3 - 1;
for (j = 1; n + 1; j *= 4, n = n / 4 - 1) ans += j * a[n % 4 * 3 + p];
printf("%lld\n", ans + j * (p + 1));
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
long long nu[4][3] = {{0, 0, 0}, {1, 2, 3}, {2, 3, 1}, {3, 1, 2}};
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long ans = 0;
long long j = (n - 1) % 3;
n = (n + 2) / 3;
long long sum = 0;
long long i = 0;
for (; i < 60; i += 2) {
sum |= 1LL << i;
if (sum >= n) {
sum ^= 1LL << i;
n -= sum + 1;
ans |= nu[1][j] << i;
break;
}
}
for (i -= 2; i >= 0; i -= 2) ans |= nu[(n >> i) & 3][j] << i;
cout << ans << endl;
}
return 0;
}
| ### Prompt
In cpp, your task is to solve the following problem:
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ...
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
long long nu[4][3] = {{0, 0, 0}, {1, 2, 3}, {2, 3, 1}, {3, 1, 2}};
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long ans = 0;
long long j = (n - 1) % 3;
n = (n + 2) / 3;
long long sum = 0;
long long i = 0;
for (; i < 60; i += 2) {
sum |= 1LL << i;
if (sum >= n) {
sum ^= 1LL << i;
n -= sum + 1;
ans |= nu[1][j] << i;
break;
}
}
for (i -= 2; i >= 0; i -= 2) ans |= nu[(n >> i) & 3][j] << i;
cout << ans << endl;
}
return 0;
}
``` |
Subsets and Splits