task_id stringlengths 5 7 | prompt stringlengths 133 1.35k | canonical_solution stringlengths 18 1.4k | test stringlengths 148 1.76k | declaration stringlengths 111 254 | example_test stringlengths 0 679 | full_code stringlengths 135 1.59k |
|---|---|---|---|---|---|---|
CPP/104 | /*
Given a vector of positive integers x. return a sorted vector of all
elements that hasn't any even digit.
Note: Returned vector should be sorted in increasing order.
For example:
>>> unique_digits({15, 33, 1422, 1})
{1, 15, 33}
>>> unique_digits({152, 323, 1422, 10})
{}
*/
#include<stdio.h>
#include<vector>
#incl... | vector<int> out={};
for (int i=0;i<x.size();i++)
{
int num=x[i];
bool u=true;
if (num==0) u=false;
while (num>0 and u)
{
if (num%2==0) u=false;
num=num/10;
}
if (u) out.push_back(x[i]);
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(unique_digits({15, 33, 1422, 1}) , {1, 15, 33}));
assert (issame(unique... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> unique_digits(vector<int> x){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(unique_digits({15, 33, 1422, 1}) , {1, 15, 33}));
assert (issame(unique... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> unique_digits(vector<int> x){
vector<int> out={};
for (int i=0;i<x.size();i++)
{
int num=x[i];
bool u=true;
if (num==0) u=false;
whi... |
CPP/105 | /*
Given a vector of integers, sort the integers that are between 1 and 9 inclusive,
reverse the resulting vector, and then replace each digit by its corresponding name from
"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
For example:
arr = {2, 1, 1, 4, 5, 8, 2, 3}
-> sort arr -> {... | map<int,string> numto={{0,"Zero"},{1,"One"},{2,"Two"},{3,"Three"},{4,"Four"},{5,"Five"},{6,"Six"},{7,"Seven"},{8,"Eight"},{9,"Nine"}};
sort(arr.begin(),arr.end());
vector<string> out={};
for (int i=arr.size()-1;i>=0;i-=1)
if (arr[i]>=1 and arr[i]<=9)
out.push_back(numto[arr[i]]);
ret... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(by_length({2, 1, 1, 4, 5, 8, 2, 3}) , {"Eight", "Five", "Four", "Thre... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<string> by_length(vector<int> arr){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(by_length({2, 1, 1, 4, 5, 8, 2, 3}) , {"Eight", "Five", "Four", "Thre... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<string> by_length(vector<int> arr){
map<int,string> numto={{0,"Zero"},{1,"One"},{2,"Two"},{3,"Three"},{4,"Four"},{5,"Five"},{6,"Six"},{7,"Seven"},{8,"Eight"},{9,"Nine... |
CPP/106 | /*
Implement the function f that takes n as a parameter,
and returns a vector of size n, such that the value of the element at index i is the factorial of i if i is even
or the sum of numbers from 1 to i otherwise.
i starts from 1.
the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
E... | int sum=0,prod=1;
vector<int> out={};
for (int i=1;i<=n;i++)
{
sum+=i;
prod*=i;
if (i%2==0) out.push_back(prod);
else out.push_back(sum);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(f(5) , {1, 2, 6, 24, 15}));
assert (issame(f(7) , {1, 2, 6, 24, 15, 720... | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
vector<int> f(int n){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(f(5) , {1, 2, 6, 24, 15}));
}
| #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
vector<int> f(int n){
int sum=0,prod=1;
vector<int> out={};
for (int i=1;i<=n;i++)
{
sum+=i;
prod*=i;
if (i%2==0) out.push_back(prod);
else out.push_back(sum);
... |
CPP/107 | /*
Given a positive integer n, return a vector that has the number of even and odd
integer palindromes that fall within the range(1, n), inclusive.
Example 1:
Input: 3
Output: (1, 2)
Explanation:
Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
Example 2:
Input: 12
... | int num1=0,num2=0;
for (int i=1;i<=n;i++)
{
string w=to_string(i);
string p(w.rbegin(),w.rend());
if (w==p and i%2==1) num1+=1;
if (w==p and i%2==0) num2+=1;
}
return {num2,num1};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(even_odd_palindrome(123) , {8, 13}));
assert (issame(even_odd_palindrom... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
vector<int> even_odd_palindrome(int n){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(even_odd_palindrome(12) , {4, 6}));
assert (issame(even_odd_palindrome(... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
vector<int> even_odd_palindrome(int n){
int num1=0,num2=0;
for (int i=1;i<=n;i++)
{
string w=to_string(i);
string p(w.rbegin(),w.rend());
if (w==p and i%2=... |
CPP/108 | /*
Write a function count_nums which takes a vector of integers and returns
the number of elements which has a sum of digits > 0.
If a number is negative, then its first signed digit will be negative:
e.g. -123 has signed digits -1, 2, and 3.
>>> count_nums({}) == 0
>>> count_nums({-1, 11, -11}) == 1
>>> count_nums({1,... | int num=0;
for (int i=0;i<n.size();i++)
if (n[i]>0) num+=1;
else
{
int sum=0;
int w;
w=abs(n[i]);
while (w>=10)
{
sum+=w%10;
w=w/10;
}
sum-=w;
if (sum>0) num+=1... | #undef NDEBUG
#include<assert.h>
int main(){
assert (count_nums({}) == 0);
assert (count_nums({-1, -2, 0}) == 0);
assert (count_nums({1, 1, 2, -2, 3, 4, 5}) == 6);
assert (count_nums({1, 6, 9, -6, 0, 1, 5}) == 5);
assert (count_nums({1, 100, 98, -7, 1, -1}) == 4);
assert (count_nums({12, 23, 34,... | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
int count_nums(vector<int> n){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (count_nums({}) == 0);
assert (count_nums({-1, 11, -11}) == 1);
assert (count_nums({1, 1, 2}) == 3);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
int count_nums(vector<int> n){
int num=0;
for (int i=0;i<n.size();i++)
if (n[i]>0) num+=1;
else
{
int sum=0;
int w;
w=abs(n[i]);
... |
CPP/109 | /*
We have a vector "arr" of N integers arr[1], arr[2], ..., arr[N].The
numbers in the vector will be randomly ordered. Your task is to determine if
it is possible to get a vector sorted in non-decreasing order by performing
the following operation on the given vector:
You are allowed to perform right shift operat... | int num=0;
if (arr.size()==0) return true;
for (int i=1;i<arr.size();i++)
if (arr[i]<arr[i-1]) num+=1;
if (arr[arr.size()-1]>arr[0]) num+=1;
if (num<2) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (move_one_ball({3, 4, 5, 1, 2})==true);
assert (move_one_ball({3, 5, 10, 1, 2})==true);
assert (move_one_ball({4, 3, 1, 2})==false);
assert (move_one_ball({3, 5, 4, 1, 2})==false);
assert (move_one_ball({})==true);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
bool move_one_ball(vector<int> arr){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (move_one_ball({3, 4, 5, 1, 2})==true);
assert (move_one_ball({3, 5, 4, 1, 2})==false);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
bool move_one_ball(vector<int> arr){
int num=0;
if (arr.size()==0) return true;
for (int i=1;i<arr.size();i++)
if (arr[i]<arr[i-1]) num+=1;
if (arr[arr.size()-1]>arr[0]) num+=1;
if... |
CPP/110 | /*
In this problem, you will implement a function that takes two vectors of numbers,
and determines whether it is possible to perform an exchange of elements
between them to make lst1 a vector of only even numbers.
There is no limit on the number of exchanged elements between lst1 and lst2.
If it is possible to exchang... | int num=0;
for (int i=0;i<lst1.size();i++)
if (lst1[i]%2==0) num+=1;
for (int i=0;i<lst2.size();i++)
if (lst2[i]%2==0) num+=1;
if (num>=lst1.size()) return "YES";
return "NO";
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (exchange({1, 2, 3, 4}, {1, 2, 3, 4}) == "YES");
assert (exchange({1, 2, 3, 4}, {1, 5, 3, 4}) == "NO");
assert (exchange({1, 2, 3, 4}, {2, 1, 4, 3}) == "YES" );
assert (exchange({5, 7, 3}, {2, 6, 4}) == "YES");
assert (exchange({5, 7, 3}, {2, 6, 3}... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string exchange(vector<int> lst1,vector<int> lst2){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (exchange({1, 2, 3, 4}, {1, 2, 3, 4}) == "YES");
assert (exchange({1, 2, 3, 4}, {1, 5, 3, 4}) == "NO");
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string exchange(vector<int> lst1,vector<int> lst2){
int num=0;
for (int i=0;i<lst1.size();i++)
if (lst1[i]%2==0) num+=1;
for (int i=0;i<lst2.size();i++)
if (lst2[i]%2==0) ... |
CPP/111 | /*
Given a string representing a space separated lowercase letters, return a map
of the letter with the most repetition and containing the corresponding count.
If several letters have the same occurrence, return all of them.
Example:
histogram("a b c") == {{"a", 1}, {"b", 1}, {"c", 1}}
histogram("a b b a") == {{"a", 2... | map<char,int> count={},out={};
map <char,int>::iterator it;
int max=0;
for (int i=0;i<test.length();i++)
if (test[i]!=' ')
{
count[test[i]]+=1;
if (count[test[i]]>max) max=count[test[i]];
}
for (it=count.begin();it!=count.end();it++)
{
char... | #undef NDEBUG
#include<assert.h>
bool issame(map<char,int> a,map<char,int> b){
if (a.size()!=b.size()) return false;
map <char,int>::iterator it;
for (it=a.begin();it!=a.end();it++)
{
char w1=it->first;
int w2=it->second;
if (b.find(w1)==b.end()) return false;
if (b[w1]!=... | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
map<char,int> histogram(string test){
| #undef NDEBUG
#include<assert.h>
bool issame(map<char,int> a,map<char,int> b){
if (a.size()!=b.size()) return false;
map <char,int>::iterator it;
for (it=a.begin();it!=a.end();it++)
{
char w1=it->first;
int w2=it->second;
if (b.find(w1)==b.end()) return false;
if (b[w1]!=... | #include<stdio.h>
#include<math.h>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
map<char,int> histogram(string test){
map<char,int> count={},out={};
map <char,int>::iterator it;
int max=0;
for (int i=0;i<test.length();i++)
if (test[i]!=' ')
{... |
CPP/112 | /*
Task
We are given two strings s and c, you have to deleted all the characters in s that are equal to any character in c
then check if the result string is palindrome.
A string is called palindrome if it reads the same backward as forward.
You should return a vector containing the result string and "True"/"False" for... | string n="";
for (int i=0;i<s.length();i++)
if (find(c.begin(),c.end(),s[i])==c.end())
n=n+s[i];
if (n.length()==0) return {n,"True"};
string w(n.rbegin(),n.rend());
if (w==n) return {n,"True"};
return {n,"False"};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(reverse_delete("abcde","ae") , {"bcd","False"}));
assert (issame(... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<string> reverse_delete(string s,string c){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(reverse_delete("abcde","ae") , {"bcd","False"}));
assert (issame(... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<string> reverse_delete(string s,string c){
string n="";
for (int i=0;i<s.length();i++)
if (find(c.begin(),c.end(),s[i])==c.end())
n=n+s[i];
if (n.length()==0) ... |
CPP/113 | /*
Given a vector of strings, where each string consists of only digits, return a vector.
Each element i of the output should be 'the number of odd elements in the
string i of the input." where all the i's should be replaced by the number
of odd digits in the i'th string of the input.
>>> odd_count({"1234567"})
{'the ... | vector<string> out={};
for (int i=0;i<lst.size();i++)
{
int sum=0;
for (int j=0;j<lst[i].length();j++)
if (lst[i][j]>=48 and lst[i][j]<=57 and lst[i][j]%2==1)
sum+=1;
string s="the number of odd elements in the string i of the input.";
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(odd_count({"1234567"}) , {"the number of odd elements 4n the str4ng 4... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
vector<string> odd_count(vector<string> lst){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(odd_count({"1234567"}) , {"the number of odd elements 4n the str4ng 4... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<map>
using namespace std;
#include<algorithm>
#include<stdlib.h>
vector<string> odd_count(vector<string> lst){
vector<string> out={};
for (int i=0;i<lst.size();i++)
{
int sum=0;
for (int j=0;j<lst[i].le... |
CPP/114 | /*
Given a vector of integers nums, find the minimum sum of any non-empty sub-vector
of nums.
Example
minSubArraySum({2, 3, 4, 1, 2, 4}) == 1
minSubArraySum({-1, -2, -3}) == -6
*/
#include<stdio.h>
#include<vector>
using namespace std;
long long minSubArraySum(vector<long long> nums){
| long long current,min;
current=nums[0];
min=nums[0];
for (int i=1;i<nums.size();i++)
{
if (current<0) current=current+nums[i];
else current=nums[i];
if (current<min) min=current;
}
return min;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (minSubArraySum({2, 3, 4, 1, 2, 4}) == 1);
assert (minSubArraySum({-1, -2, -3}) == -6);
assert (minSubArraySum({-1, -2, -3, 2, -10}) == -14);
assert (minSubArraySum({-9999999999999999}) == -9999999999999999);
assert (minSubArraySum({0, 10, 20, 1000... | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
long long minSubArraySum(vector<long long> nums){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (minSubArraySum({2, 3, 4, 1, 2, 4}) == 1);
assert (minSubArraySum({-1, -2, -3}) == -6);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
long long minSubArraySum(vector<long long> nums){
long long current,min;
current=nums[0];
min=nums[0];
for (int i=1;i<nums.size();i++)
{
if (current<0) current=current+nums[i];
... |
CPP/115 | /*
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it,
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the ... | int out=0;
for (int i=0;i<grid.size();i++)
{
int sum=0;
for (int j=0;j<grid[i].size();j++)
sum+=grid[i][j];
if (sum>0) out+=(sum-1)/capacity+1;
}
return out;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (max_fill({{0,0,1,0}, {0,1,0,0}, {1,1,1,1}}, 1) == 6);
assert (max_fill({{0,0,1,1}, {0,0,0,0}, {1,1,1,1}, {0,1,1,1}}, 2) == 5);
assert (max_fill({{0,0,0}, {0,0,0}}, 5) == 0);
assert (max_fill({{1,1,1,1}, {1,1,1,1}}, 2) == 4);
assert (max_fill({{1,1... | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
int max_fill(vector<vector<int>> grid,int capacity){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (max_fill({{0,0,1,0}, {0,1,0,0}, {1,1,1,1}}, 1) == 6);
assert (max_fill({{0,0,1,1}, {0,0,0,0}, {1,1,1,1}, {0,1,1,1}}, 2) == 5);
assert (max_fill({{0,0,0}, {0,0,0}}, 5) == 0);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
int max_fill(vector<vector<int>> grid,int capacity){
int out=0;
for (int i=0;i<grid.size();i++)
{
int sum=0;
for (int j=0;j<grid[i].size();j++)
sum+=grid[i][j];
... |
CPP/116 | /*
In this Kata, you have to sort a vector of non-negative integers according to
number of ones in their binary representation in ascending order.
For similar number of ones, sort based on decimal value.
It must be implemented like this:
>>> sort_vector({1, 5, 2, 3, 4}) == {1, 2, 3, 4, 5}
>>> sort_vector({-2, -3, -4, ... | vector<int> bin={};
int m;
for (int i=0;i<arr.size();i++)
{
int b=0,n=abs(arr[i]);
while (n>0)
{
b+=n%2;n=n/2;
}
bin.push_back(b);
}
for (int i=0;i<arr.size();i++)
for (int j=1;j<arr.size();j++)
if (bin[j]<bin[j-1] or (bin[j]==bin[j-1]... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(sort_array({1,5,2,3,4}) , {1, 2, 4, 3, 5}));
assert (issame(sort_array(... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> sort_array(vector<int> arr){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(sort_array({1,5,2,3,4}) , {1, 2, 4, 3, 5}));
assert (issame(sort_array(... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> sort_array(vector<int> arr){
vector<int> bin={};
int m;
for (int i=0;i<arr.size();i++)
{
int b=0,n=abs(arr[i]);
while (n>0)
{
b+=n%2;n=n/2;
... |
CPP/117 | /*
Given a string s and a natural number n, you have been tasked to implement
a function that returns a vector of all words from string s that contain exactly
n consonants, in order these words appear in the string s.
If the string s is empty then the function should return an empty vector.
Note: you may assume the i... | string vowels="aeiouAEIOU";
string current="";
vector<string> out={};
int numc=0;
s=s+' ';
for (int i=0;i<s.length();i++)
if (s[i]==' ')
{
if (numc==n) out.push_back(current);
current="";
numc=0;
}
else
{
cur... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(select_words("Mary had a little lamb", 4) , {"little"} ));
asse... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<string> select_words(string s,int n){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(select_words("Mary had a little lamb", 4) , {"little"} ));
asse... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<string> select_words(string s,int n){
string vowels="aeiouAEIOU";
string current="";
vector<string> out={};
int numc=0;
s=s+' ';
for (int i=0;i<s.length();i++)
... |
CPP/118 | /*
You are given a word. Your task is to find the closest vowel that stands between
two consonants from the right side of the word (case sensitive).
Vowels in the beginning and ending doesn't count. Return empty string if you didn't
find any vowel met the above condition.
You may assume that the given string contai... | string out="";
string vowels="AEIOUaeiou";
for (int i=word.length()-2;i>=1;i-=1)
if (find(vowels.begin(),vowels.end(),word[i])!=vowels.end())
if (find(vowels.begin(),vowels.end(),word[i+1])==vowels.end())
if (find(vowels.begin(),vowels.end(),word[i-1])==vowels.end())
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (get_closest_vowel("yogurt") == "u");
assert (get_closest_vowel("full") == "u");
assert (get_closest_vowel("easy") == "");
assert (get_closest_vowel("eAsy") == "");
assert (get_closest_vowel("ali") == "");
assert (get_closest_vowel("bad") == "a... | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
string get_closest_vowel(string word){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (get_closest_vowel("yogurt") == "u");
assert (get_closest_vowel("FULL") == "U");
assert (get_closest_vowel("ab") == "");
assert (get_closest_vowel("quick") == "");
}
| #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
string get_closest_vowel(string word){
string out="";
string vowels="AEIOUaeiou";
for (int i=word.length()-2;i>=1;i-=1)
if (find(vowels.begin(),vowels.end(),word[i])!=vowels.end())
... |
CPP/119 | /*
You are given a vector of two strings, both strings consist of open
parentheses '(' or close parentheses ')' only.
Your job is to check if it is possible to concatenate the two strings in
some order, that the resulting string will be good.
A string S is considered to be good if and only if all parentheses in S
are b... | string l1=lst[0]+lst[1];
int i,count=0;
bool can=true;
for (i=0;i<l1.length();i++)
{
if (l1[i]=='(') count+=1;
if (l1[i]==')') count-=1;
if (count<0) can=false;
}
if (count!=0) return "No";
if (can==true) return "Yes";
l1=lst[1]+lst[0];
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (match_parens({"()(", ")"}) == "Yes");
assert (match_parens({")", ")"}) == "No");
assert (match_parens({"(()(())", "())())"}) == "No");
assert (match_parens({")())", "(()()("}) == "Yes");
assert (match_parens({"(())))", "(()())(("}) == "Yes");
... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string match_parens(vector<string> lst){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (match_parens({"()(", ")"}) == "Yes");
assert (match_parens({")", ")"}) == "No");
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
string match_parens(vector<string> lst){
string l1=lst[0]+lst[1];
int i,count=0;
bool can=true;
for (i=0;i<l1.length();i++)
{
if (l1[i]=='(') count+=1;
... |
CPP/120 | /*
Given a vector arr of integers and a positive integer k, return a sorted vector
of length k with the maximum k numbers in arr.
Example 1:
Input: arr = {-3, -4, 5}, k = 3
Output: {-4, -3, 5}
Example 2:
Input: arr = {4, -4, 4}, k = 2
Output: {4, 4}
Example 3:
Input: arr = {-3, 2, 1, 2, -1, -... | sort(arr.begin(),arr.end());
vector<int> out(arr.end()-k,arr.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(maximum({-3, -4, 5}, 3) , {-4, -3, 5}));
assert (issame(maximum({4, -4,... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> maximum(vector<int> arr,int k){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(maximum({-3, -4, 5}, 3) , {-4, -3, 5}));
assert (issame(maximum({4, -4,... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> maximum(vector<int> arr,int k){
sort(arr.begin(),arr.end());
vector<int> out(arr.end()-k,arr.end());
return out;
}
|
CPP/121 | /*
Given a non-empty vector of integers, return the sum of all of the odd elements that are in even positions.
Examples
solution({5, 8, 7, 1}) ==> 12
solution({3, 3, 3, 3, 3}) ==> 9
solution({30, 13, 24, 321}) ==>0
*/
#include<stdio.h>
#include<vector>
using namespace std;
int solutions(vector<int> lst){
| int sum=0;
for (int i=0;i*2<lst.size();i++)
if (lst[i*2]%2==1) sum+=lst[i*2];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (solutions({5, 8, 7, 1}) == 12);
assert (solutions({3, 3, 3, 3, 3}) == 9);
assert (solutions({30, 13, 24, 321}) == 0);
assert (solutions({5, 9}) == 5);
assert (solutions({2, 4, 8}) == 0);
assert (solutions({30, 13, 23, 32}) == 23);
asser... | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
int solutions(vector<int> lst){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (solutions({5, 8, 7, 1}) == 12);
assert (solutions({3, 3, 3, 3, 3}) == 9);
assert (solutions({30, 13, 24, 321}) == 0);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
int solutions(vector<int> lst){
int sum=0;
for (int i=0;i*2<lst.size();i++)
if (lst[i*2]%2==1) sum+=lst[i*2];
return sum;
}
|
CPP/122 | /*
Given a non-empty vector of integers arr and an integer k, return
the sum of the elements with at most two digits from the first k elements of arr.
Example:
Input: arr = {111,21,3,4000,5,6,7,8,9}, k = 4
Output: 24 # sum of 21 + 3
Constraints:
1. 1 <= len(arr) <= 100
2. 1 <= k <= len(arr)
*/
#inclu... | int sum=0;
for (int i=0;i<k;i++)
if( arr[i]>=-99 and arr[i]<=99)
sum+=arr[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (add_elements({1,-2,-3,41,57,76,87,88,99}, 3) == -4);
assert (add_elements({111,121,3,4000,5,6}, 2) == 0);
assert (add_elements({11,21,3,90,5,6,7,8,9}, 4) == 125);
assert (add_elements({111,21,3,4000,5,6,7,8,9}, 4) == 24);
assert (add_elements({1},... | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
int add_elements(vector<int> arr,int k){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (add_elements({111,21,3,4000,5,6,7,8,9}, 4) == 24);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
int add_elements(vector<int> arr,int k){
int sum=0;
for (int i=0;i<k;i++)
if( arr[i]>=-99 and arr[i]<=99)
sum+=arr[i];
return sum;
}
|
CPP/123 | /*
Given a positive integer n, return a sorted vector that has the odd numbers in collatz sequence.
The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined
as follows: start with any positive integer n. Then each term is obtained from the
previous term as follows: if the previous term i... | vector<int> out={1};
while (n!=1)
{
if (n%2==1) {out.push_back(n); n=n*3+1;}
else n=n/2;
}
sort(out.begin(),out.end());
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(get_odd_collatz(14) , {1, 5, 7, 11, 13, 17}));
assert (issame(get_odd_c... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> get_odd_collatz(int n){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(get_odd_collatz(5) , {1, 5}));
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> get_odd_collatz(int n){
vector<int> out={1};
while (n!=1)
{
if (n%2==1) {out.push_back(n); n=n*3+1;}
else n=n/2;
}
sort(out.begin(),out.end());
return out;
... |
CPP/124 | /*
You have to write a function which validates a given date string and
returns true if the date is valid otherwise false.
The date is valid if all of the following rules are satisfied:
1. The date string is not empty.
2. The number of days is not less than 1 or higher than 31 days for months 1,3,5,7,8,10,12. And the n... | int mm,dd,yy,i;
if (date.length()!=10) return false;
for (int i=0;i<10;i++)
if (i==2 or i==5)
{
if (date[i]!='-') return false;
}
else
if (date[i]<48 or date[i]>57) return false;
mm=atoi(date.substr(0,2).c_str());
dd=atoi(date.substr(3,2).c_st... | #undef NDEBUG
#include<assert.h>
int main(){
assert (valid_date("03-11-2000") == true);
assert (valid_date("15-01-2012") == false);
assert (valid_date("04-0-2040") == false);
assert (valid_date("06-04-2020") == true);
assert (valid_date("01-01-2007") == true);
assert (valid_date("03-32-2011") ==... | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
bool valid_date(string date){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (valid_date("03-11-2000") == true);
assert (valid_date("15-01-2012") == false);
assert (valid_date("04-0-2040") == false);
assert (valid_date("06-04-2020") == true);
assert (valid_date("06/04/2020") == false);
}
| #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
bool valid_date(string date){
int mm,dd,yy,i;
if (date.length()!=10) return false;
for (int i=0;i<10;i++)
if (i==2 or i==5)
{
if (date[i]!='-') return false;
}
... |
CPP/125 | /*
Given a string of words, return a vector of words split on whitespace, if no whitespaces exists in the text you
should split on commas ',' if no commas exists you should return a vector with one element, the number of lower-case letters with odd order in the
alphabet, ord("a") = 0, ord("b") = 1, ... ord("z") = 25
Ex... | int i;
string current="";
vector<string> out={};
if (find(txt.begin(),txt.end(),' ')!=txt.end())
{
txt=txt+' ';
for (i=0;i<txt.length();i++)
if (txt[i]==' ')
{
if (current.length()>0)out.push_back(current);
current="";
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(split_words("Hello world!") , {"Hello","world!"}));
assert (issam... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<string> split_words(string txt){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(split_words("Hello world!") , {"Hello","world!"}));
assert (issam... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<string> split_words(string txt){
int i;
string current="";
vector<string> out={};
if (find(txt.begin(),txt.end(),' ')!=txt.end())
{
txt=txt+' ';
for... |
CPP/126 | /*
Given a vector of numbers, return whether or not they are sorted
in ascending order. If vector has more than 1 duplicate of the same
number, return false. Assume no negative numbers and only integers.
Examples
is_sorted({5}) ➞ true
is_sorted({1, 2, 3, 4, 5}) ➞ true
is_sorted({1, 3, 2, 4, 5}) ➞ false
is_sorted({1, 2... | for (int i=1;i<lst.size();i++)
{
if (lst[i]<lst[i-1]) return false;
if (i>=2 and lst[i]==lst[i-1] and lst[i]==lst[i-2]) return false;
}
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (is_sorted({5}) == true);
assert (is_sorted({1, 2, 3, 4, 5}) == true);
assert (is_sorted({1, 3, 2, 4, 5}) == false);
assert (is_sorted({1, 2, 3, 4, 5, 6}) == true);
assert (is_sorted({1, 2, 3, 4, 5, 6, 7}) == true);
assert (is_sorted({1, 3, 2, ... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
bool is_sorted(vector<int> lst){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (is_sorted({5}) == true);
assert (is_sorted({1, 2, 3, 4, 5}) == true);
assert (is_sorted({1, 3, 2, 4, 5}) == false);
assert (is_sorted({1, 2, 3, 4, 5, 6}) == true);
assert (is_sorted({1, 2, 3, 4, 5, 6, 7}) == true);
assert (is_sorted({1, 3, 2, ... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
bool is_sorted(vector<int> lst){
for (int i=1;i<lst.size();i++)
{
if (lst[i]<lst[i-1]) return false;
if (i>=2 and lst[i]==lst[i-1] and lst[i]==lst[i-2]) return false;
}
return ... |
CPP/127 | /*
You are given two intervals,
where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).
The given intervals are closed which means that the interval (start, end)
includes both start and end.
For each given interval, it is assumed that its start is less or equal its end.
Your task is to... | int inter1,inter2,l,i;
inter1=max(interval1[0],interval2[0]);
inter2=min(interval1[1],interval2[1]);
l=inter2-inter1;
if (l<2) return "NO";
for (i=2;i*i<=l;i++)
if (l%i==0) return "NO";
return "YES";
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (intersection({1, 2}, {2, 3}) == "NO");
assert (intersection({-1, 1}, {0, 4}) == "NO");
assert (intersection({-3, -1}, {-5, 5}) == "YES");
assert (intersection({-2, 2}, {-4, 0}) == "YES");
assert (intersection({-11, 2}, {-1, -1}) == "NO");
asse... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
string intersection( vector<int> interval1,vector<int> interval2){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (intersection({1, 2}, {2, 3}) == "NO");
assert (intersection({-1, 1}, {0, 4}) == "NO");
assert (intersection({-3, -1}, {-5, 5}) == "YES");
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
string intersection( vector<int> interval1,vector<int> interval2){
int inter1,inter2,l,i;
inter1=max(interval1[0],interval2[0]);
inter2=min(interval1[1],interval2[1]);
l=inter... |
CPP/128 | /*
You are given a vector arr of integers and you need to return
sum of magnitudes of integers multiplied by product of all signs
of each number in the vector, represented by 1, -1 or 0.
Note: return -32768 for empty arr.
Example:
>>> prod_signs({1, 2, 2, -4}) == -9
>>> prod_signs({0, 1}) == 0
>>> prod_signs({}) == -3... | if (arr.size()==0) return -32768;
int i,sum=0,prods=1;
for (i=0;i<arr.size();i++)
{
sum+=abs(arr[i]);
if (arr[i]==0) prods=0;
if (arr[i]<0) prods=-prods;
}
return sum*prods;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (prod_signs({1, 2, 2, -4}) == -9);
assert (prod_signs({0, 1}) == 0);
assert (prod_signs({1, 1, 1, 2, 3, -1, 1}) == -10);
assert (prod_signs({}) == -32768);
assert (prod_signs({2, 4,1, 2, -1, -1, 9}) == 20);
assert (prod_signs({-1, 1, -1, 1}) ==... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int prod_signs(vector<int> arr){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (prod_signs({1, 2, 2, -4}) == -9);
assert (prod_signs({0, 1}) == 0);
assert (prod_signs({}) == -32768);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int prod_signs(vector<int> arr){
if (arr.size()==0) return -32768;
int i,sum=0,prods=1;
for (i=0;i<arr.size();i++)
{
sum+=abs(arr[i]);
if (arr[i]==0) prods=0;
if (arr[i... |
CPP/129 | /*
Given a grid with N rows and N columns (N >= 2) and a positive integer k,
each cell of the grid contains a value. Every integer in the range {1, N * N}
inclusive appears exactly once on the cells of the grid.
You have to find the minimum path of length k in the grid. You can start
from any cell, and in each step y... | int i,j,x,y,min;
for (i=0;i<grid.size();i++)
for (j=0;j<grid[i].size();j++)
if (grid[i][j]==1) {
x=i;y=j;
}
min=grid.size()*grid.size();
if (x>0 and grid[x-1][y]<min) min=grid[x-1][y];
if (x<grid.size()-1 and grid[x+1][y]<min) min=grid[x+1][y];
if ... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(minPath({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, 3) , {1, 2, 1}));
assert (is... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> minPath(vector<vector<int>> grid, int k){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(minPath({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, 3) , {1, 2, 1}));
assert (is... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> minPath(vector<vector<int>> grid, int k){
int i,j,x,y,min;
for (i=0;i<grid.size();i++)
for (j=0;j<grid[i].size();j++)
if (grid[i][j]==1) {
x=i;y=j;
... |
CPP/130 | /*
Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in
the last couple centuries. However, what people don't know is Tribonacci sequence.
Tribonacci sequence is defined by the recurrence:
tri(1) = 3
tri(n) = 1 + n / 2, if n is even.
tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.... | vector<int> out={1,3};
if (n==0) return {1};
for (int i=2;i<=n;i++)
{
if (i%2==0) out.push_back(1+i/2);
else out.push_back(out[i-1]+out[i-2]+1+(i+1)/2);
}
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(tri(3) , {1, 3, 2, 8}));
assert (issame(tri(4) , {1, 3, 2, 8, 3}));
... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> tri(int n){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(tri(3) , {1, 3, 2, 8}));
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> tri(int n){
vector<int> out={1,3};
if (n==0) return {1};
for (int i=2;i<=n;i++)
{
if (i%2==0) out.push_back(1+i/2);
else out.push_back(out[i-1]+out[i-2]+1+(i+1)/2);... |
CPP/131 | /*
Given a positive integer n, return the product of the odd digits.
Return 0 if all digits are even.
For example:
digits(1) == 1
digits(4) == 0
digits(235) == 15
*/
#include<stdio.h>
#include<string>
using namespace std;
int digits(int n){
| int prod=1,has=0;
string s=to_string(n);
for (int i=0;i<s.length();i++)
if (s[i]%2==1)
{
has=1;
prod=prod*(s[i]-48);
}
if (has==0) return 0;
return prod;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (digits(5) == 5);
assert (digits(54) == 5);
assert (digits(120) ==1);
assert (digits(5014) == 5);
assert (digits(98765) == 315);
assert (digits(5576543) == 2625);
assert (digits(2468) == 0);
}
| #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int digits(int n){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (digits(1) == 1);
assert (digits(4) == 0);
assert (digits(235) ==15);
}
| #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int digits(int n){
int prod=1,has=0;
string s=to_string(n);
for (int i=0;i<s.length();i++)
if (s[i]%2==1)
{
has=1;
prod=prod*(s[i]-48);
}
if (h... |
CPP/132 | /*
Create a function that takes a string as input which contains only square brackets.
The function should return true if and only if there is a valid subsequence of brackets
where at least one bracket in the subsequence is nested.
is_nested("[[]]") ➞ true
is_nested("[]]]]]]][[[[[]") ➞ false
is_nested("[][]") ➞ false
... | int count=0,maxcount=0;
for (int i=0;i<str.length();i++)
{
if (str[i]=='[') count+=1;
if (str[i]==']') count-=1;
if (count<0) count=0;
if (count>maxcount) maxcount=count;
if (count<=maxcount-2) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (is_nested("[[]]") == true);
assert (is_nested("[]]]]]]][[[[[]") == false);
assert (is_nested("[][]") == false);
assert (is_nested(("[]")) == false);
assert (is_nested("[[[[]]]]") == true);
assert (is_nested("[]]]]]]]]]]") == false);
assert... | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
bool is_nested(string str){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (is_nested("[[]]") == true);
assert (is_nested("[]]]]]]][[[[[]") == false);
assert (is_nested("[][]") == false);
assert (is_nested("[]") == false);
assert (is_nested("[[]][[") == true);
assert (is_nested("[[][]]") == true);
}
| #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
bool is_nested(string str){
int count=0,maxcount=0;
for (int i=0;i<str.length();i++)
{
if (str[i]=='[') count+=1;
if (str[i]==']') count-=1;
if (count<0) count=0;
i... |
CPP/133 | /*
You are given a vector of numbers.
You need to return the sum of squared numbers in the given vector,
round each element in the vector to the upper int(Ceiling) first.
Examples:
For lst = {1,2,3} the output should be 14
For lst = {1,4,9} the output should be 98
For lst = {1,3,5,7} the output should be 84
For lst = {... | int sum=0;
for (int i=0;i<lst.size();i++)
sum+=ceil(lst[i])*ceil(lst[i]);
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (sum_squares({1,2,3})==14);
assert (sum_squares({1.0,2,3})==14);
assert (sum_squares({1,3,5,7})==84);
assert (sum_squares({1.4,4.2,0})==29);
assert (sum_squares({-2.4,1,1})==6);
assert (sum_squares({100,1,15,2})==10230);
assert (sum_squares... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int sum_squares(vector<float> lst){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (sum_squares({1,2,3})==14);
assert (sum_squares({1,4,9})==98);
assert (sum_squares({1,3,5,7})==84);
assert (sum_squares({1.4,4.2,0})==29);
assert (sum_squares({-2.4,1,1})==6);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int sum_squares(vector<float> lst){
int sum=0;
for (int i=0;i<lst.size();i++)
sum+=ceil(lst[i])*ceil(lst[i]);
return sum;
}
|
CPP/134 | /*
Create a function that returns true if the last character
of a given string is an alphabetical character and is not
a part of a word, and false otherwise.
Note: "word" is a group of characters separated by space.
Examples:
check_if_last_char_is_a_letter("apple pie") ➞ false
check_if_last_char_is_a_letter("apple pi ... | if (txt.length()==0) return false;
char chr=txt[txt.length()-1];
if (chr<65 or (chr>90 and chr<97) or chr>122) return false;
if (txt.length()==1) return true;
chr=txt[txt.length()-2];
if ((chr>=65 and chr<=90) or (chr>=97 and chr<=122)) return false;
return true;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (check_if_last_char_is_a_letter("apple") == false);
assert (check_if_last_char_is_a_letter("apple pi e") == true);
assert (check_if_last_char_is_a_letter("eeeee") == false);
assert (check_if_last_char_is_a_letter("A") == true);
assert (check_if_las... | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
bool check_if_last_char_is_a_letter(string txt){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (check_if_last_char_is_a_letter("apple pi e") == true);
assert (check_if_last_char_is_a_letter("") == false);
assert (check_if_last_char_is_a_letter("apple pie") == false);
assert (check_if_last_char_is_a_letter("apple pi e ") == false);
}
| #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
bool check_if_last_char_is_a_letter(string txt){
if (txt.length()==0) return false;
char chr=txt[txt.length()-1];
if (chr<65 or (chr>90 and chr<97) or chr>122) return false;
if (txt.length()==... |
CPP/135 | /*
Create a function which returns the largest index of an element which
is not greater than or equal to the element immediately preceding it. If
no such element exists then return -1. The given vector will not contain
duplicate values.
Examples:
can_arrange({1,2,4,3,5}) = 3
can_arrange({1,2,3}) = -1
*/
#include<stdio... | int max=-1;
for (int i=0;i<arr.size();i++)
if (arr[i]<=i) max=i;
return max;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (can_arrange({1,2,4,3,5})==3);
assert (can_arrange({1,2,4,5})==-1);
assert (can_arrange({1,4,2,5,6,7,8,9,10})==2);
assert (can_arrange({4,8,5,7,3})==4);
assert (can_arrange({})==-1);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int can_arrange(vector<int> arr){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (can_arrange({1,2,4,3,5})==3);
assert (can_arrange({1,2,3})==-1);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int can_arrange(vector<int> arr){
int max=-1;
for (int i=0;i<arr.size();i++)
if (arr[i]<=i) max=i;
return max;
}
|
CPP/136 | /*
Create a function that returns a vector (a, b), where "a" is
the largest of negative integers, and "b" is the smallest
of positive integers in a vector.
If there is no negative or positive integers, return them as 0.
Examples:
largest_smallest_integers({2, 4, 1, 3, 5, 7}) == {0, 1}
largest_smallest_integers({}) == ... | int maxneg=0,minpos=0;
for (int i=0;i<lst.size();i++)
{
if (lst[i]<0 and (maxneg==0 or lst[i]>maxneg)) maxneg=lst[i];
if (lst[i]>0 and (minpos==0 or lst[i]<minpos)) minpos=lst[i];
}
return {maxneg,minpos};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(largest_smallest_integers({2, 4, 1, 3, 5, 7}) , {0, 1}));
assert (issam... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> largest_smallest_integers(vector<int> lst){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(largest_smallest_integers({2, 4, 1, 3, 5, 7}) , {0, 1}));
assert (issam... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> largest_smallest_integers(vector<int> lst){
int maxneg=0,minpos=0;
for (int i=0;i<lst.size();i++)
{
if (lst[i]<0 and (maxneg==0 or lst[i]>maxneg)) maxneg=lst[i];
if (ls... |
CPP/137 | /*
Create a function that takes integers, floats, or strings representing
real numbers, and returns the larger variable in its given variable type.
Return "None" if the values are equal.
Note: If a real number is represented as a string, the floating point might be . or ,
compare_one(1, 2.5) ➞ 2.5
compare_one(1, "2,3"... | double numa,numb;
boost::any out;
if (a.type()==typeid(string))
{
string s;
s=boost::any_cast<string>(a);
if (find(s.begin(),s.end(),',')!=s.end())
for (int i=0;i<s.length();i++)
if (s[i]==',') s=s.substr(0,i)+'.'+s.substr(i+1);
numa=atof(... | #undef NDEBUG
#include<assert.h>
int main(){
assert (boost::any_cast<int>(compare_one(1, 2)) == 2);
assert (boost::any_cast<double>(compare_one(1, 2.5))== 2.5);
assert (boost::any_cast<int>(compare_one(2, 3)) == 3);
assert (boost::any_cast<int>(compare_one(5, 6)) == 6);
assert (boost::any_cast<strin... | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
#include<boost/any.hpp>
using namespace std;
#include<stdlib.h>
boost::any compare_one(boost::any a,boost::any b){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (boost::any_cast<double>(compare_one(1, 2.5))== 2.5);
assert (boost::any_cast<string>(compare_one(1, string("2,3")))== "2,3");
assert (boost::any_cast<string>(compare_one(string("5,1"), string("6"))) == "6");
assert (boost::any_cast<string>(compare_one... | #include<stdio.h>
#include<math.h>
#include<string>
#include<algorithm>
#include<boost/any.hpp>
using namespace std;
#include<stdlib.h>
boost::any compare_one(boost::any a,boost::any b){
double numa,numb;
boost::any out;
if (a.type()==typeid(string))
{
string s;
s=boost::any_cast<st... |
CPP/138 | /*
Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
Example
is_equal_to_sum_even(4) == false
is_equal_to_sum_even(6) == false
is_equal_to_sum_even(8) == true
*/
#include<stdio.h>
using namespace std;
bool is_equal_to_sum_even(int n){
| if (n%2==0 and n>=8) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (is_equal_to_sum_even(4) == false);
assert (is_equal_to_sum_even(6) == false);
assert (is_equal_to_sum_even(8) == true);
assert (is_equal_to_sum_even(10) == true);
assert (is_equal_to_sum_even(11) == false);
assert (is_equal_to_sum_even(12) == ... | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
bool is_equal_to_sum_even(int n){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (is_equal_to_sum_even(4) == false);
assert (is_equal_to_sum_even(6) == false);
assert (is_equal_to_sum_even(8) == true);
}
| #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
bool is_equal_to_sum_even(int n){
if (n%2==0 and n>=8) return true;
return false;
}
|
CPP/139 | /*
The Brazilian factorial is defined as:
brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
where n > 0
For example:
>>> special_factorial(4)
288
The function will receive an integer as input and should return the special
factorial of this integer.
*/
#include<stdio.h>
using namespace std;
long long special_fa... | long long fact=1,bfact=1;
for (int i=1;i<=n;i++)
{
fact=fact*i;
bfact=bfact*fact;
}
return bfact;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (special_factorial(4) == 288);
assert (special_factorial(5) == 34560);
assert (special_factorial(7) == 125411328000);
assert (special_factorial(1) == 1);
}
| #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
long long special_factorial(int n){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (special_factorial(4) == 288);
}
| #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
long long special_factorial(int n){
long long fact=1,bfact=1;
for (int i=1;i<=n;i++)
{
fact=fact*i;
bfact=bfact*fact;
}
return bfact;
}
|
CPP/140 | /*
Given a string text, replace all spaces in it with underscores,
and if a string has more than 2 consecutive spaces,
then replace all consecutive spaces with -
fix_spaces("Example") == "Example"
fix_spaces("Example 1") == "Example_1"
fix_spaces(" Example 2") == "_Example_2"
fix_spaces(" Example 3") == "_Example... | string out="";
int spacelen=0;
for (int i=0;i<text.length();i++)
if (text[i]==' ') spacelen+=1;
else
{
if (spacelen==1) out=out+'_';
if (spacelen==2) out=out+"__";
if (spacelen>2) out=out+'-';
spacelen=0;
out=out+text[i];
}
if (spacelen==1) out=out... | #undef NDEBUG
#include<assert.h>
int main(){
assert (fix_spaces("Example") == "Example");
assert (fix_spaces("Mudasir Hanif ") == "Mudasir_Hanif_");
assert (fix_spaces("Yellow Yellow Dirty Fellow") == "Yellow_Yellow__Dirty__Fellow");
assert (fix_spaces("Exa mple") == "Exa-mple");
assert (fix_spa... | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
string fix_spaces(string text){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (fix_spaces("Example") == "Example");
assert (fix_spaces("Example 1") == "Example_1");
assert (fix_spaces(" Example 2") == "_Example_2");
assert (fix_spaces(" Example 3") == "_Example-3");
}
| #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
string fix_spaces(string text){
string out="";
int spacelen=0;
for (int i=0;i<text.length();i++)
if (text[i]==' ') spacelen+=1;
else
{
if (spacelen==1) out=out+'_';
if ... |
CPP/141 | /*
Create a function which takes a string representing a file's name, and returns
"Yes" if the the file's name is valid, and returns "No" otherwise.
A file's name is considered to be valid if and only if all the following conditions
are met:
- There should not be more than three digits ('0'-'9') in the file's name.
- ... | int numdigit=0,numdot=0;
if (file_name.length()<5) return "No";
char w=file_name[0];
if (w<65 or (w>90 and w<97) or w>122) return "No";
string last=file_name.substr(file_name.length()-4,4);
if (last!=".txt" and last!=".exe" and last!=".dll") return "No";
for (int i=0;i<file_name.length();i++... | #undef NDEBUG
#include<assert.h>
int main(){
assert (file_name_check("example.txt") == "Yes");
assert (file_name_check("1example.dll") == "No");
assert (file_name_check("s1sdf3.asd") == "No");
assert (file_name_check("K.dll") == "Yes");
assert (file_name_check("MY16FILE3.exe") == "Yes");
assert ... | #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
string file_name_check(string file_name){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (file_name_check("example.txt") == "Yes");
assert (file_name_check("1example.dll") == "No");
}
| #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
string file_name_check(string file_name){
int numdigit=0,numdot=0;
if (file_name.length()<5) return "No";
char w=file_name[0];
if (w<65 or (w>90 and w<97) or w>122) return "No";
string las... |
CPP/142 | /*
"
This function will take a vector of integers. For all entries in the vector, the function shall square the integer entry if its index is a
multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The function will not
change the entries in the vector whose indexes ar... | int sum=0;
for (int i=0;i<lst.size();i++)
if (i%3==0) sum+=lst[i]*lst[i];
else if (i%4==0) sum+=lst[i]*lst[i]*lst[i];
else sum+=lst[i];
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (sum_squares({1,2,3}) == 6);
assert (sum_squares({1,4,9}) == 14);
assert (sum_squares({}) == 0);
assert (sum_squares({1,1,1,1,1,1,1,1,1}) == 9);
assert (sum_squares({-1,-1,-1,-1,-1,-1,-1,-1,-1}) == -3);
assert (sum_squares({0}) == 0);
asser... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int sum_squares(vector<int> lst){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (sum_squares({1,2,3}) == 6);
assert (sum_squares({}) == 0);
assert (sum_squares({-1,-5,2,-1,-5}) == -126);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int sum_squares(vector<int> lst){
int sum=0;
for (int i=0;i<lst.size();i++)
if (i%3==0) sum+=lst[i]*lst[i];
else if (i%4==0) sum+=lst[i]*lst[i]*lst[i];
else sum+=lst[i];
re... |
CPP/143 | /*
You are given a string representing a sentence,
the sentence contains some words separated by a space,
and you have to return a string that contains the words from the original sentence,
whose lengths are prime numbers,
the order of the words in the new string should be the same as the original one.
Example 1:
... | string out="";
string current="";
sentence=sentence+' ';
for (int i=0;i<sentence.size();i++)
if (sentence[i]!=' ') current=current+sentence[i];
else
{
bool isp=true;
int l=current.length();
if (l<2) isp=false;
for (int j=2;j*j<=l;j++)
if (l%j==0) ... | #undef NDEBUG
#include<assert.h>
int main(){
assert (words_in_sentence("This is a test") == "is");
assert (words_in_sentence("lets go for swimming") == "go for");
assert (words_in_sentence("there is no place available here") == "there is no place");
assert (words_in_sentence("Hi I am Hussein") == "Hi am... | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
string words_in_sentence(string sentence){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (words_in_sentence("This is a test") == "is");
assert (words_in_sentence("lets go for swimming") == "go for");
}
| #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
string words_in_sentence(string sentence){
string out="";
string current="";
sentence=sentence+' ';
for (int i=0;i<sentence.size();i++)
if (sentence[i]!=' ') current=current+sentence[i];
... |
CPP/144 | /*
Your task is to implement a function that will simplify the expression
x * n. The function returns true if x * n evaluates to a whole number and false
otherwise. Both x and n, are string representation of a fraction, and have the following format,
<numerator>/<denominator> where both numerator and denominator are po... | int a,b,c,d,i;
for (i=0;i<x.size();i++)
if (x[i]=='/')
{
a=atoi(x.substr(0,i).c_str());
b=atoi(x.substr(i+1).c_str());
}
for (i=0;i<n.size();i++)
if (n[i]=='/')
{
c=atoi(n.substr(0,i).c_str());
d=atoi(n.substr(i+1).c_s... | #undef NDEBUG
#include<assert.h>
int main(){
assert (simplify("1/5", "5/1") == true);
assert (simplify("1/6", "2/1") == false);
assert (simplify("5/1", "3/1") == true);
assert (simplify("7/10", "10/2") == false);
assert (simplify("2/10", "50/10") == true);
assert (simplify("7/2", "4/2") == true)... | #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
bool simplify(string x,string n){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (simplify("1/5", "5/1") == true);
assert (simplify("1/6", "2/1") == false);
assert (simplify("7/10", "10/2") == false);
}
| #include<stdio.h>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
bool simplify(string x,string n){
int a,b,c,d,i;
for (i=0;i<x.size();i++)
if (x[i]=='/')
{
a=atoi(x.substr(0,i).c_str());
b=atoi(x.substr(i+1).c_str());
... |
CPP/145 | /*
Write a function which sorts the given vector of integers
in ascending order according to the sum of their digits.
Note: if there are several items with similar sum of their digits,
order them based on their index in original vector.
For example:
>>> order_by_points({1, 11, -1, -11, -12}) == {-1, -11, 1, -12, 11}
>... | vector<int> sumdigit={};
for (int i=0;i<nums.size();i++)
{
string w=to_string(abs(nums[i]));
int sum=0;
for (int j=1;j<w.length();j++)
sum+=w[j]-48;
if (nums[i]>0) sum+=w[0]-48;
else sum-=w[0]-48;
sumdigit.push_back(sum);
}
int m;
for (... | #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(order_by_points({1, 11, -1, -11, -12}) , {-1, -11, 1, -12, 11}));
asser... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> order_by_points(vector<int> nums){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(order_by_points({1, 11, -1, -11, -12}) , {-1, -11, 1, -12, 11}));
asser... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<int> order_by_points(vector<int> nums){
vector<int> sumdigit={};
for (int i=0;i<nums.size();i++)
{
string w=to_string(abs(nums[i]));
int sum=0;
for ... |
CPP/146 | /*
Write a function that takes a vector of numbers as input and returns
the number of elements in the vector that are greater than 10 and both
first and last digits of a number are odd (1, 3, 5, 7, 9).
For example:
specialFilter({15, -73, 14, -15}) => 1
specialFilter({33, -2, -3, 45, 21, 109}) => 2
*/
#include<stdio... | int num=0;
for (int i=0;i<nums.size();i++)
if (nums[i]>10)
{
string w=to_string(nums[i]);
if (w[0]%2==1 and w[w.length()-1]%2==1) num+=1;
}
return num;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (specialFilter({5, -2, 1, -5}) == 0 );
assert (specialFilter({15, -73, 14, -15}) == 1);
assert (specialFilter({33, -2, -3, 45, 21, 109}) == 2);
assert (specialFilter({43, -12, 93, 125, 121, 109}) == 4);
assert (specialFilter({71, -2, -33, 75, 21, ... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int specialFilter(vector<int> nums){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (specialFilter({15, -73, 14, -15}) == 1);
assert (specialFilter({33, -2, -3, 45, 21, 109}) == 2);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int specialFilter(vector<int> nums){
int num=0;
for (int i=0;i<nums.size();i++)
if (nums[i]>10)
{
string w=to_string(nums[i]);
if (w[0]%2==1 and w[w.length()-1... |
CPP/147 | /*
You are given a positive integer n. You have to create an integer vector a of length n.
For each i (1 ≤ i ≤ n), the value of a{i} = i * i - i + 1.
Return the number of triples (a{i}, a{j}, a{k}) of a where i < j < k,
and a[i] + a[j] + a[k] is a multiple of 3.
Example :
Input: n = 5
Output: 1
Ex... | vector<int> a;
vector<vector<int>> sum={{0,0,0}};
vector<vector<int>> sum2={{0,0,0}};
for (int i=1;i<=n;i++)
{
a.push_back((i*i-i+1)%3);
sum.push_back(sum[sum.size()-1]);
sum[i][a[i-1]]+=1;
}
for (int times=1;times<3;times++)
{
for (int i=1;i<=n;i++)
{
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (get_matrix_triples(5) == 1);
assert (get_matrix_triples(6) == 4);
assert (get_matrix_triples(10) == 36);
assert (get_matrix_triples(100) == 53361);
}
| #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
int get_matrix_triples(int n){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (get_matrix_triples(5) == 1);
}
| #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
int get_matrix_triples(int n){
vector<int> a;
vector<vector<int>> sum={{0,0,0}};
vector<vector<int>> sum2={{0,0,0}};
for (int i=1;i<=n;i++)
{
a.push_back((i*i-i+1)%3);
sum.... |
CPP/148 | /*
There are eight planets in our solar system: the closerst to the Sun
is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
Uranus, Neptune.
Write a function that takes two planet names as strings planet1 and planet2.
The function should return a vector containing all planets whose orbits are
loca... | vector<string> planets={"Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
int pos1=-1,pos2=-1,m;
for (m=0;m<planets.size();m++)
{
if (planets[m]==planet1) pos1=m;
if (planets[m]==planet2) pos2=m;
}
if (pos1==-1 or pos2==-1) return {};
if (pos1>pos2) {m=pos1;pos... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(bf("Jupiter", "Neptune") , {"Saturn", "Uranus"}));
assert (issame... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<string> bf(string planet1,string planet2){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(bf("Jupiter", "Neptune") , {"Saturn", "Uranus"}));
assert (issame... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
vector<string> bf(string planet1,string planet2){
vector<string> planets={"Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
int pos1=-1,pos2=-1,m;
for (m=0;... |
CPP/149 | /*
Write a function that accepts a vector of strings as a parameter,
deletes the strings that have odd lengths from it,
and returns the resulted vector with a sorted order,
The vector is always a vector of strings and never a vector of numbers,
and it may contain duplicates.
The order of the vector should be ascending ... | vector<string> out={};
for (int i=0;i<lst.size();i++)
if (lst[i].length()%2==0) out.push_back(lst[i]);
string mid;
sort(out.begin(),out.end());
for (int i=0;i<out.size();i++)
for (int j=1;j<out.size();j++)
if (out[j].length()<out[j-1].length())
{
mid=out[j];out[j]=out[j-1];ou... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(sorted_list_sum({"aa", "a", "aaa"}) , {"aa"}));
assert (issame(so... | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
vector<string> sorted_list_sum(vector<string> lst){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(sorted_list_sum({"aa", "a", "aaa"}) , {"aa"}));
assert (issame(so... | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
vector<string> sorted_list_sum(vector<string> lst){
vector<string> out={};
for (int i=0;i<lst.size();i++)
if (lst[i].length()%2==0) out.push_back(lst[i]);
string mid;
sort... |
CPP/150 | /*
A simple program which should return the value of x if n is
a prime number and should return the value of y otherwise.
Examples:
for x_or_y(7, 34, 12) == 34
for x_or_y(15, 8, 5) == 5
*/
#include<stdio.h>
using namespace std;
int x_or_y(int n,int x,int y){
| bool isp=true;
if (n<2) isp=false;
for (int i=2;i*i<=n;i++)
if (n%i==0) isp=false;
if (isp) return x;
return y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (x_or_y(7, 34, 12) == 34);
assert (x_or_y(15, 8, 5) == 5);
assert (x_or_y(3, 33, 5212) == 33);
assert (x_or_y(1259, 3, 52) == 3);
assert (x_or_y(7919, -1, 12) == -1);
assert (x_or_y(3609, 1245, 583) == 583);
assert (x_or_y(91, 56, 129) == 1... | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int x_or_y(int n,int x,int y){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (x_or_y(7, 34, 12) == 34);
assert (x_or_y(15, 8, 5) == 5);
}
| #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
int x_or_y(int n,int x,int y){
bool isp=true;
if (n<2) isp=false;
for (int i=2;i*i<=n;i++)
if (n%i==0) isp=false;
if (isp) return x;
return y;
}
|
CPP/151 | /*
Given a vector of numbers, return the sum of squares of the numbers
in the vector that are odd. Ignore numbers that are negative or not integers.
double_the_difference({1, 3, 2, 0}) == 1 + 9 + 0 + 0 = 10
double_the_difference({-1, -2, 0}) == 0
double_the_difference({9, -2}) == 81
double_the_difference({0}) == 0
... | long long sum=0;
for (int i=0;i<lst.size();i++)
if (lst[i]-round(lst[i])<1e-4)
if (lst[i]>0 and (int)(round(lst[i]))%2==1) sum+=(int)(round(lst[i]))*(int)(round(lst[i]));
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (double_the_difference({}) == 0);
assert (double_the_difference({5, 4}) == 25);
assert (double_the_difference({0.1, 0.2, 0.3}) == 0 );
assert (double_the_difference({-10, -20, -30}) == 0 );
assert (double_the_difference({-1, -2, 8}) == 0);
asse... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
long long double_the_difference(vector<float> lst){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (double_the_difference({1, 3, 2, 0}) == 10);
assert (double_the_difference({-1, -2, 0}) == 0);
assert (double_the_difference({9, -2}) == 81 );
assert (double_the_difference({0}) == 0 );
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
long long double_the_difference(vector<float> lst){
long long sum=0;
for (int i=0;i<lst.size();i++)
if (lst[i]-round(lst[i])<1e-4)
if (lst[i]>0 and (int)(round(lst[i]))%2==1) sum+=(int)(round(... |
CPP/152 | /*
I think we all remember that feeling when the result of some long-awaited
event is finally known. The feelings and thoughts you have at that moment are
definitely worth noting down and comparing.
Your task is to determine if a person correctly guessed the results of a number of matches.
You are given two vectors of ... | vector<int> out;
for (int i=0;i<game.size();i++)
out.push_back(abs(game[i]-guess[i]));
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(compare({1,2,3,4,5,1},{1,2,3,4,2,-2}),{0,0,0,0,3,3}));
assert (issame(c... | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
vector<int> compare(vector<int> game,vector<int> guess){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(compare({1,2,3,4,5,1},{1,2,3,4,2,-2}),{0,0,0,0,3,3}));
assert (issame(c... | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
vector<int> compare(vector<int> game,vector<int> guess){
vector<int> out;
for (int i=0;i<game.size();i++)
out.push_back(abs(game[i]-guess[i]));
return out;
}
|
CPP/153 | /*
You will be given the name of a class (a string) and a vector of extensions.
The extensions are to be used to load additional classes to the class. The
strength of the extension is as follows: Let CAP be the number of the uppercase
letters in the extension's name, and let SM be the number of lowercase letters
in th... | string strongest="";
int max=-1000;
for (int i=0;i<extensions.size();i++)
{
int strength=0;
for (int j=0;j<extensions[i].length();j++)
{
char chr=extensions[i][j];
if (chr>=65 and chr<=90) strength+=1;
if (chr>=97 and chr<=122) strength-=1;
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (Strongest_Extension("Watashi", {"tEN", "niNE", "eIGHt8OKe"}) == "Watashi.eIGHt8OKe");
assert (Strongest_Extension("Boku123", {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"}) == "Boku123.YEs.WeCaNe");
assert (Strongest_Extension("__YESIMHERE", {"t", "eMptY",... | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
string Strongest_Extension(string class_name,vector<string> extensions){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (Strongest_Extension("my_class", {"AA", "Be", "CC"}) == "my_class.AA");
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
string Strongest_Extension(string class_name,vector<string> extensions){
string strongest="";
int max=-1000;
for (int i=0;i<extensions.size();i++)
{
int strength=0;
... |
CPP/154 | /*
You are given 2 words. You need to return true if the second word or any of its rotations is a substring in the first word
cycpattern_check("abcd","abd") => false
cycpattern_check("hello","ell") => true
cycpattern_check("whassup","psus") => false
cycpattern_check("abab","baa") => true
cycpattern_check("efef","eeff")... | for (int i=0;i<b.size();i++)
{
string rotate=b.substr(i)+b.substr(0,i);
if (a.find(rotate)!=string::npos) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (cycpattern_check("xyzw","xyw") == false );
assert (cycpattern_check("yello","ell") == true );
assert (cycpattern_check("whattup","ptut") == false );
assert (cycpattern_check("efef","fee") == true );
assert (cycpattern_check("abab","aabb") == ... | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
bool cycpattern_check(string a,string b){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (cycpattern_check("abcd","abd") == false );
assert (cycpattern_check("hello","ell") == true );
assert (cycpattern_check("whassup","psus") == false );
assert (cycpattern_check("abab","baa") == true );
assert (cycpattern_check("efef","eeff") == ... | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
bool cycpattern_check(string a,string b){
for (int i=0;i<b.size();i++)
{
string rotate=b.substr(i)+b.substr(0,i);
if (a.find(rotate)!=string::npos) return true;
}
return false;... |
CPP/155 | /*
Given an integer. return a vector that has the number of even and odd digits respectively.
Example:
even_odd_count(-12) ==> {1, 1}
even_odd_count(123) ==> {1, 2}
*/
#include<stdio.h>
#include<math.h>
#include<string>
#include<vector>
using namespace std;
vector<int> even_odd_count(int num){
| string w=to_string(abs(num));
int n1=0,n2=0;
for (int i=0;i<w.length();i++)
if (w[i]%2==1) n1+=1;
else n2+=1;
return {n2,n1};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(even_odd_count(7) , {0, 1}));
assert (issame(even_odd_count(-78) , {1, ... | #include<stdio.h>
#include<math.h>
#include<string>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
vector<int> even_odd_count(int num){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(even_odd_count(-12) , {1, 1}));
assert (issame(even_odd_count(123) , {1... | #include<stdio.h>
#include<math.h>
#include<string>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
vector<int> even_odd_count(int num){
string w=to_string(abs(num));
int n1=0,n2=0;
for (int i=0;i<w.length();i++)
if (w[i]%2==1) n1+=1;
else n2+=1;
return {n2,n1};
}
|
CPP/156 | /*
Given a positive integer, obtain its roman numeral equivalent as a string,
and return it in lowercase.
Restrictions: 1 <= num <= 1000
Examples:
>>> int_to_mini_roman(19) == "xix"
>>> int_to_mini_roman(152) == "clii"
>>> int_to_mini_roman(426) == "cdxxvi"
*/
#include<stdio.h>
#include<vector>
#include<string>
using ... | string current="";
vector<string> rep={"m","cm","d","cd","c","xc","l","xl","x","ix","v","iv","i"};
vector<int> num={1000,900,500,400,100,90,50,40,10,9,5,4,1};
int pos=0;
while(number>0)
{
while (number>=num[pos])
{
current=current+rep[pos];
number-=num[pos... | #undef NDEBUG
#include<assert.h>
int main(){
assert (int_to_mini_romank(19) == "xix");
assert (int_to_mini_romank(152) == "clii");
assert (int_to_mini_romank(251) == "ccli");
assert (int_to_mini_romank(426) == "cdxxvi");
assert (int_to_mini_romank(500) == "d");
assert (int_to_mini_romank(1) == "... | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
string int_to_mini_romank(int number){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (int_to_mini_romank(19) == "xix");
assert (int_to_mini_romank(152) == "clii");
assert (int_to_mini_romank(426) == "cdxxvi");
}
| #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
string int_to_mini_romank(int number){
string current="";
vector<string> rep={"m","cm","d","cd","c","xc","l","xl","x","ix","v","iv","i"};
vector<int> num={1000,900,500,400,100,90,... |
CPP/157 | /*
Given the lengths of the three sides of a triangle. Return true if the three
sides form a right-angled triangle, false otherwise.
A right-angled triangle is a triangle in which one angle is right angle or
90 degree.
Example:
right_angle_triangle(3, 4, 5) == true
right_angle_triangle(1, 2, 3) == false
*/
#include<st... | if (abs(a*a+b*b-c*c)<1e-4 or abs(a*a+c*c-b*b)<1e-4 or abs(b*b+c*c-a*a)<1e-4) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (right_angle_triangle(3, 4, 5) == true);
assert (right_angle_triangle(1, 2, 3) == false);
assert (right_angle_triangle(10, 6, 8) == true);
assert (right_angle_triangle(2, 2, 2) == false);
assert (right_angle_triangle(7, 24, 25) == true);
assert... | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
bool right_angle_triangle(float a,float b,float c){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (right_angle_triangle(3, 4, 5) == true);
assert (right_angle_triangle(1, 2, 3) == false);
}
| #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
bool right_angle_triangle(float a,float b,float c){
if (abs(a*a+b*b-c*c)<1e-4 or abs(a*a+c*c-b*b)<1e-4 or abs(b*b+c*c-a*a)<1e-4) return true;
return false;
}
|
CPP/158 | /*
Write a function that accepts a vector of strings.
The vector contains different words. Return the word with maximum number
of unique characters. If multiple strings have maximum number of unique
characters, return the one which comes first in lexicographical order.
find_max({"name", "of", 'string"}) == 'string"
fi... | string max="";
int maxu=0;
for (int i=0;i<words.size();i++)
{
string unique="";
for (int j=0;j<words[i].length();j++)
if (find(unique.begin(),unique.end(),words[i][j])==unique.end())
unique=unique+words[i][j];
if (unique.length()>maxu or (unique.length... | #undef NDEBUG
#include<assert.h>
int main(){
assert ((find_max({"name", "of", "string"}) == "string"));
assert ((find_max({"name", "enam", "game"}) == "enam"));
assert ((find_max({"aaaaaaa", "bb", "cc"}) == "aaaaaaa"));
assert ((find_max({"abc", "cba"}) == "abc"));
assert ((find_max({"play", "this",... | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
string find_max(vector<string> words){
| #undef NDEBUG
#include<assert.h>
int main(){
assert ((find_max({"name", "of", "string"}) == "string"));
assert ((find_max({"name", "enam", "game"}) == "enam"));
assert ((find_max({"aaaaaaa", "bb", "cc"}) == "aaaaaaa"));
}
| #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
string find_max(vector<string> words){
string max="";
int maxu=0;
for (int i=0;i<words.size();i++)
{
string unique="";
for (int j=0;j<words[i].length();j++)
... |
CPP/159 | /*
You"re a hungry rabbit, and you already have eaten a certain number of carrots,
but now you need to eat more carrots to complete the day's meals.
you should return a vector of { total number of eaten carrots after your meals,
the number of carrots left after your meals }
if there are ... | if (need>remaining) return {number+remaining, 0};
return {number+need,remaining-need};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(eat(5, 6, 10) , {11, 4}));
assert (issame(eat(4, 8, 9) , {12, 1}));
... | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
vector<int> eat(int number,int need,int remaining){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(eat(5, 6, 10) , {11, 4}));
assert (issame(eat(4, 8, 9) , {12, 1}));
... | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
vector<int> eat(int number,int need,int remaining){
if (need>remaining) return {number+remaining, 0};
return {number+need,remaining-need};
}
|
CPP/160 | /*
Given two vectors operator, and operand. The first vector has basic algebra operations, and
the second vector is a vector of integers. Use the two given vectors to build the algebric
expression and return the evaluation of this expression.
The basic algebra operations:
Addition ( + )
Subtraction ( - )
Multiplic... | vector<int> num={};
vector<int> posto={};
for (int i=0;i<operand.size();i++)
posto.push_back(i);
for (int i=0;i<operato.size();i++)
if (operato[i]=="**")
{
while (posto[posto[i]]!=posto[i]) posto[i]=posto[posto[i]];
while (posto[posto[i+1]]!=posto[i+1]) posto[i+1... | #undef NDEBUG
#include<assert.h>
int main(){
assert (do_algebra({"**", "*", "+"}, {2, 3, 4, 5}) == 37);
assert (do_algebra({"+", "*", "-"}, {2, 3, 4, 5}) == 9);
assert (do_algebra({"//", "*"}, {7, 3, 4}) == 8);
}
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
int do_algebra(vector<string> operato, vector<int> operand){
| #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
int do_algebra(vector<string> operato, vector<int> operand){
vector<int> num={};
vector<int> posto={};
for (int i=0;i<operand.size();i++)
posto.push_back(i);
for (int ... | |
CPP/161 | /*
You are given a string s.
if s[i] is a letter, reverse its case from lower to upper or vise versa,
otherwise keep it as it is.
If the string contains no letters, reverse the string.
The function should return the resulted string.
Examples
solve("1234") = "4321"
solve("ab") = "AB"
solve("#a@C") = "#A@c"
*/
#include<... | int nletter=0;
string out="";
for (int i=0;i<s.length();i++)
{
char w=s[i];
if (w>=65 and w<=90) w=w+32;
else if (w>=97 and w<=122) w=w-32;
else nletter+=1;
out=out+w;
}
if (nletter==s.length())
{
string p(s.rbegin(),s.rend());
return p... | #undef NDEBUG
#include<assert.h>
int main(){
assert (solve("AsDf") == "aSdF");
assert (solve("1234") == "4321");
assert (solve("ab") == "AB");
assert (solve("#a@C") == "#A@c");
assert (solve("#AsdfW^45") == "#aSDFw^45");
assert (solve("#6@2") == "2@6#");
assert (solve("#$a^D") == "#$A^d");
... | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
string solve(string s){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (solve("1234") == "4321");
assert (solve("ab") == "AB");
assert (solve("#a@C") == "#A@c");
}
| #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
string solve(string s){
int nletter=0;
string out="";
for (int i=0;i<s.length();i++)
{
char w=s[i];
if (w>=65 and w<=90) w=w+32;
else if (w>=97 and w<=122) w=w-32;
... |
CPP/162 | /*
Given a string 'text", return its md5 hash equivalent string.
If 'text" is an empty string, return None.
>>> string_to_md5("Hello world") == "3e25960a79dbc69b674cd4ec67a72c62"
*/
#include<stdio.h>
#include<string>
#include<openssl/md5.h>
using namespace std;
string string_to_md5(string text){
| unsigned char md[16];
if (text.length()==0) return "None";
MD5_CTX c;
int i;
MD5_Init(&c);
MD5_Update(&c, (unsigned char*)text.c_str(), text.length());
MD5_Final(md, &c);
string out_str="";
for (int i=0;i<16;i++)
{
char w;
if (md[i]<160) w=48+md[i]/16;
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (string_to_md5("Hello world") == "3e25960a79dbc69b674cd4ec67a72c62");
assert (string_to_md5("") == "None");
assert (string_to_md5("A B C") == "0ef78513b0cb8cef12743f5aeb35f888");
assert (string_to_md5("password") == "5f4dcc3b5aa765d61d8327deb882cf99");... | #include<stdio.h>
#include<string>
#include<openssl/md5.h>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
string string_to_md5(string text){
| #undef NDEBUG
#include<assert.h>
int main(){
assert (string_to_md5("Hello world") == "3e25960a79dbc69b674cd4ec67a72c62");
}
| #include<stdio.h>
#include<string>
#include<openssl/md5.h>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
string string_to_md5(string text){
unsigned char md[16];
if (text.length()==0) return "None";
MD5_CTX c;
int i;
MD5_Init(&c);
MD5_Update(&c, (unsigned char*)text.... |
CPP/163 | /*
Given two positive integers a and b, return the even digits between a
and b, in ascending order.
For example:
generate_integers(2, 8) => {2, 4, 6, 8}
generate_integers(8, 2) => {2, 4, 6, 8}
generate_integers(10, 14) => {}
*/
#include<stdio.h>
#include<vector>
using namespace std;
vector<int> generate_integers(int a... | int m;
if (b<a)
{
m=a;a=b;b=m;
}
vector<int> out={};
for (int i=a;i<=b;i++)
if (i<10 and i%2==0) out.push_back(i);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(generate_integers(2, 10) , {2, 4, 6, 8}));
assert (issame(generate_inte... | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
vector<int> generate_integers(int a,int b){
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(generate_integers(2, 8) , {2, 4, 6, 8}));
assert (issame(generate_integ... | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
vector<int> generate_integers(int a,int b){
int m;
if (b<a)
{
m=a;a=b;b=m;
}
vector<int> out={};
for (int i=a;i<=b;i++)
if (i<10 and i%2==0) out.push_back(i);
return o... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.