output
stringlengths 52
181k
| instruction
stringlengths 296
182k
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << (m * 1900 + (n - m) * 100) * pow(2,m);
} | ### Prompt
Your challenge is to write a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << (m * 1900 + (n - m) * 100) * pow(2,m);
}
``` |
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
cout<<(1900*m+100*(n-m))*(pow(2,m))<<endl;
return 0;
} | ### Prompt
Construct a Cpp code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
cout<<(1900*m+100*(n-m))*(pow(2,m))<<endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int n,m,p;
int main(){
cin>>n>>m;
cout<<(1<<m)*(1900*m+100*(n-m));
} | ### Prompt
Construct a cpp code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int n,m,p;
int main(){
cin>>n>>m;
cout<<(1<<m)*(1900*m+100*(n-m));
}
``` |
#include<cstdio>
int main(){
unsigned N, M;
scanf("%u %u", &N, &M);
printf("%u\n", (1<<M)*(1800*M + 100*N));
return 0;
} | ### Prompt
Develop a solution in cpp to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<cstdio>
int main(){
unsigned N, M;
scanf("%u %u", &N, &M);
printf("%u\n", (1<<M)*(1800*M + 100*N));
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
int a=n-m,b=pow(2,m);
cout << (1900*m+100*a)*b << endl;
} | ### Prompt
Your challenge is to write a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
int a=n-m,b=pow(2,m);
cout << (1900*m+100*a)*b << endl;
}
``` |
#include <iostream>
using namespace std;
int main(){
int n, m; cin >> n >> m;
cout << ((1900*m +100*(n-m))<<m) << endl;
return 0;
}
| ### Prompt
Generate a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int n, m; cin >> n >> m;
cout << ((1900*m +100*(n-m))<<m) << endl;
return 0;
}
``` |
#include <stdio.h>
using namespace std;
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
n = 1800 * m + 100 * n;
n <<= m;
printf("%d\n", n);
return 0;
} | ### Prompt
Create a solution in cpp for the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <stdio.h>
using namespace std;
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
n = 1800 * m + 100 * n;
n <<= m;
printf("%d\n", n);
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n,m;cin>>n>>m;
ll sum = (m*1900+(n-m)*100)*pow(2,m);
cout<<sum;
} | ### Prompt
Please formulate a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n,m;cin>>n>>m;
ll sum = (m*1900+(n-m)*100)*pow(2,m);
cout<<sum;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int main() {
cin >> N >> M;
int ans = (1900*M + (N-M)*100)*(1<<M);
cout << ans << endl;
} | ### Prompt
Please provide a CPP coded solution to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N, M;
int main() {
cin >> N >> M;
int ans = (1900*M + (N-M)*100)*(1<<M);
cout << ans << endl;
}
``` |
#include <iostream>
#include <cmath>
using namespace std;
int main(int argc, char *argv[]){
int N,M;
cin>>N>>M;
cout<<((1900*M)+100*(N-M))*pow(2,M);
}
| ### Prompt
Your task is to create a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
#include <cmath>
using namespace std;
int main(int argc, char *argv[]){
int N,M;
cin>>N>>M;
cout<<((1900*M)+100*(N-M))*pow(2,M);
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main()
{
long n,m;
cin>>n>>m;
cout<<(1900*m+100*(n-m))*(pow(2,m))<<endl;
return 0;
} | ### Prompt
Construct a cpp code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
long n,m;
cin>>n>>m;
cout<<(1900*m+100*(n-m))*(pow(2,m))<<endl;
return 0;
}
``` |
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
cout << (m*1900 + (n-m)*100) * pow(2, m) << endl;
} | ### Prompt
Create a solution in cpp for the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
cout << (m*1900 + (n-m)*100) * pow(2, m) << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a, b;
cin >> a >> b;
cout << (1 << b)*(b*1900 + 100*(a - b)) << "\n";
return 0;
}
| ### Prompt
Develop a solution in CPP to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int a, b;
cin >> a >> b;
cout << (1 << b)*(b*1900 + 100*(a - b)) << "\n";
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin>>N>>M;
cout<<(M*1900+(N-M)*100)*pow(2,M)<<endl;
return 0;
}
| ### Prompt
In Cpp, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin>>N>>M;
cout<<(M*1900+(N-M)*100)*pow(2,M)<<endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main() {
double n, m; cin >> n >> m;
cout << (1900 * m + (n - m) * 100) * pow(2, m);
} | ### Prompt
Generate a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main() {
double n, m; cin >> n >> m;
cout << (1900 * m + (n - m) * 100) * pow(2, m);
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n,m;
cin>>n>>m;
cout<<pow(2,m)*((n-m)*100+m*1900)<<endl;
return 0;
} | ### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n,m;
cin>>n>>m;
cout<<pow(2,m)*((n-m)*100+m*1900)<<endl;
return 0;
}
``` |
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main(){
int N, M;
cin >> N >> M;
cout << (100*(N-M)+1900*M)*pow(2,M) << endl;
} | ### Prompt
Your task is to create a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main(){
int N, M;
cin >> N >> M;
cout << (100*(N-M)+1900*M)*pow(2,M) << endl;
}
``` |
#include<bits/stdc++.h>
int main()
{
int n,m;
std::cin>>n>>m;
std::cout<<(1900*m+100*(n-m))*(pow(2,m))<<std::endl;
return 0;
} | ### Prompt
Generate a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
int main()
{
int n,m;
std::cin>>n>>m;
std::cout<<(1900*m+100*(n-m))*(pow(2,m))<<std::endl;
return 0;
}
``` |
#include<stdio.h>
#include<math.h>
int main(){
int x,y;
scanf("%d%d",&x,&y);
int ans=pow(2,y)*((x-y)*100+(y*1900));
printf("%d\n",ans);
return 0;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<stdio.h>
#include<math.h>
int main(){
int x,y;
scanf("%d%d",&x,&y);
int ans=pow(2,y)*((x-y)*100+(y*1900));
printf("%d\n",ans);
return 0;
}
``` |
#include <bits/stdc++.h>
int n, m;
int main() {
scanf("%d %d", &n, &m);
printf("%d", (100 * n + 1800 * m) * (1 << m));
return 0;
}
| ### Prompt
Please formulate a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
int n, m;
int main() {
scanf("%d %d", &n, &m);
printf("%d", (100 * n + 1800 * m) * (1 << m));
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
cout << (1900 * M + 100 * (N - M)) * (1 << M) << "\n";
} | ### Prompt
Please formulate a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
cout << (1900 * M + 100 * (N - M)) * (1 << M) << "\n";
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int ACT = (N-M) * 100 + M * 1900;
cout << pow(2,M) * ACT<< endl;
} | ### Prompt
In Cpp, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
int ACT = (N-M) * 100 + M * 1900;
cout << pow(2,M) * ACT<< endl;
}
``` |
#include<iostream>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
cout << (1900*m+100*(n-m)) * (1<<m) << endl;
return 0;
} | ### Prompt
Generate a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
cout << (1900*m+100*(n-m)) * (1<<m) << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,m;cin>>n>>m;
long x = 100 * (n-m) + 1900 * m;
cout << x * pow(2,m);
}
| ### Prompt
In CPP, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,m;cin>>n>>m;
long x = 100 * (n-m) + 1900 * m;
cout << x * pow(2,m);
}
``` |
#include <iostream>
#include <math.h>
using namespace std ;
int main(){
int n,m ;
cin >> n >> m ;
cout << ((n-m)*100+m*1900)*pow(2,m) << endl ;
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
#include <math.h>
using namespace std ;
int main(){
int n,m ;
cin >> n >> m ;
cout << ((n-m)*100+m*1900)*pow(2,m) << endl ;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M; cin >> N >> M;
cout << (1900 * M + 100 * (N - M)) * (1 << M) << '\n';
} | ### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M; cin >> N >> M;
cout << (1900 * M + 100 * (N - M)) * (1 << M) << '\n';
}
``` |
#include<iostream>
#include<cmath>
using namespace std;
int main(){
double n,m;
cin>>n>>m;
cout<<(int)(1900*m+100*(n-m))*powl(2,m)<<endl;
} | ### Prompt
Please formulate a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<iostream>
#include<cmath>
using namespace std;
int main(){
double n,m;
cin>>n>>m;
cout<<(int)(1900*m+100*(n-m))*powl(2,m)<<endl;
}
``` |
#include<bits/stdc++.h>
using l=long long;using namespace std;int main(){l N,M;cin>>N>>M;cout<<(1900LL*M+100LL*(N-M))*(1L<<M)<<endl;return 0;}
| ### Prompt
Please formulate a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using l=long long;using namespace std;int main(){l N,M;cin>>N>>M;cout<<(1900LL*M+100LL*(N-M))*(1L<<M)<<endl;return 0;}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M;
cin >> N >> M;
cout << ((N - M) * 100 + M * 1900) * pow(2, M) << endl;
} | ### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M;
cin >> N >> M;
cout << ((N - M) * 100 + M * 1900) * pow(2, M) << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,m;
cin>>n>>m;
int A=1;
for(int i=0; i<m; i++){
A*=2;
}
cout<<A*(1900*m+100*(n-m))<<endl;
} | ### Prompt
Your task is to create a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,m;
cin>>n>>m;
int A=1;
for(int i=0; i<m; i++){
A*=2;
}
cout<<A*(1900*m+100*(n-m))<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int i,j,m,n;
cin>>n>>m;
cout<<(1900*m+(n-m)*100)*pow(2,m)<<endl;
return 0;
} | ### Prompt
Your task is to create a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
int i,j,m,n;
cin>>n>>m;
cout<<(1900*m+(n-m)*100)*pow(2,m)<<endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
int c=1;
for(int i=0;i<b;i++) c*=2;
cout<<((a-b)*100+b*1900)*c;
} | ### Prompt
Your challenge is to write a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
int c=1;
for(int i=0;i<b;i++) c*=2;
cout<<((a-b)*100+b*1900)*c;
}
``` |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
ll n,m;
cin >> n >> m;
cout << ((n-m) *100 + 1900*m )* (1LL<<m) << endl;
}
| ### Prompt
Construct a Cpp code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
ll n,m;
cin >> n >> m;
cout << ((n-m) *100 + 1900*m )* (1LL<<m) << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main() {
int n, m, l;
cin >> n >> m;
l = ((n - m) + 19 * m) * pow(2, m) * 100;
cout << l;
} | ### Prompt
Develop a solution in Cpp to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main() {
int n, m, l;
cin >> n >> m;
l = ((n - m) + 19 * m) * pow(2, m) * 100;
cout << l;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n, m;
cin >> n >> m;
cout << ((1900 * m) + 100 * (n - m)) * pow(2, m);
return 0;
} | ### Prompt
Develop a solution in Cpp to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n, m;
cin >> n >> m;
cout << ((1900 * m) + 100 * (n - m)) * pow(2, m);
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
long long n,m;
int main()
{
cin>>n>>m;
n-=m;
cout<<(n*100+1900*m)*(1<<m);
return 0;
} | ### Prompt
Your task is to create a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
long long n,m;
int main()
{
cin>>n>>m;
n-=m;
cout<<(n*100+1900*m)*(1<<m);
return 0;
}
``` |
#include<iostream>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << ((n-m)*100+m*1900)*(1<<m) << endl;
return 0;
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<iostream>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << ((n-m)*100+m*1900)*(1<<m) << endl;
return 0;
}
``` |
#include <iostream>
#include <cmath>
int main(){
int N, M;
std::cin >> N >> M;
std::cout << (100*(N-M) + 1900*M)*pow(2,M) << std::endl;
return 0;
}
| ### Prompt
In Cpp, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
#include <cmath>
int main(){
int N, M;
std::cin >> N >> M;
std::cout << (100*(N-M) + 1900*M)*pow(2,M) << std::endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a,b;
cin>>a>>b;
cout<<(1900*b+100*(a-b))*(pow(2,b))<<endl;
return 0;
} | ### Prompt
Your challenge is to write a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a,b;
cin>>a>>b;
cout<<(1900*b+100*(a-b))*(pow(2,b))<<endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(void){
int n,m; cin>>n>>m;
cout<< ((n-m)*100+m*1900) * pow(2,m)<<endl;
}
| ### Prompt
Please formulate a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(void){
int n,m; cin>>n>>m;
cout<< ((n-m)*100+m*1900) * pow(2,m)<<endl;
}
``` |
#include <cstdio>
int f[10];
int main(){
int n,m;
scanf("%d%d",&n,&m);
int x=(1<<m);
printf("%d\n",x*m*1900+x*(n-m)*100);
return 0;
}
| ### Prompt
In cpp, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <cstdio>
int f[10];
int main(){
int n,m;
scanf("%d%d",&n,&m);
int x=(1<<m);
printf("%d\n",x*m*1900+x*(n-m)*100);
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;cin>>n>>m;
int t=100*n+1800*m;
cout<<t*pow(2,m)<<endl;
} | ### Prompt
Your challenge is to write a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;cin>>n>>m;
int t=100*n+1800*m;
cout<<t*pow(2,m)<<endl;
}
``` |
#include <iostream>
#include <cmath>
int main(){
int n,m;
std::cin>>n>>m;
std::cout<<(1900*m+100*(n-m))*pow(2,m)<<std::endl;
} | ### Prompt
Develop a solution in Cpp to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
#include <cmath>
int main(){
int n,m;
std::cin>>n>>m;
std::cout<<(1900*m+100*(n-m))*pow(2,m)<<std::endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(void)
{
int n,m;
cin>>n>>m;
cout<<((m)*1900 + (n - m)*100)*pow(2,m)<<endl;
return 0;
} | ### Prompt
Please create a solution in Cpp to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(void)
{
int n,m;
cin>>n>>m;
cout<<((m)*1900 + (n - m)*100)*pow(2,m)<<endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin >> N >> M;
int one = M*1900 +(N-M)*100;
cout << one * pow(2,M) << endl;
} | ### Prompt
Please provide a CPP coded solution to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin >> N >> M;
int one = M*1900 +(N-M)*100;
cout << one * pow(2,M) << endl;
}
``` |
#include <iostream>
using namespace std;
int main(){
int n,m; cin >> n >> m;
int success = (1<<m);
cout << ((n-m) * 100 + m * 1900) * success << endl;
} | ### Prompt
Create a solution in CPP for the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
using namespace std;
int main(){
int n,m; cin >> n >> m;
int success = (1<<m);
cout << ((n-m) * 100 + m * 1900) * success << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int main() {
cin >> N >> M;
cout << (100 * N + 1800 * M)*(1 << M) << endl;
}
| ### Prompt
Please create a solution in cpp to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int N, M;
int main() {
cin >> N >> M;
cout << (100 * N + 1800 * M)*(1 << M) << endl;
}
``` |
#include <iostream>
using namespace std;
int main()
{
int n,m;
int ans=0;
cin>>n>>m;
ans=1900*m+100*(n-m);
ans*=(1<<m);
cout<<ans<<endl;
return 0;
} | ### Prompt
Generate a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
using namespace std;
int main()
{
int n,m;
int ans=0;
cin>>n>>m;
ans=1900*m+100*(n-m);
ans*=(1<<m);
cout<<ans<<endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
int ans;
ans=((n-m)*100+1900*m)*pow(2,m);
cout<<ans;
}
| ### Prompt
Please formulate a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
int ans;
ans=((n-m)*100+1900*m)*pow(2,m);
cout<<ans;
}
``` |
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
cout << pow(2, m)*(100*n+1800*m);
return 0;
} | ### Prompt
Generate a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
cout << pow(2, m)*(100*n+1800*m);
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n, m;
cin >> n >> m;
cout << (1800*m + 100*n)*(pow(2, m)) << endl;
} | ### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n, m;
cin >> n >> m;
cout << (1800*m + 100*n)*(pow(2, m)) << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int n, m;
int main()
{
cin >> n >> m;
cout << ((n-m)*100+m*1900)*(1<<m);
} | ### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int n, m;
int main()
{
cin >> n >> m;
cout << ((n-m)*100+m*1900)*(1<<m);
}
``` |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n >> m;
cout << ((n-m) * 100 + m * 1900) * (1 << m) << endl;
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n >> m;
cout << ((n-m) * 100 + m * 1900) * (1 << m) << endl;
}
``` |
#include <cstdio>
int main()
{
long long n, m;
scanf("%lld %lld", &n, &m);
printf("%lld\n", (1 << m) * (1800 * m + 100 * n));
return 0;
}
| ### Prompt
In Cpp, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <cstdio>
int main()
{
long long n, m;
scanf("%lld %lld", &n, &m);
printf("%lld\n", (1 << m) * (1800 * m + 100 * n));
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
cout<<(1900*m+100*(n-m))*(int)pow(2,m)<<endl;
} | ### Prompt
Please provide a Cpp coded solution to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
cout<<(1900*m+100*(n-m))*(int)pow(2,m)<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int N,M;
cin>>N>>M;
int ans=(1900*M+100*(N-M))*pow(2,M);
cout<<ans<<endl;
return 0;
} | ### Prompt
Construct a Cpp code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(void){
int N,M;
cin>>N>>M;
int ans=(1900*M+100*(N-M))*pow(2,M);
cout<<ans<<endl;
return 0;
}
``` |
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
int N,M;cin>>N>>M;
cout<<pow(2,M)*(M*1900+(N-M)*100)<<endl;
return 0;
} | ### Prompt
Your task is to create a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
int N,M;cin>>N>>M;
cout<<pow(2,M)*(M*1900+(N-M)*100)<<endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n, m; cin >> n >> m;
cout << (1900*m + 100*(n-m))*pow(2, m) << endl;
} | ### Prompt
Construct a cpp code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n, m; cin >> n >> m;
cout << (1900*m + 100*(n-m))*pow(2, m) << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int a,b;
int main()
{cin>>a>>b;cout<<(1900*b+100*(a-b))*(pow(2,b));cout<<endl;return 0;} | ### Prompt
Generate a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int a,b;
int main()
{cin>>a>>b;cout<<(1900*b+100*(a-b))*(pow(2,b));cout<<endl;return 0;}
``` |
#include<bits/stdc++.h>
using namespace std ;
int main(){
long long N , M , A ;
cin >> N >> M ;
A = (1900*M+100*(N-M))*pow(2,M) ;
cout << A << endl;
} | ### Prompt
Develop a solution in Cpp to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std ;
int main(){
long long N , M , A ;
cin >> N >> M ;
A = (1900*M+100*(N-M))*pow(2,M) ;
cout << A << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << (100*(n-m)+1900*m)*(pow(2,m)) << endl;
} | ### Prompt
Develop a solution in CPP to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << (100*(n-m)+1900*m)*(pow(2,m)) << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
int t = (n-m)*100+m*1900;
cout << (int)(pow(2.0,m)*t)<<endl;
} | ### Prompt
Generate a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
int t = (n-m)*100+m*1900;
cout << (int)(pow(2.0,m)*t)<<endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
cout << 100 * (18 * m + n) * floor(pow(2, m));
} | ### Prompt
Construct a cpp code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
cout << 100 * (18 * m + n) * floor(pow(2, m));
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
cout<<(1900*m+100*(n-m))*pow(2,m)<<endl;
} | ### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
cout<<(1900*m+100*(n-m))*pow(2,m)<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long n,m;
cin>>n>>m;
printf("%.0f\n",(1900*m+100*(n-m))*pow(2,m));
return 0;
} | ### Prompt
In CPP, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long n,m;
cin>>n>>m;
printf("%.0f\n",(1900*m+100*(n-m))*pow(2,m));
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main () {
int N, M;
cin >> N >> M;
cout <<(long) (1800 * M + 100 * N) * pow(2,M) << endl;
return 0;
} | ### Prompt
Generate a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main () {
int N, M;
cin >> N >> M;
cout <<(long) (1800 * M + 100 * N) * pow(2,M) << endl;
return 0;
}
``` |
#include<iostream>
using namespace std;
int main() {
long long n,m;
cin>>n>>m;
cout<<((n-m)*100+m*1900)*((long long)1<<m)<<endl;
} | ### Prompt
In Cpp, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<iostream>
using namespace std;
int main() {
long long n,m;
cin>>n>>m;
cout<<((n-m)*100+m*1900)*((long long)1<<m)<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << ((n - m) * 100 + m * 1900) * pow(2, m) << endl;
}
| ### Prompt
Please create a solution in Cpp to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << ((n - m) * 100 + m * 1900) * pow(2, m) << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
cout<<((n-m)*100+1900*m)*pow(2,m)<<endl;
}
| ### Prompt
Your challenge is to write a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
cout<<((n-m)*100+1900*m)*pow(2,m)<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
cout<<(1900*m+100*(n-m))*(1<<m)<<endl;
} | ### Prompt
Please provide a Cpp coded solution to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
cout<<(1900*m+100*(n-m))*(1<<m)<<endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a,b;cin>>a>>b;
cout<<(pow(2,b))*(100*(a-b)+b*1900);
cout<<"\n";
return 0;
}
| ### Prompt
Create a solution in cpp for the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a,b;cin>>a>>b;
cout<<(pow(2,b))*(100*(a-b)+b*1900);
cout<<"\n";
return 0;
}
``` |
#include<stdio.h>
int main(){
int N,M,m=1,i;
scanf("%d%d",&N,&M);
for(i=0;i<M;i++){
m=m*2;}
printf("%d",(N-M)*100*m+M*1900*m);
return 0;} | ### Prompt
Create a solution in CPP for the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<stdio.h>
int main(){
int N,M,m=1,i;
scanf("%d%d",&N,&M);
for(i=0;i<M;i++){
m=m*2;}
printf("%d",(N-M)*100*m+M*1900*m);
return 0;}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N, M;
cin >> N >> M;
cout << (1900*M+(N-M)*100)*pow(2,M) << endl;
}
| ### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int N, M;
cin >> N >> M;
cout << (1900*M+(N-M)*100)*pow(2,M) << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N, M; cin >> N >> M;
cout << (N * 100 + M * 1800) * pow(2, M) << endl;
} | ### Prompt
Construct a CPP code solution to the problem outlined:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int N, M; cin >> N >> M;
cout << (N * 100 + M * 1800) * pow(2, M) << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << (1900*m+100*(n-m))*(pow(2,m))<<endl;
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << (1900*m+100*(n-m))*(pow(2,m))<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin >> N >> M;
cout << (1800*M+100*N)*pow(2,M) << endl;
return 0;
} | ### Prompt
Generate a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin >> N >> M;
cout << (1800*M+100*N)*pow(2,M) << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << (1900*m + 100 * (n-m)) * pow(2, m);
} | ### Prompt
In cpp, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << (1900*m + 100 * (n-m)) * pow(2, m);
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, M;
cin >> N >> M;
cout << ((N - M)*100 + 1900*M)*pow(2,M) << endl;
return 0;
} | ### Prompt
Your challenge is to write a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, M;
cin >> N >> M;
cout << ((N - M)*100 + 1900*M)*pow(2,M) << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
cout<<pow(2,m)*(1900*m + 100*(n-m));
} | ### Prompt
Your challenge is to write a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
cout<<pow(2,m)*(1900*m + 100*(n-m));
}
``` |
#include <iostream>
using namespace std;
int main()
{
int n, m;
cin >> n >> m;
cout << (1 << m)*(1800 * m + 100 * n) << endl;
return 0;
}
| ### Prompt
Your task is to create a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
using namespace std;
int main()
{
int n, m;
cin >> n >> m;
cout << (1 << m)*(1800 * m + 100 * n) << endl;
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
int x = 1900*m + 100*(n-m);
cout << (1 << m) * x << '\n';
} | ### Prompt
Generate a CPP solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
int x = 1900*m + 100*(n-m);
cout << (1 << m) * x << '\n';
}
``` |
#include <iostream>
#include <cmath>
using namespace std;
int main(void){
int n, m;
cin >> n >> m;
cout << pow(2,m)*(1800*m+100*n) << endl;
} | ### Prompt
Create a solution in cpp for the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
#include <cmath>
using namespace std;
int main(void){
int n, m;
cin >> n >> m;
cout << pow(2,m)*(1800*m+100*n) << endl;
}
``` |
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int N,M;
cin>>N>>M;
long ans=pow(2,M)*(100*(N-M)+1900*M);
cout<<ans<<endl;
}
| ### Prompt
Please create a solution in cpp to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int N,M;
cin>>N>>M;
long ans=pow(2,M)*(100*(N-M)+1900*M);
cout<<ans<<endl;
}
``` |
#include <cstdio>
int main() {
int n, m;
scanf("%d%d", &n, &m);
printf("%d\n", 1900*(1 << m)*m + 100*(n - m)*(1 << m));
return 0;
} | ### Prompt
In CPP, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <cstdio>
int main() {
int n, m;
scanf("%d%d", &n, &m);
printf("%d\n", 1900*(1 << m)*m + 100*(n - m)*(1 << m));
return 0;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin >> N >> M;
int ans=(100*(N-M)+1900*M)*pow(2,M);
cout << ans << endl;
} | ### Prompt
Please create a solution in CPP to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin >> N >> M;
int ans=(100*(N-M)+1900*M)*pow(2,M);
cout << ans << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
cout << pow(2,b)*(1900*b+100*(a-b)) << endl;
return 0;
}
| ### Prompt
Your task is to create a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
cout << pow(2,b)*(1900*b+100*(a-b)) << endl;
return 0;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin>>N>>M;
cout<<(1900ll*M + 100ll*(N-M))*(1ll<<M)<<endl;
} | ### Prompt
Generate a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin>>N>>M;
cout<<(1900ll*M + 100ll*(N-M))*(1ll<<M)<<endl;
}
``` |
#include <iostream>
#include <cmath>
using namespace std;
int n, m;
int main() {
cin>>n>>m;
cout<<(1900*m + 100*(n-m)) * pow(2,m);
return 0;
} | ### Prompt
Please create a solution in cpp to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
#include <cmath>
using namespace std;
int n, m;
int main() {
cin>>n>>m;
cout<<(1900*m + 100*(n-m)) * pow(2,m);
return 0;
}
``` |
#include <iostream>
#include <math.h>
using namespace std;
int main(){
int n,m,time;
cin>>n>>m;
time=((n-m)*100+m*1900)*pow(2,m);
cout<< time;
}
| ### Prompt
Please provide a CPP coded solution to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
#include <math.h>
using namespace std;
int main(){
int n,m,time;
cin>>n>>m;
time=((n-m)*100+m*1900)*pow(2,m);
cout<< time;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long N,M;cin>>N>>M;
cout<<((N-M)*100+1900*M)*pow(2,M)<<endl;
} | ### Prompt
Generate a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
long long N,M;cin>>N>>M;
cout<<((N-M)*100+1900*M)*pow(2,M)<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n,m;
cin>>n>>m;
cout<<(ll)pow(2,m)*(1800*m+100*n)<<endl;
}
| ### Prompt
In Cpp, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n,m;
cin>>n>>m;
cout<<(ll)pow(2,m)*(1800*m+100*n)<<endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int i,j,k,n,m;
cin>>n>>m;
int ans=(1900*m+100*(n-m))*pow(2,m);
cout<<ans<<endl;
} | ### Prompt
Your task is to create a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main()
{
int i,j,k,n,m;
cin>>n>>m;
int ans=(1900*m+100*(n-m))*pow(2,m);
cout<<ans<<endl;
}
``` |
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << (100*n+1800*m)*pow(2,m) << endl;
} | ### Prompt
Develop a solution in Cpp to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << (100*n+1800*m)*pow(2,m) << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int x[100000];
int main(){
int n,m;
cin>>n>>m;
int s=1800*m+100*n;
cout<<s*pow(2,m)<<endl;
return 0;
} | ### Prompt
Your task is to create a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int x[100000];
int main(){
int n,m;
cin>>n>>m;
int s=1800*m+100*n;
cout<<s*pow(2,m)<<endl;
return 0;
}
``` |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
ll n,m;
cin>>n>>m;
cout<<pow(2,m)*(100*(n-m)+1900*m)<<endl;
} | ### Prompt
Your challenge is to write a cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
ll n,m;
cin>>n>>m;
cout<<pow(2,m)*(100*(n-m)+1900*m)<<endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,M,ans=0;
cin >> N >> M;
cout << pow(2,M)*((N-M)*100+1900*M) << endl;
} | ### Prompt
Your challenge is to write a Cpp solution to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,M,ans=0;
cin >> N >> M;
cout << pow(2,M)*((N-M)*100+1900*M) << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << (100*n+1800*m)*pow(2,m) << endl;
} | ### Prompt
Develop a solution in cpp to the problem described below:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
cout << (100*n+1800*m)*pow(2,m) << endl;
}
``` |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,M;
cin >> N >> M;
cout << std::pow(2,M) * ((N-M)*100 + M*1900) << endl;
}
| ### Prompt
Create a solution in Cpp for the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,M;
cin >> N >> M;
cout << std::pow(2,M) * ((N-M)*100 + M*1900) << endl;
}
``` |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long N,M;
cin >> N >> M;
cout << (1900 * M + 100*(N - M) ) * pow(2,M) << endl;
} | ### Prompt
In CPP, your task is to solve the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include<bits/stdc++.h>
using namespace std;
int main(){
long long N,M;
cin >> N >> M;
cout << (1900 * M + 100*(N - M) ) * pow(2,M) << endl;
}
``` |
#include"bits/stdc++.h"
using namespace std;
int main(){
int n,m;
cin>>n>>m;
cout<<(100*n+1800*m)*(1<<m);
}
| ### Prompt
Please create a solution in cpp to the following problem:
Takahashi is now competing in a programming contest, but he received TLE in a problem where the answer is `YES` or `NO`.
When he checked the detailed status of the submission, there were N test cases in the problem, and the code received TLE in M of those cases.
Then, he rewrote the code to correctly solve each of those M cases with 1/2 probability in 1900 milliseconds, and correctly solve each of the other N-M cases without fail in 100 milliseconds.
Now, he goes through the following process:
* Submit the code.
* Wait until the code finishes execution on all the cases.
* If the code fails to correctly solve some of the M cases, submit it again.
* Repeat until the code correctly solve all the cases in one submission.
Let the expected value of the total execution time of the code be X milliseconds. Print X (as an integer).
Constraints
* All input values are integers.
* 1 \leq N \leq 100
* 1 \leq M \leq {\rm min}(N, 5)
Input
Input is given from Standard Input in the following format:
N M
Output
Print X, the expected value of the total execution time of the code, as an integer. It can be proved that, under the constraints in this problem, X is an integer not exceeding 10^9.
Examples
Input
1 1
Output
3800
Input
10 2
Output
18400
Input
100 5
Output
608000
### Response
```cpp
#include"bits/stdc++.h"
using namespace std;
int main(){
int n,m;
cin>>n>>m;
cout<<(100*n+1800*m)*(1<<m);
}
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.