int main() {
int a, b, c, d; scanf("%d%d%d%d", &a, &b, &c, &d);
if (check1(a, b, c) || check1(a, b, d) || check1(a, c, d) ||
check1(b, c, d))
puts("TRIANGLE");
else if (check2(a, b, c) || check2(a, b, d) || check2(a, c, d) ||
check2(b, c, d))
puts("SEGMENT");
else
puts("IMPOSSIBLE");
return 0;
}
void
test (void)
{
int i = 0, j;
const fnt pcheck1 = check1;
const fnt pcheck3 = check3;
A a;
B b;
C c;
if (check1 ())
return;
i += check1 ();
i += ({ check1 (); });
bool judge()
{
if(2 * m <= x && x <= 6 * m && x % m == 0)
return true;
if(check2(x - m, 1))
return true;
if(check2(x - 2 * m, 0))
return true;
if(check1(x - 3 * m, 0))
return true;
if(check1(x - 4 * m, 0))
return true;
return check3(x);
}
int main()
{
int p[8], i, j;
while (gets(buf)) {
memset(p, 0, sizeof(p));
p[1] = check1();
if (p[1]) {
p[2] = ispal(s2);
p[3] = check3();
p[4] = check4();
p[5] = check5();
p[6] = check6();
p[7] = check7();
}
for (i = 1, j = 1; i <= 7; i++) {
putchar(p[i] ? 'T' : 'F');
j &= p[i];
}
printf(" The solution is %s\n", j ? "accepted" : "not accepted");
}
return 0;
}
int main()
{
int a = 10;
int b = 20;
check1(a, b);
double c = check2(30.0);
}
int main()
{
struct A *p;
if (local.a != 1 || local.b != 2 || local.c != 3)
abort ();
if (a1.a != 4 || a1.b != 5 || a1.c != 6)
abort ();
if (a2.a != 22 || a2.b != 23 || a2.c != 24)
abort ();
if (a3.a != 10 || a3.b != 11 || a3.c != 12)
abort ();
if (a4.a != 25 || a4.b != 26 || a4.c != 27)
abort ();
check1 ();
check2 ();
if (f1a () != &a1 || f2a () != &a2 || f3a () != &a3 || f4a () != &a4)
abort ();
CHECK (5, 16);
CHECK (6, 19);
if (f7a () != &a2 || f8a () != &a4)
abort ();
CHECK (9, 28);
CHECK (10, 31);
exit (0);
}
double AngularGradient_dfy1(Vector v0, Vector v1, Vector v2, double w, int mass) {
double x0, y0, x1, y1, x2, y2;
x0 = v0.x;
y0 = v0.y;
x1 = v1.x;
y1 = v1.y;
x2 = v2.x;
y2 = v2.y;
double a00 = -x1 + x2;
double a01 = x0 - x1;
double a02 = y0 - y1;
double a03 = -y1 + y2;
double a04 = 2 * M_PI / mass;
double a05 = -y0 + 2 * y1 - y2;
double b00 = pow(a01, 2);
double b01 = pow(a02, 2);
double b02 = pow(a00, 2);
double b04 = pow(a03, 2);
double b05 = a01 * a00 + a02 * a03;
double c00 = sqrt(b00 + b01);
double c01 = sqrt(b02 + b04);
double c02 = pow(b00 + b01, 1.5);
double c03 = pow(b05, 2);
double c04 = pow(b02 + b04, 1.5);
double c05 = b00 + b01;
double c06 = b02 + b04;
double c08 = a02 * b05;
double c10 = a03 * b05;
double d00 = c00 * c01;
double d01 = c02 * c01;
double d03 = c05 * c06;
double d04 = c00 * c04;
check3(&d00, &d01, &d03, &d04);
/*assert(!Util_is_zero(d00));*/
/*assert(!Util_is_zero(d01));*/
/*assert(!Util_is_zero(d03));*/
/*assert(!Util_is_zero(d04));*/
double e02 = b05 / d00;
double e03 = c03 / d03;
double e05 = c08 / d01;
double e09 = c10 / d04;
double e11 = a05 / d00;
check1(&e02, &e03);
double f01 = acosf(e02);
double f02 = sqrt(1 - e03);
double f05 = e09 +e11 +e05;
check2(&f02);
double g00 = a04 - f01;
double h03 = (2*w*f05*g00);
return h03/f02;
}
int main()
{
struct A *p;
check1 ();
CHECK (1, 4);
CHECK (2, 7);
exit (0);
}
static int
test_main (void)
{
test_init ();
check1 ();
printf ("%23s", "");
FOR_EACH_IMPL (impl, 0)
printf ("\t%s", impl->name);
putchar ('\n');
for (size_t klen = 2; klen < 32; ++klen)
for (size_t hlen = 2 * klen; hlen < 16 * klen; hlen += klen)
{
do_test (0, 0, hlen, klen, 0);
do_test (0, 0, hlen, klen, 1);
do_test (0, 3, hlen, klen, 0);
do_test (0, 3, hlen, klen, 1);
do_test (0, 9, hlen, klen, 0);
do_test (0, 9, hlen, klen, 1);
do_test (0, 15, hlen, klen, 0);
do_test (0, 15, hlen, klen, 1);
do_test (3, 0, hlen, klen, 0);
do_test (3, 0, hlen, klen, 1);
do_test (3, 3, hlen, klen, 0);
do_test (3, 3, hlen, klen, 1);
do_test (3, 9, hlen, klen, 0);
do_test (3, 9, hlen, klen, 1);
do_test (3, 15, hlen, klen, 0);
do_test (3, 15, hlen, klen, 1);
do_test (9, 0, hlen, klen, 0);
do_test (9, 0, hlen, klen, 1);
do_test (9, 3, hlen, klen, 0);
do_test (9, 3, hlen, klen, 1);
do_test (9, 9, hlen, klen, 0);
do_test (9, 9, hlen, klen, 1);
do_test (9, 15, hlen, klen, 0);
do_test (9, 15, hlen, klen, 1);
do_test (15, 0, hlen, klen, 0);
do_test (15, 0, hlen, klen, 1);
do_test (15, 3, hlen, klen, 0);
do_test (15, 3, hlen, klen, 1);
do_test (15, 9, hlen, klen, 0);
do_test (15, 9, hlen, klen, 1);
do_test (15, 15, hlen, klen, 0);
do_test (15, 15, hlen, klen, 1);
}
do_test (0, 0, page_size - 1, 16, 0);
do_test (0, 0, page_size - 1, 16, 1);
return ret;
}
int
main (int argc, char *argv[])
{
tests_start_mpfr ();
check1 ();
tests_end_mpfr ();
return 0;
}
int main(void) {
check1();
printf("--------------------------------------");
check2();
printf("--------------------------------------");
check3();
printf("--------------------------------------");
return 0;
}
bool Control::check(std::vector<int> &n)
{
getOutCard(n);
bool result=false;
switch (n.size())
{
case 1:
result=check1();
break;
case 2:
result=check2();
break;
case 3:
result=check3();
break;
case 4:
result=check4();
break;
case 5:
result=check5();
break;
case 6:
result=check6();
break;
case 7:
case 11:
case 13:
result=check7();
break;
case 8:
result=check8();
break;
case 9:
result=check9();
break;
case 10:
result=check10();
break;
case 12:
result=check12();
break;
case 14:
result=check14();
break;
case 15:
result=check15();
break;
case 16:
result=check16();
break;
}
return result;
}
int countNQueens(int &k, int n, int* array, int row){
if(row == n)
return ++k;
for(int i = 0; i < n; i++){
array[row] = i;
if(check1(row,n,array)){
countNQueens(k,n,array, row + 1);
}
}
return k;
}
int main() {
std::cout.precision(10);
// lattice structure
int n = 16;
int ibond = n;
std::vector<int> ipair;
for (int i = 0; i < ibond; ++i) {
ipair.push_back(i);
ipair.push_back((i + 1) % n);
}
// Hamiltonian parameters
std::vector<double> bondwt(ibond, -1);
std::vector<double> zrtio(ibond, 1);
// table of configurations
std::vector<int> list1;
std::vector<std::pair<int, int> > list2;
int idim = sz(n, 0, list1, list2);
// You may alternatively use szdy or sztn for faster processing
// int idim = szdy(n, 0, list1, list2);
// or
// int idim = sztn(n, 0, list1, list2);
// Eigenvalues
int nvec = 0;
int iv = idim / 3 - 1;
std::vector<double> E, alpha, beta;
matrix_type coeff;
matrix_type v;
int itr = lnc1(n, ipair, bondwt, zrtio, nvec, iv, E, alpha, beta, coeff, v, list1, list2);
std::cout << "[Eigenvalues]\n";
for (int i = 0; i < 4; ++i) std::cout << '\t' << E[i];
std::cout << std::endl;
std::cout << "[Iteration number]\n\t" << itr << std::endl;
// Ground-state eigenvector
std::vector<double> x;
inv1(n, ipair, bondwt, zrtio, E[2], iv, x, v, list1, list2);
std::cout << "[Eigenvector components (selected)]";
int count = 0;
for (int i = 12; i < idim; i += idim/20, ++count) {
if (count % 4 == 0) std::cout << std::endl;
std::cout << '\t' << x[i];
}
std::cout << std::endl;
// Precision check and correlation functions
double Hexpec = check1(n, ipair, bondwt, zrtio, x, v, 0, list1, list2);
}
int main()
{
check1();
check2();
convert1();
convert2();
convert3();
convert4();
convert5();
return 0;
}
bool proof_checker::check(proof* p, expr_ref_vector& side_conditions) {
proof_ref curr(m);
m_todo.push_back(p);
bool result = true;
while (result && !m_todo.empty()) {
curr = m_todo.back();
m_todo.pop_back();
result = check1(curr.get(), side_conditions);
if (!result) {
IF_VERBOSE(0, ast_ll_pp(verbose_stream() << "Proof check failed\n", m, curr.get()););
UNREACHABLE();
}
//==============================================================================
PoissonData::PoissonData(int L,
int numProcs, int localProc, int outputLevel)
{
//
//PoissonData constructor.
//
//Arguments:
//
// L: global square size (number-of-elements along side)
// numProcs: number of processors participating in this FEI test.
// localProc: local processor number.
// outputLevel: affects the amount of screen output.
//
L_ = L;
startElement_ = 0;
numLocalElements_ = 0;
numProcs_ = numProcs;
localProc_ = localProc;
outputLevel_ = outputLevel;
check1();
elem_ = new Poisson_Elem();
int err = elem_->allocateInternals(1);
err += elem_->allocateLoad(1);
err += elem_->allocateStiffness(1);
if (err) messageAbort("Allocation error in element.");
fieldArraysAllocated_ = false;
elemIDsAllocated_ = false;
numFields_ = NULL;
fieldIDs_ = NULL;
elemIDs_ = NULL;
calculateDistribution();
numElemBlocks_ = 1;
elemBlockID_ = (GlobalID)0;
elemSetID_ = 0;
elemFormat_ = 0;
nodesPerElement_ = 4;
fieldsPerNode_ = 1;
initializeFieldStuff();
}
// Establish a regular tcp connection
static int tcpConnect(const char* ip, short port) {
int handle = socket(AF_INET, SOCK_STREAM, 0);
check1(handle >= 0, SSLERR_CONNECT, "socket return error");
setNonBlock(handle, 1);
struct sockaddr_in server;
bzero(&server, sizeof server);
server.sin_family = AF_INET;
server.sin_port = htons(port);
char *newIP = formatIP(ip);
inet_aton(ip, (struct in_addr *)&server.sin_addr.s_addr);
free(newIP);
int r = connect(handle, (struct sockaddr *) &server, sizeof(struct sockaddr));
if (r < 0 && (errno == EWOULDBLOCK || errno == EAGAIN)) {
struct pollfd pfd;
pfd.fd = handle;
pfd.events = POLLOUT | POLLERR;
while (r == 0) {
r = poll(&pfd, 1, 100);
}
check1(pfd.revents == POLLOUT, SSLERR_CONNECT, "poll return error events: %d", pfd.revents);
}
return handle;
}
int main()
{
zeropad();
printfield();
calculate();
if (check1() || check2() || check3())
printf("No solution\n");
else
if (solve())
drawpath();
else
printf("Path not found\n");
return 0;
}
int main(int argc, char **argv) {
fprintf(stderr, "Started...\n");
#if 0
int rv;
rv=check1();
if (rv)
return rv;
rv=check2();
if (rv)
return rv;
#endif
return 0;
}
int main()
{
int t;
scanf("%d",&t);
while(t-->0)
{
int i,flag=0,flag1=0,flag2=0;
char str[100];
scanf("%s",str);
for(i=0;i<5;i++)
{
if(check(str[i])!=1)
{
flag=1;
break;
}
}
if(flag==1)
printf("NO\n");
else
{
if(check(str[9])!=1)
{
flag1=1;
}
if(flag1==1)
printf("NO\n");
else
{
if(check1(str[i])!=1)
{
flag2=1;
}
if(flag2==1)
printf("NO\n");
else
printf("YES\n");
}
}
}
system("pause");
return 0;
}
void play()
{
char ar[3][3];
int r,c,b=0;
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
ar[i][j]='~';
}
}
for(i=1;i<=9;i++)
{
if(i%2==1)
{
a1:
cout<<"\n\tEnter a CROSS (X):\n\n";
cout<<"\tEnter row and column:";
cin>>r>>c;
if(ar[r-1][c-1]=='~'&&r<=3&&c<=3)
{
ar[r-1][c-1]='X';
}
else
{
cout<<"\tWrong parameters inputed ! ! !\tEnter again ! !\n";
goto a1;
}
output(ar);
if(check1(ar,'X')==3||check2(ar,'X')==3||check3(ar,'X')==3||check4(ar,'X')==3)
{
cout<<"\t****PLAYER MARKING WITH X SIGN WINS!**** \n\n\tCONGRATULATIONS\n\n";
b=1;
cout<<"\tPRESS ANY KEY FOR MAIN MENU:";
getch();
break;
}
}
else
{
int main()
{
struct A *p;
check1 ();
check2 ();
CHECK (1, 4);
CHECK (2, 22);
CHECK (3, 10);
CHECK (4, 25);
CHECK (5, 16);
CHECK (6, 19);
CHECK (7, 22);
CHECK (8, 25);
CHECK (9, 28);
CHECK (10, 31);
exit (0);
}
Polynomial spolynomial(const SPI & spi,const FactBase & fc,TimingRecorder * timers) {
if(timers) {
timers->start(s_spolynomialsTiming);
};
const GroebnerRule & first = fc.rule(spi.leftID());
const GroebnerRule & second = fc.rule(spi.rightID());
Monomial tip1(first.LHS());
Monomial tip2(second.LHS());
Monomial right1, left2, one;
int len1 = spi.overlapLength();
MonomialIterator w1 = tip2.begin();
for(int k=1;k<=len1;++k) { ++w1;};
int max1 = tip2.numberOfFactors()-1;
// The following line is for a faster run-time.
right1.reserve(max1-len1+1);
for(int i=len1;i<=max1;++i,++w1) {
right1 *= (*w1);
}
MonomialIterator w2 = tip1.begin();
int max2 = tip1.numberOfFactors() - len1;
// The following line is for a faster run-time.
left2.reserve(max2);
for(i=0;i< max2;++i,++w2) {
left2 *= (*w2);
}
Term ONE(one);
#if 0
Monomial check1(tip1);
check1 *= right1;
Monomial check2(left2);
check2 *= tip1;
if(check1!=check2) {
DBG();
};
#endif
Polynomial result1(first.RHS());
Polynomial result2(second.RHS());
result1 *= Term(right1);
result2.premultiply(Term(left2));
result1 -= result2;
if(timers) {
timers->printpause("spolynomial Timing:",s_spolynomialsTiming);
};
return result1;
};
int main(){
char str[1000];
while(gets(str)){
bool YES=true;
int index=0;
int i;
for(i=0;str[i]!='\0';i++)
if(!check1(str[i])){
YES=false;
break;
}
if(YES&&(!check2(str,&index)||str[index]!='\0'))
YES=false;
if(YES)
puts("YES");
else
puts("NO");
}
return 0;
}
int
main (int argc, char *argv[])
{
int h;
if (argc == 5)
{
check_random (atoi (argv[1]), atoi (argv[2]), atoi (argv[3]),
(mpfr_rnd_t) atoi (argv[4]));
return 0;
}
tests_start_mpfr ();
if (argc != 1)
{
fprintf (stderr, "Usage: tsum\n tsum n k prec rnd\n");
exit (1);
}
check_simple ();
check_special ();
check_more_special ();
for (h = 0; h <= 64; h++)
check1 (h);
check2 ();
check3 ();
check4 ();
bug20131027 ();
bug20150327 ();
bug20160315 ();
generic_tests ();
check_extreme ();
cancel ();
check_overflow ();
check_underflow ();
check_coverage ();
tests_end_mpfr ();
return 0;
}
int check2(char str[],int *index){
if(str[*index]=='\0')
return false;
int temp=check1(str[(*index)++]);
if(temp==N) // N
if(check2(str,index))
return true;
else
return false;
else if(temp==CDEI) // CDEI
if(check2(str,index))
if(check2(str,index))
return true;
else
return false;
else
return false;
else
return true; // q~z
}
int check(int length1, float *number3, int *oper3){
if (length1 == 1)
return check1(number3,oper3);
if (length1 == 2)
return check2(number3,oper3);
if (length1 == 3)
return check3(number3,oper3);
if (length1 == 4)
return check4(number3,oper3);
if (length1 == 5)
return check5(number3,oper3);
if (length1 == 6)
return check6(number3,oper3);
if (length1 == 7)
return check7(number3,oper3);
if (length1 == 8)
return check8(number3,oper3);
if (length1 == 9)
return check9(number3,oper3);
if (length1 == 10)
return check10(number3,oper3);
return 0;
}
int
main (int argc, char** argv)
{
double x = 2.0;
double y = -5.0;
double epsilon = 0.00001;
double expected = -2.0;
if (fabs (check (x, y) - expected) >= epsilon)
__builtin_abort ();
expected = 2.0;
if (fabs (check1 (x) - expected) >= epsilon)
__builtin_abort ();
expected = 1.0;
if (fabs (check2 (x) - expected) >= epsilon)
__builtin_abort ();
expected = -2.0;
if (fabs (check3 (x) - expected) >= epsilon)
__builtin_abort ();
expected = -4.0;
if (fabs (check4 (x, y) - expected) >= epsilon)
__builtin_abort ();
expected = 2.0;
if (fabs (check5 (x, y) - expected) >= epsilon)
__builtin_abort ();
}
int main(){
freopen("transform.in", "r", stdin);
freopen("transform.out", "w", stdout);
scanf("%d", &total_length);
for(int i = 0; i < total_length; ++i)
scanf("%s", before[i]);
for(int i = 0; i < total_length; ++i)
scanf("%s", after[i]);
if(check1())
printf("1\n");
else if(check2())
printf("2\n");
else if(check3())
printf("3\n");
else if(check4())
printf("4\n");
else if(check5())
printf("5\n");
else if(check6())
printf("6\n");
else
printf("7\n");
return 0;
}
