output
stringlengths 52
181k
| instruction
stringlengths 296
182k
|
|---|---|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]==s[1]||s[1]==s[2]||s[2]==s[0]){
cout<<"No";
}else{
cout<<"Yes";
}
return 0;
}
| ### Prompt
Please provide a cpp coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]==s[1]||s[1]==s[2]||s[2]==s[0]){
cout<<"No";
}else{
cout<<"Yes";
}
return 0;
}
``` |
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
int main(){
string s;cin>>s;
sort(s.begin(),s.end());
puts(s=="abc"?"Yes":"No");
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
int main(){
string s;cin>>s;
sort(s.begin(),s.end());
puts(s=="abc"?"Yes":"No");
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
cout << ((((s[0] - '0')+(s[1] - '0') + (s[2] - '0'))==150)?"Yes":"No") << endl;
return 0;
} | ### Prompt
Your challenge is to write a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
cout << ((((s[0] - '0')+(s[1] - '0') + (s[2] - '0'))==150)?"Yes":"No") << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char x,y,z;
cin >> x >> y >> z ;
if ( x==y || x==z || y==z ) cout << "No";
else cout << "Yes" ;
} | ### Prompt
Please create a solution in cpp to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char x,y,z;
cin >> x >> y >> z ;
if ( x==y || x==z || y==z ) cout << "No";
else cout << "Yes" ;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c[3];cin>>c;
bool ans = c[0] != c[1] && c[1] != c[2] && c[0] != c[2];
cout << (ans ? "Yes" : "No") << endl;
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char c[3];cin>>c;
bool ans = c[0] != c[1] && c[1] != c[2] && c[0] != c[2];
cout << (ans ? "Yes" : "No") << endl;
}
``` |
#include <iostream>
using namespace std;
char x, y, z;
int main() {
cin>>x>>y>>z;
cout<<(x!=y && y!=z && z!=x ? "Yes":"No");
return 0;
} | ### Prompt
Please provide a cpp coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
char x, y, z;
int main() {
cin>>x>>y>>z;
cout<<(x!=y && y!=z && z!=x ? "Yes":"No");
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
char a,b,c;
int flag=1;
cin >> a >> b >> c;
if(a==b||b==c||c==a)flag=0;
cout << ((flag)?"Yes":"No") << endl;
} | ### Prompt
Create a solution in cpp for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
char a,b,c;
int flag=1;
cin >> a >> b >> c;
if(a==b||b==c||c==a)flag=0;
cout << ((flag)?"Yes":"No") << endl;
}
``` |
#include<cstdio>
#include<iostream>
using namespace std;
int main()
{
string s;
cin>>s;
if(s[0]!=s[1]&&s[1]!=s[2]&&s[2]!=s[0]) printf("Yes");
else printf("No");
} | ### Prompt
Generate a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<cstdio>
#include<iostream>
using namespace std;
int main()
{
string s;
cin>>s;
if(s[0]!=s[1]&&s[1]!=s[2]&&s[2]!=s[0]) printf("Yes");
else printf("No");
}
``` |
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
string s;
cin>>s;
(s[0]!=s[1] && s[1]!=s[2] && s[0]!=s[2])? cout<<"Yes" : cout<<"No";
} | ### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
string s;
cin>>s;
(s[0]!=s[1] && s[1]!=s[2] && s[0]!=s[2])? cout<<"Yes" : cout<<"No";
}
``` |
//abc of ABC
#include <bits/stdc++.h>
using namespace std;
int main(void){
string s;
cin>>s;
sort(s.begin(),s.end());
cout<<( s=="abc"? "Yes":"No")<<endl;
return 0;
} | ### Prompt
Please provide a CPP coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
//abc of ABC
#include <bits/stdc++.h>
using namespace std;
int main(void){
string s;
cin>>s;
sort(s.begin(),s.end());
cout<<( s=="abc"? "Yes":"No")<<endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
sort(s.begin(),s.end());
cout<< ((s=="abc")?"Yes":"No") <<endl;
}
| ### Prompt
Construct a cpp code solution to the problem outlined:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
sort(s.begin(),s.end());
cout<< ((s=="abc")?"Yes":"No") <<endl;
}
``` |
#include <iostream>
using namespace std;
int main(){
string s;
cin >> s;
cout << ((s[0] != s[1] && s[1] != s[2] && s[2] != s[0]) ? "Yes" : "No") << endl;
} | ### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
string s;
cin >> s;
cout << ((s[0] != s[1] && s[1] != s[2] && s[2] != s[0]) ? "Yes" : "No") << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if((s[0]==s[1])||(s[1]==s[2])||(s[0]==s[2]))cout <<"No";
else cout <<"Yes";
} | ### Prompt
In Cpp, your task is to solve the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if((s[0]==s[1])||(s[1]==s[2])||(s[0]==s[2]))cout <<"No";
else cout <<"Yes";
}
``` |
#include<iostream>
#include<string>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]==s[1]||s[1]==s[2]||s[0]==s[2]) cout<<"No"<<endl;
else cout<<"Yes"<<endl;
} | ### Prompt
Develop a solution in cpp to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
#include<string>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]==s[1]||s[1]==s[2]||s[0]==s[2]) cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
``` |
#include"bits/stdc++.h"
using namespace std;
int main() {
string S;
cin >> S;
sort(S.begin(), S.end());
if (S == "abc") {
puts("Yes");
}
else {
puts("No");
}
return 0;
} | ### Prompt
Construct a cpp code solution to the problem outlined:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include"bits/stdc++.h"
using namespace std;
int main() {
string S;
cin >> S;
sort(S.begin(), S.end());
if (S == "abc") {
puts("Yes");
}
else {
puts("No");
}
return 0;
}
``` |
#include <iostream>
using namespace std;
int main(void) {
string s;
cin >> s;
if(s[0]!=s[1] && s[0]!=s[2] && s[1]!=s[2]) cout << "Yes" << "\n";
else cout << "No" << "\n";
return 0;
} | ### Prompt
Create a solution in Cpp for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main(void) {
string s;
cin >> s;
if(s[0]!=s[1] && s[0]!=s[2] && s[1]!=s[2]) cout << "Yes" << "\n";
else cout << "No" << "\n";
return 0;
}
``` |
#include <stdio.h>
int main() {
char s[4];
scanf("%s", s);
if (s[0] != s[1] && s[1] != s[2] && s[2] != s[0]) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
}
| ### Prompt
Please provide a cpp coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <stdio.h>
int main() {
char s[4];
scanf("%s", s);
if (s[0] != s[1] && s[1] != s[2] && s[2] != s[0]) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main()
{
char a,b,c;
scanf("%c%c%c",&a,&b,&c);
if(a!=b&&b!=c&&a!=c)
printf("Yes");
else
printf("No");
return 0;
} | ### Prompt
In cpp, your task is to solve the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
char a,b,c;
scanf("%c%c%c",&a,&b,&c);
if(a!=b&&b!=c&&a!=c)
printf("Yes");
else
printf("No");
return 0;
}
``` |
#include <stdio.h>
int main() {
char a, b, c;
scanf("%c%c%c", &a, &b, &c);
if(a == b | a == c | b == c) printf("No\n");
else printf("Yes\n");
return 0;
} | ### Prompt
Construct a cpp code solution to the problem outlined:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <stdio.h>
int main() {
char a, b, c;
scanf("%c%c%c", &a, &b, &c);
if(a == b | a == c | b == c) printf("No\n");
else printf("Yes\n");
return 0;
}
``` |
#include<cstdio>
char c;
int a[10];
int main()
{
for(int i=0;i<3;i++)
{
scanf("%c",&c);
a[c-'a']++;
}
if(a[0]==1&&a[1]==1&&a[2]==1)printf("Yes");
else
printf("No");
} | ### Prompt
Construct a cpp code solution to the problem outlined:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<cstdio>
char c;
int a[10];
int main()
{
for(int i=0;i<3;i++)
{
scanf("%c",&c);
a[c-'a']++;
}
if(a[0]==1&&a[1]==1&&a[2]==1)printf("Yes");
else
printf("No");
}
``` |
#include<iostream>
using namespace std;
string a;
int main()
{
cin >> a;
if(a[0]!=a[1]&&a[2]!=a[1]&&a[0]!=a[2])printf("Yes");
else printf("No");
} | ### Prompt
Please formulate a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
using namespace std;
string a;
int main()
{
cin >> a;
if(a[0]!=a[1]&&a[2]!=a[1]&&a[0]!=a[2])printf("Yes");
else printf("No");
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
cout<<(s[0]!=s[1]&&s[0]!=s[2]&&s[1]!=s[2]?"Yes":"No")<<endl;
return 0;
} | ### Prompt
Construct a CPP code solution to the problem outlined:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
cout<<(s[0]!=s[1]&&s[0]!=s[2]&&s[1]!=s[2]?"Yes":"No")<<endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]+s[1]+s[2]=='a'+'b'+'c') cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
} | ### Prompt
Please create a solution in Cpp to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]+s[1]+s[2]=='a'+'b'+'c') cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s; cin >> s;
sort(s.begin(), s.end());
cout << (s == "abc" ? "Yes" : "No") << endl;
return 0;
} | ### Prompt
Develop a solution in Cpp to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s; cin >> s;
sort(s.begin(), s.end());
cout << (s == "abc" ? "Yes" : "No") << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
if(s[0]!=s[1] && s[0]!=s[2] && s[1]!=s[2]) cout << "Yes" << endl;
else cout << "No" << endl;
} | ### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
if(s[0]!=s[1] && s[0]!=s[2] && s[1]!=s[2]) cout << "Yes" << endl;
else cout << "No" << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
string x;
cin>>x;
if(x[0]!=x[1]&&x[0]!=x[2]&&x[1]!=x[2]){
cout<<"Yes"<<endl;
}
else
cout<<"No"<<endl;
}
| ### Prompt
Create a solution in Cpp for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
string x;
cin>>x;
if(x[0]!=x[1]&&x[0]!=x[2]&&x[1]!=x[2]){
cout<<"Yes"<<endl;
}
else
cout<<"No"<<endl;
}
``` |
#include<stdio.h>
int main()
{
char a[10];
scanf("%s",a);
if(a[0]!=a[1]&&a[0]!=a[2]&&a[1]!=a[2])
printf("Yes");
else
printf("No");
return 0;
}
| ### Prompt
Please formulate a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<stdio.h>
int main()
{
char a[10];
scanf("%s",a);
if(a[0]!=a[1]&&a[0]!=a[2]&&a[1]!=a[2])
printf("Yes");
else
printf("No");
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
if(s[0] != s[1] && s[1] != s[2] && s[2] != s[0]) cout << "Yes" << endl;
else cout << "No" << endl;
} | ### Prompt
Please provide a CPP coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
if(s[0] != s[1] && s[1] != s[2] && s[2] != s[0]) cout << "Yes" << endl;
else cout << "No" << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main()
{
char a[4];
cin>>a;
if (a[0]!=a[1]&&a[1]!=a[2]&&a[2]!=a[0])
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
} | ### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
char a[4];
cin>>a;
if (a[0]!=a[1]&&a[1]!=a[2]&&a[2]!=a[0])
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
}
``` |
#include <iostream>
#include <string>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]!=s[1]&&s[1]!=s[2]&&s[2]!=s[0])cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
| ### Prompt
Construct a cpp code solution to the problem outlined:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]!=s[1]&&s[1]!=s[2]&&s[2]!=s[0])cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
``` |
#include<iostream>
using namespace std;
int main() {
char a, b, c;
cin >> a >> b >> c;
puts(a != b && b != c && c != a ? "Yes" : "No");
} | ### Prompt
Develop a solution in Cpp to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
using namespace std;
int main() {
char a, b, c;
cin >> a >> b >> c;
puts(a != b && b != c && c != a ? "Yes" : "No");
}
``` |
#include<iostream>
using namespace std;
int main(){
string s;
cin>>s;
cout<<(s=="abc"||s=="acb"||s=="bac"||s=="bca"||s=="cab"||s=="cba"?"Yes":"No");
}
| ### Prompt
Please create a solution in cpp to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
string s;
cin>>s;
cout<<(s=="abc"||s=="acb"||s=="bac"||s=="bca"||s=="cab"||s=="cba"?"Yes":"No");
}
``` |
# include<bits/stdc++.h>
using namespace std;
int main () {
string s;
cin>>s;
sort(s.begin(),s.end());
if (s[0]=='a' && s[1]=='b' && s[2]=='c'){
cout<<"Yes";
}
else
cout<<"No";
}
| ### Prompt
Please create a solution in CPP to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
# include<bits/stdc++.h>
using namespace std;
int main () {
string s;
cin>>s;
sort(s.begin(),s.end());
if (s[0]=='a' && s[1]=='b' && s[2]=='c'){
cout<<"Yes";
}
else
cout<<"No";
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]==s[1]||s[0]==s[2]||s[1]==s[2]) cout<<"No";
else cout<<"Yes";
return 0;
}
| ### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]==s[1]||s[0]==s[2]||s[1]==s[2]) cout<<"No";
else cout<<"Yes";
return 0;
}
``` |
#include <iostream>
int main() {char c;int sum=0;while (std::cin>>c){(c=='a'?sum+=1:c=='b'?sum+=3:sum+=7);}std::cout<<(sum==11?"Yes":"No");} | ### Prompt
Please create a solution in Cpp to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
int main() {char c;int sum=0;while (std::cin>>c){(c=='a'?sum+=1:c=='b'?sum+=3:sum+=7);}std::cout<<(sum==11?"Yes":"No");}
``` |
#include <iostream>
using namespace std;
int main()
{
string q;
cin>>q;
if((q=="abc")||(q=="acb")||(q=="cab")||(q=="cba")||(q=="bac")||(q=="bca"))cout<<"Yes";else cout<<"No";
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main()
{
string q;
cin>>q;
if((q=="abc")||(q=="acb")||(q=="cab")||(q=="cba")||(q=="bac")||(q=="bca"))cout<<"Yes";else cout<<"No";
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
cout << (S.at(0)!=S.at(1)&&S.at(1)!=S.at(2)&&S.at(2)!=S.at(0) ? "Yes" : "No") << endl;
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
cout << (S.at(0)!=S.at(1)&&S.at(1)!=S.at(2)&&S.at(2)!=S.at(0) ? "Yes" : "No") << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
sort(s.begin(),s.end());
if(s=="abc")
cout<<"Yes";
else cout<<"No";
return 0;
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
sort(s.begin(),s.end());
if(s=="abc")
cout<<"Yes";
else cout<<"No";
return 0;
}
``` |
#include <iostream>
using namespace std;
int main(){
string S;
cin >> S;
if(S[0]!=S[1]&&S[1]!=S[2]&&S[2]!=S[0])
cout << "Yes" << endl;
else cout << "No" << endl;
} | ### Prompt
Please create a solution in cpp to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
string S;
cin >> S;
if(S[0]!=S[1]&&S[1]!=S[2]&&S[2]!=S[0])
cout << "Yes" << endl;
else cout << "No" << endl;
}
``` |
// A - abc of ABC
#include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(),(x).end()
int main(){
string s; cin>>s;
sort(all(s));
cout<< (s=="abc"?"Yes":"No") <<endl;
} | ### Prompt
Develop a solution in CPP to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
// A - abc of ABC
#include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(),(x).end()
int main(){
string s; cin>>s;
sort(all(s));
cout<< (s=="abc"?"Yes":"No") <<endl;
}
``` |
#include<iostream>
using namespace std;
int main(){
char a,b,c;cin>>a>>b>>c;if(a==b || b==c || c==a)cout<<"No"<<endl;else cout<<"Yes"<<endl;
} | ### Prompt
Create a solution in CPP for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
char a,b,c;cin>>a>>b>>c;if(a==b || b==c || c==a)cout<<"No"<<endl;else cout<<"Yes"<<endl;
}
``` |
#include <iostream>
using namespace std;
int main(void){
string s;
cin >> s;
if(s[0] != s[1] && s[1] != s[2] && s[0] != s[2]) cout << "Yes" << endl;
else cout << "No" << endl;
}
| ### Prompt
Generate a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main(void){
string s;
cin >> s;
if(s[0] != s[1] && s[1] != s[2] && s[0] != s[2]) cout << "Yes" << endl;
else cout << "No" << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
sort(s.begin(), s.end());
if(s == "abc")cout << "Yes" << endl;
else cout << "No" << endl;
} | ### Prompt
Your task is to create a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
sort(s.begin(), s.end());
if(s == "abc")cout << "Yes" << endl;
else cout << "No" << endl;
}
``` |
#include<iostream>
using namespace std;
int main(){
string a;cin>>a;if(a[0]==a[1] || a[1]==a[2] || a[2]==a[0])cout<<"No"<<endl;else cout<<"Yes"<<endl;
} | ### Prompt
Your task is to create a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
string a;cin>>a;if(a[0]==a[1] || a[1]==a[2] || a[2]==a[0])cout<<"No"<<endl;else cout<<"Yes"<<endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
cout << ((str[0]+str[1]+str[2]==98*3 && !(str == "bbb")) ? "Yes":"No") << endl;
} | ### Prompt
In CPP, your task is to solve the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
cout << ((str[0]+str[1]+str[2]==98*3 && !(str == "bbb")) ? "Yes":"No") << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s; cin >> s;
sort(s.begin(), s.end());
cout << (s == "abc" ? "Yes\n" : "No\n");
return 0;
}
| ### Prompt
Generate a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s; cin >> s;
sort(s.begin(), s.end());
cout << (s == "abc" ? "Yes\n" : "No\n");
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
set<char> s;
for(int i=0;i<3;i++){
char a;cin>>a;
s.insert(a);
}
cout<<(s.size()==3?"Yes":"No")<<endl;
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
set<char> s;
for(int i=0;i<3;i++){
char a;cin>>a;
s.insert(a);
}
cout<<(s.size()==3?"Yes":"No")<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(void)
{
string s;
cin >> s;
sort(s.begin(), s.end());
if (s == "abc")cout << "Yes";
else cout << "No";
} | ### Prompt
Your task is to create a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(void)
{
string s;
cin >> s;
sort(s.begin(), s.end());
if (s == "abc")cout << "Yes";
else cout << "No";
}
``` |
#include<cstdio>
#define N 5
char s[N];
bool f[N];
int main()
{
scanf("%s",s);
for(int i=0;i<3;i++)
f[int(s[i]-97)]=1;
if(f[0]&&f[1]&&f[2]) printf("Yes\n");
else printf("No\n");
} | ### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<cstdio>
#define N 5
char s[N];
bool f[N];
int main()
{
scanf("%s",s);
for(int i=0;i<3;i++)
f[int(s[i]-97)]=1;
if(f[0]&&f[1]&&f[2]) printf("Yes\n");
else printf("No\n");
}
``` |
#include <iostream>
using namespace std;
int main(){
string s,a;
cin>>s;
if(s.at(0)!=s.at(1)&&s.at(1)!=s.at(2)&&s.at(2)!=s.at(0))cout<<"Yes"<<endl;
else cout<<"No"<<endl;
} | ### Prompt
Construct a Cpp code solution to the problem outlined:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
string s,a;
cin>>s;
if(s.at(0)!=s.at(1)&&s.at(1)!=s.at(2)&&s.at(2)!=s.at(0))cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
sort(s.begin(),s.end());
cout<<(s=="abc"?"Yes":"No");
return 0;
}
| ### Prompt
Please formulate a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
sort(s.begin(),s.end());
cout<<(s=="abc"?"Yes":"No");
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin>>S;
if(S[0]!=S[1]&&S[1]!=S[2]&&S[2]!=S[0]){
cout<<"Yes"<<endl;
}
else{
cout<<"No"<<endl;
}
} | ### Prompt
In cpp, your task is to solve the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin>>S;
if(S[0]!=S[1]&&S[1]!=S[2]&&S[2]!=S[0]){
cout<<"Yes"<<endl;
}
else{
cout<<"No"<<endl;
}
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
cout << (S.at(0) != S.at(1) && S.at(1) != S.at(2) && S.at(0) != S.at(2) ? "Yes" : "No") << endl;
} | ### Prompt
Generate a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
cout << (S.at(0) != S.at(1) && S.at(1) != S.at(2) && S.at(0) != S.at(2) ? "Yes" : "No") << endl;
}
``` |
#include<cstdio>
char s[10];
bool f[500];
int main()
{
scanf("%s",s+1);
for(int i=1;i<=3;i++)
f[s[i]]++;
if(f['a']&&f['b']&&f['c'])
puts("Yes");
else
puts("No");
return 0;
} | ### Prompt
Generate a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<cstdio>
char s[10];
bool f[500];
int main()
{
scanf("%s",s+1);
for(int i=1;i<=3;i++)
f[s[i]]++;
if(f['a']&&f['b']&&f['c'])
puts("Yes");
else
puts("No");
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]*s[1]*s[2]=='a'*'b'*'c') cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
} | ### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]*s[1]*s[2]=='a'*'b'*'c') cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a, b, c; cin >> a >> b >> c;
cout << ((a != b && b != c && c != a) ? "Yes" : "No") << endl;
} | ### Prompt
Please formulate a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
char a, b, c; cin >> a >> b >> c;
cout << ((a != b && b != c && c != a) ? "Yes" : "No") << endl;
}
``` |
#include <iostream>
using namespace std;
int main()
{
string a;
cin>>a;
if(a=="abc"||a=="bac"||a=="acb"||a=="bca"||a=="cab"||a=="cba") cout<<"Yes";
else cout<<"No";
} | ### Prompt
Please formulate a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main()
{
string a;
cin>>a;
if(a=="abc"||a=="bac"||a=="acb"||a=="bca"||a=="cab"||a=="cba") cout<<"Yes";
else cout<<"No";
}
``` |
#include<bits/stdc++.h>
int main(){char s[3];std::cin>>s;std::cout<<((s[0]!=s[1]&&s[1]!=s[2]&&s[0]!=s[2])?"Yes":"No");} | ### Prompt
Develop a solution in Cpp to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
int main(){char s[3];std::cin>>s;std::cout<<((s[0]!=s[1]&&s[1]!=s[2]&&s[0]!=s[2])?"Yes":"No");}
``` |
#include <iostream>
#include <string>
int main() {
std::string S;
std::cin >> S;
sort(S.begin(), S.end());
std::cout << (S == "abc" ? "Yes" : "No") << std::endl;
} | ### Prompt
Your task is to create a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
#include <string>
int main() {
std::string S;
std::cin >> S;
sort(S.begin(), S.end());
std::cout << (S == "abc" ? "Yes" : "No") << std::endl;
}
``` |
#import<ios>
int main(){printf(getchar()^getchar()^getchar()&3?"No":"Yes");} | ### Prompt
Create a solution in Cpp for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#import<ios>
int main(){printf(getchar()^getchar()^getchar()&3?"No":"Yes");}
``` |
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main(){
string a;
cin>>a;
sort(a.begin(),a.end());
if(a=="abc")cout<<"Yes";
else cout<<"No";
} | ### Prompt
Create a solution in CPP for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main(){
string a;
cin>>a;
sort(a.begin(),a.end());
if(a=="abc")cout<<"Yes";
else cout<<"No";
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
sort(s.begin(),s.end());
if(s=="abc")cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return(0);
}
| ### Prompt
Generate a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
sort(s.begin(),s.end());
if(s=="abc")cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return(0);
}
``` |
#include<iostream>
#include<string>
using namespace std;
string s;
int main(void){
cin>>s;
if(s[0]!=s[1]&&s[1]!=s[2]&&s[2]!=s[0])cout<<"Yes";
else cout<<"No";
return 0;
} | ### Prompt
Create a solution in CPP for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
#include<string>
using namespace std;
string s;
int main(void){
cin>>s;
if(s[0]!=s[1]&&s[1]!=s[2]&&s[2]!=s[0])cout<<"Yes";
else cout<<"No";
return 0;
}
``` |
#include <iostream>
using namespace std;
int main() {
char c,x=0;
for (int i = 0; i < 3; ++i) {cin>>c;x^=c;}
cout << (x == '`' ? "Yes" : "No") << endl;
}
| ### Prompt
Generate a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main() {
char c,x=0;
for (int i = 0; i < 3; ++i) {cin>>c;x^=c;}
cout << (x == '`' ? "Yes" : "No") << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin>>s;
if(s[0]!=s[1]&&s[2]!=s[1]&&s[2]!=s[0]) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
} | ### Prompt
Your task is to create a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin>>s;
if(s[0]!=s[1]&&s[2]!=s[1]&&s[2]!=s[0]) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
sort(&s[0],&s[2]+1);
cout << (s=="abc"?"Yes":"No");
return 0;
} | ### Prompt
Develop a solution in Cpp to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
sort(&s[0],&s[2]+1);
cout << (s=="abc"?"Yes":"No");
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
char a,b,c;
cin >> a >> b >> c;
if (a!=b && b!=c && c!=a) cout << "Yes" << endl;
else cout << "No" << endl;
} | ### Prompt
Create a solution in Cpp for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
char a,b,c;
cin >> a >> b >> c;
if (a!=b && b!=c && c!=a) cout << "Yes" << endl;
else cout << "No" << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s.at(0)!=s.at(1)&&s.at(1)!=s.at(2)&&s.at(0)!=s.at(2))cout<<"Yes"<<endl;
else cout<<"No"<<endl;
} | ### Prompt
Your task is to create a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s.at(0)!=s.at(1)&&s.at(1)!=s.at(2)&&s.at(0)!=s.at(2))cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
``` |
#include <iostream>
#include <algorithm>
using namespace std;
string s;
int main()
{
cin >> s;
sort(s.begin(), s.end());
cout << (s == "abc" ? "Yes" : "No");
return 0;
} | ### Prompt
Construct a Cpp code solution to the problem outlined:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
string s;
int main()
{
cin >> s;
sort(s.begin(), s.end());
cout << (s == "abc" ? "Yes" : "No");
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
string S;
cin>>S;
cout<<((S=="abc"||S=="acb"||S=="bac"||S=="bca"||S=="cab"||S=="cba")?"Yes":"No")<<endl;
} | ### Prompt
Please provide a cpp coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
string S;
cin>>S;
cout<<((S=="abc"||S=="acb"||S=="bac"||S=="bca"||S=="cab"||S=="cba")?"Yes":"No")<<endl;
}
``` |
// A - abc of ABC
#include <bits/stdc++.h>
using namespace std;
int main(){
string s; cin>>s;
cout<< (s[0]==s[1] || s[0]==s[2] || s[1]==s[2]? "No":"Yes") <<endl;
} | ### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
// A - abc of ABC
#include <bits/stdc++.h>
using namespace std;
int main(){
string s; cin>>s;
cout<< (s[0]==s[1] || s[0]==s[2] || s[1]==s[2]? "No":"Yes") <<endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
string S; cin >> S;
sort(S.begin(),S.end());
cout << (S=="abc"?"Yes":"No") << endl;
} | ### Prompt
Create a solution in cpp for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
string S; cin >> S;
sort(S.begin(),S.end());
cout << (S=="abc"?"Yes":"No") << endl;
}
``` |
#include <iostream>
using namespace std;
int main(){
string s;
cin >> s;
if(s[0] + s[1] + s[2] == 294)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| ### Prompt
Please provide a cpp coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
string s;
cin >> s;
if(s[0] + s[1] + s[2] == 294)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(void){
string s;
cin >> s;
sort(s.begin(), s.end());
if(s == "abc") cout << "Yes" << endl;
else cout << "No" << endl;
} | ### Prompt
Please provide a Cpp coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(void){
string s;
cin >> s;
sort(s.begin(), s.end());
if(s == "abc") cout << "Yes" << endl;
else cout << "No" << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;cin>>s;set<int>se;se.insert({s[0],s[1],s[2]});
if(se.size()==3) cout<<"Yes";
else cout<<"No";
} | ### Prompt
Your task is to create a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;cin>>s;set<int>se;se.insert({s[0],s[1],s[2]});
if(se.size()==3) cout<<"Yes";
else cout<<"No";
}
``` |
#include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin >> s;
sort(s.begin(),s.end());
if(s=="abc") cout << "Yes" << endl;
else cout << "No" << endl;
} | ### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin >> s;
sort(s.begin(),s.end());
if(s=="abc") cout << "Yes" << endl;
else cout << "No" << endl;
}
``` |
#include<iostream>
int main(){char c,d,e;std::cin>>c>>d>>e;puts(c^d&&c+d+e==294?"Yes":"No");} | ### Prompt
In cpp, your task is to solve the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
int main(){char c,d,e;std::cin>>c>>d>>e;puts(c^d&&c+d+e==294?"Yes":"No");}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]+s[1]+s[2]=='a'+'b'+'c'){
cout<<"Yes"<<endl;
}else{
cout<<"No"<<endl;
}
} | ### Prompt
Your challenge is to write a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if(s[0]+s[1]+s[2]=='a'+'b'+'c'){
cout<<"Yes"<<endl;
}else{
cout<<"No"<<endl;
}
}
``` |
#include "stdio.h"
int main() {
char S[4];
scanf("%s", S);
if (S[0] != S[1] && S[1] != S[2] && S[2] != S[0]) {
puts("Yes");
}
else {
puts("No");
}
return 0;
}
| ### Prompt
Please create a solution in cpp to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include "stdio.h"
int main() {
char S[4];
scanf("%s", S);
if (S[0] != S[1] && S[1] != S[2] && S[2] != S[0]) {
puts("Yes");
}
else {
puts("No");
}
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >>s;
if(s[0]==s[1]||s[0]==s[2]||s[1]==s[2])cout << "No" << endl;
else cout << "Yes" << endl;
return 0;
}
| ### Prompt
Please create a solution in Cpp to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >>s;
if(s[0]==s[1]||s[0]==s[2]||s[1]==s[2])cout << "No" << endl;
else cout << "Yes" << endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if((s[1]==s[2])||(s[2]==s[0])||(s[0]==s[1])) cout<<"No";
else cout<<"Yes";
}
| ### Prompt
Your task is to create a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
if((s[1]==s[2])||(s[2]==s[0])||(s[0]==s[1])) cout<<"No";
else cout<<"Yes";
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
string S;
cin >> S;
if(S[0]!=S[1] && S[1]!=S[2] && S[2]!=S[0]) cout << "Yes";
else cout << "No";
} | ### Prompt
Please create a solution in cpp to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
string S;
cin >> S;
if(S[0]!=S[1] && S[1]!=S[2] && S[2]!=S[0]) cout << "Yes";
else cout << "No";
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
sort(s.begin(),s.end());
if(s!="abc")
cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
| ### Prompt
Please formulate a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
sort(s.begin(),s.end());
if(s!="abc")
cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
``` |
#include <iostream>
int main(){std::string s;std::cin>>s;puts((s[0]+s[1]+s[2]==294)?"Yes":"No");} | ### Prompt
Please provide a CPP coded solution to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
int main(){std::string s;std::cin>>s;puts((s[0]+s[1]+s[2]==294)?"Yes":"No");}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
cout << (S=="abc"||S=="acb"||S=="bac"||S=="bca"||S=="cab"||S=="cba" ? "Yes" : "No") << endl;
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
cout << (S=="abc"||S=="acb"||S=="bac"||S=="bca"||S=="cab"||S=="cba" ? "Yes" : "No") << endl;
}
``` |
#include<iostream>
using namespace std;
int main(){
string S;
cin >> S;
cout << (S[0] == S[1] || S[0] == S[2] || S[1]==S[2] ? "No" : "Yes") << endl;
return 0;
}
| ### Prompt
Generate a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
string S;
cin >> S;
cout << (S[0] == S[1] || S[0] == S[2] || S[1]==S[2] ? "No" : "Yes") << endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(void){
string a;
cin>>a;
sort(a.begin(),a.end());;
cout<<(a=="abc"?"Yes":"No")<<endl;
return 0;
}
| ### Prompt
Create a solution in Cpp for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(void){
string a;
cin>>a;
sort(a.begin(),a.end());;
cout<<(a=="abc"?"Yes":"No")<<endl;
return 0;
}
``` |
#include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin>>s;
sort(s.begin(),s.end());
if(s=="abc")cout<<"Yes\n";
else cout<<"No\n";
} | ### Prompt
In Cpp, your task is to solve the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin>>s;
sort(s.begin(),s.end());
if(s=="abc")cout<<"Yes\n";
else cout<<"No\n";
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
if (S[0]!=S[1] && S[0]!=S[2] && S[1]!=S[2]) cout << "Yes\n";
else cout << "No\n";
} | ### Prompt
Your challenge is to write a Cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
if (S[0]!=S[1] && S[0]!=S[2] && S[1]!=S[2]) cout << "Yes\n";
else cout << "No\n";
}
``` |
#include <iostream>
using namespace std ;
int main()
{
string s;
cin>>s;
if(s[0]+s[1]+s[2]==294)
cout<<"Yes";
else cout<<"No";
return 0;
}
| ### Prompt
In cpp, your task is to solve the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std ;
int main()
{
string s;
cin>>s;
if(s[0]+s[1]+s[2]==294)
cout<<"Yes";
else cout<<"No";
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s,ans="No";cin>>s;
sort(s.begin(), s.end());
if(s=="abc")ans="Yes";
cout <<ans<<endl;
} | ### Prompt
In CPP, your task is to solve the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s,ans="No";cin>>s;
sort(s.begin(), s.end());
if(s=="abc")ans="Yes";
cout <<ans<<endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin >> s;
if(s[0] != s[1] && s[1] != s[2] && s[0] != s[2]) printf("Yes");
else printf("No");
return 0;
}
| ### Prompt
Please create a solution in CPP to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin >> s;
if(s[0] != s[1] && s[1] != s[2] && s[0] != s[2]) printf("Yes");
else printf("No");
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s ;
cin >> s;
sort ( s.begin() , s.end() );
cout << ( s == "abc" ? "Yes" : "No" ) << endl;
} | ### Prompt
Develop a solution in cpp to the problem described below:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s ;
cin >> s;
sort ( s.begin() , s.end() );
cout << ( s == "abc" ? "Yes" : "No" ) << endl;
}
``` |
#include <iostream>
using namespace std;
int main() {
string s;
cin>>s ;
if(s[0]==s[1] || s[0]==s[2]||s[1]==s[2])
{
cout<<"No";
}
else {cout<<"Yes" ;}
return 0;
}
| ### Prompt
In cpp, your task is to solve the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main() {
string s;
cin>>s ;
if(s[0]==s[1] || s[0]==s[2]||s[1]==s[2])
{
cout<<"No";
}
else {cout<<"Yes" ;}
return 0;
}
``` |
#include <stdio.h>
int main(void)
{
char s[4];
scanf("%s",s);
if(s[0]!=s[1] && s[0]!=s[2] && s[1]!=s[2]){
printf("Yes\n");
}else{
printf("No\n");
}
return 0;
} | ### Prompt
Create a solution in Cpp for the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <stdio.h>
int main(void)
{
char s[4];
scanf("%s",s);
if(s[0]!=s[1] && s[0]!=s[2] && s[1]!=s[2]){
printf("Yes\n");
}else{
printf("No\n");
}
return 0;
}
``` |
#include <iostream>
using namespace std;
int main(){
string S;
cin >> S;
if(S[0]!=S[1] && S[1]!=S[2] && S[2]!=S[0]){
cout << "Yes";
return 0;
}
cout << "No";
return 0;
} | ### Prompt
Your task is to create a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
string S;
cin >> S;
if(S[0]!=S[1] && S[1]!=S[2] && S[2]!=S[0]){
cout << "Yes";
return 0;
}
cout << "No";
return 0;
}
``` |
#include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin >> s;
sort(s.begin(), s.end());
if (s == "abc") puts("Yes");
else puts("No");
} | ### Prompt
Your challenge is to write a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin >> s;
sort(s.begin(), s.end());
if (s == "abc") puts("Yes");
else puts("No");
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main () {
string s;
cin >> s;
sort(s.begin(), s.end());
string ans = "No";
if(s == "abc") ans = "Yes";
cout << ans << endl;
} | ### Prompt
Generate a cpp solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main () {
string s;
cin >> s;
sort(s.begin(), s.end());
string ans = "No";
if(s == "abc") ans = "Yes";
cout << ans << endl;
}
``` |
#include <iostream>
using namespace std;
int main()
{
char a, s, d;
cin >> a >> s >> d;
if(a!=s&&a!=d&&s!=d)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include <iostream>
using namespace std;
int main()
{
char a, s, d;
cin >> a >> s >> d;
if(a!=s&&a!=d&&s!=d)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
``` |
#include<cstdio>
char c;
int a[10];
int main()
{
for(int i=0;i<3;i++)
{
scanf("%c",&c);
a[c-'a']++;
}
if(a[0]==1&&a[1]==1&&a[2]==1)printf("Yes");
else
printf("No");
return 0;
} | ### Prompt
Your challenge is to write a CPP solution to the following problem:
You are given a string S of length 3 consisting of `a`, `b` and `c`. Determine if S can be obtained by permuting `abc`.
Constraints
* |S|=3
* S consists of `a`, `b` and `c`.
Input
Input is given from Standard Input in the following format:
S
Output
If S can be obtained by permuting `abc`, print `Yes`; otherwise, print `No`.
Examples
Input
bac
Output
Yes
Input
bab
Output
No
Input
abc
Output
Yes
Input
aaa
Output
No
### Response
```cpp
#include<cstdio>
char c;
int a[10];
int main()
{
for(int i=0;i<3;i++)
{
scanf("%c",&c);
a[c-'a']++;
}
if(a[0]==1&&a[1]==1&&a[2]==1)printf("Yes");
else
printf("No");
return 0;
}
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.