int run_test_case(int casenum__) {
switch (casenum__) {
case 0: {
string grid[] = {".o",
"o."};
int expected__ = 1;
clock_t start__ = clock();
int received__ = DucksAlignment().minimumTime(vector <string>(grid, grid + (sizeof grid / sizeof grid[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 1: {
string grid[] = {".o...",
"..o..",
"....o"};
int expected__ = 3;
clock_t start__ = clock();
int received__ = DucksAlignment().minimumTime(vector <string>(grid, grid + (sizeof grid / sizeof grid[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 2: {
string grid[] = {"o..........",
"..o........",
".......o...",
"...........",
"...........",
"...........",
"........o..",
"..........."};
int expected__ = 16;
clock_t start__ = clock();
int received__ = DucksAlignment().minimumTime(vector <string>(grid, grid + (sizeof grid / sizeof grid[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 3: {
string grid[] = {".........",
"....o....",
"........."};
int expected__ = 0;
clock_t start__ = clock();
int received__ = DucksAlignment().minimumTime(vector <string>(grid, grid + (sizeof grid / sizeof grid[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 4: {
string grid[] = {"...o..........................",
"............................o.",
".o............................",
"............o.................",
".................o............",
"......................o.......",
"......o.......................",
"....o.........................",
"...............o..............",
".......................o......",
"...........................o..",
".......o......................"};
int expected__ = 99;
clock_t start__ = clock();
int received__ = DucksAlignment().minimumTime(vector <string>(grid, grid + (sizeof grid / sizeof grid[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
// custom cases
/* case 5: {
string grid[] = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = DucksAlignment().minimumTime(vector <string>(grid, grid + (sizeof grid / sizeof grid[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
/* case 6: {
string grid[] = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = DucksAlignment().minimumTime(vector <string>(grid, grid + (sizeof grid / sizeof grid[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
/* case 7: {
string grid[] = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = DucksAlignment().minimumTime(vector <string>(grid, grid + (sizeof grid / sizeof grid[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
default:
return -1;
}
}
void test_case_4() { int Arg0 = 577007436; int Arg1 = 384671628; verify_case(4, Arg1, cut(Arg0)); }
int run_test_case( int casenum ) {
switch( casenum ) {
case 0: {
int sequence[] = {1, 5, 10, 4};
int k = 10;
int expected = 6;
clock_t start = clock();
int received = TheSequencesLevelThree().find( vector <int>( sequence, sequence + ( sizeof sequence / sizeof sequence[0] ) ), k );
return verify_case( casenum, expected, received, clock()-start );
}
case 1: {
int sequence[] = {1, 5, 10, 4};
int k = 6;
int expected = 4;
clock_t start = clock();
int received = TheSequencesLevelThree().find( vector <int>( sequence, sequence + ( sizeof sequence / sizeof sequence[0] ) ), k );
return verify_case( casenum, expected, received, clock()-start );
}
case 2: {
int sequence[] = {4, 44, 7, 77};
int k = 1;
int expected = 0;
clock_t start = clock();
int received = TheSequencesLevelThree().find( vector <int>( sequence, sequence + ( sizeof sequence / sizeof sequence[0] ) ), k );
return verify_case( casenum, expected, received, clock()-start );
}
case 3: {
int sequence[] = {96, 29, 21, 90, 46, 77, 31, 63, 79};
int k = 44;
int expected = 126;
clock_t start = clock();
int received = TheSequencesLevelThree().find( vector <int>( sequence, sequence + ( sizeof sequence / sizeof sequence[0] ) ), k );
return verify_case( casenum, expected, received, clock()-start );
}
// custom cases
/* case 4: {
int sequence[] = ;
int k = ;
int expected = ;
clock_t start = clock();
int received = TheSequencesLevelThree().find( vector <int>( sequence, sequence + ( sizeof sequence / sizeof sequence[0] ) ), k );
return verify_case( casenum, expected, received, clock()-start );
}*/
/* case 5: {
int sequence[] = ;
int k = ;
int expected = ;
clock_t start = clock();
int received = TheSequencesLevelThree().find( vector <int>( sequence, sequence + ( sizeof sequence / sizeof sequence[0] ) ), k );
return verify_case( casenum, expected, received, clock()-start );
}*/
/* case 6: {
int sequence[] = ;
int k = ;
int expected = ;
clock_t start = clock();
int received = TheSequencesLevelThree().find( vector <int>( sequence, sequence + ( sizeof sequence / sizeof sequence[0] ) ), k );
return verify_case( casenum, expected, received, clock()-start );
}*/
default:
return -1;
}
}
void test_case_2() { int Arg0 = 15; int Arg1 = 7; verify_case(2, Arg1, cut(Arg0)); }
void test_case_3() { int Arg0 = 1000000000; int Arg1 = 600000000; verify_case(3, Arg1, cut(Arg0)); }
void test_case_0() { int Arg0 = 6; int Arg1 = 4; verify_case(0, Arg1, cut(Arg0)); }
void test_case_1() { int Arg0 = 3; int Arg1 = 1; verify_case(1, Arg1, cut(Arg0)); }
int run_test_case(int casenum) {
switch (casenum) {
case 0: {
int n = 5;
int m = 2;
int k = 3;
int expected__ = 5;
clock_t start__ = clock();
int received__ = KidsGame().kthKid(n, m, k);
return verify_case(casenum, expected__, received__, clock()-start__);
}
case 1: {
int n = 1;
int m = 10;
int k = 1;
int expected__ = 1;
clock_t start__ = clock();
int received__ = KidsGame().kthKid(n, m, k);
return verify_case(casenum, expected__, received__, clock()-start__);
}
case 2: {
int n = 99;
int m = 100;
int k = 99;
int expected__ = 94;
clock_t start__ = clock();
int received__ = KidsGame().kthKid(n, m, k);
return verify_case(casenum, expected__, received__, clock()-start__);
}
case 3: {
int n = 19999;
int m = 7;
int k = 5;
int expected__ = 18019;
clock_t start__ = clock();
int received__ = KidsGame().kthKid(n, m, k);
return verify_case(casenum, expected__, received__, clock()-start__);
}
case 4: {
int n = 99999;
int m = 11111;
int k = 3;
int expected__ = 69557;
clock_t start__ = clock();
int received__ = KidsGame().kthKid(n, m, k);
return verify_case(casenum, expected__, received__, clock()-start__);
}
// custom cases
/* case 5: {
int n = ;
int m = ;
int k = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = KidsGame().kthKid(n, m, k);
return verify_case(casenum, expected__, received__, clock()-start__);
}*/
/* case 6: {
int n = ;
int m = ;
int k = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = KidsGame().kthKid(n, m, k);
return verify_case(casenum, expected__, received__, clock()-start__);
}*/
/* case 7: {
int n = ;
int m = ;
int k = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = KidsGame().kthKid(n, m, k);
return verify_case(casenum, expected__, received__, clock()-start__);
}*/
default:
return -1;
}
}
int run_test_case( int casenum__ ) {
long long starttime__ = get_time();
switch( casenum__ ) {
case 0: {
string cardNumber = "21378";
string expected__ = "VALID";
return verify_case( casenum__, starttime__, expected__, VerifyCreditCard().checkDigits( cardNumber ) );
}
case 1: {
string cardNumber = "31378";
string expected__ = "INVALID";
return verify_case( casenum__, starttime__, expected__, VerifyCreditCard().checkDigits( cardNumber ) );
}
case 2: {
string cardNumber = "11111101";
string expected__ = "VALID";
return verify_case( casenum__, starttime__, expected__, VerifyCreditCard().checkDigits( cardNumber ) );
}
case 3: {
string cardNumber = "50005";
string expected__ = "VALID";
return verify_case( casenum__, starttime__, expected__, VerifyCreditCard().checkDigits( cardNumber ) );
}
case 4: {
string cardNumber = "542987223412";
string expected__ = "INVALID";
return verify_case( casenum__, starttime__, expected__, VerifyCreditCard().checkDigits( cardNumber ) );
}
// custom cases
/*
case 5: {
string cardNumber = ;
string expected__ = ;
return verify_case( casenum__, starttime__, expected__, VerifyCreditCard().checkDigits( cardNumber ) );
}
*/
/*
case 6: {
string cardNumber = ;
string expected__ = ;
return verify_case( casenum__, starttime__, expected__, VerifyCreditCard().checkDigits( cardNumber ) );
}
*/
/*
case 7: {
string cardNumber = ;
string expected__ = ;
return verify_case( casenum__, starttime__, expected__, VerifyCreditCard().checkDigits( cardNumber ) );
}
*/
default:
return -1;
}
}
int run_test_case(int casenum__) {
switch (casenum__) {
case 0: {
string S = "topcoderdivtwo";
int expected__ = 2;
clock_t start__ = clock();
int received__ = AkariDaisukiDiv2().countTuples(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 1: {
string S = "foxciel";
int expected__ = 0;
clock_t start__ = clock();
int received__ = AkariDaisukiDiv2().countTuples(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 2: {
string S = "magicalgirl";
int expected__ = 4;
clock_t start__ = clock();
int received__ = AkariDaisukiDiv2().countTuples(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 3: {
string S = "waaiusushioakariusushiodaisuki";
int expected__ = 75;
clock_t start__ = clock();
int received__ = AkariDaisukiDiv2().countTuples(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 4: {
string S = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
int expected__ = 8924;
clock_t start__ = clock();
int received__ = AkariDaisukiDiv2().countTuples(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
// custom cases
case 5: {
string S = "yw";
int expected__ = 0;
clock_t start__ = clock();
int received__ = AkariDaisukiDiv2().countTuples(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
/* case 6: {
string S = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = AkariDaisukiDiv2().countTuples(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
/* case 7: {
string S = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = AkariDaisukiDiv2().countTuples(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
default:
return -1;
}
}
int run_test_case( int casenum ) {
switch( casenum ) {
case 0: {
int velocities[] = {100};
int consumptions[] = {10000};
int fuel = 10000;
double expected = 100.0;
clock_t moj_start_time = clock();
double received = FuelConsumption().maximalDistance( vector <int>( velocities, velocities + ( sizeof velocities / sizeof velocities[0] ) ), vector <int>( consumptions, consumptions + ( sizeof consumptions / sizeof consumptions[0] ) ), fuel );
return verify_case( casenum, expected, received, clock()-moj_start_time );
}
case 1: {
int velocities[] = {70, 80, 90, 100, 60, 110};
int consumptions[] = {4000, 4000, 4000, 4000, 4000, 4000};
int fuel = 40000;
double expected = 1100.0;
clock_t moj_start_time = clock();
double received = FuelConsumption().maximalDistance( vector <int>( velocities, velocities + ( sizeof velocities / sizeof velocities[0] ) ), vector <int>( consumptions, consumptions + ( sizeof consumptions / sizeof consumptions[0] ) ), fuel );
return verify_case( casenum, expected, received, clock()-moj_start_time );
}
case 2: {
int velocities[] = {250, 240, 230, 220, 210, 211};
int consumptions[] = {5000, 4500, 4000, 3500, 3000, 3000};
int fuel = 50000;
double expected = 3516.6666666666665;
clock_t moj_start_time = clock();
double received = FuelConsumption().maximalDistance( vector <int>( velocities, velocities + ( sizeof velocities / sizeof velocities[0] ) ), vector <int>( consumptions, consumptions + ( sizeof consumptions / sizeof consumptions[0] ) ), fuel );
return verify_case( casenum, expected, received, clock()-moj_start_time );
}
case 3: {
int velocities[] = {5, 10, 20, 40, 80};
int consumptions[] = {1000, 2500, 6250, 9000, 18000};
int fuel = 47832;
double expected = 239.16;
clock_t moj_start_time = clock();
double received = FuelConsumption().maximalDistance( vector <int>( velocities, velocities + ( sizeof velocities / sizeof velocities[0] ) ), vector <int>( consumptions, consumptions + ( sizeof consumptions / sizeof consumptions[0] ) ), fuel );
return verify_case( casenum, expected, received, clock()-moj_start_time );
}
case 4: {
int velocities[] = {5, 10, 20, 40, 80, 160};
int consumptions[] = {1000, 2500, 6250, 8000, 9500, 20000};
int fuel = 47832;
double expected = 402.79578947368424;
clock_t moj_start_time = clock();
double received = FuelConsumption().maximalDistance( vector <int>( velocities, velocities + ( sizeof velocities / sizeof velocities[0] ) ), vector <int>( consumptions, consumptions + ( sizeof consumptions / sizeof consumptions[0] ) ), fuel );
return verify_case( casenum, expected, received, clock()-moj_start_time );
}
case 5: {
int velocities[] = {240, 195, 130, 133, 15, 160, 111, 206, 72, 149, 146, 115, 235, 183, 102, 96, 163, 61, 196, 52, 87, 139, 33, 7, 90, 67, 118, 227, 197, 114};
int consumptions[] = {14837, 2981, 17292, 18591, 4832, 7461, 17991, 18369, 18291, 9400, 15179, 3317, 2595, 2441, 6936, 8028, 14973, 18981, 12503, 7816, 2883, 6385, 6230, 18157, 16567, 9310, 2866, 4687, 14171, 4477};
int fuel = 31710;
double expected = 2871.6184971098264;
clock_t moj_start_time = clock();
double received = FuelConsumption().maximalDistance( vector <int>( velocities, velocities + ( sizeof velocities / sizeof velocities[0] ) ), vector <int>( consumptions, consumptions + ( sizeof consumptions / sizeof consumptions[0] ) ), fuel );
return verify_case( casenum, expected, received, clock()-moj_start_time );
}
// custom cases
/* case 6: {
int velocities[] = ;
int consumptions[] = ;
int fuel = ;
double expected = ;
clock_t moj_start_time = clock();
double received = FuelConsumption().maximalDistance( vector <int>( velocities, velocities + ( sizeof velocities / sizeof velocities[0] ) ), vector <int>( consumptions, consumptions + ( sizeof consumptions / sizeof consumptions[0] ) ), fuel );
return verify_case( casenum, expected, received, clock()-moj_start_time );
}*/
/* case 7: {
int velocities[] = ;
int consumptions[] = ;
int fuel = ;
double expected = ;
clock_t moj_start_time = clock();
double received = FuelConsumption().maximalDistance( vector <int>( velocities, velocities + ( sizeof velocities / sizeof velocities[0] ) ), vector <int>( consumptions, consumptions + ( sizeof consumptions / sizeof consumptions[0] ) ), fuel );
return verify_case( casenum, expected, received, clock()-moj_start_time );
}*/
/* case 8: {
int velocities[] = ;
int consumptions[] = ;
int fuel = ;
double expected = ;
clock_t moj_start_time = clock();
double received = FuelConsumption().maximalDistance( vector <int>( velocities, velocities + ( sizeof velocities / sizeof velocities[0] ) ), vector <int>( consumptions, consumptions + ( sizeof consumptions / sizeof consumptions[0] ) ), fuel );
return verify_case( casenum, expected, received, clock()-moj_start_time );
}*/
default:
return -1;
}
}
int run_test_case(int casenum__) {
switch (casenum__) {
case 0: {
int blockHeights[] = {4,7};
int expected__ = 11;
clock_t start__ = clock();
int received__ = BlockTower().getTallest(vector <int>(blockHeights, blockHeights + (sizeof blockHeights / sizeof blockHeights[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 1: {
int blockHeights[] = {7,4};
int expected__ = 7;
clock_t start__ = clock();
int received__ = BlockTower().getTallest(vector <int>(blockHeights, blockHeights + (sizeof blockHeights / sizeof blockHeights[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 2: {
int blockHeights[] = {7};
int expected__ = 7;
clock_t start__ = clock();
int received__ = BlockTower().getTallest(vector <int>(blockHeights, blockHeights + (sizeof blockHeights / sizeof blockHeights[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 3: {
int blockHeights[] = {4};
int expected__ = 4;
clock_t start__ = clock();
int received__ = BlockTower().getTallest(vector <int>(blockHeights, blockHeights + (sizeof blockHeights / sizeof blockHeights[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 4: {
int blockHeights[] = {48,1,50,1,50,1,48};
int expected__ = 196;
clock_t start__ = clock();
int received__ = BlockTower().getTallest(vector <int>(blockHeights, blockHeights + (sizeof blockHeights / sizeof blockHeights[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 5: {
int blockHeights[] = {49,2,49,2,49};
int expected__ = 147;
clock_t start__ = clock();
int received__ = BlockTower().getTallest(vector <int>(blockHeights, blockHeights + (sizeof blockHeights / sizeof blockHeights[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 6: {
int blockHeights[] = {44,3,44,3,44,47,2,47,2,47,2};
int expected__ = 273;
clock_t start__ = clock();
int received__ = BlockTower().getTallest(vector <int>(blockHeights, blockHeights + (sizeof blockHeights / sizeof blockHeights[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
// custom cases
case 7: {
int blockHeights[] = {2, 1, 1, 33, 40};
int expected__ = 42;
clock_t start__ = clock();
int received__ = BlockTower().getTallest(vector <int>(blockHeights, blockHeights + (sizeof blockHeights / sizeof blockHeights[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 8: {
int blockHeights[] = {11, 6, 6, 6};
int expected__ = 18;
clock_t start__ = clock();
int received__ = BlockTower().getTallest(vector <int>(blockHeights, blockHeights + (sizeof blockHeights / sizeof blockHeights[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}
/* case 9: {
int blockHeights[] = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = BlockTower().getTallest(vector <int>(blockHeights, blockHeights + (sizeof blockHeights / sizeof blockHeights[0])));
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
default:
return -1;
}
}
int run_test_case( int casenum__ ) {
long long starttime__ = get_time();
switch( casenum__ ) {
case 0: {
int n = 2;
int minInv = 1;
string minStr = "ab";
string expected__ = "ba";
return verify_case( casenum__, starttime__, expected__, StrIIRec().recovstr( n, minInv, minStr ) );
}
case 1: {
int n = 9;
int minInv = 1;
string minStr = "efcdgab";
string expected__ = "efcdgabhi";
return verify_case( casenum__, starttime__, expected__, StrIIRec().recovstr( n, minInv, minStr ) );
}
case 2: {
int n = 11;
int minInv = 55;
string minStr = "debgikjfc";
string expected__ = "kjihgfedcba";
return verify_case( casenum__, starttime__, expected__, StrIIRec().recovstr( n, minInv, minStr ) );
}
case 3: {
int n = 15;
int minInv = 0;
string minStr = "e";
string expected__ = "eabcdfghijklmno";
return verify_case( casenum__, starttime__, expected__, StrIIRec().recovstr( n, minInv, minStr ) );
}
case 4: {
int n = 9;
int minInv = 20;
string minStr = "fcdebiha";
string expected__ = "fcdehigba";
return verify_case( casenum__, starttime__, expected__, StrIIRec().recovstr( n, minInv, minStr ) );
}
// custom cases
/*
case 5: {
int n = ;
int minInv = ;
string minStr = ;
string expected__ = ;
return verify_case( casenum__, starttime__, expected__, StrIIRec().recovstr( n, minInv, minStr ) );
}
*/
/*
case 6: {
int n = ;
int minInv = ;
string minStr = ;
string expected__ = ;
return verify_case( casenum__, starttime__, expected__, StrIIRec().recovstr( n, minInv, minStr ) );
}
*/
/*
case 7: {
int n = ;
int minInv = ;
string minStr = ;
string expected__ = ;
return verify_case( casenum__, starttime__, expected__, StrIIRec().recovstr( n, minInv, minStr ) );
}
*/
default:
return -1;
}
}
int run_test_case(int casenum__) {
switch (casenum__) {
case 0: {
string S = "ABAA";
int expected__ = 1;
clock_t start__ = clock();
int received__ = TaroFillingAStringDiv2().getNumber(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 1: {
string S = "??";
int expected__ = 0;
clock_t start__ = clock();
int received__ = TaroFillingAStringDiv2().getNumber(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 2: {
string S = "A?A";
int expected__ = 0;
clock_t start__ = clock();
int received__ = TaroFillingAStringDiv2().getNumber(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 3: {
string S = "A??B???AAB?A???A";
int expected__ = 3;
clock_t start__ = clock();
int received__ = TaroFillingAStringDiv2().getNumber(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 4: {
string S = "?BB?BAAB???BAB?B?AAAA?ABBA????A?AAB?BBA?A?";
int expected__ = 10;
clock_t start__ = clock();
int received__ = TaroFillingAStringDiv2().getNumber(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
// custom cases
/* case 5: {
string S = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = TaroFillingAStringDiv2().getNumber(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
/* case 6: {
string S = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = TaroFillingAStringDiv2().getNumber(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
/* case 7: {
string S = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = TaroFillingAStringDiv2().getNumber(S);
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
default:
return -1;
}
}
int run_test_case( int casenum__ ) {
long long starttime__ = get_time();
switch( casenum__ ) {
case 0: {
string rolls[] = {"137", "364", "115", "724"};
int expected__ = 14;
return verify_case( casenum__, starttime__, expected__, RollingDiceDivTwo().minimumFaces( vector <string>( rolls, rolls + ( sizeof rolls / sizeof(string) ) ) ) );
}
case 1: {
string rolls[] = {"1112", "1111", "1211", "1111"};
int expected__ = 5;
return verify_case( casenum__, starttime__, expected__, RollingDiceDivTwo().minimumFaces( vector <string>( rolls, rolls + ( sizeof rolls / sizeof(string) ) ) ) );
}
case 2: {
string rolls[] = {"24412", "56316", "66666", "45625"};
int expected__ = 30;
return verify_case( casenum__, starttime__, expected__, RollingDiceDivTwo().minimumFaces( vector <string>( rolls, rolls + ( sizeof rolls / sizeof(string) ) ) ) );
}
case 3: {
string rolls[] = {"931", "821", "156", "512", "129", "358", "555"};
int expected__ = 19;
return verify_case( casenum__, starttime__, expected__, RollingDiceDivTwo().minimumFaces( vector <string>( rolls, rolls + ( sizeof rolls / sizeof(string) ) ) ) );
}
case 4: {
string rolls[] = {"3", "7", "4", "2", "4"};
int expected__ = 7;
return verify_case( casenum__, starttime__, expected__, RollingDiceDivTwo().minimumFaces( vector <string>( rolls, rolls + ( sizeof rolls / sizeof(string) ) ) ) );
}
case 5: {
string rolls[] = {"281868247265686571829977999522", "611464285871136563343229916655", "716739845311113736768779647392", "779122814312329463718383927626", "571573431548647653632439431183", "547362375338962625957869719518", "539263489892486347713288936885", "417131347396232733384379841536"};
int expected__ = 176;
return verify_case( casenum__, starttime__, expected__, RollingDiceDivTwo().minimumFaces( vector <string>( rolls, rolls + ( sizeof rolls / sizeof(string) ) ) ) );
}
// custom cases
/*
case 6: {
string rolls[] = ;
int expected__ = ;
return verify_case( casenum__, starttime__, expected__, RollingDiceDivTwo().minimumFaces( vector <string>( rolls, rolls + ( sizeof rolls / sizeof(string) ) ) ) );
}
*/
/*
case 7: {
string rolls[] = ;
int expected__ = ;
return verify_case( casenum__, starttime__, expected__, RollingDiceDivTwo().minimumFaces( vector <string>( rolls, rolls + ( sizeof rolls / sizeof(string) ) ) ) );
}
*/
/*
case 8: {
string rolls[] = ;
int expected__ = ;
return verify_case( casenum__, starttime__, expected__, RollingDiceDivTwo().minimumFaces( vector <string>( rolls, rolls + ( sizeof rolls / sizeof(string) ) ) ) );
}
*/
default:
return -1;
}
}
int run_test_case(int casenum__) {
switch (casenum__) {
case 0: {
string places = "CVVVC";
int expected__ = 5;
clock_t start__ = clock();
int received__ = EllysTSP().getMax(places);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 1: {
string places = "VVV";
int expected__ = 1;
clock_t start__ = clock();
int received__ = EllysTSP().getMax(places);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 2: {
string places = "VVVVCVV";
int expected__ = 3;
clock_t start__ = clock();
int received__ = EllysTSP().getMax(places);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 3: {
string places = "CVCVCVC";
int expected__ = 7;
clock_t start__ = clock();
int received__ = EllysTSP().getMax(places);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
case 4: {
string places = "V";
int expected__ = 1;
clock_t start__ = clock();
int received__ = EllysTSP().getMax(places);
return verify_case(casenum__, expected__, received__, clock()-start__);
}
// custom cases
/* case 5: {
string places = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = EllysTSP().getMax(places);
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
/* case 6: {
string places = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = EllysTSP().getMax(places);
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
/* case 7: {
string places = ;
int expected__ = ;
clock_t start__ = clock();
int received__ = EllysTSP().getMax(places);
return verify_case(casenum__, expected__, received__, clock()-start__);
}*/
default:
return -1;
}
}
