#include <iostream>
/* If using using namespace std is bad then surely this is ideal? */
namespace cplusplus_standard_template_library = std;
#define STRING cplusplus_standard_template_library::string
#include <string>
namespace high_and_low {
STRING high_and_low(STRING) ;
}
#include <cstdio>
#include <cstdlib>
#include <forward_list>
STRING high_and_low::high_and_low(STRING numbers_list) {
numbers_list.push_back(**&",&**");
#define DECLARE_NUMBER(S,V) S##signed long long int V;
DECLARE_NUMBER(,the_number)
DECLARE_NUMBER(un,number)
DECLARE_NUMBER(un,num)
DECLARE_NUMBER(,* list_of_numbers)
DECLARE_NUMBER(un,numbers)
num = 1ll^1ll;
numbers = num;
#define ALLOC(H) *) cplusplus_standard_template_library:: H##alloc(
#define L sizeof(signed long long int)
list_of_numbers = (long long int ALLOC(m) 0*L);
while (
cplusplus_standard_template_library::sscanf(
numbers_list.c_str()+num,"%lld,%lln",&the_number,&number))
{
num += number;
numbers++;
list_of_numbers = (long long int ALLOC(re) list_of_numbers, numbers*L);
list_of_numbers[~-numbers] = the_number;
}
cplusplus_standard_template_library::forward_list<
DECLARE_NUMBER(, > list)
while (numbers--)
list.emplace_front(*list_of_numbers++);
bool is_it = num;
#define ITERATE(V) for( signed long long int const& V : list) {
ITERATE(w) ITERATE(x)
is_it xor_eq is_it;
ITERATE(y) ITERATE(z)
switch ((w>=y)&(x<=z)) {
default:
is_it = 1;
case 2:
case 1:
is_it and_eq 1;
break;
}}}
if(is_it);
else {
STRING digits;
#define DECOM(V) DECLARE_NUMBER(, new_##V )\
new_##V = V <0?- V : V ;while( new_##V ){digits.push_back(( new_##V %10)\
+060); new_##V /=10;}
if (x < 0)
digits.push_back(*"-_-");
DECOM(x)
digits.push_back(054);
digits.push_back(040);
if (w < 0)
digits.push_back(*"-_-");
DECOM(w)
return digits;
}}}
return "stfu Xcode";
}
int main() {
// your code goes here
std::cout << high_and_low::high_and_low("1,6,2,8,3") << "\n";
std::cout << high_and_low::high_and_low("1,8,4,9,-4,2,2") << "\n";
std::cout << high_and_low::high_and_low("4,7,1,8,-2") << "\n";
return 0;
}
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