text
stringlengths 291
465k
|
|---|
### Prompt
Your challenge is to write a cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>
using namespace std;
vector<string> tokenize(string s) {
vector<string> ret;
int beg = 0;
for(int i=1; i<s.length(); ++i) {
if(s[i] == '_') {
ret.push_back(s.substr(beg,i-beg));
beg = i+1;
}
if(s[i] <= 'Z' && s[i] >= 'A') {
ret.push_back(s.substr(beg,i-beg));
beg = i;
}
}
if(beg < s.length()) ret.push_back(s.substr(beg));
return ret;
}
string toL(vector<string> sv) {
string ret;
sv[0][0] = tolower(sv[0][0]);
ret += sv[0];
for(int i=1; i<sv.size(); ++i) {
sv[i][0] = toupper(sv[i][0]);
ret += sv[i];
}
return ret;
}
string toU(vector<string> sv) {
string ret;
for(int i=0; i<sv.size(); ++i) {
sv[i][0] = toupper(sv[i][0]);
ret += sv[i];
}
return ret;
}
string toD(vector<string> sv) {
string ret;
sv[0][0] = tolower(sv[0][0]);
ret += sv[0];
for(int i=1; i<sv.size(); ++i) {
ret += "_";
sv[i][0] = tolower(sv[i][0]);
ret += sv[i];
}
return ret;
}
int main() {
string input,op;
while(cin>>input>>op) {
if(op == "X") break;
vector<string> tokens;
tokens = tokenize(input);
if(op == "U") cout<<toU(tokens)<<endl;
else if(op == "L") cout<<toL(tokens)<<endl;
else if(op == "D") cout<<toD(tokens)<<endl;
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
char s[101], o;
while (cin >> s >> o)
{
if (o == 'X') break;
int k = 0, u = 0;
char t[100][101] = {""};
t[k][u] = ('A' <= s[0] && s[0] <= 'Z') ? s[0]-'A'+'a' : s[0];
++u;
for (int i = 1; i < strlen(s); ++i)
{
if ('A' <= s[i] && s[i] <= 'Z')
{
t[k][u] = '\0';
++k, u = 0;
t[k][u] = s[i]-'A'+'a';
++u;
}
else if (s[i] == '_')
{
t[k][u] = '\0';
++k, u = 0;
}
else if (s[i] == '\0')
{
t[k][u] = '\0';
break;
}
else
{
t[k][u] = s[i];
++u;
}
}
int m = k;
k = 0;
char r[201] = "";
if (o == 'U' || o == 'L')
{
for (int i = 0; i <= m; ++i)
{
for (int j = 0; j < strlen(t[i]); ++j)
{
if (i == 0 && j == 0) r[k] = (o == 'U') ? 'A'+t[i][j]-'a' : t[i][j];
else if (j == 0) r[k] = 'A'+t[i][j]-'a';
else r[k] = t[i][j];
++k;
}
}
r[k] = '\0';
}
else
{
for (int i = 0; i <= m; ++i)
{
for (int j = 0; j < strlen(t[i]); ++j)
{
r[k] = t[i][j];
++k;
}
r[k] = '_';
++k;
}
r[k-1] = '\0';
}
cout << r << endl;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
#include <cctype>
using namespace std;
int main(void) {
string s;
char c;
while(1) {
cin >> s >> c;
if(c == 'X') break;
switch(c) {
case 'U':
for(int i = 0; i < s.length(); i++) {
if(i == 0) cout << (char)toupper(s[i]);
else if(s[i] == '_') cout << (char)toupper(s[++i]);
else cout << s[i];
}
break;
case 'L':
for(int i = 0; i < s.length(); i++) {
if(i == 0) cout << (char)tolower(s[i]);
else if(s[i] == '_') cout << (char)toupper(s[++i]);
else cout << s[i];
}
break;
case 'D':
for(int i = 0; i < s.length(); i++) {
if(i == 0) cout << (char)tolower(s[i]);
else if(isupper(s[i])) cout << '_' << (char)tolower(s[i]);
else cout << s[i];
}
break;
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<cstring>
#include<cstdio>
#include<string>
#include<vector>
#include<algorithm>
#include<iostream>
using namespace std;
char change1(char a){
if('A'<=a && a<='Z')
return a;
else
return a+'A'-'a';
}
char change2(char a){
if('a'<=a && a<='z')
return a;
else
return a+'a'-'A';
}
int main(){
while(1){
string name,type;
vector<string> word;
cin >> name >> type;
if(type=="X") break;
int st = 0;
name += "_";
for(int i=1;i<(int)name.size();i++){
if(name[i]=='_'){
word.push_back(name.substr(st,i-st));
st = i+1;
} else if('A'<=name[i] && name[i]<='Z'){
word.push_back(name.substr(st,i-st));
st = i;
}
}
if(type=="L"){
for(int i=0;i<(int)word.size();i++){
if(i==0) word[i][0]=change2(word[i][0]);
else word[i][0]=change1(word[i][0]);
cout << word[i];
}
} else if(type=="U"){
for(int i=0;i<(int)word.size();i++){
word[i][0]=change1(word[i][0]);
cout << word[i];
}
} else {
for(int i=0;i<(int)word.size();i++){
word[i][0]=change2(word[i][0]);
cout << word[i];
if(i!=(int)word.size()-1) cout << "_";
}
}
cout << endl;
}
}
``` |
### Prompt
Please formulate a JAVA solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.Scanner;
//CamelCase
public class Main{
void run(){
Scanner sc = new Scanner(System.in);
while(true){
String s = sc.next();
char ch = sc.next().charAt(0);
if(ch=='X')break;
char f = Character.isUpperCase(s.charAt(0))?'U':s.contains("_")?'D':'L';
StringBuilder sb = new StringBuilder();
char[] t = s.toCharArray();
if(f==ch)sb.append(s);
else if(f=='U'){
if(ch=='L'){
t[0] = Character.toLowerCase(t[0]);
sb.append(t);
}
else{
t[0] = Character.toLowerCase(t[0]);
for(int i=0;i<t.length;i++){
if(Character.isUpperCase(t[i]))sb.append('_');
sb.append(Character.toLowerCase(t[i]));
}
}
}
else if(f=='L'){
if(ch=='U'){
t[0] = Character.toUpperCase(t[0]);
sb.append(t);
}
else{
for(int i=0;i<t.length;i++){
if(Character.isUpperCase(t[i]))sb.append('_');
sb.append(Character.toLowerCase(t[i]));
}
}
}
else{
if(ch=='U'){
sb.append(Character.toUpperCase(t[0]));
for(int i=1;i<t.length;i++){
if(t[i]=='_'){
i++;
sb.append(Character.toUpperCase(t[i]));
}
else sb.append(t[i]);
}
}
else{
for(int i=0;i<t.length;i++){
if(t[i]=='_'){
i++;
sb.append(Character.toUpperCase(t[i]));
}
else sb.append(t[i]);
}
}
}
System.out.println(sb);
}
}
public static void main(String[] args) {
new Main().run();
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <bits/stdc++.h>
#define reps(v, f, l) for (int v = (f), v##_ = (l); v < v##_; ++v)
#define rep(v, n) reps(v, 0, n)
#define lep(v, n) reps(v, 1, n + 1)
using namespace std;
typedef long long int lint;
static inline int in(){ int x; scanf("%d", &x); return x; }
static inline lint inl(){ lint x; scanf("%lld", &x); return x; }
template<typename T> void show(T& a, char del='\n', char last='\n'){ rep(i, a.size() - 1) cout << a[i] << del; cout << a[a.size() - 1] << last; }
int main()
{
string n;
char type;
while (cin >> n >> type, type != 'X'){
rep(i, n.size()){
if (type == 'U'){
if (i == 0){
putchar(toupper(n[i]));
}
else if (n[i] == '_'){
putchar(toupper(n[i + 1]));
i++;
}
else {
putchar(n[i]);
}
}
if (type == 'L'){
if (i == 0){
putchar(tolower(n[i]));
}
else if (n[i] == '_'){
putchar(toupper(n[i + 1]));
i++;
}
else {
putchar(n[i]);
}
}
if (type == 'D'){
if (i == 0){
putchar(tolower(n[i]));
}
else if (isupper(n[i])){
putchar('_');
putchar(tolower(n[i]));
}
else {
putchar(n[i]);
}
}
}
puts("");
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
int main(void){
string s1, s2;
while(true){
//scanf("%s %s", s1, s2);
cin >> s1 >> s2;
if(s2 == "X") break;
if(s2 == "D"){
for(int i = 1; i < s1.size(); i++){
if(isupper(s1[i])) s1.insert(i++, "_");
}
for(int i = 0; i < s1.size(); i++){
s1[i] = tolower(s1[i]);
}
cout << s1 << endl;
}
else{
for(int i = 0; i < s1.size(); i++){
if(s1[i] == '_'){
s1[i + 1] = toupper(s1[i + 1]);
s1.erase(i, 1);
}
}
if(s2 == "U"){
s1[0] = toupper(s1[0]);
cout << s1 << endl;
}
else{
s1[0] = tolower(s1[0]);
cout << s1 << endl;
}
}
}
}
``` |
### Prompt
Create a solution in CPP for the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
//37
#include<iostream>
#include<string>
#include<sstream>
#include<cctype>
using namespace std;
int main(){
string s;
char c;
while(cin>>s>>c,c!='X'){
s[0]=tolower(s[0]);
string su;
for(int i=0;i<s.size();i++){
if(isupper(s[i])){
su+='_';
}
su+=tolower(s[i]);
}
if(c=='D'){
cout<<su<<endl;
}else{
string so;
bool f=false;
for(int i=0;i<su.size();i++){
if(su[i]=='_'){
f=true;
}else{
so+=(f)?toupper(su[i]):tolower(su[i]);
f=false;
}
}
if(c=='U'){
so[0]=toupper(so[0]);
}
cout<<so<<endl;
}
}
return 0;
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <stdio.h>
#include<math.h>
#include <algorithm>
using namespace std;
int main(){
char buf[101],result[500],type;
int p,i;
while(true){
scanf("%s %c",buf,&type);
if(type == 'X')break;
p = 0;
switch(type){
case 'U':
for(i = 0;buf[i] != '\0';){
if(i == 0){
if(buf[i] >= 97 && buf[i] <= 122){
result[p++] = buf[i] - 32;
}else{
result[p++] = buf[i];
}
i++;
}else if(buf[i] == '_'){
i++;
if(buf[i] >= 97 && buf[i] <= 122){
result[p++] = buf[i] - 32;
}else{
result[p++] = buf[i];
}
i++;
}else{
if(buf[i] >= 65 && buf[i] <= 90){
result[p++] = buf[i];
}else{
result[p++] = buf[i];
}
i++;
}
}
result[p] = '\0';
printf("%s\n",result);
break;
case 'L':
for(i = 0;buf[i] != '\0';){
if(i == 0){
if(buf[i] >= 65 && buf[i] <= 90){
result[p++] = buf[i] + 32;
}else{
result[p++] = buf[i];
}
i++;
}else if(buf[i] == '_'){
i++;
if(buf[i] >= 97 && buf[i] <= 122){
result[p++] = buf[i] - 32;
}else{
result[p++] = buf[i];
}
i++;
}else{
if(buf[i] >= 65 && buf[i] <= 90){
result[p++] = buf[i];
}else{
result[p++] = buf[i];
}
i++;
}
}
result[p] = '\0';
printf("%s\n",result);
break;
case 'D':
for(i = 0;buf[i] != '\0';){
if(i == 0){
if(buf[i] >= 65 && buf[i] <= 90){
result[p++] = buf[i] + 32;
}else{
result[p++] = buf[i];
}
i++;
}else if(buf[i] == '_'){
result[p++] = buf[i];
i++;
}else{
if(buf[i] >= 65 && buf[i] <= 90){
result[p++] = '_';
result[p++] = buf[i] + 32;
}else{
result[p++] = buf[i];
}
i++;
}
}
result[p] = '\0';
printf("%s\n",result);
break;
}
}
return 0;
}
``` |
### Prompt
Please create a solution in JAVA to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
new Main().run();
}
void run(){
Scanner sc=new Scanner(System.in);
while(true){
char ch[]=sc.next().toCharArray();
String type=sc.next();
if(type.equals("X")) break;
int now=typeCheck(ch);
if(type.equals("U")){
System.out.println(Uchange(ch, now));
}
else if(type.equals("L")){
System.out.println(Lchange(ch, now));
}
else if(type.equals("D")){
System.out.println(Dchange(ch, now));
}
}
}
int typeCheck(char ch[]){
for(int i=0; i<ch.length; i++){
if(ch[i]=='_'){
return 2;
}
}
if(Character.isUpperCase(ch[0])){
return 0;
}
else return 1;
}
String Uchange(char ch[],int now){
if(now==0){//テ・ツ?・テ・ツ環崚」ツ?袈
//テ」ツ?敕」ツ?ョテ」ツ?セテ」ツ?セテ」ツ?ァOK
return String.valueOf(ch);
}
else if(now==1){//テ・ツ?・テ・ツ環崚」ツ?鍬
ch[0]=Character.toUpperCase(ch[0]);
return String.valueOf(ch);
}
else if(now==2){//テ・ツ?・テ・ツ環崚」ツ?轡
String str="";
ch[0]=Character.toUpperCase(ch[0]);
str+=String.valueOf(ch[0]);
for(int i=1; i<ch.length; i++){
if(ch[i]=='_'){
i++;
ch[i]=Character.toUpperCase(ch[i]);
str+=String.valueOf(ch[i]);
}
else{
str+=String.valueOf(ch[i]);
}
}
return str;
}
return "NG";
}
String Lchange(char ch[],int now){
if(now==0){//テ・ツ?・テ・ツ環崚」ツ?袈
ch[0]=Character.toLowerCase(ch[0]);
return String.valueOf(ch);
}
else if(now==1){//テ・ツ?・テ・ツ環崚」ツ?鍬
//テ」ツ?敕」ツ?ョテ」ツ?セテ」ツ?セテ」ツ?ァOK
return String.valueOf(ch);
}
else if(now==2){//テ・ツ?・テ・ツ環崚」ツ?轡
String str="";
for(int i=0; i<ch.length; i++){
if(ch[i]=='_'){
i++;
ch[i]=Character.toUpperCase(ch[i]);
str+=String.valueOf(ch[i]);
}
else{
str+=String.valueOf(ch[i]);
}
}
return str;
}
return "NG";
}
String Dchange(char ch[],int now){
if(now==0){//テ・ツ?・テ・ツ環崚」ツ?袈
ch[0]=Character.toLowerCase(ch[0]);
String str="";
str+=ch[0];
for(int i=1; i<ch.length; i++){
if(Character.isUpperCase(ch[i])){
str+="_";
str+=String.valueOf(Character.toLowerCase(ch[i]));
}
else{
str+=String.valueOf(ch[i]);
}
}
return str;
}
else if(now==1){//テ・ツ?・テ・ツ環崚」ツ?鍬
String str="";
for(int i=0; i<ch.length; i++){
if(Character.isUpperCase(ch[i])){
str+="_";
str+=String.valueOf(Character.toLowerCase(ch[i]));
}
else{
str+=String.valueOf(ch[i]);
}
}
return str;
}
else if(now==2){//テ・ツ?・テ・ツ環崚」ツ?轡
//テ」ツ?敕」ツ?ョテ」ツ?セテ」ツ?セテ」ツ?ァOK
return String.valueOf(ch);
}
return "NG";
}
}
``` |
### Prompt
Create a solution in python3 for the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
while True:
Name, Type = input().split()
if Type=='X':
break
if '_' in Name:
Name_ = Name
_n_ = [0]
i = 0
while True:
Namelist_ = list(Name_)
n_ = Name_.find('_')
if n_==-1:
break
_n_.append(n_+_n_[i])
i += 1
del(Namelist_[0:n_+1])
Name_ = ''.join(Namelist_)
Name = ''.join(Name.split('_'))
Namelist = list(Name)
for i in range(len(_n_)):
o = str(Namelist[_n_[i]])
O = o.upper()
Namelist.pop(_n_[i])
Namelist.insert(_n_[i],O)
Name = ''.join(Namelist)
if Type=='U':
NameLIST = list(Name)
o = str(NameLIST[0])
O = o.upper()
NameLIST.pop(0)
NameLIST.insert(0,O)
NAME = ''.join(NameLIST)
if Type=='L':
NameLIST = list(Name)
O = str(NameLIST[0])
o = O.lower()
NameLIST.pop(0)
NameLIST.insert(0,o)
NAME = ''.join(NameLIST)
if Type=='D':
NameLIST = list(Name)
_T_ = []
t = 0
for i in range(len(NameLIST)):
T = str(NameLIST[i])
if T.isupper()==False:
pass
if T.isupper()==True:
if i==0:
pass
if i>0:
_T_.append(i+t)
t += 1
Tt = T.lower()
NameLIST.pop(i)
NameLIST.insert(i,Tt)
for i in range(len(_T_)):
NameLIST.insert(_T_[i],'_')
NAME = ''.join(NameLIST)
print(NAME)
``` |
### Prompt
Please provide a python coded solution to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python
upp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
low = "abcdefghijklmnopqrstuvwxyz"
while 1:
a,type = raw_input().split()
if type == "X": break
ans = ""
if type == "U":
if "_" in a:
words = a.split("_")
for word in words:
ans += upp[low.index(word[0])] + word[1:]
else:
ans = upp[low.index(a[0])] + a[1:] if a[0] in low else a
elif type == "L":
if "_" in a:
words = a.split("_")
ans += words[0]
for word in words[1:]:
ans += upp[low.index(word[0])] + word[1:]
else:
ans = low[upp.index(a[0])] + a[1:] if a[0] in upp else a
else:
if "_" not in a:
words = []
sp = 0
for i in range(1,len(a)):
if a[i] in upp:
words.append(a[sp:i].lower())
sp = i
words.append(a[sp:].lower())
ans = "_".join(words)
else:
ans = a
print ans
``` |
### Prompt
Please create a solution in Java to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.Scanner;
public class Main
{
public static void main(String arg[])
{
Scanner in=new Scanner(System.in);
for(;;)
{
char ch[]=in.next().toCharArray();
String ans="";
String st=in.next();
if(st.equals("X"))
return;
else if(st.equals("U"))
for(int i=0;i<ch.length;i++)
{
if(ch[i]=='_')
{
ans+=(ch[i+1]+"").toUpperCase();
i++;
}
else
{
String tmp=ch[i]+"";
if(i==0)
ans+=tmp.toUpperCase();
else
ans+=tmp;
}
}
else if(st.equals("L"))
for(int i=0;i<ch.length;i++)
{
if(ch[i]=='_')
{
ans+=(ch[i+1]+"").toUpperCase();
i++;
}
else
{
String tmp=ch[i]+"";
if(i==0)
ans+=tmp.toLowerCase();
else
ans+=tmp;
}
}
else if(st.equals("D"))
for(int i=0;i<ch.length;i++)
{
if(i!=0&&Character.isUpperCase(ch[i]))
{
ans+="_";
ans+=(ch[i]+"").toLowerCase();
}
else
ans+=(ch[i]+"").toLowerCase();
}
System.out.println(ans);
}
}
}
``` |
### Prompt
Create a solution in cpp for the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<sstream>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<utility>
#include<numeric>
#include<algorithm>
#include<bitset>
#include<complex>
using namespace std;
typedef long long Int;
typedef vector<int> vint;
typedef pair<int,int> pint;
#define mp make_pair
template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }
template<class T> void chmin(T &t, T f) { if (t > f) t = f; }
template<class T> void chmax(T &t, T f) { if (t < f) t = f; }
int in() { int x; scanf("%d", &x); return x; }
int main() {
string name,type;
int i;
while(cin>>name>>type,type!="X"){
if(isupper(name[0])){
if(type=="U"){
cout<<name<<endl;
}else if(type=="L"){
name[0]^=' ';
cout<<name<<endl;
}else{
cout<<(char)(name[0]^' ');
for(i=1;i<name.size();i++){
if(isupper(name[i])){
cout<<"_"<<(char)(name[i]^' ');
}else{
cout<<name[i];
}
}
cout<<endl;
}
}else if(name.find("_")==string::npos){
if(type=="U"){
name[0]^=' ';
cout<<name<<endl;
}else if(type=="L"){
cout<<name<<endl;
}else{
for(i=0;i<name.size();i++){
if(isupper(name[i])){
cout<<"_"<<(char)(name[i]^' ');
}else{
cout<<name[i];
}
}
cout<<endl;
}
}else{
if(type=="U"){
cout<<(char)(name[0]^' ');
for(i=1;i<name.size();i++){
if(name[i]=='_'){
cout<<(char)(name[++i]^' ');
}else{
cout<<name[i];
}
}
cout<<endl;
}else if(type=="L"){
for(i=0;i<name.size();i++){
if(name[i]=='_'){
cout<<(char)(name[++i]^' ');
}else{
cout<<name[i];
}
}
cout<<endl;
}else{
cout<<name<<endl;
}
}
}
return 0;
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <cstring>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <fstream>
#include <complex>
#include <stack>
#include <queue>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
static const double EPS = 1e-5;
#define FOR(i,k,n) for (int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
int main(void){
string name,type;
while(cin>>name>>type){
if(type=="X") break;
if(type=="D"){
FOR(i,1,name.size()){
if(isupper(name[i])){
name.insert(i++,"_");
}
}
REP(i,name.size())
name[i] = tolower(name[i]);
cout<<name<<endl;
}else{
REP(i,name.size()){
if(name[i]=='_'){
name[i+1] = toupper(name[i+1]);
name.erase(i,1);
}
}
if(type=="U"){
name[0] = toupper(name[0]);
cout<<name<<endl;
}else{
name[0] = tolower(name[0]);
cout<<name<<endl;
}
}
}
return 0;
}
``` |
### Prompt
In PYTHON, your task is to solve the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python
#!/usr/bin/env python
from collections import deque
import itertools as it
import sys
import math
sys.setrecursionlimit(10000000)
while True:
S, tp = raw_input().split()
if tp == 'X':
break
if tp == 'L':
if '_' in S:
ls = S.split('_')
S = ''
for s in ls:
S += chr(ord('A') + ord(s[0]) - ord('a')) + s[1:]
if 0 <= ord(S[0]) - ord('A') < 26:
S = chr(ord('a') + ord(S[0]) - ord('A')) + S[1:]
if tp == 'U':
if '_' in S:
ls = S.split('_')
S = ''
for s in ls:
S += chr(ord('A') + ord(s[0]) - ord('a')) + s[1:]
if 0 <= ord(S[0]) - ord('a') < 26:
S = chr(ord('A') + ord(S[0]) - ord('a')) + S[1:]
if tp == 'D':
for i in range(26):
S = S.replace(chr(ord('A') + i), '_' + chr(ord('a') + i))
if S[0] == '_':
S = S[1:]
print S
``` |
### Prompt
Generate a JAVA solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.lang.ArrayIndexOutOfBoundsException;
/**
* @author yoshikyoto
*/
class Main extends MyUtil{
public static ArrayList<ArrayList<Integer>> g;
// 0=48 9=57 A=65 Z=90 a=97 z=122
public static boolean isUpper(char c){return 'A'<=c&&c<='Z';}
public static boolean isLower(char c){return 'a'<=c&&c<='z';}
public static char toUpper(char c){
if(isLower(c)) return (char)(c - 'a' + 'A');
return c;
}
public static char toLower(char c){
if(isUpper(c)) return (char)(c - 'A' + 'a');
return c;
}
public static void main(String[] args) throws Exception{
while(true){
String[] strs = readLine().split(" ");
if(strs[1].equals("X")) return;
ArrayList<String> arr = new ArrayList<String>();
char c = strs[0].charAt(0);
if(strs[1].equals("U")) c = toUpper(c);
else c = toLower(c);
String str = "" + c;
for(int i = 1; i < strs[0].length(); i++){
c = strs[0].charAt(i);
if(isUpper(c)){
arr.add(str);
if(strs[1].equals("D")) c = toLower(c);
else c = toUpper(c);
str = "" + c;
}else if(c == '_'){
arr.add(str);
i++;
c = strs[0].charAt(i);
if(strs[1].equals("D")) c = toLower(c);
else c = toUpper(c);
str = "" + c;
}else{
str += c;
}
}
arr.add(str);
pr(arr.get(0));
for(int i = 1; i < arr.size(); i++){
if(strs[1].equals("D")) pr("_");
pr(arr.get(i));
}
p("");
}
}
}
class Data extends MyUtil{
public int i, u, a, p;
Data(String str){
String strs[] = str.split(" ");
i = parseInt(strs[0]);
u = parseInt(strs[1]);
a = parseInt(strs[2]);
p = parseInt(strs[3]);
}
}
class DataComparator implements Comparator<Data>{
//比較メソッド（データクラスを比較して-1, 0, 1を返すように記述する）
public int compare(Data a, Data b) {
// a > b で昇順、a < b で降順
if (a.a < b.a) {
// 正解数が多い方が上位
return 1;
} else if (a.a > b.a) {
return -1;
} else {
// 正解数が同じ場合、ペナルティが小さいほうが上位
if(a.p > b.p){
return 1;
}else if(a.p < b.p){
return -1;
}else{
// 最終的にIDが小さいほうが上位
if(a.i > b.i){
return 1;
}else{
return -1;
}
}
}
}
}
/**
* UnionFindTree Set周りは未実装
* @author yoshikyoto
*/
class UnionFindTree{
public int[] parent, rank;
public int n;
public Set<Integer> set;
// 初期化
UnionFindTree(int _n){
n = _n;
for(int i = 0; i < n; i++){
parent = new int[n];
rank = new int[n];
parent[i] = i;
rank[i] = 0;
}
}
// 根を求める
int find(int x){
if(parent[x] == x){
return x;
}else{
return parent[x] = find(parent[x]);
}
}
// xとyの集合を結合
void unite(int x, int y){
x = find(x);
y = find(y);
if(x == y){
return;
}
if(rank[x] < rank[y]){
parent[x] = y;
}else{
parent[y] = x;
if(rank[x] == rank[y]) rank[x]++;
}
}
// xとyが同じ集合か
boolean same(int x, int y){
return find(x) == find(y);
}
};
/**
* 整数を数え上げたりするクラス
* new Prime(int n) でnまでエラトステネスの篩を実行。
* @author yoshikyoto
* @param a[i] iが素数の時true
* @param count[i] i以下の素数の数
*/
class Prime{
boolean[] a;
int[] count;
Prime(int n){
a = new boolean[n+1];
a[0] = false; a[1] = false;
for(int i = 2; i <= n; i++) a[i] = true;
// ふるい
for(int i = 2; i < (n - 3) / 2; i++)
if(a[i]) for(int j = 2; j * i <= n; j++)
a[j * i] = false;
// 数え上げ
count = new int[n+1];
count[0] = 0;
for(int i = 1; i <= n; i++){
int gain = 0;
if(a[i]) gain = 1;
count[i] = count[i-1] + gain;
}
}
}
class AI extends ArrayList<Integer>{}
class SI extends Stack<Integer>{}
class CountHashMap<E> extends HashMap<E, Integer>{
ArrayList<E> keyArray = new ArrayList<E>();
public void add(E key){add(key, 1);}
public void add(E key, Integer value){
if(containsKey(key)){value += get(key);
}else{keyArray.add(key);}
put(key, value);
}
}
class HM extends CountHashMap<String>{}
class Q<E> extends ArrayDeque<E>{
public void push(E item){add(item);}
public E pop(){return poll();}
}
class QS extends Q<String>{}
class QI extends Q<Integer>{}
/**
* MyUtil
* @author yoshikyoto
*/
class MyUtil extends MyIO{
public static Random rand = new Random();
public static long start_time = 0;
public static void start(){start_time = System.currentTimeMillis();}
public static void end(){
if(start_time == 0) return;
long time = System.currentTimeMillis() - start_time;
if(DEBUG) p(time + "ms");
}
public static int digit(int n){return String.valueOf(n).length();}
public static String reverse(String s){
StringBuffer sb = new StringBuffer(s);
return sb.reverse().toString();
}
public static void sort(int[] a){Arrays.sort(a);}
public static void dsort(int[] a){
Arrays.sort(a);
int l = a.length;
for(int i = 0; i < l/2; i++){
int tmp = a[i]; a[i] = a[l-1-i]; a[l-1-i] = tmp;
}
}
public static void sleep(int t){try{Thread.sleep(t);}catch(Exception e){}}
public static int sum(int[] a){int s = 0; for(int i = 0; i < a.length; i++)s+=a[i]; return s;}
public static int[] cp(int[] a){
int[] b = new int[a.length];
for(int i = 0; i < a.length; i++) b[i] = a[i];
return b;
}
public static int randomInt(int min, int max){return min + rand.nextInt(max - min + 1);}
static boolean inside(int y, int x, int h, int w){return 0 <= y && y <= (h-1) && 0 <= x && x <= (w-1);};
}
/**
* MyIO
* @author yoshikyoto
*/
class MyIO extends MyMath{
static Scanner sc = new Scanner(new InputStreamReader(System.in));
public static char scNextChar(){return sc.next().charAt(0);}
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
public static boolean DEBUG = false;
public static String line;
public static void debug(){DEBUG = !DEBUG;};
public static int[] readIntMap() throws IOException{return parseInt(readLine().split(" "));}
public static int[] readNoDistIntMap() throws IOException{
String[] strs = readLine().split("");
int l = strs.length;
int[] ret = new int[l-1];
for(int i = 1; i < l; i++)
ret[i-1] = parseInt(strs[i]);
return ret;
}
public static boolean readToLine() throws IOException{return (line = br.readLine()) != null;}
public static String readLine() throws IOException{return br.readLine();}
public static int readInt() throws IOException{return Integer.parseInt(br.readLine());}
public static void p(Object o){System.out.println(o.toString());}
public static void pr(Object o){System.out.print(o.toString());}
public static void d(Object o){if(DEBUG)System.out.println(o.toString());}
public static void dr(Object o){if(DEBUG)System.out.print(o.toString());}
public static void da(Object[] o){if(DEBUG)System.out.println(Arrays.toString(o));}
public static void da(int[] arr){if(DEBUG)System.out.println(Arrays.toString(arr));}
public static void da(double[] arr){if(DEBUG)System.out.println(Arrays.toString(arr));}
public static void da(boolean[] arr){if(DEBUG)System.out.println(Arrays.toString(arr));}
public static int[] parseInt(String[] arr){
int[] res = new int[arr.length];
for(int i = 0; i < arr.length; i++)res[i] = Integer.parseInt(arr[i]);
return res;
}
public static double[] parseDouble(String[] arr){
double[] res = new double[arr.length];
for(int i = 0; i < arr.length; i++)res[i] = Double.parseDouble(arr[i]);
return res;
}
public static boolean[] parseBool(String[] arr){
int[] t = parseInt(arr);
boolean[] res = new boolean[t.length];
for(int i = 0; i < t.length; i++){
if(t[i] == 1){res[i] = true;
}else{res[i] = false;}
}
return res;
}
public static int parseInt(Object o){return Integer.parseInt(o.toString());}
public static PrintWriter getFilePrintWriter(String file) throws IOException{
FileWriter fw = new FileWriter(file);
BufferedWriter bw = new BufferedWriter(fw);
PrintWriter pw = new PrintWriter(bw);
return pw;
}
public static BufferedReader getFileBufferdReader(String file) throws FileNotFoundException{
FileReader fr = new FileReader(file);
BufferedReader br = new BufferedReader(fr);
return br;
}
}
class MyMath{
/**
* 弧度法の角度を入力してsinの値を返す（Math.sin の入力はラジアン）
*/
public static double sin(int r){return Math.sin(Math.toRadians(r));}
/**
* 弧度法の角度を入力してcosの値を返す（Math.sin の入力はラジアン）
*/
public static double cos(int r){return Math.cos(Math.toRadians(r));}
public static int max(int a, int b){return Math.max(a, b);}
public static int min(int a, int b){return Math.min(a, b);}
public static boolean isCross(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4){
// 並行な場合
int m = (x2-x1)*(y4-y3)-(y2-y1)*(x4-x3);
if(m == 0) return false;
// 媒介変数の値が0より大きく1以下なら交差する、これは問題の状況によって変わるかも。
double r =(double)((y4-y3)*(x3-x1)-(x4-x3)*(y3-y1))/m;
double s =(double)((y2-y1)*(x3-x1)-(x2-x1)*(y3-y1))/m;
return (0 < r && r <= 1 && 0 < s && s <= 1);
}
public static boolean isParallel(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4){
if((x2-x1)*(y4-y3) == (y2-y1)*(x4-x3)) return true;
else return false;
}
public static double sq(double d){return d*d;}
public static int sq(int i){return i*i;}
public static int sqdist(int x1, int y1, int x2, int y2){
return sq(x1-x2) + sq(y1-y2);}
public static double sqdist(double x1, double y1, double x2, double y2){
return sq(x1-x2) + sq(y1-y2);}
public static double dist(int x1, int y1, int x2, int y2){
return Math.sqrt(sqdist(x1, y1, x2, y2));}
public static double dist(double x1, double y1, double x2, double y2){
return Math.sqrt(sqdist(x1, y1, x2, y2));}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
#define INF (1<<22)
int main(){
while(1){
string str;
getline(cin,str);
int len = str.size();
char type = str[len-1];
if(type == 'X') break;
string ans = "";
for(int i=0;i<len-2;i++){
if(i == 0){
if(type == 'L' || type == 'D'){
if(str[i] >= 'A' && str[i] <= 'Z') ans += str[i]+32;
else ans += str[i];
} else {
if(str[i] >= 'a' && str[i] <= 'z') ans += str[i]-32;
else ans += str[i];
}
}
else if(str[i] >= 'A' && str[i] <= 'Z'){
if(type == 'D') {
ans += '_';
ans += (str[i]+32);
}
else ans += str[i];
}
else if(str[i] == '_'){
if(type == 'D') ans += str[i];
else {
i++;
ans += str[i]-32;
}
}
else ans += str[i];
}
cout << ans << endl;
}
}
``` |
### Prompt
Please formulate a Java solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.Scanner;
public class Main {
private static final int UP = 'A' - 'a';
private static final int LOW = -UP;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
char s[];
char targetType;
StringBuilder sb = new StringBuilder(100);
while (in.hasNext()) {
s = in.next().toCharArray();
sb.setLength(0);
targetType = in.next().charAt(0);
if (targetType == 'X') {
break;
}
if (targetType == 'U') {
if (!(s[0] <= 'Z')) {
s[0] += UP;
}
} else {
if (s[0] <= 'Z') {
s[0] += LOW;
}
}
sb.append(s[0]);
for (int i = 1; i < s.length; i++) {
if (s[i] == '_') {
s[i + 1] += UP;
} else if (s[i] <= 'Z' && targetType == 'D') {
s[i] += LOW;
sb.append('_').append(s[i]);
} else {
sb.append(s[i]);
}
}
System.out.println(sb.toString());
}
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define REP(i,s,n) for(int i=(int)(s);i<(int)(n);i++)
#define DEBUGP(val) cerr << #val << "=" << val << "\n"
using namespace std;
typedef long long int ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> PI;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
string s,t;
while(cin>>s>>t&&t!="X") {
vector<string> words;
int last = 0;
REP(i, 0, s.size()) {
if (s[i] == '_') {
words.push_back(s.substr(last, i - last));
last = i + 1;
}
if (s[i] <= 'Z' && i > 0) {
words.push_back(s.substr(last, i - last));
last = i;
}
}
words.push_back(s.substr(last));
if (t == "U" || t == "L") {
REP(i, 0, words.size()) {
if (i > 0 || t == "U") words[i][0] = toupper(words[i][0]);
else words[i][0] = tolower(words[i][0]);
cout << words[i];
}
cout << endl;
} else {
REP(i, 0, words.size()) {
if (i > 0) cout << "_";
transform(words[i].begin(), words[i].end(), words[i].begin(), ::tolower);
cout << words[i];
}
cout << endl;
}
}
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <sstream>
#include <ctype.h>
#include <vector>
using namespace std;
string solve(vector<string> v,char t){
string ret;
switch(t){
case 'U':
for(int i=0;i<v.size();i++){
for(int j=0;j<v[i].length();j++){
v[i][j] = tolower(v[i][j]);
}
v[i][0] = toupper(v[i][0]);
ret += v[i];
}
return ret;
case 'L':
for(int i=0;i<v.size();i++){
for(int j=0;j<v[i].length();j++){
v[i][j] = tolower(v[i][j]);
}
if(i)v[i][0] = toupper(v[i][0]);
ret += v[i];
}
return ret;
case 'D':
for(int i=0;i<v.size();i++){
if(i)ret+="_";
for(int j=0;j<v[i].length();j++){
v[i][j] = tolower(v[i][j]);
}
ret+=v[i];
}
return ret;
}
}
int main(){
char type;
string s;
string t;
while(cin >> s >> type,type != 'X'){
vector<string> data;
if(~s.find("_")){
for(int i=0;i<s.length();i++){
if(s[i]=='_'){
s[i] = ' ';
}
}
stringstream ss(s);
while(ss >> t)data.push_back(t);
}else{
for(int i=0;i<s.length();i++){
if(isupper(s[i])){
s.insert(i," ");
i++;
}
}
stringstream ss(s);
while(ss >> t)data.push_back(t);
}
cout << solve(data,type) << endl;
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
int dif='a'-'A';
void outU( string &s ){
char c;
for(unsigned int i=0;i<s.size();i++ ){
c=s.at( i );
if( i==0 ) c-= dif;
cout << c;
}
}
int main(){
string name, type;
string names[100];
int nw;
while( true ){
cin >> name >> type;
// cout << name << "," << type << endl;
if( type=="X" ) break;
for( int i=0;i<100;i++ )names[i]="";
nw=0;
char c;
for( unsigned int i=0; i<name.size();i++ ){
c = name.at(i);
if( c== '_' ) nw++;
else if( c<='Z'){
c+= dif;
if( names[nw].size()!=0 ){
nw++; names[nw]="";
}
names[nw] += c;
}else
names[nw] += c;
}
if( c!='_' )
nw++;
// cout << "\ndiv "<<name<<endl;
// for( int i=0;i<nw;i++ ) cout << names[i] << endl;
if( type=="D" ){
int i;
for( i=0;i<nw-1;i++ )
cout << names[i] << "_" ;
cout << names[i] << endl;
}else{
if( type=="U" ) // ツ渉可づ淞づ個閉カツ篠堋療アツづ債陛渉環キ
outU( names[0] );
else
cout << names[0];
for( int i=1;i<nw;i++ )
outU( names[i] );
cout << endl;
}
}
return 0;
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <vector>
#include <sstream> // require stringstream
#include <cctype> // require tolower, toupper
//#include <fstream> // require freopen
using namespace std;
int main()
{
// cut here before submit
// freopen ("testcase.camelcase", "r", stdin );
string str, s;
char type;
int i;
while (cin >> str >> type && type != 'X' ){
char curr_type = 'X';
if (str.find ('_') != string::npos ){
curr_type = 'D';
}else{
str[0] = toupper(str[0] );
} // end if
vector <string> word;
if (curr_type == 'D'){
while (str.find('_') != string::npos ){
str = str.replace (str.find('_'), 1, " " );
} // end while
stringstream ss (str );
s = "";
while (ss >> s ){
s[0] = toupper(s[0] );
word.push_back(s);
} // end while
}else{
s = "";
s += str[0];
for (i = 1; i < str.length(); ++i ){
if (toupper(str[i] ) != str[i] ){
s += str[i];
}else{
word.push_back(s);
s = "";
s += str[i];
} // end if
} // end for
word.push_back (s );
} // end if
string res = "";
switch (type ){
case 'D':
for (i = 0; i < word.size(); ++i ){
s = word[i];
s[0] = tolower(s[0]);
res += s;
if (i != word.size() - 1 ){
res += '_';
} // end if
} // end for
break;
case 'U':
for (i = 0; i < word.size(); ++i ){
res += word[i];
} // end for
break;
case 'L':
for (i = 0; i < word.size(); ++i ){
s = word[i];
s[0] = (i == 0 ? tolower(s[0]) : toupper(s[0]) );
res += s;
} // end for
break;
} // end switch
cout << res << endl;
} // end loop
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
using namespace std;
string convL(vector<string> vec)
{
string str = vec[0];
for(int i = 1; i < vec.size(); i++){
string st = vec[i];
str += (char)('A'+(int)(st[0]-'a'));
for(int j = 1; j < st.size(); j++){
str += st[j];
}
}
return str;
}
string convU(vector<string> vec)
{
string str = "";
for(int i = 0; i < vec.size(); i++){
string st = vec[i];
str += (char)('A'+(int)(st[0]-'a'));
for(int j = 1; j < st.size(); j++){
str += st[j];
}
}
return str;
}
string convD(vector<string> vec)
{
string str = vec[0];
for(int i = 1; i < vec.size(); i++){
str += ("_" + vec[i]);
}
return str;
}
vector<string> split(string str)
{
vector<string> vec;
string s = "";
for(int i = 0; i < str.size(); i++){
if(str[i] == '_'){
vec.push_back(s);
s = "";
} else if(str[i] >= 'a' && str[i] <= 'z'){
s += str[i];
} else {
if(s.size() > 0){
vec.push_back(s);
}
s = "";
s += (char)('a'+(int)(str[i]-'A'));
}
}
if(s.size() > 0){
vec.push_back(s);
}
return vec;
}
int main()
{
string s1, s2;
while(cin>>s1>>s2){
if(s2 == "X"){
break;
}
vector<string> vec = split(s1);
if(s2 == "L"){
s1 = convL(vec);
} else if(s2 == "U"){
s1 = convU(vec);
} else {
s1 = convD(vec);
}
cout << s1 << endl;
}
return 0;
}
``` |
### Prompt
Construct a PYTHON3 code solution to the problem outlined:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
# coding: utf-8
# 89
import re
while True:
n,t = input().split()
if t == 'X':
break
if '_' in n:
N=n.split('_')
#print(N)
else:
i = n[0].upper()
#print(i)
k = n[1:]
K = i +k
#print(K)
#N = re.split('[A-Z]',n)
N = re.findall('[A-Z][^A-Z]*',K)
#print(N)
if t=='U':
for i in range(len(N)):
if i == len(N)-1:
print(N[i].capitalize())
else:
print(N[i].capitalize(),end='')
elif t=='L':
for j in range(len(N)):
if j == 0:
if j==len(N)-1:
print(N[j].lower())
else:
print(N[j].lower(),end='')
elif j == len(N)-1:
print(N[j].capitalize())
else:
print(N[j].capitalize(),end='')
elif t=='D':
for z in range(len(N)):
if z == len(N)-1:
print(N[z].lower())
else:
print(N[z].lower(),end='')
print('_',end='')
``` |
### Prompt
Generate a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<vector>
#include<string>
using namespace std;
int main()
{
string name,type,ans;
string upper="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string under="_";
int start;
while(cin>>name>>type,type!="X"){
vector<string>word;
vector<string>::iterator it;
start=0;
if(name.find("_")!=string::npos){
for(int i=0;i<name.size();i++){
if(under.find(name[i])!=string::npos){
word.push_back(name.substr(start,i-start));
start=i+1;
}
}
word.push_back(name.substr(start,name.size()-start));
}else{
if(upper.find(name[0])!=string::npos)name[0]+='a'-'A';
for(int i=0;i<name.size();i++){
if(upper.find(name[i])!=string::npos){
name[i]+='a'-'A';
word.push_back(name.substr(start,i-start));
start=i;
}
}
word.push_back(name.substr(start,name.size()-start));
}
ans="";
for(it=word.begin();it!=word.end();it++){
if(it==word.begin()){
if(type=="U")(*it)[0]+='A'-'a';
ans+=*it;
continue;
}
if(type=="D")*it="_"+*it;
else (*it)[0]+='A'-'a';
ans+=*it;
}
cout<<ans<<endl;
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
#define to 'A'-'a'
#define small(x) (x) >= 'a' && (x) <= 'z'
#define big(x) (x) >= 'A' && (x) <= 'Z'
int main(){
string line;
char s;
while(1){
cin >> line >> s;
if(s == 'X') break;
if(s == 'U' || s == 'L'){
for(int i=0;i<line.size();i++){
if(i == 0 && s == 'U' && small(line[i])) line[i] += to;
else if(i == 0 && s == 'L' && big(line[i])) line[i] -= to;
if(line[i] == '_') line[i+1] += to;
}
while(line.find("_") != string::npos) line.erase(line.find("_"),1);
}
else {
for(int i=0;i<line.size();i++){
if(i == 0 && big(line[i])) line[i] -= to;
else if(big(line[i])) {
line[i] -= to;
line.insert(i,"_");
}
}
}
cout << line << endl;
}
}
``` |
### Prompt
Construct a Cpp code solution to the problem outlined:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<string>
#include<vector>
using namespace std ;
string s ;
char ans[200] ;
int main(){
char t ;
while( cin >> s >> t ){
if( t == 'X' ) break ;
int p = 1 ;
if( s[0] <= 90 && t != 'U' ) ans[0] = s[0] +32 ;
else if( s[0] >= 97 && t == 'U' ) ans[0] = s[0] -32 ;
else ans[0] = s[0] ;
for( int i=1 ; i<s.size() ; i++ ){
if( s[i] == '_' && t != 'D' ){
ans[p] = s[i+1] -32 ;
i++ ;
}
else if( s[i] <= 90 && t == 'D' ){
ans[p] = '_' ;
ans[p+1] = s[i] +32 ;
p++ ;
} else ans[p] = s[i] ;
p++ ;
}
for( int i=0 ; i<p ; i++ ){
cout << ans[i] ;
}cout << endl ;
}
return 0 ;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<vector>
#include<cctype>
#include<sstream>
using namespace std;
vector<string> parse(const string &str){
vector<string> ret;
stringstream ss;
for(int i = 0; i <= str.size(); i++){
if(i == str.size()){
ret.push_back(ss.str());
ss.str("");
}else if(str[i] == '_'){
ret.push_back(ss.str());
ss.str("");
}else if(isupper(str[i])){
if(ss.str().size() > 0) ret.push_back(ss.str());
ss.str("");
ss << (char)tolower(str[i]);
}else{
ss << str[i];
}
}
return ret;
}
string convert(const vector<string> &v, char dist){
stringstream ss;
bool first = true;
for(int i = 0; i < v.size(); i++){
string tmp = v[i];
if(dist == 'U'){
tmp[0] = toupper(tmp[0]);
}else if(dist == 'L'){
if(!first)
tmp[0] = toupper(tmp[0]);
}else if(dist == 'D'){
if(!first)
tmp = "_" + tmp;
}
ss << tmp;
first = false;
}
return ss.str();
}
int main(){
string buff;
char dist;
while(cin >> buff >> dist, dist != 'X'){
cout << convert(parse(buff), dist) << endl;
}
return 0;
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string name;
char type;
string UP;
for (int i = 0; i < 26; i++) {
UP += 'A' + i;
}
while (cin >> name >> type) {
if (type == 'U') {
stringstream ss;
for (auto& i : name) if (i == '_') i = ' ';
ss << name;
string str;
while (ss >> str) {
str[0] = toupper(str[0]);
cout << str;
}
cout << endl;
} else if (type == 'L') {
stringstream ss;
for (auto& i : name) if (i == '_') i = ' ';
ss << name;
string str;
ss >> str;
str[0] = tolower(str[0]);
cout << str;
while (ss >> str) {
str[0] = toupper(str[0]);
cout << str;
}
cout << endl;
} else if (type == 'D'){
for (int i = 0; i < name.size(); i++) {
if (UP.find(name[i]) != string::npos) {
name[i] = name[i] - 'A' + 'a';
name.insert(i, " ");
}
}
stringstream ss;
ss << name;
string str;
ss >> str;
cout << str;
while (ss >> str) {
cout << "_" << str;
}
cout << endl;
} else {
break;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <vector>
#include <cctype>
using namespace std;
int main()
{
string name, type;
while (cin >> name >> type) {
if (type == "X")
break;
name[0] = tolower(name[0]);
vector<string> words;
if (name.find_first_of("_") != string::npos) {
int s = 0;
name += "_";
for (int i = 0; i < name.size(); ++i) {
if (name[i] == '_') {
words.push_back(name.substr(s, i-s));
s = i+1;
}
}
} else {
int s = 0;
name += "X";
for (int i = 0; i < name.size(); ++i) {
if (isupper(name[i])) {
words.push_back(name.substr(s, i-s));
name[i] = tolower(name[i]);
s = i;
}
}
}
if (type == "D") {
cout << words[0];
for (int i = 1; i < words.size(); ++i)
cout << "_" << words[i];
} else {
if (type == "U")
words[0][0] = toupper(words[0][0]);
cout << words[0];
for (int i = 1; i < words.size(); ++i) {
words[i][0] = toupper(words[i][0]);
cout << words[i];
}
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<set>
#include<string>
#include<algorithm>
using namespace std;
string b[1000];
int main() {
string a;
char s;
while (cin >> a >> s&&s != 'X') {
bool l = false;
for (int i = 0; i < a.length(); i++) {
if (a[i] == '_') {
l = true;
break;
}
}
int sum = 0;
string h = "";
if (l) {
a += "_";
for (int i = 0; i < a.length(); i++) {
if (a[i] == '_') {
b[sum] = h;
sum++;
h = "";
}
else
h += a[i];
}
}
else {
if (a[0] <= 'Z'&&a[0] >= 'A')
a[0] = (char)(int)a[0] - (int)('A' - 'a');
a += 'A';
for (int i = 0; i < a.length(); i++) {
if (a[i] <= 'Z'&&a[i] >= 'A') {
b[sum] = h;
sum++;
h = "";
h += (char)((int)a[i] - (int)('A' - 'a'));
}
else
h += a[i];
}
}
switch (s) {
case 'D':
for (int i = 0; i < sum; i++) {
if (i == 0) cout << b[i];
else cout << "_" << b[i];
}
break;
case 'U':
for (int i = 0; i < sum; i++) {
b[i][0] += ('A' - 'a');
cout << b[i];
}
break;
case 'L':
for (int i = 0; i < sum; i++) {
if(i!=0) b[i][0] += ('A' - 'a');
cout << b[i];
}
}
cout << endl;
}
}
``` |
### Prompt
Please provide a PYTHON coded solution to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python
while 1:
a,type = raw_input().split()
if type == "X": break
ans = ""
if type == "U":
for word in a.split("_"):
ans += word[0].upper() + word[1:]
elif type == "L":
for word in a.split("_"):
ans += word[0].upper() + word[1:]
ans = ans[0].lower() + ans[1:]
else:
if "_" not in a:
words = []
sp = 0
for i in range(1,len(a)):
if a[i].isupper() :
words.append(a[sp:i].lower())
sp = i
words.append(a[sp:].lower())
ans = "_".join(words)
else:
ans = a
print ans
``` |
### Prompt
Please formulate a Python solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python
while True:
name,type = map(str, raw_input().split())
ans = ""
if (type == 'X'):
break
names = []
if (name.find("_") != -1):
names = name.split("_")
elif (name[0].islower() == True):
tmp = name[0]
for i in range(1, len(name)):
if (name[i].isupper() == True):
names.append(tmp)
tmp = name[i]
else:
tmp += name[i]
if (len(tmp) > 0):
names.append(tmp)
else:
tmp = name[0]
for i in range(1, len(name)):
if (name[i].isupper() == True):
names.append(tmp)
tmp = name[i]
else:
tmp += name[i]
if (len(tmp) > 0):
names.append(tmp)
# print names
if (type == "U"):
for x in names:
ans += x[0].upper()
ans += x[1:].lower()
elif (type == "L"):
cnt = 0
for x in names:
if (cnt == 0):
ans += x.lower()
else:
ans += x[0].upper()
ans += x[1:].lower()
cnt += 1
else:
ans = "_".join(names)
ans = ans.lower()
print ans
``` |
### Prompt
Construct a PYTHON3 code solution to the problem outlined:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
import re
while True:
n,t=input().split()
if t=='X':
break
if '_'in t:
ans=s.split('_')
else :
ans=re.findall(r'[a-z]+|[A-Z][a-z]*',n)
if t=='D':
ans='_'.join(map(str.lower,ans))
else :
ans=''.join(map(str.capitalize,ans))
if t=='L':
ans=ans[0].lower()+ans[1:]
print(ans)
``` |
### Prompt
Your task is to create a java solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.*;
public class Main {
Scanner in = new Scanner(System.in);
public static void main(String[] args) {
new Main();
}
public Main() {
new B().doIt();
}
class B{
String input;
char type;
void solve(){
Data d = new Data(input);
// System.out.println(Arrays.toString(d.input));
if(type=='U')System.out.println(d.toU());
else if(type=='L')System.out.println(d.toL());
else if(type=='D')System.out.println(d.toD());
}
void doIt(){
while(in.hasNext()){
input = in.next();
type = in.next().charAt(0);
if(type=='X')break;
solve();
}
}
class Data{
String[] input;
int n;
public Data(String a) {
String[] test = a.split("_");
if(test.length==1){
String b = a.charAt(0)+"";
for(int i=1;i<a.length();i++){
if(Character.isUpperCase(a.charAt(i)))b+=" ";
b+=a.charAt(i);
}
input = b.split(" ");
n = input.length;
}else{
input = a.split("_");
n = test.length;
}
}
String toU(){
// System.out.println(Arrays.toString(input));
// System.out.println(n);
String result = "";
for(int i=0;i<n;i++){
result += Character.toUpperCase(input[i].charAt(0));
for(int s=1;s<input[i].length();s++)result += input[i].charAt(s);
}
return result;
}
String toL(){
String result = toU();
String result2 = Character.toLowerCase(result.charAt(0))+"";
for(int i=1;i<result.length();i++)result2+=result.charAt(i);
return result2;
}
String toD(){
String result = Character.toLowerCase(input[0].charAt(0))+input[0].substring(1,input[0].length());
for(int i=1;i<n;i++){
// System.out.println(input[i]);
result += "_";
for(int s=0;s<input[i].length();s++){
// System.out.println(result);
result += Character.toLowerCase(input[i].charAt(s));
}
}
return result;
}
}
}
// class B{
// int n,a,b;
//
// void solve(){
//
// }
//
// void doIt(){
// while(in.hasNext()){
// n = in.nextInt();
// a = in.nextInt();
// b = in.nextInt();
// if(n+a+b==0)break;
// solve();
// }
// }
// }
//
}
``` |
### Prompt
Develop a solution in python to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python
import re
while True:
name,typ=raw_input().split()
if name=="EndOfInput" and typ=="X":break
if "_" in name:
L=name.split("_")
else:
L=re.findall("[A-Z][a-z]*",name[0].upper()+name[1:])
if typ=="D":
print "_".join(map(lambda s:s.lower(),L))
elif typ=="U":
print "".join(map(lambda s:s.capitalize(),L))
else:
print L[0].lower()+"".join(map(lambda s:s.capitalize(),L[1:]))
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
#define all(a) a.begin(),a.end()
#define o(a) cout<<a<<endl
#define int long long
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
bool large(char c){
if('A'<=c && c<='Z') return true;
return false;
}
char change(char c){
if('A'<=c && c<='Z') c+='a'-'A';
else if('a'<=c && c<='z') c+='A'-'a';
return c;
}
signed main(){
while(1){
string s,ans="";
char c;
cin>>s>>c;
if(c=='X') break;
else if(c=='D'){
if(large(s[0])) ans+=change(s[0]);
else ans+=s[0];
rep(i,1,s.size()){
if(large(s[i])) ans=ans+'_'+change(s[i]);
else ans+=s[i];
}
}else if(c=='U'){
if(!large(s[0])) ans+=change(s[0]);
else ans+=s[0];
rep(i,1,s.size()){
if(s[i]=='_'){
ans+=change(s[i+1]);
i++;
}else ans+=s[i];
}
}else if(c=='L'){
if(large(s[0])) ans+=change(s[0]);
else ans+=s[0];
rep(i,1,s.size()){
if(s[i]=='_'){
ans+=change(s[i+1]);
i++;
}else ans+=s[i];
}
}
o(ans);
}
}
``` |
### Prompt
Construct a PYTHON3 code solution to the problem outlined:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
while True:
words, type_ = input().split()
if type_ == "L":
if "_" in words:
words = words.split("_")
words = words[0] + "".join([w[0].upper() + w[1:] for w in words[1:]])
else:
words = words[0].lower() + words[1:]
elif type_ == "U":
if "_" in words:
words = words.split("_")
words = "".join([w[0].upper() + w[1:] for w in words])
else:
words = words[0].upper() + words[1:]
elif type_ == "D":
indices = [i for i, w in enumerate(words) if w.isupper()] + [len(words)]
if words[0].islower():
indices.insert(0, 0)
words = "_".join([words[indices[i]].lower() + words[indices[i]+1: indices[i+1]] for i in range(len(indices) - 1)])
else:
break
print(words)
``` |
### Prompt
Generate a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <ctype.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define all(v) (v).begin(), (v).end()
#define rev(s) (s).rbegin(), (s).rend()
#define MP make_pair
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<double, double> dP;
const int INF = 100000000;
const double EPS = 1e-10;
vector<string> parse(string s){
int idx = 0;
vector<string> words;
FOR(i, 1, s.size()){
if(s[i] == '_' || (s[i] >= 'A' && s[i] <= 'Z')){
words.push_back(s.substr(idx, i-idx));
if(s[i] == '_')i++;
idx = i;
}
}
words.push_back(s.substr(idx, s.size()-idx));
return words;
}
string ChangeCamelCase(vector<string> words, char type){
string res;
rep(i, words.size()){
if(type == 'D' || (type == 'L' && i == 0)) words[i][0] = tolower(words[i][0]);
else words[i][0] = toupper(words[i][0]);
res += words[i];
if(type == 'D' && (i != words.size()-1)) res+= '_';
}
return res;
}
int main(){
string s;
char t;
while(cin >> s >> t, t != 'X'){
cout << ChangeCamelCase(parse(s), t) << endl;
}
return 0;
}
``` |
### Prompt
In cpp, your task is to solve the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<string>
using namespace std ;
string s ;
char ans[200] ;
int main(){
char t ;
while( cin >> s >> t ){
if( t == 'X' ) break ;
int p = 1 ;
if( s[0] <= 90 && t != 'U' ) ans[0] = s[0] +32 ;
else if( s[0] >= 97 && t == 'U' ) ans[0] = s[0] -32 ;
else ans[0] = s[0] ;
for( int i=1 ; i<s.size() ; i++ ){
if( s[i] == '_' && t != 'D' ){
ans[p] = s[i+1] -32 ;
i++ ;
}
else if( s[i] <= 90 && t == 'D' ){
ans[p] = '_' ;
ans[p+1] = s[i] +32 ;
p++ ;
} else ans[p] = s[i] ;
p++ ;
}
for( int i=0 ; i<p ; i++ ){
cout << ans[i] ;
}cout << endl ;
}
return 0 ;
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<string>
#include<cstdio>
using namespace std;
int main(void){
string s;
char c;
for(;;){
cin >> s >> c;
if(c=='X') break;
if(s[0]>='A' && s[0]<='Z') s[0]+=32;
for(int i=1;i<s.size();i++){
if(s[i]=='_') s[i]=' ';
else if(s[i]>='A' && s[i]<='Z'){
s[i]+=32;
s.insert(i," ");
}
}
if(c=='L'){
for(int i=0;i<s.size();i++){
if(s[i]==' ') continue;
if(i!=0 && s[i-1]==' ') printf("%c",s[i]-32);
else cout << s[i];
}
}
else if(c=='U'){
for(int i=0;i<s.size();i++){
if(s[i]==' ') continue;
if(i==0 || s[i-1]==' ') printf("%c",s[i]-32);
else cout << s[i];
}
}
else if(c=='D'){
for(int i=0;i<s.size();i++){
if(s[i]==' ') cout << "_";
else cout << s[i];
}
}
cout << "\n";
}
}
``` |
### Prompt
Generate a cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <functional>
#include <algorithm>
#include <iostream>
#include <numeric>
#include <iomanip>
#include <utility>
#include <cstdlib>
#include <sstream>
#include <bitset>
#include <vector>
#include <cstdio>
#include <ctime>
#include <queue>
#include <deque>
#include <cmath>
#include <stack>
#include <list>
#include <map>
#include <set>
using namespace std;
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
#define dump(x) cerr << #x << " = " << (x) << endl
#define rep(i,n) for(int i=0;i<(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb push_back
string sol(string s){
string ret="";
rep(i,s.size()){
if(i!=0 && isupper(s[i]) && s[i]!='_'){
ret+='_';
ret+=tolower(s[i]);
}
else{
ret+=tolower(s[i]);
}
}
return ret;
}
int main() {
string s;
char type;
while(cin>>s>>type){
if(type=='X')break;
s=sol(s);
if(type=='D')cout<<s<<endl;
else if(type=='L'){
string ans="";
rep(i,s.size()){
if(s[i]=='_'){
ans+=toupper(s[i+1]);
i++;
}
else ans+=tolower(s[i]);
}
cout<<ans<<endl;
}
else if(type=='U'){
string ans="";
rep(i,s.size()){
if(i==0){
ans+=toupper(s[i]);
}
else if(s[i]=='_'){
ans+=toupper(s[i+1]);
i++;
}
else ans+=tolower(s[i]);
}
cout<<ans<<endl;
}
}
return 0;
}
``` |
### Prompt
Please provide a cpp coded solution to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
using namespace std;
string toL(string in,int n){
string out;
for(int i = 0; i < in.length(); i++){
if(in[i] == '_'){
if(in[i+1] >= 'a' && in[i+1] <= 'z'){
out += in[i+1]-('a' - 'A');
}else out += in[i+1];
i++;
}else{
// if(in[i] >= 'A' && in[i] <= 'Z') out += in[i]+('a'-'A');
//else out += in[i];
out += in[i];
}
}
if(n && out[0] >= 'A' && out[0] <= 'Z') out[0] += ('a'-'A');
if(!n && out[0] >= 'a' && out[0] <= 'z' ) out[0] -= ('a'-'A');
return out;
}
string toD(string in){
string out;
for(int i = 0; i < in.length(); i++){
if(in[i] >= 'A' && in[i] <= 'Z'){
if(i)out += "_";
out += in[i] + ('a'-'A');
}else out += in[i];
}
return out;
}
int main(){
string in;
char c;
while(cin >> in >> c){
if(c == 'X') break;
if(c == 'L') in = toL(in,1);
if(c == 'U') in = toL(in,0);
if(c == 'D') in = toD(in);
cout << in << endl;
}
return 0;
}
``` |
### Prompt
Please provide a Python3 coded solution to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
# AOJ 1044: CamelCase
# Python3 2018.7.6 bal4u
while True:
n, t = input().split()
if t == 'X': break
ans, n = '', list(n)
if t == 'U':
ans += n.pop(0).upper()
while n != []:
while n != [] and n[0] != '_': ans += n.pop(0)
if len(n) > 1 and n[0] == '_':
del n[0]
ans += n.pop(0).upper()
elif t == 'L':
ans += n.pop(0).lower()
while n != []:
while n != [] and n[0] != '_': ans += n.pop(0)
if len(n) > 1 and n[0] == '_':
del n[0]
ans += n.pop(0).upper()
else:
ans += n.pop(0).lower()
while n != []:
while n != [] and n[0].isupper() == False: ans += n.pop(0)
if n != [] and n[0].isupper(): ans += '_' + n.pop(0).lower()
print(ans)
``` |
### Prompt
Generate a PYTHON3 solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
while True:
s=list(map(str,input().split(' ')))
if s[1]=='X':
break
name=list(s[0])
der=0
n=[]
for i in range(1,len(name)):
if name[i].isupper()==True:
n.append(i)
if name[i]=='_':
n.append(i-der)
der+=1
if s[1]=='U':
name[0]=name[0].upper()
for u in range(len(n)):
if name[n[u]]=='_':
name.pop(n[u])
name[n[u]]=name[n[u]].upper()
print(''.join(name))
if s[1]=='L':
name[0]=name[0].lower()
for l in range(len(n)):
if name[n[l]]=='_':
name.pop(n[l])
name[n[l]]=name[n[l]].upper()
print(''.join(name))
if s[1]=='D':
if '_' in name:
print(''.join(name))
else:
name[0]=name[0].lower()
der=0
for d in range(len(n)):
name[n[d]+der]=name[n[d]+der].lower()
name.insert(n[d]+der,'_')
der+=1
print(''.join(name))
``` |
### Prompt
Develop a solution in CPP to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main( void )
{
string s;
string t;
while ( cin >> s >> t && t != "X" )
{
vector <string> list;
string token;
// _ª éÈçA_[XRA
if ( s.find( "_" ) != string::npos )
{
token = "";
for ( int i = 0; i < s.size(); i++ )
{
if ( s[i] == '_' )
{
list.push_back( token );
token = "";
}
else
{
token += s[i];
}
}
list.push_back( token );
}
else if ( s[0] >= 'A' && s[0] <= 'Z' )
{
token = "";
s[0] = tolower( s[0] );
for ( int i = 0; i < s.size(); i++ )
{
if ( s[i] >= 'A' && s[i] <= 'Z' )
{
list.push_back( token );
token = "";
token += tolower( s[i] );
}
else
{
token += s[i];
}
}
list.push_back( token );
}
else if ( s[0] >= 'a' && s[0] <= 'z' )
{
token = "";
for ( int i = 0; i < s.size(); i++ )
{
if ( s[i] >= 'A' && s[i] <= 'Z' )
{
list.push_back( token );
token = "";
token += tolower( s[i] );
}
else
{
token += s[i];
}
}
list.push_back( token );
}
if ( t == "U" )
{
for ( int i = 0; i < list.size(); i++ )
{
list[i][0] = toupper( list[i][0] );
}
}
else if ( t == "L" )
{
for ( int i = 1; i < list.size(); i++ )
{
list[i][0] = toupper( list[i][0] );
}
}
else if ( t == "D" )
{
for ( int i = 1; i < list.size(); i++ )
{
list[i] = "_" + list[i];
}
}
string kotae = "";
for ( int i = 0; i < list.size(); i++ )
kotae += list[i];
cout << kotae << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in python3 to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
while True:
a, b = map(str,input().split())
if b=='X':
break
if '_' in a:
c = a.split('_')
else:
c=[]
k = 0
for i in range(1,len(a)):
if a[i].isupper():
c.append(a[k:i])
k = i
c.append(a[k:])
if b=='D':
c = '_'.join(map(str.lower,c))
else:
c = ''.join(map(str.capitalize,c))
if b =='L':
c = c[0].lower() + c[1:]
print(c)
``` |
### Prompt
Develop a solution in Java to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
while (true) {
String word = sc.next();
String query = sc.next();
if (query.equals("X")) break;
ArrayList<String> elems = new ArrayList<String>();
if (word.indexOf("_") >= 0) {
String[] vals = word.split("_");
for (String val : vals) {
elems.add(val);
}
} else {
int pos = 0;
for (int i = 1; i < word.length(); ++i) {
if (Character.isUpperCase(word.charAt(i))) {
elems.add(word.substring(pos, i).toLowerCase());
pos = i;
}
}
elems.add(word.substring(pos).toLowerCase());
}
StringBuilder result = new StringBuilder();
if (query.equals("U")) {
for (int i = 0; i < elems.size(); ++i) {
result.append(Character.toUpperCase(elems.get(i).charAt(0)));
result.append(elems.get(i).substring(1));
}
} else if (query.equals("L")) {
result.append(elems.get(0));
for (int i = 1; i < elems.size(); ++i) {
result.append(Character.toUpperCase(elems.get(i).charAt(0)));
result.append(elems.get(i).substring(1));
}
} else {
result.append(elems.get(0));
for (int i = 1; i < elems.size(); ++i) {
result.append("_");
result.append(elems.get(i));
}
}
System.out.println(result);
}
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <cctype>
#include <cstdio>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
char SmallToLarge(char x){
return x-'a'+'A';
}
char LargeToSmall(char x){
return x-'A'+'a';
}
int main(){
string s;
char c;
while(cin >> s >> c){
if(c=='X') break;
string t=s;
//UpperCmaelCase??????
if('a'<=s[0] && s[0]<='z'){
bool underscore=false;
for(int i=0; i<s.size(); ++i){
if(s[i]=='_'){
underscore=true;
break;
}
}
stringstream ss;
ss << SmallToLarge(s[0]);
if(underscore){
for(int i=1; i<s.size(); ++i){
if(s[i]=='_') continue;
if(s[i-1]=='_') ss << SmallToLarge(s[i]);
else ss << s[i];
}
}
else for(int i=1; i<s.size(); ++i) ss << s[i];
t=ss.str();
}
//cout << t <<endl;
if(c=='L') t[0]=t[0]-'A'+'a';
else if(c=='D'){
stringstream tt;
tt<<LargeToSmall(t[0]);
for(int i=1; i<t.size(); ++i){
if('A'<=t[i] && t[i]<='Z'){
tt<<'_';
tt<<LargeToSmall(t[i]);
}
else tt<<t[i];
}
t=tt.str();
}
cout << t <<endl;
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
string s;
char c;
int n = 'a' - 'A';
while(true){
cin >> s >> c;
if(c == 'X') break;
string ss = "";
if(c == 'U'){
if(s[0] <= 'z' && s[0] >= 'a') s[0] -= n;
for(int i=0;i<s.size();i++){
if(s[i] == '_'){
s[i+1] -= n;
continue;
}
ss += s[i];
}
}
if(c == 'L'){
if(s[0] <= 'Z' && s[0] >= 'A') s[0] += n;
for(int i=0;i<s.size();i++){
if(s[i] == '_'){
s[i+1] -= n;
continue;
}
ss += s[i];
}
}
if(c == 'D'){
if(s[0] <= 'Z' && s[0] >= 'A') s[0] += n;
for(int i=0;i<s.size();i++){
if(s[i+1] <= 'Z' && s[i+1] >= 'A'){
ss += s[i];
ss += '_';
s[i+1] += n;
continue;
}
ss += s[i];
}
}
cout << ss << endl;
}
}
``` |
### Prompt
Your challenge is to write a cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
void str_U(string s){
string S="";
for(int i=0;i<s.size();i++){
if(s[i]=='_'){
i++;
if('a'<=s[i]&&s[i]<='z'){
S+=(s[i]-'a'+'A');
}
else{
S+=s[i];
}
}
else{
S+=s[i];
}
}
if('a'<=S[0] && S[0]<='z'){
S[0]-='a';
S[0]+='A';
}
cout<<S<<endl;
}
void str_L(string s){
string S="";
for(int i=0;i<s.size();i++){
if(s[i]=='_'){
i++;
if('a'<=s[i]&&s[i]<='z'){
S+=(s[i]-'a'+'A');
}
else{
S+=s[i];
}
}
else{
S+=s[i];
}
}
if('A'<=S[0] && S[0]<='Z'){
S[0]-='A';
S[0]+='a';
}
cout<<S<<endl;
}
void str_D(string s){
string S="";
for(int i=0;i<s.size();i++){
if('A'<=s[i]&&s[i]<='Z'){
if(i!=0)S+="_";
S+=(s[i]-'A'+'a');
}
else{
S+=s[i];
}
}
cout<<S<<endl;
}
int main(){
string s;
char c;
while(cin>>s>>c){
if(c=='X')break;
if(c=='U')str_U(s);
if(c=='L')str_L(s);
if(c=='D')str_D(s);
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <string>
#include <sstream>
#include <algorithm>
#include <math.h>
#include <map>
#include <iomanip>
#include <vector>
#include <queue>
#include <set>
#define PI 3.14159265359
#define INF 99999999;
#define rep(i, n) for(int i=0; i<n; i++)
#define REP(n) rep(i, n)
typedef long long ll;
using namespace std;
/*
class LightSwitchingPuzzle
{
public:
int minFlips(string s)
{
}
}
*/
string get_underscore(string inp)
{
if (inp.find("_") != string::npos)
{
return inp;
}
if (inp[0] < 'a') inp[0] += 32;
string ret = "";
for (int i=0; i<inp.length(); i++)
{
if (inp[i] < 'a')
{
char c = inp[i] + 32;
ret = ret + "_" + c;
} else {
ret += inp[i];
}
}
return ret;
}
string upper_camel_case(string inp)
{
char c = inp[0] - 32;
string ret = "";
ret += c;
for (int i=1; i<inp.length(); i++)
{
if (inp[i] == '_')
{
ret += inp[i+1] - 32;
i++;
} else {
ret += inp[i];
}
}
return ret;
}
string lower_camel_case(string inp)
{
string ret = "";
for (int i=0; i<inp.length(); i++)
{
if (inp[i] == '_')
{
ret += inp[i+1] - 32;
i++;
} else {
ret += inp[i];
}
}
return ret;
}
int main()
{
string name;
char type;
while (cin >> name >> type)
{
if (type == 'X') break;
name = get_underscore(name);
switch (type)
{
case 'U':
cout << upper_camel_case(name) << endl;
break;
case 'L':
cout << lower_camel_case(name) << endl;
break;
case 'D':
cout << name << endl;
break;
}
}
//cout << upper_camel_case("get_user_name") << endl;
return 0;
}
``` |
### Prompt
Develop a solution in python3 to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
import re
while True:
s, c = input().split()
if c == 'X':
break
if '_' in s:
t = s.split('_')
else:
t = re.findall(r'^[a-z]+|[A-Z][a-z]*', s)
if c == 'D':
t = '_'.join(map(str.lower, t))
else:
t = ''.join(map(str.capitalize, t))
if c == 'L':
t = t[0].lower() + t[1:]
print(t)
``` |
### Prompt
Please provide a CPP coded solution to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
using namespace std;
string name, type;
vector<string> split(string name) {
vector<string> ret;
string word;
for (int i = 0; i < name.length(); i++) {
if (name[i] == '_' || ('A' <= name[i] && name[i] <= 'Z')) {
if (word.length() > 0) ret.push_back(word);
word = "";
}
if ('A' <= name[i] && name[i] <= 'Z') word += name[i] + 32;
else if (name[i] != '_') word += name[i];
}
ret.push_back(word);
return ret;
}
int main() {
while (cin >> name >> type) {
char t = type[0];
vector<string> names = split(name);
if (t == 'X') break;
if (t == 'U' || t == 'L') {
for (int i = (t == 'L'); i < names.size(); i++) {
if ('a' <= names[i][0] && names[i][0] <= 'z')
names[i][0] = names[i][0] - 32;
}
}
if (t == 'D') {
for (int i = 0; i < (int)names.size() - 1; i++) {
names[i] += '_';
}
}
for (int i = 0; i < names.size(); i++) {
cout << names[i];
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<cstdio>
#include<vector>
#include<algorithm>
#include<iostream>
#include<string>
#include<cctype>
#include<cstdlib>
using namespace std;
int main(){
string str;char type;
while(cin>>str>>type,str!="EndOfInput"||type!='X'){
vector<char>ans;ans.push_back(tolower(str[0]));
for(int i=1;i<str.length();i++){
if(str[i]!='_'&&islower(str[i])){
ans.push_back(str[i]);
continue;
}
if(isupper(str[i])){
if(type=='L'||type=='U')ans.push_back(str[i]);
else{
ans.push_back('_');
ans.push_back(tolower(str[i]));
}
}
else{
i++;
if(type=='L'||type=='U')ans.push_back(toupper(str[i]));
else{
ans.push_back('_');
ans.push_back(str[i]);
}
}
}
if(type=='U')ans[0]=toupper(ans[0]);
for(int i=0;i<ans.size();i++)cout<<ans[i];cout<<endl;
}
return 0;
}
``` |
### Prompt
Create a solution in CPP for the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<cstdio>
#include<sstream>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double EPS=1e-10;
const int inf=1e9;
using namespace std;
typedef long long ll;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
int main(){
string s,t;
while(cin>>s>>t,t!="X"){
if(t=="L"){
rep(i,s.size())if(s[i]=='_'){
s[i+1]=toupper(s[i+1]);
s.erase(s.begin()+i);
i--;
}
s[0]=tolower(s[0]);
}else if(t=="U"){
rep(i,s.size())if(s[i]=='_'){
s[i+1]=toupper(s[i+1]);
s.erase(s.begin()+i);
i--;
}
s[0]=toupper(s[0]);
}else{
rep(i,s.size())if(i&&isupper(s[i])){
s[i]=tolower(s[i]);
s.insert(i,"_");
}
s[0]=tolower(s[0]);
}
cout<<s<<endl;
}
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <algorithm>
#include <iostream>
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
using namespace std;
int main(){
int i=0;
string s,t;
for(;cin >> s >> t,t!="X";){
if(find(s.begin(),s.end(),'_')!=s.end()){
if(t!="D"){
for(i=0;i<s.length();i++)
if(s[i]=='_'){
if(s[i+1]=='_'||s[i+1]==0){cout << "Error!" << endl;return 0;}
s.erase(i,1),s[i]-=0x20;
}
if(t=="U")s[0]-=0x20;
}
cout << s << endl;
}else{
if(between('A',s[0],'Z'))s[0]+=0x20;
if(t=="U")s[0]-=0x20;
if(t=="D")
for(i=0;i<s.length();i++)
if(between('A',s[i],'Z'))s.insert(i,1,'_'),s[++i]+=0x20;
cout << s << endl;
}
}
}
``` |
### Prompt
Your task is to create a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <vector>
using namespace std;
string upperCamel(string& s){
return (char)(s[0]-'a'+'A')+s.substr(1,s.size());
}
int main(void){
string s;
while(cin>>s){
char c;cin>>c;
if(c=='X')break;
vector<string> splited;
string tmp;
for(int i=0;i<s.size();++i){
if('A'<=s[i]&&s[i]<='Z'){
if(i==0){
tmp+=s[i]-'A'+'a';
continue;
}
splited.push_back(tmp);
tmp=s[i]-'A'+'a';
}else if(s[i]=='_'){
splited.push_back(tmp);
tmp="";
}else tmp+=s[i];
}
splited.push_back(tmp);
if(c=='L'){
for(int i=0;i<splited.size();++i){
if(i) cout<<upperCamel(splited[i]);
else cout<<splited[i];
}
cout<<endl;
}else if(c=='U'){
for(int i=0;i<splited.size();++i){
cout<<upperCamel(splited[i]);
}
cout<<endl;
}else if(c=='D'){
for(int i=0;i<splited.size();++i){
if(i)cout<<"_";
cout<<splited[i];
}
cout<<endl;
}
}
return 0;
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
int main(){
int i,len;
char type;
string name,out;
while(1){
out="";
cin >> name >> type;
if(type=='X') break;
len=name.size();
for(i=0;i<len;i++){
if(i==0){
if('A'<=name[i]&&name[i]<='Z'&&type!='U') out+=name[i]-'A'+'a';
else if('a'<=name[i]&&name[i]<='z'&&type=='U') out+=name[i]-'a'+'A';
else out+=name[i];
}
else{
if(name[i]=='_'&&type!='D'){
out+=name[i+1]-'a'+'A';
i++;
}
else if('A'<=name[i]&&name[i]<='Z'&&type=='D'){
out+='_';
out+=name[i]-'A'+'a';
}else out+=name[i];
}
}
cout << out << endl;
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#define _USE_MATH_DEFINES
#define INF 100000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
static const double EPS = 1e-8;
int main(){
string str;
char conv;
while(cin>>str){
cin >> conv;
if(conv == 'X') break;
//under score
if(count(str.begin(),str.end(),'_')){
if(conv == 'L'){
//str[0] = 'A' + (str[0]-'a');
string res="";
for(int i=0;i+1<str.size();i++){
if(str[i]=='_' && ('a' <= str[i+1] && str[i+1] <= 'z')){
str[i+1]='A'+(str[i+1]-'a');
i++;
}
}
string::iterator it = remove(str.begin(),str.end(),'_');
str.erase(it,str.end());
}
else if(conv == 'U'){
str[0] = 'A' + (str[0]-'a');
for(int i=0;i+1<str.size();i++){
if(str[i]=='_' && ('a' <= str[i+1] && str[i+1] <= 'z')){
str[i+1]='A'+(str[i+1]-'a');
i++;
}
}
string::iterator it = remove(str.begin(),str.end(),'_');
str.erase(it,str.end());
}
}
//Upper CamelCase
else if('A' <= str[0] && str[0] <= 'Z'){
if(conv == 'L'){
str[0] = 'a' + (str[0]-'A');
}
else if(conv == 'D'){
string res="";
str[0] = 'a' + (str[0]-'A');
res.push_back(str[0]);
for(int i=1;i<str.size();i++){
if('A' <= str[i] && str[i] <= 'Z'){
res.push_back('_');
res.push_back('a' + (str[i]-'A'));
}
else{
res.push_back(str[i]);
}
}
str = res;
}
}
//Lower CamelCase
else{
if(conv == 'U'){
str[0] = 'A' + (str[0]-'a');
}
else if(conv == 'D'){
string res="";
str[0] = 'a' + (str[0]-'a');
res.push_back(str[0]);
for(int i=1;i<str.size();i++){
if('A' <= str[i] && str[i] <= 'Z'){
res.push_back('_');
res.push_back('a' + str[i]-'A');
}
else{
res.push_back(str[i]);
}
}
str = res;
}
}
cout << str << endl;
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <cctype>
#include <vector>
using namespace std;
int len;
string UpperCamelCase(vector<string> v){
string res = "";
for(int i = 0 ; i < len ; i++){
if(islower(v[i][0])){
v[i][0] = toupper(v[i][0]);
}
res += v[i];
}
return res;
}
string LowerCamelCase(vector<string> v){
string res = v[0];
for(int i = 1 ; i < len ; i++){
if(islower(v[i][0])){
v[i][0] = toupper(v[i][0]);
}
res += v[i];
}
return res;
}
string Under(vector<string> v){
string res = v[0];
for(int i = 1 ; i < len ; i++){
res += '_' + v[i];
}
return res;
}
int main(){
string s;
char order;
while(cin >> s >> order, order != 'X'){
if(isupper(s[0])){
s[0] = tolower(s[0]);
}
s += '_';
vector<string> v;
int pos = 0;
len = (int)s.size();
for(int i = 0 ; i < len ; i++){
if(isupper(s[i])){
s[i] = tolower(s[i]);
v.push_back(s.substr(pos,i-pos));
pos = i;
}else if(s[i] == '_'){
v.push_back(s.substr(pos,i-pos));
pos = i + 1;
}
}
len = (int)v.size();
if(order == 'U'){
cout << UpperCamelCase(v) << endl;
}else if(order == 'L'){
cout << LowerCamelCase(v) << endl;
}else{
cout << Under(v) << endl;
}
}
return 0;
}
``` |
### Prompt
Generate a python solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python
while(1):
[inp, s]=raw_input().split()
if s=='X':
break
else:
words=[]
if '_' in inp:
words=inp.split('_')
else:
w=inp[0].lower()
for c in inp[1:]:
if c.isupper():
words.append(w)
w=c.lower()
else:
w+=c
words.append(w)
if s=='D':
print '_'.join(words)
else:
if s=='U':
words=[w[0].upper()+w[1:] for w in words]
else:
words=[words[0]]+[w[0].upper()+w[1:] for w in words[1:]]
print ''.join(words)
``` |
### Prompt
Create a solution in Java for the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
StringBuilder sb = new StringBuilder(101);
while(sc.hasNext()){
char[] s = sc.next().toCharArray();
sb.setLength(0); //1文字ずつ
char a = sc.next().charAt(0);
if(a == 'X')break;
if(a == 'U') {
if(!(s[0] <= 'Z')) {
s[0] = Character.toUpperCase(s[0]);
}
}
else {
if(s[0] <= 'Z') {
s[0] = Character.toLowerCase(s[0]);
}
}
sb.append(s[0]);
for(int i=1;i<s.length;i++) {
if(s[i]=='_') {
s[i+1] = Character.toUpperCase(s[i+1]);
}
else if(s[i]<='Z' && a =='D') {
s[i] = Character.toLowerCase(s[i]);
sb.append('_').append(s[i]);
}
else sb.append(s[i]);
}
System.out.println(sb.toString());
}
}
}
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<string>
using namespace std;
void smallToLarge( char& a )
{
if( 'a' <= a && a <= 'z' )
a -= ( 'a' - 'A' );
}
void LargeToSmall( char& a )
{
if( 'A' <= a && a <= 'Z' )
a += ( 'a' - 'A' );
}
int main()
{
string s;
char c;
while( cin >> s >> c )
{
int a = s.size();
if( c == 'X' )
break;
else if( c == 'U' || c == 'L' )
{
c == 'U' ? smallToLarge(s[0]) : LargeToSmall(s[0]);
for( int i = 0; i < a; i++ )
if( s[i] == '_' )
smallToLarge(s[i+1]);
else
cout << s[i];
}
else
{
LargeToSmall(s[0]);
for( int i = 0; i < a; i++ )
{
if( 'A' <= s[i] && s[i] <= 'Z' )
{
cout << '_';
LargeToSmall(s[i]);
}
cout << s[i];
}
}
cout << endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <vector>
#include <cctype>
using namespace std;
int main(){
string s,type;
while(cin>> s >> type, type!="X" ){
int st=0;
vector<string> v;
for( int i=0;i<(int)s.length();i++ ){
if( isupper(s[i]) ){
s[i] = tolower(s[i]);
if( i>0 )
v.push_back( s.substr(st,i-st) );
st = i;
}
if( s[i]=='_' ){
v.push_back( s.substr(st, i-st) );
st = i+1;
}
if( i==s.length()-1 ){
v.push_back( s.substr(st) ); break;
}
}
//#define DEBUG
#ifdef DEBUG
cout << endl;
cout << s << " => " << type << endl;
for( int i=0;i<v.size();i++ )
cout << " [" << v[i] << "]";
cout << endl;
cout << "[";
#endif
for( int i=0;i<v.size();i++ ){
if( (type=="L"&&i>0) || type=="U" ){
v[i][0] = toupper(v[i][0]);
}
if( type=="D" && i>0 )
cout << "_";
cout << v[i];
}
cout
#ifdef DEBUG
<< "]"
#endif
<< endl;
}
return 0;
}
``` |
### Prompt
In Java, your task is to solve the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.Scanner;
public class Main {
public static void main ( String[] args ){
Scanner sc = new Scanner( System.in );
while( true ){
String src = sc.next();
char[] strc = src.toCharArray();
String type = sc.next();
char diff = 'a' - 'A';
switch (type.toCharArray()[ 0 ] ){
case 'X':
return;
case 'U':
if( 'a' <= strc[ 0 ] && strc[ 0 ] <= 'z' ){
strc[ 0 ] -= diff; // to upper case
}
for( int i = 1; i < strc.length; i++ ){
if( strc[ i ] == '_' ){
String s1 = "";
String s2 = "";
for( int j = 0; j < i; j++ ){
s1 += strc[ j ];
}
if( 'a' <= strc[ i + 1 ] && strc[ i + 1 ] <= 'z' ){
strc[ i + 1 ] -= diff;
}
for( int j = i + 1; j < strc.length; j++ ){
s2 += strc[ j ];
}
strc = ( s1 + s2 ).toCharArray();
}
}
System.out.println( strc );
break;
case 'L':
if( 'A' <= strc[ 0 ] && strc[ 0 ] <= 'Z' ){
strc[ 0 ] += diff; // to upper case
}
for( int i = 1; i < strc.length; i++ ){
if( strc[ i ] == '_' ){
String s1 = "";
String s2 = "";
for( int j = 0; j < i; j++ ){
s1 += strc[ j ];
}
if( 'a' <= strc[ i + 1 ] && strc[ i + 1 ] <= 'z' ){
strc[ i + 1 ] -= diff;
}
for( int j = i + 1; j < strc.length; j++ ){
s2 += strc[ j ];
}
strc = ( s1 + s2 ).toCharArray();
}
}
System.out.println( strc );
break;
case 'D':
if( 'A' <= strc[ 0 ] && strc[ 0 ] <= 'Z' ){
strc[ 0 ] += diff; // to upper case
}
for( int i = 1; i < strc.length; i++ ){
if( 'A' <= strc[ i ] && strc[ i ] <= 'Z' ){
String s = "";
for( int j = 0; j < i; j++ ){
s += strc[ j ];
}
s += "_";
strc[ i ] += diff;
for( int j = i; j < strc.length; j++ ){
s += strc[ j ];
}
strc = s.toCharArray();
}
}
System.out.println( strc );
break;
}
}
}
}
``` |
### Prompt
In Python3, your task is to solve the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
while True:
s, cc = input().split()
if cc == "X":break
if "_" in s:
t = s.split("_")
else:
t = []
j = 0
for i in range(1, len(s)):
if s[i].isupper():
t.append(s[j:i])
j = i
t.append(s[j:])
if cc == "U":
for i in range(len(t)):t[i] = t[i][0].upper() + t[i][1:]
print("".join(t))
elif cc == "L":
t[0] = t[0].lower()
for i in range(1, len(t)):t[i] = t[i][0].upper() + t[i][1:]
print("".join(t))
else:
for i in range(len(t)):t[i] = t[i].lower()
print("_".join(t))
``` |
### Prompt
Your task is to create a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
string UOP(string str){
string ans="";
if('a' <= str[0] && str[0] <= 'z') str[0] = toupper(str[0]);
for(int i = 0 ; i < str.size() ; i++){
if(str[i] == '_'){
if('a' <= str[i+1] && str[i+1] <= 'z') str[i+1] = toupper(str[i+1]);
}
else ans += str[i];
}
return ans;
}
string LOP(string str){
string ans="";
if('A' <= str[0] && str[0] <= 'Z') str[0] = tolower(str[0]);
for(int i = 0 ; i < str.size() ; i++){
if(str[i] == '_'){
if('a' <= str[i+1] && str[i+1] <= 'z') str[i+1] = toupper(str[i+1]);
}
else ans += str[i];
}
return ans;
}
string DOP(string str){
string ans="";
for(int i = 0 ; i < str.size() ; i++){
if('A' <= str[i] && str[i] <= 'Z') str[i] = tolower(str[i]);
ans += str[i];
if('A' <= str[i+1] && str[i+1] <= 'Z') ans += '_';
}
return ans;
}
int main(){
string str;
char op;
while(cin >> str >> op, op != 'X'){
if(op == 'U'){
cout << UOP(str) << endl;
}
else if(op == 'L'){
cout << LOP(str) << endl;
}
else if(op == 'D'){
cout << DOP(str) << endl;
}
}
return 0;
}
``` |
### Prompt
Please create a solution in cpp to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<string>
#include<vector>
using namespace std;
char Aa(char a, bool b) {
//b ??§??????
if (b) {
if (a >= 'a')return a - 32;
return a;
}
else {
if (a <= 'Z')return a + 32;
return a;
}
}
int main() {
string a; char b;
while (cin >> a >> b, b != 'X') {
vector<string>c; string d;
d += a[0];
for (int i = 1; i < a.length();i++) {
char e = a[i];
if (e == '_') { c.push_back(d); d = ""; }
else if (e <= 'Z') { c.push_back(d); d = ""; d += e; }
else d += e;
}
c.push_back(d);
switch (b)
{
case 'U':
for (string i : c) {
cout << Aa(i[0], true);
for (int x = 1; x < i.length(); x++) {
cout << i[x];
}
}
cout << endl; break;
case 'L':
for (int j = 0; j < c.size(); j++) {
if (j)cout << Aa(c[j][0], true);
else cout << Aa(c[j][0], false);
for (int i = 1; i < c[j].length(); i++)cout << c[j][i];
}
cout << endl; break;
case 'D':
for (int j = 0; j < c.size(); j++) {
if (j)cout << '_';
cout << Aa(c[j][0], false);
for (int i = 1; i < c[j].length(); i++)cout << c[j][i];
}
cout << endl;
}
}
}
``` |
### Prompt
Please provide a Cpp coded solution to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <utility>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define repc(i,s,e) for(int i=(s); i<(e); i++)
#define pb(n) push_back((n))
#define mp(n,m) make_pair((n),(m))
#define all(r) r.begin(),r.end()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<ll> vl;
typedef vector<vl> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 10000000;
vector<string> split(const string &s, char c = ' '){
vector<string> ret;
stringstream ss(s);
string t;
while(getline(ss,t,c)){
ret.pb(t);
}
return ret;
}
vector<string> get_word(string s){
vector<string> ret;
for(int i = 0; i < s.size(); i++){
for(int j = i; j < s.size(); j++){
if((s[j] >= 'A' && s[j] <= 'Z') || j == s.size() - 1){
if(s[j] > 'Z' && j == s.size() - 1) j++;
else s[j] += 'a' - 'A';
ret.push_back(s.substr(i, j - i));
i = j - 1;
break;
}
}
}
return ret;
}
string calc(string s, string t1, string t2){
string ret;
if(t1 == "U"){
if(t2 == "L"){
ret = s;
ret[0] += 'a' - 'A';
}
else if(t2 == "D"){
s[0] += 'a' - 'A';
vector<string> v = get_word(s);
// cout<<" ";
// for(int i = 0; i < v.size(); i++){
// cout<<v[i];
// }
// cout<<endl;
for(int i = 0; i < v.size(); i++){
s = v[i];
//s[0] += 'a' - 'A';
if(ret.size() != 0) ret += "_";
ret += s;
}
}
else ret = s;
}
else if(t1 == "L"){
if(t2 == "U"){
ret = s;
ret[0] += 'A' - 'a';
}
else if(t2 == "D"){
vector<string> v = get_word(s);
for(int i = 0; i < v.size(); i++){
s = v[i];
//s[0] +='a' - 'A';
if(ret.size() != 0) ret += "_";
ret += s;
}
}
else ret = s;
}
else{
if(t2 == "U"){
vector<string> v = split(s, '_');
for(int i = 0; i < v.size(); i++){
s = v[i];
s[0] += 'A' - 'a';
ret += s;
}
}
else if(t2 == "L"){
vector<string> v = split(s, '_');
for(int i = 0; i < v.size(); i++){
s = v[i];
if(i != 0) s[0] += 'A' - 'a';
ret += s;
}
}
else ret = s;
}
return ret;
}
int main(){
string s, t;
while(cin>>s>>t && t != "X"){
if(s.find("_") != string::npos) cout<<calc(s, "D", t);
else if(s[0] >= 'A' && s[0] <= 'Z') cout<<calc(s, "U", t);
else cout<<calc(s,"L", t);
cout<<endl;
}
}
``` |
### Prompt
Generate a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<vector>
using namespace std;
int main(){
string s,t;
for(;;){
cin >> s;
cin >> t;
if(t=="X")break;
vector<string> v;
int pos=0;
while(pos<s.size()){
string tmp;
if('A' <= s[pos] && s[pos]<='Z'){
tmp += (char)(s[pos] + 32);
pos++;
}
while(pos<s.size() && ('a'<= s[pos] && s[pos]<='z'))tmp += s[pos++];
v.push_back(tmp);
if(pos<s.size() && s[pos]=='_')pos++;
}
string ans;
if(t=="U"){
for(int i=0;i<(int)v.size();i++){
v[i][0] = v[i][0]-32;
ans += v[i];
}
}
if(t=="L"){
ans = v[0];
for(int i=1;i<(int)v.size();i++){
v[i][0] = v[i][0]-32;
ans += v[i];
}
}
if(t=="D"){
ans = v[0];
for(int i=1;i<(int)v.size();i++)ans += "_" + v[i];
}
cout << ans << endl;
}
}
``` |
### Prompt
Please formulate a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
using namespace std;
int main()
{
string str;
char type;
for(;cin>>str>>type,type!='X';)
{
if(type=='U')
{
for(int i=0;i<str.size();i++)
{
bool up=false;
if(i==0 || str[i]=='_')
up=true;
if( str[i]=='_')
i++;
if(up)
cout<<(char)toupper(str[i]);
else
cout<<str[i];
}
}
else if(type=='L')
{
for(int i=0;i<str.size();i++)
{
if(str[i]=='_')
{
i++;
cout<<(char)toupper(str[i]);
}
else if(i==0)
cout<<(char)tolower(str[i]);
else
cout<<str[i];
}
}
else
{
for(int i=0;i<str.size();i++)
{
if(i!=0 && isupper(str[i]))
cout<<"_";
cout<<(char)tolower(str[i]);
}
}
cout<<endl;
}
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <set>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,j) FOR(i,0,j)
#define mp std::make_pair
const int INF = 1 << 24;
const int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1}, dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};
typedef unsigned long long ull;
typedef std::pair<int,int> P;
bool isUSCase(const std::string &s){
return s.find("_") != std::string::npos;
}
bool isUCCase(const std::string &s){
return std::isupper(s[0]);
}
bool isLCCase(const std::string &s){
return !isUSCase(s) && std::islower(s[0]);
}
int main(){
std::string s;
char c;
while(std::cin >> s >> c, c != 'X'){
if(isUSCase(s)){
if(c == 'U'){
s[0] = std::toupper(s[0]);
int pos = 0;
while(pos = s.find("_", pos), pos != std::string::npos){
s.replace(pos, 2, 1, std::toupper(s[pos+1]));
pos++;
}
}else if(c == 'L'){
int pos = 0;
while(pos = s.find("_", pos), pos != std::string::npos){
s.replace(pos, 1, "");
s[pos] = std::toupper(s[pos]);
}
}else if(c == 'D'){
}
}else if(isUCCase(s)){
if(c == 'U'){
}else if(c == 'L'){
s[0] = std::tolower(s[0]);
}else if(c == 'D'){
s[0] = std::tolower(s[0]);
std::string _s = "";
REP(i, s.size()){
if(std::isupper(s[i]) && i > 0){
_s += "_";
s[i] = std::tolower(s[i]);
}
_s += s[i];
}
s = _s;
}
}else if(isLCCase(s)){
if(c == 'U'){
s[0] = std::toupper(s[0]);
}else if(c == 'L'){
}else if(c == 'D'){
std::string _s = "";
REP(i, s.size()){
if(std::isupper(s[i])){
_s += '_';
s[i] = std::tolower(s[i]);
}
_s += s[i];
}
s = _s;
}
}
std::cout << s << std::endl;
}
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define F first
#define S second
#define INF 1 << 30
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
string name;
char type;
int main(){
while(cin >> name >> type){
if(type == 'X') break;
if(name.find("_") != std::string::npos){
if(type == 'D') goto e;
if(type == 'U') name[0] -= 32;
rep(i, name.size()){
if(name[i] != '_') continue;
name.erase(name.begin()+i);
name[i] -= 32;
}
}else{
if(type == 'L' ){ if(name[0] < 97) name[0] += 32;}
else if(type == 'U'){ if( name[0] > 96) name[0] -= 32;}
else{
if(name[0] < 97) name[0] += 32;
rep(i, name.size()){
if(name[i] > 96) continue;
name[i] += 32;
name.insert(i, "_");
}
}
}
e:
cout << name << endl;
}
return 0;
}
``` |
### Prompt
In Cpp, your task is to solve the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class t>
using table = vector<vector<t>>;
const ld eps = 1e-9;
//// < "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\b.txt"
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
vector<string> split(const string &str, char delim) {
vector<string> res;
size_t current = 0, found;
while ((found = str.find_first_of(delim, current)) != string::npos) {
res.push_back(string(str, current, found - current));
current = found + 1;
}
res.push_back(string(str, current, str.size() - current));
return res;
}
int main() {
while (1) {
string st; cin >> st;
char c; cin >> c;
if (c == 'X')break;
else {
vector<string>names(1);
if (st.find('_') == string::npos) {
int now = 0;
for (int i = 0; i < st.size(); ++i) {
if (i&&st[i] >= 'A'&&'Z' >= st[i]) {
names.push_back(string());
now++;
}
names[now].push_back(char(tolower(st[i])));
}
}
else {
names = split(st, '_');
}
if (c == 'U') {
for (int i = 0; i < names.size(); ++i) {
for (int j = 0; j < names[i].size(); ++j) {
if (j)cout << names[i][j];
else cout << char(toupper(names[i][j]));
}
}
cout << endl;
}
else if (c == 'L') {
for (int i = 0; i < names.size(); ++i) {
for (int j = 0; j < names[i].size(); ++j) {
if (!i||j)cout << names[i][j];
else cout << char(toupper(names[i][j]));
}
}
cout << endl;
}
else {
for (int i = 0; i < names.size(); ++i) {
for (int j = 0; j < names[i].size(); ++j) {
cout << names[i][j];
}
if (i == names.size() - 1)cout << endl;
else cout << '_';
}
}
}
}
return 0;
}
``` |
### Prompt
Your challenge is to write a JAVA solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.Scanner;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc=new Scanner(System.in)
;
for(;;){
String s1 = sc.next();
String s2 = sc.next();
if(s2.equals("X"))break;
String[]s=null;
if(s1.contains("_")){
s=s1.split("_");
}
else if('a'<=s1.charAt(0)&&s1.charAt(0)<='z'){
StringBuffer sb=new StringBuffer();
for(int i=0;i<s1.length();i++){
if(Character.isUpperCase(s1.charAt(i))){
sb.append(",");
sb.append(s1.charAt(i));
}
else{
sb.append(s1.charAt(i));
}
}
s=sb.toString().split(",");
}
else{
StringBuffer sb=new StringBuffer();
sb.append(s1.charAt(0));
for(int i=1;i<s1.length();i++){
if(Character.isUpperCase(s1.charAt(i))){
sb.append(",");
sb.append(s1.charAt(i));
}
else{
sb.append(s1.charAt(i));
}
}
s=sb.toString().split(",");
}
StringBuffer sb=new StringBuffer();
if(s2.equals("U")){
for(int i=0;i<s.length;i++){
for(int j=0;j<s[i].length();j++){
if(j==0&&Character.isLowerCase(s[i].charAt(j))){
int add=s[i].charAt(j)-32;
sb.append((char)add);
}
else{
sb.append(s[i].charAt(j));
}
}
}
}
else if(s2.equals("L")){
for(int i=0;i<s.length;i++){
for(int j=0;j<s[i].length();j++){
if(i!=0&&j==0&&Character.isLowerCase(s[i].charAt(j))){
int add=s[i].charAt(j)-32;
sb.append((char)add);
}
else if(i==0&&j==0&&Character.isUpperCase(s[i].charAt(j))){
int add=s[i].charAt(j)+32;
sb.append((char)add);
}
else{
sb.append(s[i].charAt(j));
}
}
}
}
else{
for(int i=0;i<s.length;i++){
for(int j=0;j<s[i].length();j++){
if(j==0&&Character.isUpperCase(s[i].charAt(j))){
int add=s[i].charAt(j)+32;
sb.append((char)add);
}
else{
sb.append(s[i].charAt(j));
}
}
if(i==s.length-1){
}
else
sb.append("_");
}
}
System.out.println(sb);
}
}
}
``` |
### Prompt
Create a solution in Cpp for the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <cstdio>
#include <cstring>
using namespace std;
int main()
{
char str[1024];
char type;
while (scanf("%s %c", str, &type), type != 'X'){
char word[128][128];
int j = 0;
for (int i = 0; i < 128; i++){
strcpy(word[i], "");
}
{
int i = 0;
while (str[i] != '\0'){
if ( (str[i] >= 'a' && str[i] <= 'z') || i == 0 ){
if (str[i] >= 'A' && str[i] <= 'Z'){
str[i] += 32;
}
strncat(word[j], &str[i], 1);
i++;
}
else if (str[i] >= 'A' && str[i] <= 'Z'){
j++;
str[i] += 32;
strncat(word[j], &str[i], 1);
i++;
}
else if (str[i] == '_'){
i++;
j++;
}
}
}
switch (type){
case 'U':
case 'L':
for (int i = 0; i <= j; i++){
if (i == 0 && type == 'L'){
printf("%s", word[i]);
}
else {
word[i][0] -= 32;
printf("%s", word[i]);
}
}
break;
case 'D':
for (int i = 0; i <= j; i++){
if (i > 0){
printf("_");
}
printf("%s", word[i]);
}
}
puts("");
}
return 0;
}
``` |
### Prompt
Develop a solution in cpp to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
using namespace std;
char low(char x){return ('A'<=x && x<='Z')?x+32:x;}
char up(char x){return ('a'<=x && x<='z')?x-32:x;}
int main(){
string s;
char o;
while(cin >> s >> o && o!='X'){
cout << ((o-'U')?low(s[0]):up(s[0]));
for(int i=1;i<(int)s.size();i++){
if(s[i]=='_' && o-'D'){
s.erase(s.begin()+i);
cout << up(s[i]);
}else if('A'<=s[i] && s[i]<='Z' && o=='D'){
cout << '_' << low(s[i]);
}else cout << s[i];
}
cout << endl;
}
}
``` |
### Prompt
Construct a JAVA code solution to the problem outlined:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.*;
class Main{
public static void main(String args[]){
Scanner s = new Scanner(System.in);
String str, input;
while(true){
str = s.next();
input = s.next();
if(input.charAt(0) == 'X') break;
String change = "";
String[]column = str.split("_");
switch(input.charAt(0)){
case 'U':
if(column.length == 1){
change = (char)(str.charAt(0)&(~32)) + str.substring(1);
}else{
for(int i = 0; i < column.length; i++){
change += (char)(column[i].charAt(0)&(~32)) + column[i].substring(1);
}
}
break;
case 'L':
if(column.length == 1){
change = (char)(str.charAt(0)|(32)) + str.substring(1);
}else{
change += column[0];
for(int i = 1; i < column.length; i++){
change += (char)(column[i].charAt(0)&(~32)) + column[i].substring(1);
}
}
break;
case 'D':
if(column.length !=1 ) change = str;
else for(int i = 0; i < str.length(); i++){
if(i > 0 && str.charAt(i) >= 'A' && str.charAt(i) <= 'Z'){
change += "_"+(char)(str.charAt(i)|32);
}
else change += (char)(str.charAt(i)|32);
}
break;
}
System.out.println(change);
}
}
}
``` |
### Prompt
Generate a Cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <cctype>
#include <string>
#include <iostream>
using namespace std;
string LowerCamelCaseDiv2(string S)
{
string T;
for(int i = 0; i < S.size(); i++)
{
if(i == 0)
{
T += tolower(S[i]);
}
else if(S[i - 1] == '_')
{
T += toupper(S[i]);
}
else if(S[i] != '_')
{
T += S[i];
}
}
return T;
}
string UpperCamelCaseDiv2(string S)
{
string T;
for(int i = 0; i < S.size(); i++)
{
if(i == 0)
{
T += toupper(S[i]);
}
else if(S[i - 1] == '_')
{
T += toupper(S[i]);
}
else if(S[i] != '_')
{
T += S[i];
}
}
return T;
}
string UnderLineDiv2(string S)
{
string T;
for(int i = 0; i < S.size(); i++)
{
if(i != 0 && isupper(S[i]))
{
T += '_';
}
T += tolower(S[i]);
}
return T;
}
int main()
{
string S, T;
while(true)
{
cin >> S >> T;
if(T == "X") { break; }
if(T == "L") { cout << LowerCamelCaseDiv2(S) << endl; }
if(T == "U") { cout << UpperCamelCaseDiv2(S) << endl; }
if(T == "D") { cout << UnderLineDiv2(S) << endl; }
}
return 0;
}
``` |
### Prompt
Generate a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
bool isLower( char c ){
return ( c >= 'a' && c <= 'z' )? true : false ;
}
bool isUpper(char c){
return ( c >= 'A' && c <= 'Z' )? true : false ;
}
vector<string> splitString(const string& s){
string s_ = "";
vector<string> vc;
for(int i=0 ; i<(int)s.size() ; i++ ){
if( s[i] == '_' ){
vc.push_back( s_ );
s_ = "";
}else if( isLower( s[i] ) ){
s_.push_back( s[i] );
if( i == (int)s.size()-1 ){
vc.push_back( s_ );
}
}else if( isUpper( s[i] ) ){
vc.push_back( s_ );
s_ = "";
s_.push_back( s[i] );
if( i == (int)s.size()-1 ){
vc.push_back( s_ );
}
}
}
return vc;
}
string solve(string s, string c){
vector<string> vc = splitString( s );
string str = "";
for(int i=0 ; i<(int)vc.size() ; i++ ){
if( !vc[i].empty() ){
if( c == "D" ){
if( isUpper(vc[i][0]) )
vc[i][0] += 'a'-'A';
str += vc[i];
if( i != (int)vc.size()-1 )
str.push_back('_');
}else{
if( isLower(vc[i][0]) )
vc[i][0] -= 'a'-'A';
str += vc[i];
}
}
}
if( c == "L" && isUpper(str[0]) ){
str[0] += 'a'-'A';
}
return str;
}
int main(){
string s, c;
while( cin >> s >> c , c != "X" ){
cout << solve( s , c ) << endl;
}
}
``` |
### Prompt
In CPP, your task is to solve the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<string>
#include<vector>
#include<iostream>
#define pb push_back
using namespace std;
vector<string> split(string s){
int n=s.length();
bool d=false;
for(int i=0;i<n;i++) if(s[i]=='_') d=true;
vector<string> ans;
if(d){
s+='_';
n++;
int bef=-1;
for(int i=0;i<n;i++){
if(s[i]=='_' && ~bef){
ans.pb(s.substr(bef,i-bef));
bef=-1;
}
else{
if(bef==-1) bef=i;
}
}
return ans;
}
else{
s[0]=tolower(s[0]);
s+='Q';
n++;
int bef=0;
for(int i=0;i<n;i++){
if(isupper(s[i])){
ans.pb(s.substr(bef,i-bef));
s[i]=tolower(s[i]);
bef=i;
}
}
return ans;
}
}
int main(){
while(1){
string s;
char c;
cin>>s>>c;
vector<string> part=split(s);
int n=part.size();
if(c=='U'){
for(int i=0;i<n;i++){
part[i][0]=toupper(part[i][0]);
cout<<part[i];
}
cout<<endl;
}
else if(c=='L'){
for(int i=0;i<n;i++){
if(i>0) part[i][0]=toupper(part[i][0]);
cout<<part[i];
}
cout<<endl;
}
else if(c=='D'){
for(int i=0;i<n;i++){
if(i>0) cout<<'_';
cout<<part[i];
}
cout<<endl;
}
else break;
}
return 0;
}
``` |
### Prompt
Develop a solution in CPP to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
//#include <boost/foreach.hpp>
//#include <boost/range/algorithm.hpp>
#define rep(i,j,k) for(int i=(int)j;i<(int)k;i++)
#define ll long long
#define Sort(v) sort(all(v))
#define INF 1e9
#define LINF 1e18
#define END return 0
#define pb push_back
#define se second
#define fi first
#define pb push_back
#define all(v) (v).begin() , (v).end()
#define MP make_pair
#define MOD 1000000007LL
#define int long long
using namespace std;
int day[12]={31,28,31,30,31,30,31,31,30,31,30,31};
// int dx[]={0,1,0,-1};
// int dy[]={1,0,-1,0};
struct edge{int to,cost;};
//typedef pair<int,int> P;
bool isupper(char c){if('A'<=c&&c<='Z')return 1;return 0;}
bool islower(char c){if('a'<=c&&c<='z')return 1;return 0;}
bool isPrime(int x){if(x==1)return 0;if(x==2)return 1;if(x%2==0)return 0;for(int i=3;i*i<=x;i++)if(x%i==0)return 0;return 1;}
bool iskaibun(string s){for(int i=0;i<s.size()/2;i++)if(s[i]!=s[s.size()-i-1])return 0;return 1;}
bool isnumber(char c){return ('0'<=c&&c<='9');}
bool isalpha(char c){return (isupper(c)||islower(c));}
void printvi(vector<int> v){rep(i,0,v.size()){if(i)cout<<" ";cout<<v[i];}cout<<endl;}
void printvil(vector<int> v){rep(i,0,v.size()){cout<<v[i]<<endl;}}
void printvvi(vector<vector<int>> v){
rep(i,0,v.size()){
rep(j,0,v[i].size()){
if(j)cout<<" ";
cout<<v[i][j];
}
cout<<endl;
}
}
void printvstr(vector<string> v){
rep(i,0,v.size()){
cout<<v[i]<<endl;
}
}
int gcd(int a,int b){
if(a<b)swap(a,b);
if(b==0)return a;
else return gcd(b,a%b);
}
struct S{
int id,team,ac,pena;
};
string alllower(string s){
string ret;
rep(i,0,s.size()){
if(isupper(s[i]))ret+=char(s[i]+'a'-'A');
else ret+=s[i];
}
return ret;
}
string first_upper(string s){
string ret;
rep(i,0,s.size()){
if(i==0 && islower(s[i]))ret+=char(s[i]-('a'-'A'));
else ret+=s[i];
}
return ret;
}
signed main (){
for(;;){
string s;cin>>s;
char cmd;cin>>cmd;
if(cmd=='X')break;
vector<string> words;
string temp;
rep(i,0,s.size()){
if(isupper(s[i])){
if(i!=0)words.emplace_back(temp);
temp=s[i];
}else if(s[i]=='_'){
words.emplace_back(temp);
temp="";
}else temp+=s[i];
}
words.emplace_back(temp);
if(cmd=='L'){
rep(i,0,words.size()){
if(i==0)cout<<alllower(words[i]);
else cout<<first_upper(words[i]);
}
}else if(cmd=='U'){
rep(i,0,words.size())cout<<first_upper(words[i]);
}else if(cmd=='D'){
rep(i,0,words.size()){
if(i)cout<<"_";
cout<<alllower(words[i]);
}
}
cout<<endl;
}
}
/*
*/
``` |
### Prompt
Develop a solution in CPP to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
string s;
char c;
string abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string abc2 = "abcdefghijklmnopqrstuvwxyz";
while (cin >> s >> c) {
if (c == 'X') {
break;
}
vector<string> ss;
if (s.find("_") != string::npos) {
string sa = "";
for (int i = 0; i < s.size(); i++) {
if (s[i] == '_') {
ss.push_back(sa);
sa = "";
} else {
sa += s[i];
}
}
ss.push_back(sa);
} else {
bool h = false;
for (int i = 0; i < 26; i++) {
if (s[0] == abc[i]) {
h = true;
break;
}
}
if (h) {
string sb = "";
for (int i = 0; i < s.size(); i++) {
bool h2 = false;
for (int j = 0; j < 26; j++) {
if (s[i] == abc[j]) {
h2 = true;
if (sb == "") {
} else {
ss.push_back(sb);
}
sb = "";
sb += abc2[j];
break;
}
}
if (!h2) {
sb += s[i];
}
}
ss.push_back(sb);
} else {
string sc = "";
for (int i = 0; i < s.size(); i++) {
bool h2 = false;
for (int j = 0; j < 26; j++) {
if (s[i] == abc[j]) {
h2 = true;
ss.push_back(sc);
sc = "";
sc += abc2[j];
break;
}
}
if (!h2) {
sc += s[i];
}
}
ss.push_back(sc);
}
}
string s2 = "";
if (c == 'U') {
for (int i = 0; i < ss.size(); i++) {
for (int j = 0; j < 26; j++) {
if (ss[i][0] == abc2[j]) {
ss[i][0] = abc[j];
break;
}
}
s2 += ss[i];
}
} else if (c == 'L') {
s2 += ss[0];
for (int i = 1; i < ss.size(); i++) {
for (int j = 0; j < 26; j++) {
if (ss[i][0] == abc2[j]) {
ss[i][0] = abc[j];
break;
}
}
s2 += ss[i];
}
} else {
for (int i = 0; i < ss.size(); i++) {
if (s2 != "") {
s2 += "_";
}
s2 += ss[i];
}
}
cout << s2 << endl;
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<vector>
using namespace std;
bool isAL(char ch){ return ('A'<=ch&&ch<='Z'); }
bool isAl(char ch){return ('a'<=ch&&ch<='z');}
char change(char ch){
if(isAl(ch))ch=ch-'a'+'A';
return ch;
}
char change2(char ch){
if(isAL(ch))ch=ch-'A'+'a';
return ch;
}
string str,type;
vector<string> t;
int main(){
while(1){
cin>>str>>type;
if(type=="X")break;
t.clear();
string tmp="";
tmp.push_back(str[0]);
str.push_back('_');
for(int i=1;i<(int)str.size();i++){
if(str[i]=='_'){
t.push_back(tmp);
tmp="";
}else if(isAL(str[i])){
t.push_back(tmp);
tmp="";
tmp.push_back(str[i]);
}else{
tmp.push_back(str[i]);
}
}
for(int i=0;i<(int)t.size();i++){
if(type=="L"){
if(i)t[i][0]=change(t[i][0]);
else t[i][0]=change2(t[i][0]);
}else if(type=="U"){
t[i][0]=change(t[i][0]);
}else{
t[i][0]=change2(t[i][0]);
}
if(i)cout<<(type=="D"?"_":"");
cout<<t[i];
}
cout<<endl;
}
return 0;
}
``` |
### Prompt
Generate a python3 solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
while True:
a, b = input().split()
if b == 'X':
break
if '_' in a:
ans = a.split('_')
else:
ans = []
j = 0
for i in range(1, len(a)):
if a[i].isupper():
ans.append(a[j:i])
j = i
ans.append(a[j:])
if b == 'D':
ans = '_'.join(map(str.lower, ans))
else:
ans = ''.join(map(str.capitalize, ans))
if b == 'L':
ans = ans[0].lower() + ans[1:]
print(ans)
``` |
### Prompt
In CPP, your task is to solve the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
char s[1024], type[2];
while (scanf("%s %s", s, type) && type[0] != 'X'){
char t[1024];
int resLen = 0;
memset(t, 0, sizeof(t));
for (int i = 0; s[i]; i++){
if (i == 0){
if (type[0] == 'U') t[resLen++] = toupper(s[i]);
else t[resLen++] = tolower(s[i]);
}
else {
if (islower(s[i])){
if (s[i - 1] == '_' && type[0] != 'D') t[resLen++] = toupper(s[i]);
else t[resLen++] = s[i];
}
else if (isupper(s[i])){
if (type[0] != 'D') t[resLen++] = s[i];
else {
t[resLen++] = '_';
t[resLen++] = tolower(s[i]);
}
}
else {
if (type[0] == 'D') t[resLen++] = s[i];
}
}
}
printf("%s\n", t);
}
return (0);
}
``` |
### Prompt
Develop a solution in java to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try {
String line;
/* input */
while(true){
line = br.readLine();
String str = line.split(" ")[0], type = line.split(" ")[1];
if(type.equals("X")) break;
if(str.indexOf('_')>-1){
if(type.equals("D")){
System.out.println(str);
} else {
String[] s = str.split("_");
if(type.equals("U")){
for(String t : s){
System.out.print(t.substring(0,1).toUpperCase() + t.substring(1));
}
System.out.println();
} else {
System.out.print(s[0]);
for(int i=1;i<s.length;i++){
System.out.print(s[i].substring(0,1).toUpperCase() + s[i].substring(1));
}
System.out.println();
}
}
} else {
String[] s = str.split("(?<!^)(?=[A-Z])");
if(type.equals("D")){
System.out.print(s[0].toLowerCase());
for(int i=1;i<s.length;i++){
System.out.print("_" + s[i].toLowerCase());
}
System.out.println();
} else if(type.equals("U")){
for(String t : s){
System.out.print(t.substring(0,1).toUpperCase() + t.substring(1));
}
System.out.println();
} else {
System.out.print(s[0].toLowerCase());
for(int i=1;i<s.length;i++){
System.out.print(s[i].substring(0,1).toUpperCase() + s[i].substring(1));
}
System.out.println();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
``` |
### Prompt
Develop a solution in python3 to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
from string import ascii_uppercase
while 1:
s, t = input().split()
if t == 'X':
break
if "_" in s:
W = s.split("_")
else:
W = []; w = []
for c in s:
if c in ascii_uppercase:
if w:
W.append("".join(w).lower())
w = [c]
else:
w.append(c)
if w:
W.append("".join(w).lower())
if t == 'D':
print(*W, sep='_')
elif t == 'U':
print(*map(lambda x: x.capitalize(), W), sep='')
else:
print(W[0], *map(lambda x: x.capitalize(), W[1:]), sep='')
``` |
### Prompt
Develop a solution in cpp to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
void solve()
{
string s;
char c;
while(cin >> s >> c)
{
string ans;
if(c == 'X')
{
break;
}
else if(c == 'L')
{
if('A' <= s[0] && s[0] <= 'Z')
{
ans += s[0] - 'A' + 'a';
}
else
{
ans += s[0];
}
bool underbar_flag = false;
for(int i = 1; i < s.size(); ++i)
{
if(underbar_flag)
{
ans += s[i] - 'a' + 'A';
underbar_flag = false;
}
else if(s[i] != '_')
{
ans += s[i];
}
else if(s[i] == '_')
{
underbar_flag = true;
}
}
}
else if(c == 'U')
{
if('a' <= s[0] && s[0] <= 'z')
{
ans += s[0] - 'a' + 'A';
}
else
{
ans += s[0];
}
bool underbar_flag = false;
for(int i = 1; i < s.size(); ++i)
{
if(underbar_flag)
{
ans += s[i] - 'a' + 'A';
underbar_flag = false;
}
else if(s[i] != '_')
{
ans += s[i];
}
else if(s[i] == '_')
{
underbar_flag = true;
}
}
}
else if(c == 'D')
{
if('A' <= s[0] && s[0] <= 'Z')
{
ans += s[0] - 'A' + 'a';
}
else
{
ans += s[0];
}
for(int i = 1; i < s.size(); ++i)
{
if('A' <= s[i] && s[i] <= 'Z')
{
ans += '_';
ans += s[i] - 'A' + 'a';
}
else
{
ans += s[i];
}
}
}
cout << ans << endl;
}
}
int main()
{
solve();
return(0);
}
``` |
### Prompt
Develop a solution in Cpp to the problem described below:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <string>
using namespace std;
void toUpperString(string& upper_str, const string& src_str)
{
bool is_under_score = false;
if (src_str[0] >= 0x61 && src_str[0] <= 0x7A) {
upper_str += src_str[0] - 0x20;
} else {
upper_str += src_str[0];
}
for (int i = 1; i != src_str.size(); i++) {
if (src_str[i] == '_') {
is_under_score = true;
continue;
}
if (!is_under_score) {
upper_str += src_str[i];
} else {
upper_str += src_str[i] - 0x20;
is_under_score = false;
}
}
}
void toLowerString(string& lower_str, const string& src_str)
{
bool is_under_score = false;
if (src_str[0] >= 0x41 && src_str[0] <= 0x5A) {
lower_str += src_str[0] + 0x20;
} else {
lower_str += src_str[0];
}
for (int i = 1; i != src_str.size(); i++) {
if (src_str[i] == '_') {
is_under_score = true;
continue;
}
if (!is_under_score) {
lower_str += src_str[i];
} else {
lower_str += src_str[i] - 0x20;
is_under_score = false;
}
}
}
void toSnakeString(string& snake_str, const string& src_str)
{
if (src_str[0] >= 0x41 && src_str[0] <= 0x5A) {
snake_str += src_str[0] + 0x20;
} else {
snake_str += src_str[0];
}
for (int i = 1; i != src_str.size(); i++) {
if (src_str[i] == '_' ||
(src_str[i] >= 0x61 && src_str[i] <= 0x7A)) {
snake_str += src_str[i];
} else {
snake_str += '_';
snake_str += src_str[i] + 0x20;
}
}
}
int main()
{
string name;
string output;
char type;
while (1) {
cin >> name >> type;
cin.ignore();
output.clear();
if (type == 'U') {
toUpperString(output, name);
cout << output << endl;
} else if (type == 'L') {
toLowerString(output, name);
cout << output << endl;
} else if (type == 'D') {
toSnakeString(output, name);
cout << output << endl;
} else if (type == 'X') {
break;
}
}
}
``` |
### Prompt
Your task is to create a cpp solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <cctype>
#include <string>
#include <vector>
using namespace std;
int main() {
string s;
while(cin >> s) {
int p=0;
vector<string> v;
char c;
cin >> c;
if (c == 'X') break;
for (int i=0; i<s.length(); i++) {
if (s[i] == '_') {
v.push_back(s.substr(p,i-p));
p=i+1;
}
if (i>0 && isupper(s[i])) {
v.push_back(s.substr(p,i-p));
p=i;
}
}
v.push_back(s.substr(p));
string ans;
for (int i=0; i<v.size(); i++) {
string s1 = v[i];
if (c == 'U') {
s1[0] = toupper(s1[0]);
ans += s1;
}
if (c == 'L') {
if (i==0) {
s1[0] = tolower(s1[0]);
ans += s1;
} else {
s1[0] = toupper(s1[0]);
ans += s1;
}
}
if (c == 'D') {
s1[0] = tolower(s1[0]);
if (i>=1)
ans += "_" + s1;
else
ans += s1;
}
}
cout << ans << endl;
}
}
``` |
### Prompt
Your challenge is to write a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <cctype>
#include <cstdlib>
#include <iostream>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
for(string name, type; cin >> name >> type && type != "X";) {
string ans = "";
int prev = 0;
for(unsigned i = 0; i < name.size(); ++i) {
if(name[i] == '_' || isupper(name[i])) {
if(type == "D") {
name[prev] = tolower(name[prev]);
if(prev) ans += '_';
}
else {
name[prev] = toupper(name[prev]);
}
ans += name.substr(prev, i - prev);
prev = i;
if(name[i] == '_') ++prev;
}
}
if(type == "D") {
name[prev] = tolower(name[prev]);
if(prev) ans += '_';
}
else {
name[prev] = toupper(name[prev]);
}
ans += name.substr(prev);
if(type == "L") ans[0] = tolower(ans[0]);
cout << ans << endl;
}
return EXIT_SUCCESS;
}
``` |
### Prompt
Please formulate a CPP solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
// includes
#include <bits/stdc++.h>
// macros
#define ll long long int
#define pb emplace_back
#define mk make_pair
#define pq priority_queue
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) for(int i=((int)(n)-1);i>=0;i--)
#define irep(itr, st) for(auto itr = (st).begin(); itr != (st).end(); ++itr)
#define irrep(itr, st) for(auto itr = (st).rbegin(); itr != (st).rend(); ++itr)
#define vrep(v, i) for(int i = 0; i < (v).size(); i++)
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define FI first
#define SE second
#define dump(a, n) for(int i = 0; i < n; i++)cout << a[i] << "\n "[i + 1 != n];
#define dump2(a, n, m) for(int i = 0; i < n; i++)for(int j = 0; j < m; j++)cout << a[i][j] << "\n "[j + 1 != m];
#define bit(n) (1LL<<(n))
#define INT(n) int n; cin >> n;
#define LL(n) ll n; cin >> n;
#define DOUBLE(n) double n; cin >> n;
using namespace std;
// types
typedef pair<int, int> P;
typedef pair<ll, int> Pl;
typedef pair<ll, ll> Pll;
typedef pair<double, double> Pd;
typedef complex<double> cd;
// constants
const int inf = 1e9;
const ll linf = 1LL << 50;
const double EPS = 1e-10;
const int mod = 1e9 + 7;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
// solve
template <class T>bool chmax(T &a, const T &b){if(a < b){a = b; return 1;} return 0;}
template <class T>bool chmin(T &a, const T &b){if(a > b){a = b; return 1;} return 0;}
template <typename T> istream &operator>>(istream &is, vector<T> &vec){for(auto &v: vec)is >> v; return is;}
template <typename T> ostream &operator<<(ostream &os, const vector<T>& vec){for(int i = 0; i < vec.size(); i++){ os << vec[i]; if(i + 1 != vec.size())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const set<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const unordered_set<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const multiset<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const unordered_multiset<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &p){os << p.first << " " << p.second; return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const map<T1, T2> &mp){for(auto itr = mp.begin(); itr != mp.end(); ++itr){ os << itr->first << ":" << itr->second; auto titr = itr; if(++titr != mp.end())os << " "; } return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const unordered_map<T1, T2> &mp){for(auto itr = mp.begin(); itr != mp.end(); ++itr){ os << itr->first << ":" << itr->second; auto titr = itr; if(++titr != mp.end())os << " "; } return os;}
int main(int argc, char const* argv[])
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
string s;
char c;
while(true){
cin >> s >> c;
if(s == "EndOfInput" && c == 'X')break;
vector<string> v; string curr = "";
bool u = false;
rep(i, sz(s)){
if('A' <= s[i] && s[i] <= 'Z')u = true;
}
if(u && 'A' <= s[0] && s[0] <= 'Z'){
s += 'X';
rep(i, sz(s)){
if(i > 0 && 'A' <= s[i] && s[i] <= 'Z'){
v.pb(curr);
curr = "";
}
curr += s[i];
}
}else if(u){
s += 'X';
rep(i, sz(s)){
if('A' <= s[i] && s[i] <= 'Z'){
v.pb(curr);
curr = "";
}
curr += s[i];
}
}else{
s += '_';
rep(i, sz(s)){
if(s[i] == '_'){
v.pb(curr);
curr = "";
}else curr += s[i];
}
}
rep(i, sz(v)){
if('A' <= v[i][0] && v[i][0] <= 'Z'){
v[i][0] = 'a' + v[i][0] - 'A';
}
}
if(c == 'L'){
rep(i, sz(v)){
if(i != 0)cout << char('A' + v[i][0] - 'a');
else cout << v[i][0];
FOR(j, 1, sz(v[i]))cout << v[i][j];
}
cout << endl;
}else if(c == 'U'){
rep(i, sz(v)){
cout << char('A' + v[i][0] - 'a');
FOR(j, 1, sz(v[i]))cout << v[i][j];
}
cout << endl;
}else{
rep(i, sz(v)){
cout << v[i];
if(i + 1 != sz(v))cout << "_";
}
cout << endl;
}
}
return 0;
}
``` |
### Prompt
Please create a solution in CPP to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstring>
#include <sstream>
#include <cassert>
using namespace std;
static const double EPS = 1e-5;
typedef long long ll;
typedef pair<int,int> PI;
#define rep(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define MP make_pair
#define PB push_back
string str;
char type;
void pr(int pos){
if(str[pos]=='_')return;
if(pos==0 || str[pos-1]=='_' || isupper(str[pos])){
switch(type){
case 'U':
cout<<(char)toupper(str[pos]);
break;
case 'L':
if(pos==0)cout<<(char)tolower(str[pos]);
else cout<<(char)toupper(str[pos]);
break;
case 'D':
if(pos==0)cout<<(char)tolower(str[pos]);
else cout<<"_"<<(char)tolower(str[pos]);
break;
}
}else{
cout<<str[pos];
}
}
int main(){
while(cin>>str){
cin>>type;
if(type=='X')break;
rep(i,str.size()){
pr(i);
}
cout<<endl;
}
}
``` |
### Prompt
Please create a solution in Java to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```java
import java.util.*;
public class Main {
public static void main(String[] args){
new Main().calc();
}
void calc(){
Scanner cin = new Scanner(System.in);
while(true){
String s = cin.next();
String t = cin.next();
if(t.equals("X")) break;
List<String> l = new LinkedList<String>();
String now = "";
for(char c : s.toCharArray()){
if(c=='_' || Character.isUpperCase(c)){
if(now.length()!=0) l.add(now);
now = "";
}
if(c!='_') now += c;
}
if(now.length()!=0) l.add(now);
int count = 0;
for(String ss: l){
int count2 = 0;
for(char c : ss.toCharArray()){
if(count2 == 0 && !t.equals("D") && !(t.equals("L") && count==0)){
System.out.print(Character.toUpperCase(c));
}
else System.out.print(Character.toLowerCase(c));
count2++;
}
count++;
if(count!=l.size() && t.equals("D")) System.out.print("_");
}
System.out.println();
}
}
}
``` |
### Prompt
Please create a solution in Cpp to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
int main(){
string str;
while(1){
getline(cin,str);
string name = str.substr(0,str.size()-2);
char type = str[str.size()-1];
if(type=='L'){
if(name[0] >= 'a' && name[0] <= 'z'){
for(int i = 0; i < name.size(); i++){
if(name[i] == '_'){
cout << (char)(name[i+1]-'a'+'A') << flush;
i++;
}
else{
cout << name[i] << flush;
}
}
cout<<endl;
}
else{
cout << (char)(name[0]+'a'-'A') << flush;
for(int i = 1; i < name.size(); i++){
cout << name[i]<<flush;
}
cout<<endl;
}
}
else if(type=='U'){
if(name[0] >= 'a' && name[0] <= 'z'){
cout << (char)(name[0]-'a'+'A') << flush;
for(int i = 1; i < name.size(); i++){
if(name[i] == '_'){
cout << (char)(name[i+1]-'a'+'A') << flush;
i++;
}
else{
cout << name[i]<<flush;
}
}
cout<<endl;
}
else{
cout << name[0] << flush;
for(int i = 1; i < name.size(); i++){
cout << name[i]<<flush;
}
cout<<endl;
}
}
else if(type=='D'){
if(name[0] >= 'a' && name[0] <= 'z'){
for(int i = 0; i < name.size(); i++){
if(name[i] >= 'A' && name[i] <= 'Z'){
cout <<'_'<<flush;
cout << (char)(name[i]+'a'-'A') << flush;
//i++;
}
else{
cout << name[i] << flush;
}
}
cout<<endl;
}
else{
cout << (char)(name[0]-'A'+'a') << flush;
for(int i = 1; i < name.size(); i++){
if(name[i] >= 'A' && name[i] <= 'Z'){
cout <<'_'<<flush;
cout << (char)(name[i] - 'A'+'a') << flush;
}
else
cout << name[i]<<flush;
}
cout << endl;
}
}
else
break;
//cout<<endl;
}
return 0;
}
``` |
### Prompt
Your challenge is to write a PYTHON3 solution to the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```python3
while True :
name, type = map(str, input().split())
if type == "X" :
break
else :
N = list(name)
if "_" in N :
if type == "U" or type == "L" :
cnt = 0
for i in range(len(N)) :
if i == 0 and type == "U" :
N[i] = N[i].upper()
elif N[i] == "_" :
cnt += 1
elif cnt == 1 :
N[i] = N[i].upper()
cnt = 0
N = [i for i in N if i != "_"]
elif type == "U" :
N[0] = N[0].upper()
elif type == "L" :
N[0] = N[0].lower()
else :
s = 0
for i in range(len(N)) :
if i == 0 :
N[s] = N[s].lower()
s += 1
elif N[s].isupper() :
N[s] = N[s].lower()
N.insert(s, "_")
s += 2
else :
s += 1
for i in range(len(N)) :
if i == len(N) - 1 :
print(N[i])
else :
print(N[i], end = "")
``` |
### Prompt
Create a solution in Cpp for the following problem:
When naming identifiers (variables and functions) in programming, compound words that concatenate words are used. However, if you concatenate them as they are, you will not be able to understand the word breaks, so in general, select and apply the one that is unified from the following naming conventions:
* Set to Upper CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word.
Example: GetUserName
* Set to Lower CamelCase
Connect words directly to form a compound word, and capitalize only the first letter of each word. However, the first letter of the compound word should be lowercase.
Example: getUserName
* Connect with underscore
Words are concatenated with underscores to form a compound word. Make all letters of the word lowercase.
Example: get_user_name
Create a program that outputs the given identifier by applying the specified naming convention. It is assumed that any of the above naming conventions has already been applied to the identifier given.
Input
Multiple datasets are given as input. Each dataset is given in the following format:
name type (identifier, naming convention: space-separated strings and characters)
type is a character indicating the naming convention and is as shown in the table below:
type | Naming convention
--- | ---
U | Upper CamelCase
L | Lower CamelCase
D | Connect with underscore
The number of characters in the given identifier is 1 or more and 100 or less.
End of input when type is'X'. Do not output to this input.
Output
For each dataset, print the identifier with the naming convention on one line.
Example
Input
get_user_name L
getUserName U
GetUserName D
EndOfInput X
Output
getUserName
GetUserName
get_user_name
### Response
```cpp
#include<iostream>
#include<string>
#include<algorithm>
#include<cmath>
#include<map>
#include<vector>
#include<deque>
using namespace std;
int main() {
string name;
char t;
while(true) {
cin >> name >> t;
if (t == 'X') break;
switch(t) {
case 'U':
if (name.find("_") == string::npos) {
if (name[0] >= 'a' && name[0] <= 'z') {
name[0] += 'A' - 'a';
}
cout << name << endl;
} else {
while(name.find("_") != string::npos) {
name[0] += 'A' - 'a';
cout << name.substr(0, name.find("_"));
name = name.substr(name.find("_") + 1);
}
name[0] += 'A' - 'a';
cout << name << endl;
}
break;
case 'L':
if (name.find("_") == string::npos) {
if (name[0] >= 'A' && name[0] <= 'Z') {
name[0] -= 'A' - 'a';
}
cout << name << endl;
} else {
cout << name.substr(0, name.find("_"));
while(name.find("_") != string::npos) {
name = name.substr(name.find("_") + 1);
name[0] += 'A' - 'a';
cout << name.substr(0, name.find("_"));
}
cout << endl;
}
break;
case 'D':
if (name.find("_") != string::npos) {
cout << name << endl;
} else {
for(int i = 0; i < name.length(); i++) {
if(name[i] >= 'A' && name[i] <= 'Z') {
name[i] -= 'A' - 'a';
if(i != 0) cout << "_";
}
cout << name[i];
}
cout << endl;
}
}
}
return 0;
}
``` |