├── 2014 ├── qualification_round │ ├── A │ │ ├── 1-kai-1 │ │ │ ├── main.cc │ │ │ └── out │ │ ├── 2-Gennady.Korotkevich │ │ │ ├── Gennady.Korotkevich_0_0.zip │ │ │ ├── in │ │ │ ├── new_sol.cc │ │ │ ├── orig_sol.cpp │ │ │ └── out │ │ ├── 3-Eryx │ │ │ ├── Eryx_0_0.zip │ │ │ ├── new_solution.cc │ │ │ └── orig_solution.cpp │ │ ├── 4-Marcin.Smulewicz │ │ │ ├── Marcin.Smulewicz_0_0.zip │ │ │ ├── new_A.cc │ │ │ └── orig_A.cpp │ │ ├── 5-SnapDragon │ │ │ ├── SnapDragon_0_0.zip │ │ │ ├── new_A.cc │ │ │ └── orig_A.cc │ │ ├── A-small-practice.in │ │ ├── input_sample │ │ ├── output_sample │ │ └── problem.org │ ├── B │ │ ├── 1-kai-1 │ │ │ ├── main.cc │ │ │ └── out │ │ ├── 2-Gennady.Korotkevich │ │ │ ├── Gennady.Korotkevich_1_1.zip │ │ │ ├── small │ │ │ │ ├── Gennady.Korotkevich_1_0.zip │ │ │ │ ├── new_sol.cc │ │ │ │ └── orig_sol.cpp │ │ │ └── sol.cpp │ │ ├── 3-surwdkgo │ │ │ ├── large │ │ │ │ ├── new_B.cc │ │ │ │ ├── orig_B.cpp │ │ │ │ └── surwdkgo_1_1.zip │ │ │ └── small │ │ │ │ ├── new_B.cc │ │ │ │ ├── orig_B.cpp │ │ │ │ ├── out │ │ │ │ └── surwdkgo_1_0.zip │ │ ├── 4-Eryx │ │ │ ├── large │ │ │ │ ├── Eryx_1_1.zip │ │ │ │ ├── new_solution.cc │ │ │ │ └── orig_solution.cpp │ │ │ └── small │ │ │ │ ├── Eryx_1_0.zip │ │ │ │ ├── new_solution.cc │ │ │ │ └── orig_solution.cpp │ │ ├── 5-Marcin.Smulewicz │ │ │ ├── large │ │ │ │ ├── Marcin.Smulewicz_1_1.zip │ │ │ │ ├── new_B.cc │ │ │ │ └── orig_B.cpp │ │ │ └── small │ │ │ │ ├── Marcin.Smulewicz_1_0.zip │ │ │ │ ├── new_B.cc │ │ │ │ └── orig_B.cpp │ │ ├── B-large-practice.in │ │ ├── B-small-practice.in │ │ ├── input_example │ │ ├── output_example │ │ └── problem.org │ ├── C │ │ ├── 0-kai-1 │ │ │ ├── main.cc │ │ │ └── out │ │ ├── 1-Gennady.Korotkevich │ │ │ ├── Gennady.Korotkevich_2_0.zip │ │ │ ├── new_sol.cc │ │ │ └── orig_sol.cpp │ │ ├── 2-surwdkgo │ │ │ ├── new_C.cc │ │ │ ├── orig_C.cpp │ │ │ └── surwdkgo_2_0.zip │ │ ├── 3-Eryx │ │ │ ├── Eryx_2_0.zip │ │ │ ├── new_solution.cc │ │ │ └── orig_solution.cpp │ │ ├── 5-Marcin.Smulewicz │ │ │ ├── C.cpp │ │ │ ├── Marcin.Smulewicz_2_0.zip │ │ │ ├── new_C.cc │ │ │ └── orig_C.cpp │ │ ├── 6-SnapDragon │ │ │ ├── SnapDragon_2_0.zip │ │ │ └── new_C.cc │ │ ├── C-large-practice.in │ │ ├── C-small-practice.in │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_example │ │ └── problem.org │ └── D │ │ ├── 0-kai-1 │ │ ├── out │ │ └── sol.cc │ │ ├── D-large-practice.in │ │ ├── D-small-practice.in │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_dbg │ │ ├── output_example │ │ └── problem.org ├── round-1a │ ├── A │ │ ├── 0-kai-1 │ │ │ ├── log │ │ │ ├── out │ │ │ ├── out_small │ │ │ └── sol.cc │ │ ├── 0-kai-large │ │ │ ├── out │ │ │ └── sol.cc │ │ ├── A-large-practice.in │ │ ├── A-small-practice.in │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_dbg │ │ ├── output_example │ │ └── problem.org │ ├── B │ │ ├── 0-kai-1 │ │ │ ├── out │ │ │ └── sol.cc │ │ ├── B-large-practice.in │ │ ├── B-small-practice.in │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_dbg │ │ ├── output_example │ │ └── problem.org │ └── C │ │ ├── 0-kai-1 │ │ ├── generate_permutation.cc │ │ ├── out │ │ └── sol.cc │ │ ├── C-small-practice.in │ │ ├── input_example │ │ ├── output_example │ │ └── problem.org └── round-1b │ ├── A │ ├── 0-kai-1 │ │ ├── log.txt │ │ └── sol.cc │ ├── input_dbg │ ├── input_example │ ├── output_dbg │ ├── output_example │ └── problem.org │ ├── B │ ├── 0-kai-1 │ │ ├── dbg.sh │ │ ├── log.txt │ │ ├── ooooooooooooooooooooo │ │ ├── run.sh │ │ └── sol.cc │ ├── 0-kai-large │ │ ├── dbg.sh │ │ ├── log.txt │ │ ├── ooooooooooooooooooooo │ │ ├── ooooooooooooooooooooo_1 │ │ ├── run.sh │ │ └── sol.cc │ ├── 1-ACMonster │ │ ├── ACMonster_1_1.zip │ │ ├── orig_sol.cc │ │ └── sol.cc │ ├── B-large-practice.in │ ├── B-small-practice.in │ ├── input_dbg │ ├── input_example │ ├── output_dbg │ ├── output_example │ └── problem.org │ └── C │ ├── 0-kai-1 │ ├── dbg.sh │ ├── log.txt │ ├── run.sh │ └── sol.cc │ ├── input_dbg │ ├── input_example │ ├── output_dbg │ ├── output_example │ └── problem.org ├── 2015 ├── qualification_round │ ├── A │ │ ├── 0-kai-1 │ │ │ ├── out │ │ │ └── sol.cc │ │ ├── A-large.in │ │ ├── A-small-attempt0.in │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_example │ │ └── problem.org │ ├── B │ │ ├── 0-kai-1 │ │ │ ├── out │ │ │ └── sol.cc │ │ ├── 0-kai-large │ │ │ ├── out │ │ │ └── sol.cc │ │ ├── B-large-practice.in │ │ ├── B-large.in │ │ ├── B-small-attempt0.in │ │ ├── B-small-attempt1.in │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_dbg │ │ ├── output_example │ │ └── problem.org │ ├── C │ │ ├── 0-kai-1 │ │ │ ├── out │ │ │ └── sol.cc │ │ ├── 0-kai-large │ │ │ ├── out │ │ │ └── sol.cc │ │ ├── C-small-attempt0.in │ │ ├── Untitled Document │ │ ├── Untitled Document~ │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_example │ │ └── problem.org │ └── D │ │ ├── 0-kai-1 │ │ ├── D-small-attempt1.in │ │ ├── new_out │ │ ├── old_out │ │ ├── out │ │ └── sol.cc │ │ ├── 0-kai-large │ │ ├── out │ │ └── sol.cc │ │ ├── D-large.in │ │ ├── D-small-attempt0.in │ │ ├── D-small-attempt1.in │ │ ├── D-small-attempt2.in │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_dbg │ │ ├── output_example │ │ └── problem.org ├── round_1a │ ├── A │ │ ├── 0-kai-1 │ │ │ ├── out │ │ │ ├── out_e │ │ │ ├── out_l │ │ │ └── sol.cc │ │ ├── A-large.in │ │ ├── A-small-attempt0.in │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_dbg │ │ ├── output_example │ │ └── problem.org │ ├── B │ │ ├── 0-kai-1 │ │ │ ├── log.txt │ │ │ ├── out │ │ │ └── sol.cc │ │ ├── 0-kai-large │ │ │ ├── log.txt │ │ │ ├── out │ │ │ └── sol.cc │ │ ├── B-large-practice.in │ │ ├── B-small-practice.in │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_dbg │ │ ├── output_example │ │ └── problem.org │ └── C │ │ ├── 0-kai-1 │ │ └── sol.cc │ │ ├── 0-kai-2 │ │ ├── out │ │ └── sol.cc │ │ ├── 1-Burrunduk1 │ │ ├── Burunduk1_2_0.zip │ │ ├── Burunduk1_2_1.zip │ │ ├── c.cpp │ │ ├── c.cpp.back │ │ └── out │ │ ├── C-large-practice.in │ │ ├── C-small-practice.in │ │ ├── input_dbg │ │ ├── input_example │ │ ├── output_dbg │ │ ├── output_example │ │ └── problem.org └── round_1b │ ├── A │ ├── 0-kai-1 │ │ ├── log.txt │ │ ├── out │ │ └── sol.cc │ ├── A-large.in │ ├── A-small-attempt0.in │ ├── input_dbg │ ├── input_example │ ├── output_dbg │ ├── output_example │ └── problem.org │ ├── B │ ├── 0-kai-1 │ │ ├── log.txt │ │ ├── out │ │ └── sol.cc │ ├── B-large-practice.in │ ├── B-small-attempt0.in │ ├── B-small-practice.in │ ├── input_dbg │ ├── input_example │ ├── output_dbg │ ├── output_example │ └── problem.org │ └── C │ ├── 0-kai-1 │ ├── dbg.sh │ ├── log.txt │ ├── oooooo │ ├── run.sh │ └── sol.cc │ ├── 1-vepifanov │ ├── dbg.sh │ ├── log.txt │ ├── orig_sol.cc │ ├── sol.cc │ └── vepifanov_2_0.zip │ ├── C-large-practice.in │ ├── C-small-practice-1.in │ ├── C-small-practice-2.in │ ├── input_dbg │ ├── input_example │ ├── output_dbg │ ├── output_example │ └── problem.org ├── 2016 └── round_1a │ ├── A │ ├── 0-kai-1 │ │ ├── A-large-practice.in │ │ ├── A-large.in │ │ ├── A-larget-practice.exp_output │ │ ├── A-larget.exp_output │ │ ├── A-small-attempt0.exp_output │ │ ├── A-small-attempt0.in │ │ ├── A-small-practice.in │ │ ├── A-small-pratice.exp_output │ │ ├── dbg.sh │ │ ├── ooooooooooooooooooooo │ │ ├── run.sh │ │ ├── sol.cc │ │ └── utils.h │ ├── input_dbg │ ├── input_example │ ├── output_dbg │ └── output_example │ ├── B │ ├── 0-kai-1 │ │ ├── B-large-practice.in │ │ ├── B-large-practice.in.exp_output │ │ ├── B-large.in │ │ ├── B-large.in.exp_output │ │ ├── B-small-attempt0.in │ │ ├── B-small-attempt0.in.exp_output │ │ ├── B-small-attempt1.in │ │ ├── B-small-attempt1.in.exp_output │ │ ├── B-small-practice.in │ │ ├── B-small-practice.in.exp_output │ │ ├── dbg.sh │ │ ├── log.txt │ │ ├── ooooooooooooooooooooo │ │ ├── out │ │ ├── run.sh │ │ ├── sol.cc │ │ └── utils.h │ ├── input_dbg │ ├── input_example │ ├── output_dbg │ └── output_example │ ├── C │ ├── 0-kai-1 │ │ ├── C-large-practice.in │ │ ├── C-large-practice.in.expected_output │ │ ├── C-small-practice.in │ │ ├── C-small-practice.in.expected_output │ │ ├── c.cpp │ │ ├── cebrusfs_2_1.zip │ │ ├── dbg.sh │ │ ├── ooooooooooooooooooooo │ │ ├── run.sh │ │ ├── sol.cc │ │ └── utils.h │ ├── input_dbg │ ├── input_example │ ├── output_dbg │ └── output_example │ └── D │ ├── 0-kai-1 │ ├── D-large-practice.in │ ├── D-large-practice.in.expected_output │ ├── D-small-practice.in │ ├── D-small-practice.in.expected_output │ ├── dbg.sh │ ├── run.sh │ ├── sol.cc │ └── utils.h │ ├── input_dbg │ ├── input_example │ ├── output_dbg │ └── output_example ├── .gitignore ├── README.md └── demo ├── 0-kai-1 ├── dbg.sh ├── dbg_sol.cc ├── log.txt ├── ooooooooooooooooooooo ├── run.sh ├── sol.cc └── utils.h ├── input_dbg ├── input_example ├── output_dbg └── output_example /.gitignore: -------------------------------------------------------------------------------- 1 | a.out 2 | ooooooooo* 3 | out 4 | -------------------------------------------------------------------------------- /2014/qualification_round/A/1-kai-1/main.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int useless; 6 | 7 | int first_row; 8 | int second_row; 9 | 10 | int first_row_arr[4]; 11 | int second_row_arr[4]; 12 | 13 | 14 | void input() 15 | { 16 | cin >> first_row; 17 | 18 | for (int row = 0; row < 4; ++row) { 19 | for (int line = 0; line < 4; ++line) { 20 | if (row + 1 == first_row) 21 | cin >> first_row_arr[line]; 22 | else 23 | cin >> useless; 24 | } 25 | } 26 | 27 | cin >> second_row; 28 | 29 | for (int row = 0; row < 4; ++row) { 30 | for (int line = 0; line < 4; ++line) { 31 | if (row + 1 == second_row) 32 | cin >> second_row_arr[line]; 33 | else 34 | cin >> useless; 35 | } 36 | } 37 | } 38 | 39 | 40 | int run() 41 | { 42 | int card_number = 0; 43 | 44 | for (int first_line = 0; first_line < 4; ++first_line) { 45 | for (int second_line = 0; second_line < 4; ++second_line) { 46 | if (first_row_arr[first_line] == second_row_arr[second_line]) { 47 | if (0 == card_number) 48 | card_number = first_row_arr[first_line]; 49 | else 50 | return -1; // Bad magician! 51 | } 52 | } 53 | } 54 | 55 | return card_number; 56 | } 57 | 58 | 59 | int main() 60 | { 61 | int T = 0; 62 | cin >> T; 63 | 64 | // cout << "T=" << T << endl; 65 | 66 | for (int i = 1; i <=T; ++i) { 67 | 68 | input(); 69 | 70 | const int ret = run(); 71 | 72 | cout << "Case #" << i << ": "; 73 | 74 | if (0 < ret) 75 | cout << ret; 76 | else if (-1 == ret) 77 | cout << "Bad magician!"; 78 | else if (0 == ret) 79 | cout << "Volunteer cheated!"; 80 | 81 | cout << endl; 82 | } 83 | 84 | return 0; 85 | } 86 | 87 | 88 | 89 | -------------------------------------------------------------------------------- /2014/qualification_round/A/1-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: Bad magician! 2 | Case #2: Bad magician! 3 | Case #3: Volunteer cheated! 4 | Case #4: Volunteer cheated! 5 | Case #5: 14 6 | Case #6: 10 7 | Case #7: 6 8 | Case #8: 6 9 | Case #9: 10 10 | Case #10: Bad magician! 11 | Case #11: Volunteer cheated! 12 | Case #12: Bad magician! 13 | Case #13: 10 14 | Case #14: Bad magician! 15 | Case #15: Bad magician! 16 | Case #16: Bad magician! 17 | Case #17: 10 18 | Case #18: 1 19 | Case #19: Volunteer cheated! 20 | Case #20: Bad magician! 21 | Case #21: Volunteer cheated! 22 | Case #22: Bad magician! 23 | Case #23: Bad magician! 24 | Case #24: 9 25 | Case #25: Bad magician! 26 | Case #26: Bad magician! 27 | Case #27: Bad magician! 28 | Case #28: 5 29 | Case #29: Volunteer cheated! 30 | Case #30: 11 31 | Case #31: 3 32 | Case #32: 1 33 | Case #33: Volunteer cheated! 34 | Case #34: Volunteer cheated! 35 | Case #35: Volunteer cheated! 36 | Case #36: 12 37 | Case #37: Volunteer cheated! 38 | Case #38: Volunteer cheated! 39 | Case #39: Volunteer cheated! 40 | Case #40: 11 41 | Case #41: 15 42 | Case #42: Volunteer cheated! 43 | Case #43: 10 44 | Case #44: 4 45 | Case #45: Volunteer cheated! 46 | Case #46: Volunteer cheated! 47 | Case #47: 15 48 | Case #48: 5 49 | Case #49: Volunteer cheated! 50 | Case #50: Bad magician! 51 | Case #51: Volunteer cheated! 52 | Case #52: 5 53 | Case #53: Volunteer cheated! 54 | Case #54: 16 55 | Case #55: Bad magician! 56 | Case #56: 9 57 | Case #57: Volunteer cheated! 58 | Case #58: Volunteer cheated! 59 | Case #59: 13 60 | Case #60: Bad magician! 61 | Case #61: Volunteer cheated! 62 | Case #62: 6 63 | Case #63: Volunteer cheated! 64 | Case #64: Volunteer cheated! 65 | Case #65: Bad magician! 66 | Case #66: Bad magician! 67 | Case #67: Bad magician! 68 | Case #68: 8 69 | Case #69: 16 70 | Case #70: Volunteer cheated! 71 | Case #71: Bad magician! 72 | Case #72: 7 73 | Case #73: 7 74 | Case #74: Bad magician! 75 | Case #75: 7 76 | Case #76: 7 77 | Case #77: Bad magician! 78 | Case #78: Bad magician! 79 | Case #79: Volunteer cheated! 80 | Case #80: Volunteer cheated! 81 | Case #81: 1 82 | Case #82: 16 83 | Case #83: Bad magician! 84 | Case #84: 6 85 | Case #85: Volunteer cheated! 86 | Case #86: Bad magician! 87 | Case #87: Bad magician! 88 | Case #88: 2 89 | Case #89: Volunteer cheated! 90 | Case #90: 5 91 | Case #91: 16 92 | Case #92: 3 93 | Case #93: Volunteer cheated! 94 | Case #94: Bad magician! 95 | Case #95: Volunteer cheated! 96 | Case #96: 12 97 | Case #97: 7 98 | Case #98: Bad magician! 99 | Case #99: Bad magician! 100 | Case #100: Volunteer cheated! 101 | -------------------------------------------------------------------------------- /2014/qualification_round/A/2-Gennady.Korotkevich/Gennady.Korotkevich_0_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2014/qualification_round/A/2-Gennady.Korotkevich/Gennady.Korotkevich_0_0.zip -------------------------------------------------------------------------------- /2014/qualification_round/A/2-Gennady.Korotkevich/new_sol.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | using namespace std; 21 | 22 | int main() { 23 | 24 | freopen("in", "r", stdin); 25 | freopen("out", "w", stdout); 26 | 27 | int tt; 28 | scanf("%d", &tt); 29 | 30 | for (int qq=1;qq<=tt;qq++) { 31 | printf("Case #%d: ", qq); 32 | 33 | bool can[42]; 34 | for (int i = 1; i <= 16; i++) can[i] = true; 35 | 36 | for (int q = 0; q < 2; q++) { 37 | int row; 38 | scanf("%d", &row); 39 | for (int i = 1; i <= 4; i++) 40 | for (int j = 1; j <= 4; j++) { 41 | int a; 42 | scanf("%d", &a); 43 | if (i != row) can[a] = false; 44 | } 45 | } 46 | 47 | int res = -1; 48 | for (int i = 1; i <= 16; i++) 49 | if (can[i]) { 50 | if (res != -1) { 51 | res = -2; 52 | break; 53 | } 54 | res = i; 55 | } 56 | if (res == -1) puts("Volunteer cheated!"); else 57 | if (res == -2) puts("Bad magician!"); 58 | else printf("%d\n", res); 59 | } 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /2014/qualification_round/A/2-Gennady.Korotkevich/orig_sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | using namespace std; 21 | 22 | int main() { 23 | freopen("in", "r", stdin); 24 | freopen("out", "w", stdout); 25 | int tt; 26 | scanf("%d", &tt); 27 | for (int qq=1;qq<=tt;qq++) { 28 | printf("Case #%d: ", qq); 29 | bool can[42]; 30 | for (int i = 1; i <= 16; i++) can[i] = true; 31 | for (int q = 0; q < 2; q++) { 32 | int row; 33 | scanf("%d", &row); 34 | for (int i = 1; i <= 4; i++) 35 | for (int j = 1; j <= 4; j++) { 36 | int a; 37 | scanf("%d", &a); 38 | if (i != row) can[a] = false; 39 | } 40 | } 41 | int res = -1; 42 | for (int i = 1; i <= 16; i++) 43 | if (can[i]) { 44 | if (res != -1) { 45 | res = -2; 46 | break; 47 | } 48 | res = i; 49 | } 50 | if (res == -1) puts("Volunteer cheated!"); else 51 | if (res == -2) puts("Bad magician!"); 52 | else printf("%d\n", res); 53 | } 54 | return 0; 55 | } 56 | -------------------------------------------------------------------------------- /2014/qualification_round/A/2-Gennady.Korotkevich/out: -------------------------------------------------------------------------------- 1 | Case #1: Bad magician! 2 | Case #2: Bad magician! 3 | Case #3: Volunteer cheated! 4 | Case #4: Volunteer cheated! 5 | Case #5: 14 6 | Case #6: 10 7 | Case #7: 6 8 | Case #8: 6 9 | Case #9: 10 10 | Case #10: Bad magician! 11 | Case #11: Volunteer cheated! 12 | Case #12: Bad magician! 13 | Case #13: 10 14 | Case #14: Bad magician! 15 | Case #15: Bad magician! 16 | Case #16: Bad magician! 17 | Case #17: 10 18 | Case #18: 1 19 | Case #19: Volunteer cheated! 20 | Case #20: Bad magician! 21 | Case #21: Volunteer cheated! 22 | Case #22: Bad magician! 23 | Case #23: Bad magician! 24 | Case #24: 9 25 | Case #25: Bad magician! 26 | Case #26: Bad magician! 27 | Case #27: Bad magician! 28 | Case #28: 5 29 | Case #29: Volunteer cheated! 30 | Case #30: 11 31 | Case #31: 3 32 | Case #32: 1 33 | Case #33: Volunteer cheated! 34 | Case #34: Volunteer cheated! 35 | Case #35: Volunteer cheated! 36 | Case #36: 12 37 | Case #37: Volunteer cheated! 38 | Case #38: Volunteer cheated! 39 | Case #39: Volunteer cheated! 40 | Case #40: 11 41 | Case #41: 15 42 | Case #42: Volunteer cheated! 43 | Case #43: 10 44 | Case #44: 4 45 | Case #45: Volunteer cheated! 46 | Case #46: Volunteer cheated! 47 | Case #47: 15 48 | Case #48: 5 49 | Case #49: Volunteer cheated! 50 | Case #50: Bad magician! 51 | Case #51: Volunteer cheated! 52 | Case #52: 5 53 | Case #53: Volunteer cheated! 54 | Case #54: 16 55 | Case #55: Bad magician! 56 | Case #56: 9 57 | Case #57: Volunteer cheated! 58 | Case #58: Volunteer cheated! 59 | Case #59: 13 60 | Case #60: Bad magician! 61 | Case #61: Volunteer cheated! 62 | Case #62: 6 63 | Case #63: Volunteer cheated! 64 | Case #64: Volunteer cheated! 65 | Case #65: Bad magician! 66 | Case #66: Bad magician! 67 | Case #67: Bad magician! 68 | Case #68: 8 69 | Case #69: 16 70 | Case #70: Volunteer cheated! 71 | Case #71: Bad magician! 72 | Case #72: 7 73 | Case #73: 7 74 | Case #74: Bad magician! 75 | Case #75: 7 76 | Case #76: 7 77 | Case #77: Bad magician! 78 | Case #78: Bad magician! 79 | Case #79: Volunteer cheated! 80 | Case #80: Volunteer cheated! 81 | Case #81: 1 82 | Case #82: 16 83 | Case #83: Bad magician! 84 | Case #84: 6 85 | Case #85: Volunteer cheated! 86 | Case #86: Bad magician! 87 | Case #87: Bad magician! 88 | Case #88: 2 89 | Case #89: Volunteer cheated! 90 | Case #90: 5 91 | Case #91: 16 92 | Case #92: 3 93 | Case #93: Volunteer cheated! 94 | Case #94: Bad magician! 95 | Case #95: Volunteer cheated! 96 | Case #96: 12 97 | Case #97: 7 98 | Case #98: Bad magician! 99 | Case #99: Bad magician! 100 | Case #100: Volunteer cheated! 101 | -------------------------------------------------------------------------------- /2014/qualification_round/A/3-Eryx/Eryx_0_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2014/qualification_round/A/3-Eryx/Eryx_0_0.zip -------------------------------------------------------------------------------- /2014/qualification_round/A/4-Marcin.Smulewicz/Marcin.Smulewicz_0_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2014/qualification_round/A/4-Marcin.Smulewicz/Marcin.Smulewicz_0_0.zip -------------------------------------------------------------------------------- /2014/qualification_round/A/4-Marcin.Smulewicz/new_A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | typedef pair PI; 11 | typedef long long LL; 12 | typedef double D; 13 | #define FI first 14 | #define SE second 15 | #define MP make_pair 16 | #define PB push_back 17 | #define R(I,N) for(int I=0;I=0;I--) 20 | #define make(A) scanf("%d",&A) 21 | #define MAX 17 22 | int cz[MAX]; 23 | void test(){ 24 | R(i,MAX)cz[i] = 0; 25 | R(_,2){ 26 | int pom;make(pom);pom--; 27 | R(i,4)R(j,4){ 28 | int pom2;make(pom2); 29 | if(i==pom)cz[pom2]++; 30 | } 31 | } 32 | int il=0,kt; 33 | R(i,MAX){ 34 | if(cz[i]==2){ 35 | il++; 36 | kt=i; 37 | } 38 | } 39 | static int nr = 0;nr++; 40 | printf("Case #%d: ",nr); 41 | if(il == 0)printf("Volunteer cheated!\n"); 42 | if(il == 1)printf("%d\n",kt); 43 | if(il > 1)printf("Bad magician!\n"); 44 | } 45 | main(){ 46 | int t;make(t);while(t--)test(); 47 | } 48 | -------------------------------------------------------------------------------- /2014/qualification_round/A/4-Marcin.Smulewicz/orig_A.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | typedef pair PI; 11 | typedef long long LL; 12 | typedef double D; 13 | #define FI first 14 | #define SE second 15 | #define MP make_pair 16 | #define PB push_back 17 | #define R(I,N) for(int I=0;I=0;I--) 20 | #define make(A) scanf("%d",&A) 21 | #define MAX 17 22 | int cz[MAX]; 23 | void test(){ 24 | R(i,MAX)cz[i] = 0; 25 | R(_,2){ 26 | int pom;make(pom);pom--; 27 | R(i,4)R(j,4){ 28 | int pom2;make(pom2); 29 | if(i==pom)cz[pom2]++; 30 | } 31 | } 32 | int il=0,kt; 33 | R(i,MAX){ 34 | if(cz[i]==2){ 35 | il++; 36 | kt=i; 37 | } 38 | } 39 | static int nr = 0;nr++; 40 | printf("Case #%d: ",nr); 41 | if(il == 0)printf("Volunteer cheated!\n"); 42 | if(il == 1)printf("%d\n",kt); 43 | if(il > 1)printf("Bad magician!\n"); 44 | } 45 | main(){ 46 | int t;make(t);while(t--)test(); 47 | } 48 | -------------------------------------------------------------------------------- /2014/qualification_round/A/5-SnapDragon/SnapDragon_0_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2014/qualification_round/A/5-SnapDragon/SnapDragon_0_0.zip -------------------------------------------------------------------------------- /2014/qualification_round/A/5-SnapDragon/new_A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int g1[4][4], g2[4][4]; 5 | 6 | main() { 7 | int T, prob=1; 8 | for (cin >> T; T--;) { 9 | int ret = -1; 10 | int r1, r2; 11 | 12 | cin >> r1; 13 | for (int y = 0; y < 4; y++) 14 | for (int x = 0; x < 4; x++) { 15 | cin >> g1[y][x]; 16 | } 17 | cin >> r2; 18 | for (int y = 0; y < 4; y++) 19 | for (int x = 0; x < 4; x++) { 20 | cin >> g2[y][x]; 21 | } 22 | 23 | for (int v = 1; v <= 16; v++) { 24 | int x; 25 | for (x = 0; x < 4; x++) if (g1[r1-1][x] == v) break; 26 | if (x == 4) continue; 27 | for (x = 0; x < 4; x++) if (g2[r2-1][x] == v) break; 28 | if (x == 4) continue; 29 | if (ret != -1) ret = -2; else ret = v; 30 | } 31 | 32 | cout << "Case #" << prob++ << ": "; 33 | if (ret == -1) { 34 | cout << "Volunteer cheated!" << endl; 35 | } else if (ret == -2) { 36 | cout << "Bad magician!" << endl; 37 | } else { 38 | cout << ret << endl; 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /2014/qualification_round/A/5-SnapDragon/orig_A.cc: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int g1[4][4], g2[4][4]; 5 | 6 | main() { 7 | int T, prob=1; 8 | for (cin >> T; T--;) { 9 | int ret = -1; 10 | int r1, r2; 11 | cin >> r1; 12 | for (int y = 0; y < 4; y++) 13 | for (int x = 0; x < 4; x++) { 14 | cin >> g1[y][x]; 15 | } 16 | cin >> r2; 17 | for (int y = 0; y < 4; y++) 18 | for (int x = 0; x < 4; x++) { 19 | cin >> g2[y][x]; 20 | } 21 | for (int v = 1; v <= 16; v++) { 22 | int x; 23 | for (x = 0; x < 4; x++) if (g1[r1-1][x] == v) break; 24 | if (x == 4) continue; 25 | for (x = 0; x < 4; x++) if (g2[r2-1][x] == v) break; 26 | if (x == 4) continue; 27 | if (ret != -1) ret = -2; else ret = v; 28 | } 29 | 30 | cout << "Case #" << prob++ << ": "; 31 | if (ret == -1) { 32 | cout << "Volunteer cheated!" << endl; 33 | } else if (ret == -2) { 34 | cout << "Bad magician!" << endl; 35 | } else { 36 | cout << ret << endl; 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /2014/qualification_round/A/input_sample: -------------------------------------------------------------------------------- 1 | 3 2 | 2 3 | 1 2 3 4 4 | 5 6 7 8 5 | 9 10 11 12 6 | 13 14 15 16 7 | 3 8 | 1 2 5 4 9 | 3 11 6 15 10 | 9 10 7 12 11 | 13 14 8 16 12 | 2 13 | 1 2 3 4 14 | 5 6 7 8 15 | 9 10 11 12 16 | 13 14 15 16 17 | 2 18 | 1 2 3 4 19 | 5 6 7 8 20 | 9 10 11 12 21 | 13 14 15 16 22 | 2 23 | 1 2 3 4 24 | 5 6 7 8 25 | 9 10 11 12 26 | 13 14 15 16 27 | 3 28 | 1 2 3 4 29 | 5 6 7 8 30 | 9 10 11 12 31 | 13 14 15 16 -------------------------------------------------------------------------------- /2014/qualification_round/A/output_sample: -------------------------------------------------------------------------------- 1 | Case #1: 7 2 | Case #2: Bad magician! 3 | Case #3: Volunteer cheated! 4 | -------------------------------------------------------------------------------- /2014/qualification_round/B/1-kai-1/main.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | double c_g, f_g, x_g; 8 | 9 | double run_impl() 10 | { 11 | double cnt_speed = 2; 12 | double total_acc_time = 0; 13 | double last_total_time = x_g / 2; 14 | 15 | // Return last_total_time if the total time only but a cookie farm 16 | // is larger than last_total_time 17 | total_acc_time += c_g / cnt_speed; 18 | cnt_speed += f_g; 19 | double cnt_total_time = x_g/cnt_speed + total_acc_time; 20 | 21 | while (last_total_time > cnt_total_time) { 22 | // Go on search if cnt_toal_time is better 23 | 24 | last_total_time = cnt_total_time; 25 | 26 | total_acc_time += c_g / cnt_speed; 27 | cnt_speed += f_g; 28 | 29 | cnt_total_time = x_g / cnt_speed + total_acc_time; 30 | } 31 | 32 | return last_total_time; 33 | } 34 | 35 | 36 | double run() 37 | { 38 | cin >> c_g >> f_g >> x_g; 39 | 40 | return run_impl(); 41 | } 42 | 43 | 44 | int main() 45 | { 46 | int total_test_cases = 0; 47 | 48 | cin >> total_test_cases; 49 | cout << fixed; 50 | 51 | for (int tt = 1; tt <= total_test_cases; ++tt) { 52 | 53 | const double ret = run(); 54 | 55 | cout << "Case #" << tt << ": " << setprecision(7) << ret << endl; 56 | } 57 | 58 | return 0; 59 | } 60 | 61 | -------------------------------------------------------------------------------- /2014/qualification_round/B/1-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: 23081.6737783 2 | Case #2: 193.6185209 3 | Case #3: 23080.9566172 4 | Case #4: 4282.0841584 5 | Case #5: 5733.7607542 6 | Case #6: 0.6518189 7 | Case #7: 425.3496150 8 | Case #8: 5663.4285714 9 | Case #9: 23096.8007281 10 | Case #10: 24585.7358899 11 | Case #11: 357.7563333 12 | Case #12: 6.3482975 13 | Case #13: 114.6104243 14 | Case #14: 3418.8701382 15 | Case #15: 28051.6896579 16 | Case #16: 3826.7059226 17 | Case #17: 332.5146373 18 | Case #18: 1.7757080 19 | Case #19: 278.5000000 20 | Case #20: 366.9500000 21 | Case #21: 25889.4588263 22 | Case #22: 23124.6825067 23 | Case #23: 26588.6235695 24 | Case #24: 3302.2894737 25 | Case #25: 3964.6341714 26 | Case #26: 31.2327150 27 | Case #27: 209.1614036 28 | Case #28: 24095.8726045 29 | Case #29: 23553.2618436 30 | Case #30: 0.6349369 31 | Case #31: 23916.4630595 32 | Case #32: 25801.7962655 33 | Case #33: 8189.0000000 34 | Case #34: 8685.0000000 35 | Case #35: 24022.1376275 36 | Case #36: 5135.7812500 37 | Case #37: 26021.5968580 38 | Case #38: 410.8830000 39 | Case #39: 215.5375400 40 | Case #40: 0.6722084 41 | Case #41: 85.6810200 42 | Case #42: 6708.8189459 43 | Case #43: 290.3261328 44 | Case #44: 1064.4840030 45 | Case #45: 22766.7053629 46 | Case #46: 531.3320000 47 | Case #47: 197.4133250 48 | Case #48: 171.2146500 49 | Case #49: 963.6518395 50 | Case #50: 373.0800000 51 | Case #51: 23588.1566158 52 | Case #52: 27404.7372194 53 | Case #53: 271.1557774 54 | Case #54: 346.2738492 55 | Case #55: 88.7383245 56 | Case #56: 504.4451200 57 | Case #57: 24568.0101985 58 | Case #58: 27823.6426306 59 | Case #59: 7151.0000000 60 | Case #60: 25170.1262075 61 | Case #61: 69.0700000 62 | Case #62: 22698.8491985 63 | Case #63: 0.6413761 64 | Case #64: 24063.2131025 65 | Case #65: 25072.9833536 66 | Case #66: 124.3479400 67 | Case #67: 23525.9193658 68 | Case #68: 5055.0497993 69 | Case #69: 33.8435400 70 | Case #70: 25319.7188241 71 | Case #71: 370.5341955 72 | Case #72: 204.3922350 73 | Case #73: 27396.2110535 74 | Case #74: 22903.5970884 75 | Case #75: 328.4818900 76 | Case #76: 23459.4864406 77 | Case #77: 62.0000000 78 | Case #78: 10266.6575057 79 | Case #79: 23746.1751395 80 | Case #80: 551.8121138 81 | Case #81: 4543.0000000 82 | Case #82: 22968.1834988 83 | Case #83: 84.0946750 84 | Case #84: 184.0000000 85 | Case #85: 25650.4586489 86 | Case #86: 25196.2562818 87 | Case #87: 167.0216950 88 | Case #88: 187.6794500 89 | Case #89: 113.6119813 90 | Case #90: 41.8667091 91 | Case #91: 4793.0000000 92 | Case #92: 110.0713463 93 | Case #93: 69.5849800 94 | Case #94: 321.4459522 95 | Case #95: 368.2697854 96 | Case #96: 3911.4419006 97 | Case #97: 26168.3764614 98 | Case #98: 26877.6187693 99 | Case #99: 299.9626210 100 | Case #100: 22607.7680715 101 | -------------------------------------------------------------------------------- /2014/qualification_round/B/2-Gennady.Korotkevich/Gennady.Korotkevich_1_1.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2014/qualification_round/B/2-Gennady.Korotkevich/Gennady.Korotkevich_1_1.zip -------------------------------------------------------------------------------- /2014/qualification_round/B/2-Gennady.Korotkevich/small/Gennady.Korotkevich_1_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2014/qualification_round/B/2-Gennady.Korotkevich/small/Gennady.Korotkevich_1_0.zip -------------------------------------------------------------------------------- /2014/qualification_round/B/2-Gennady.Korotkevich/small/new_sol.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | using namespace std; 21 | 22 | int main() { 23 | 24 | freopen("in", "r", stdin); 25 | freopen("out", "w", stdout); 26 | 27 | int tt; 28 | scanf("%d", &tt); 29 | 30 | for (int qq=1;qq<=tt;qq++) { 31 | printf("Case #%d: ", qq); 32 | double c, f, x; 33 | cin >> c >> f >> x; 34 | 35 | double spent = 0, ans = 1e30; 36 | int km = -1; 37 | double rate = 2.0; 38 | for (int farms = 0; farms <= 1000000; farms++) { 39 | double current = spent + x / rate; 40 | if (current < ans) { 41 | ans = current; 42 | km = farms; 43 | } 44 | spent += c / rate; 45 | rate += f; 46 | } 47 | printf("%.7lf\n", ans); 48 | cerr << "at " << km << endl; 49 | } 50 | return 0; 51 | } 52 | -------------------------------------------------------------------------------- /2014/qualification_round/B/2-Gennady.Korotkevich/small/orig_sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | using namespace std; 21 | 22 | int main() { 23 | freopen("in", "r", stdin); 24 | freopen("out", "w", stdout); 25 | int tt; 26 | scanf("%d", &tt); 27 | for (int qq=1;qq<=tt;qq++) { 28 | printf("Case #%d: ", qq); 29 | double c, f, x; 30 | cin >> c >> f >> x; 31 | double spent = 0, ans = 1e30; 32 | int km = -1; 33 | double rate = 2.0; 34 | for (int farms = 0; farms <= 1000000; farms++) { 35 | double current = spent + x / rate; 36 | if (current < ans) { 37 | ans = current; 38 | km = farms; 39 | } 40 | spent += c / rate; 41 | rate += f; 42 | } 43 | printf("%.7lf\n", ans); 44 | cerr << "at " << km << endl; 45 | } 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /2014/qualification_round/B/2-Gennady.Korotkevich/sol.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | using namespace std; 21 | 22 | int main() { 23 | freopen("in", "r", stdin); 24 | freopen("out", "w", stdout); 25 | int tt; 26 | scanf("%d", &tt); 27 | for (int qq=1;qq<=tt;qq++) { 28 | printf("Case #%d: ", qq); 29 | double c, f, x; 30 | cin >> c >> f >> x; 31 | double spent = 0, ans = 1e30; 32 | int km = -1; 33 | double rate = 2.0; 34 | for (int farms = 0; farms <= 1000000; farms++) { 35 | double current = spent + x / rate; 36 | if (current < ans) { 37 | ans = current; 38 | km = farms; 39 | } 40 | spent += c / rate; 41 | rate += f; 42 | } 43 | printf("%.7lf\n", ans); 44 | if (km > 1000) { 45 | cerr << "at " << km << endl; 46 | } 47 | } 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /2014/qualification_round/B/3-surwdkgo/large/new_B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | int main() { 3 | int cas; 4 | scanf("%d", &cas); 5 | for (int ii=0; ii 2 | int main() { 3 | int cas; 4 | scanf("%d", &cas); 5 | for (int ii=0; ii 2 | int main() { 3 | int cas; 4 | scanf("%d", &cas); 5 | for (int ii=0; ii 2 | int main() { 3 | int cas; 4 | scanf("%d", &cas); 5 | for (int ii=0; ii 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | typedef pair PI; 11 | typedef long long LL; 12 | typedef double D; 13 | #define FI first 14 | #define SE second 15 | #define MP make_pair 16 | #define PB push_back 17 | #define R(I,N) for(int I=0;I=0;I--) 20 | #define make(A) scanf("%d",&A) 21 | D c,f,x,wyn; 22 | void test(){ 23 | scanf("%lf%lf%lf",&c,&f,&x); 24 | wyn = x/2; 25 | D czas = 0; 26 | int i; 27 | for(i=0;1;i++){ 28 | czas += c/(2+i*f); 29 | D pom = czas + x/(2+(i+1)*f); 30 | if(pom < wyn){ 31 | wyn = pom; 32 | }else 33 | break; 34 | } 35 | static int nr = 0;nr++; 36 | printf("Case #%d: %.8f\n",nr,wyn); 37 | //printf("%lf %lf %lf %d\n",c,f,x,i); 38 | } 39 | main(){ 40 | int t;make(t);while(t--)test(); 41 | } 42 | -------------------------------------------------------------------------------- /2014/qualification_round/B/5-Marcin.Smulewicz/large/orig_B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | typedef pair PI; 11 | typedef long long LL; 12 | typedef double D; 13 | #define FI first 14 | #define SE second 15 | #define MP make_pair 16 | #define PB push_back 17 | #define R(I,N) for(int I=0;I=0;I--) 20 | #define make(A) scanf("%d",&A) 21 | D c,f,x,wyn; 22 | void test(){ 23 | scanf("%lf%lf%lf",&c,&f,&x); 24 | wyn = x/2; 25 | D czas = 0; 26 | int i; 27 | for(i=0;1;i++){ 28 | czas += c/(2+i*f); 29 | D pom = czas + x/(2+(i+1)*f); 30 | if(pom < wyn){ 31 | wyn = pom; 32 | }else 33 | break; 34 | } 35 | static int nr = 0;nr++; 36 | printf("Case #%d: %.8f\n",nr,wyn); 37 | //printf("%lf %lf %lf %d\n",c,f,x,i); 38 | } 39 | main(){ 40 | int t;make(t);while(t--)test(); 41 | } 42 | -------------------------------------------------------------------------------- /2014/qualification_round/B/5-Marcin.Smulewicz/small/Marcin.Smulewicz_1_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2014/qualification_round/B/5-Marcin.Smulewicz/small/Marcin.Smulewicz_1_0.zip -------------------------------------------------------------------------------- /2014/qualification_round/B/5-Marcin.Smulewicz/small/new_B.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | typedef pair PI; 11 | typedef long long LL; 12 | typedef double D; 13 | #define FI first 14 | #define SE second 15 | #define MP make_pair 16 | #define PB push_back 17 | #define R(I,N) for(int I=0;I=0;I--) 20 | #define make(A) scanf("%d",&A) 21 | D c,f,x,wyn; 22 | void test(){ 23 | scanf("%lf%lf%lf",&c,&f,&x); 24 | wyn = x/2; 25 | D czas = 0; 26 | for(int i=0;1;i++){ 27 | czas += c/(2+i*f); 28 | D pom = czas + x/(2+(i+1)*f); 29 | if(pom < wyn){ 30 | wyn = pom; 31 | }else 32 | break; 33 | } 34 | static int nr = 0;nr++; 35 | printf("Case #%d: %.8f\n",nr,wyn); 36 | } 37 | main(){ 38 | int t;make(t);while(t--)test(); 39 | } 40 | -------------------------------------------------------------------------------- /2014/qualification_round/B/5-Marcin.Smulewicz/small/orig_B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | typedef pair PI; 11 | typedef long long LL; 12 | typedef double D; 13 | #define FI first 14 | #define SE second 15 | #define MP make_pair 16 | #define PB push_back 17 | #define R(I,N) for(int I=0;I=0;I--) 20 | #define make(A) scanf("%d",&A) 21 | D c,f,x,wyn; 22 | void test(){ 23 | scanf("%lf%lf%lf",&c,&f,&x); 24 | wyn = x/2; 25 | D czas = 0; 26 | for(int i=0;1;i++){ 27 | czas += c/(2+i*f); 28 | D pom = czas + x/(2+(i+1)*f); 29 | if(pom < wyn){ 30 | wyn = pom; 31 | }else 32 | break; 33 | } 34 | static int nr = 0;nr++; 35 | printf("Case #%d: %.8f\n",nr,wyn); 36 | } 37 | main(){ 38 | int t;make(t);while(t--)test(); 39 | } 40 | -------------------------------------------------------------------------------- /2014/qualification_round/B/input_example: -------------------------------------------------------------------------------- 1 | 4 2 | 30.0 1.0 2.0 3 | 30.0 2.0 100.0 4 | 30.50000 3.14159 1999.19990 5 | 500.0 4.0 2000.0 -------------------------------------------------------------------------------- /2014/qualification_round/B/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 1.0000000 2 | Case #2: 39.1666667 3 | Case #3: 63.9680013 4 | Case #4: 526.1904762 5 | -------------------------------------------------------------------------------- /2014/qualification_round/C/1-Gennady.Korotkevich/Gennady.Korotkevich_2_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2014/qualification_round/C/1-Gennady.Korotkevich/Gennady.Korotkevich_2_0.zip -------------------------------------------------------------------------------- /2014/qualification_round/C/2-surwdkgo/orig_C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | char ans[55][55]; 5 | int main() { 6 | int cas, r, c, m, pos, v; 7 | scanf("%d", &cas); 8 | for (int ii=0; ii 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | typedef pair PI; 11 | typedef long long LL; 12 | typedef double D; 13 | #define FI first 14 | #define SE second 15 | #define MP make_pair 16 | #define PB push_back 17 | #define R(I,N) for(int I=0;I=0;I--) 20 | #define make(A) scanf("%d",&A) 21 | #define MAX 52 22 | int r,c,m; 23 | char z[MAX]; 24 | void test(){ 25 | static int nr = 0;nr++; 26 | printf("Case #%d:\n",nr); 27 | make(r);make(c);make(m); 28 | z[c] = 0; 29 | if(r == 1){ 30 | R(i,c)z[i] = '.'; 31 | R(i,m)z[i] = '*'; 32 | z[c-1] = 'c'; 33 | printf("%s\n",z); 34 | return; 35 | } 36 | if(c == 1){ 37 | R(i,r)z[i] = '.'; 38 | R(i,m)z[i] = '*'; 39 | z[r-1] = 'c'; 40 | R(i,r)printf("%c\n",z[i]); 41 | puts(""); 42 | return; 43 | } 44 | m = r*c - m; 45 | if(m == 1){ 46 | R(i,c)z[i] = '*'; 47 | R(i,r-1)printf("%s\n",z); 48 | z[0] = 'c'; 49 | printf("%s\n",z); 50 | return; 51 | } 52 | F(i,1,c)F(j,1,r){ 53 | if(m >= 2*(i+j) && m <= (i+1)*(j+1)){ 54 | R(k,c)z[k] = (k<=i?'.':'*'); 55 | z[0]='c'; 56 | printf("%s\n",z); 57 | z[0]='.'; 58 | printf("%s\n",z); 59 | m -= 2*(i+j); 60 | F(k,2,j+1){ 61 | F(l,2,i+1){ 62 | if(m){ 63 | z[l] = '.'; 64 | m--; 65 | }else 66 | z[l] = '*'; 67 | } 68 | printf("%s\n",z); 69 | } 70 | R(k,c)z[k] = '*'; 71 | R(_,r-j-1)printf("%s\n",z); 72 | return; 73 | } 74 | } 75 | printf("Impossible\n"); 76 | } 77 | main(){ 78 | int t;make(t);while(t--)test(); 79 | } 80 | -------------------------------------------------------------------------------- /2014/qualification_round/C/5-Marcin.Smulewicz/Marcin.Smulewicz_2_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2014/qualification_round/C/5-Marcin.Smulewicz/Marcin.Smulewicz_2_0.zip -------------------------------------------------------------------------------- /2014/qualification_round/C/5-Marcin.Smulewicz/orig_C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | typedef pair PI; 11 | typedef long long LL; 12 | typedef double D; 13 | #define FI first 14 | #define SE second 15 | #define MP make_pair 16 | #define PB push_back 17 | #define R(I,N) for(int I=0;I=0;I--) 20 | #define make(A) scanf("%d",&A) 21 | #define MAX 52 22 | int r,c,m; 23 | char z[MAX]; 24 | void test(){ 25 | static int nr = 0;nr++; 26 | printf("Case #%d:\n",nr); 27 | make(r);make(c);make(m); 28 | z[c] = 0; 29 | if(r == 1){ 30 | R(i,c)z[i] = '.'; 31 | R(i,m)z[i] = '*'; 32 | z[c-1] = 'c'; 33 | printf("%s\n",z); 34 | return; 35 | } 36 | if(c == 1){ 37 | R(i,r)z[i] = '.'; 38 | R(i,m)z[i] = '*'; 39 | z[r-1] = 'c'; 40 | R(i,r)printf("%c\n",z[i]); 41 | puts(""); 42 | return; 43 | } 44 | m = r*c - m; 45 | if(m == 1){ 46 | R(i,c)z[i] = '*'; 47 | R(i,r-1)printf("%s\n",z); 48 | z[0] = 'c'; 49 | printf("%s\n",z); 50 | return; 51 | } 52 | F(i,1,c)F(j,1,r){ 53 | if(m >= 2*(i+j) && m <= (i+1)*(j+1)){ 54 | R(k,c)z[k] = (k<=i?'.':'*'); 55 | z[0]='c'; 56 | printf("%s\n",z); 57 | z[0]='.'; 58 | printf("%s\n",z); 59 | m -= 2*(i+j); 60 | F(k,2,j+1){ 61 | F(l,2,i+1){ 62 | if(m){ 63 | z[l] = '.'; 64 | m--; 65 | }else 66 | z[l] = '*'; 67 | } 68 | printf("%s\n",z); 69 | } 70 | R(k,c)z[k] = '*'; 71 | R(_,r-j-1)printf("%s\n",z); 72 | return; 73 | } 74 | } 75 | printf("Impossible\n"); 76 | } 77 | main(){ 78 | int t;make(t);while(t--)test(); 79 | } 80 | -------------------------------------------------------------------------------- /2014/qualification_round/C/6-SnapDragon/SnapDragon_2_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2014/qualification_round/C/6-SnapDragon/SnapDragon_2_0.zip -------------------------------------------------------------------------------- /2014/qualification_round/C/6-SnapDragon/new_C.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int R, C, M, F; 7 | char g[100][100]; 8 | 9 | int memo[61][61][3001]; 10 | 11 | bool doit(int y, int r, int cur) 12 | { 13 | int& ret = memo[y][r][cur]; 14 | 15 | if (ret != -1) 16 | return ret; 17 | int x; 18 | if (y == 0) 19 | { 20 | for (x = 0; r && x < C && x < r+1; x++) 21 | { 22 | g[y][x] = '.'; 23 | cur++; 24 | } 25 | for (; x < C; x++) 26 | g[y][x] = '*'; 27 | } 28 | 29 | if (y+1 == R) 30 | return ret = (cur == F); 31 | 32 | for (x = 0; r && x < C && x < r+1; x++) 33 | { 34 | g[y+1][x] = '.'; 35 | cur++; 36 | } 37 | 38 | for (; x < C; x++) 39 | g[y+1][x] = '*'; 40 | 41 | if (cur > F) 42 | return ret = false; 43 | 44 | for (int r2 = 0; r2 <= r; r2++) 45 | if (doit(y+1, r2, cur)) 46 | return ret = true; 47 | 48 | return ret = false; 49 | } 50 | 51 | main() 52 | { 53 | int T, prob=1; 54 | for (cin >> T; T--;) 55 | { 56 | cin >> R >> C >> M; 57 | 58 | F = R*C-M; 59 | 60 | int r; 61 | 62 | cout << "Case #" << prob++ << ":" << endl; 63 | 64 | memset(memo, -1, sizeof(memo)); 65 | 66 | for (r = 1; r <= C; r++) { 67 | if (doit(0, r, 0)) 68 | break; 69 | } 70 | 71 | if (F == 1) 72 | { 73 | memset(g, '*', sizeof(g)); 74 | g[0][0] = 'c'; 75 | for (int y = 0; y < R; y++) 76 | { 77 | for (int x = 0; x < C; x++) 78 | cout << g[y][x]; 79 | cout << endl; 80 | } 81 | } 82 | else if (r > C) 83 | { 84 | cout << "Impossible" << endl; 85 | } 86 | else 87 | { 88 | g[0][0] = 'c'; 89 | for (int y = 0; y < R; y++) 90 | { 91 | for (int x = 0; x < C; x++) 92 | cout << g[y][x]; 93 | cout << endl; 94 | } 95 | } 96 | } 97 | } 98 | 99 | -------------------------------------------------------------------------------- /2014/qualification_round/C/C-large-practice.in: -------------------------------------------------------------------------------- 1 | 134 2 | 50 1 0 3 | 50 3 49 4 | 4 4 0 5 | 50 3 47 6 | 3 50 42 7 | 3 3 5 8 | 4 4 2 9 | 50 50 2450 10 | 50 1 3 11 | 50 3 4 12 | 4 4 3 13 | 50 50 2492 14 | 3 50 4 15 | 50 50 251 16 | 2 50 44 17 | 2 2 1 18 | 50 50 2490 19 | 50 50 250 20 | 50 2 49 21 | 50 2 0 22 | 4 4 12 23 | 3 3 2 24 | 50 50 3 25 | 4 7 3 26 | 4 4 15 27 | 2 50 4 28 | 3 50 44 29 | 50 50 2399 30 | 50 3 1 31 | 3 3 8 32 | 50 2 2 33 | 50 50 2497 34 | 50 2 3 35 | 1 50 2 36 | 50 50 248 37 | 4 4 5 38 | 3 50 48 39 | 50 50 0 40 | 50 50 2498 41 | 3 50 45 42 | 50 3 43 43 | 50 2 42 44 | 50 50 2495 45 | 50 3 5 46 | 3 3 4 47 | 4 4 7 48 | 3 50 49 49 | 50 50 2 50 | 3 3 6 51 | 2 50 48 52 | 3 3 7 53 | 10 10 82 54 | 50 2 4 55 | 50 3 0 56 | 50 3 3 57 | 4 4 13 58 | 50 50 2491 59 | 50 1 2 60 | 50 2 1 61 | 2 50 45 62 | 50 3 42 63 | 50 2 48 64 | 50 2 5 65 | 50 2 43 66 | 4 4 6 67 | 3 50 2 68 | 50 1 47 69 | 50 50 2451 70 | 3 50 5 71 | 2 50 47 72 | 2 50 42 73 | 3 50 47 74 | 50 50 2400 75 | 2 50 49 76 | 2 50 46 77 | 3 3 1 78 | 50 50 2499 79 | 50 2 47 80 | 50 1 49 81 | 1 50 47 82 | 50 50 2493 83 | 50 50 2398 84 | 4 4 4 85 | 4 4 8 86 | 3 50 1 87 | 50 50 2452 88 | 1 50 49 89 | 4 4 1 90 | 1 50 0 91 | 2 50 0 92 | 50 1 48 93 | 2 50 5 94 | 50 50 2402 95 | 50 50 2448 96 | 50 50 49 97 | 50 50 252 98 | 50 2 44 99 | 2 50 2 100 | 3 3 0 101 | 50 50 52 102 | 50 50 48 103 | 50 50 50 104 | 4 4 14 105 | 50 3 2 106 | 3 50 43 107 | 50 3 48 108 | 50 50 2496 109 | 3 3 3 110 | 50 3 45 111 | 50 50 51 112 | 50 3 44 113 | 3 1 1 114 | 2 50 3 115 | 50 3 46 116 | 50 2 45 117 | 3 50 0 118 | 2 50 1 119 | 3 50 46 120 | 1 50 3 121 | 2 50 43 122 | 50 50 2401 123 | 1 50 48 124 | 4 4 9 125 | 50 50 2494 126 | 50 1 1 127 | 50 50 1 128 | 50 50 249 129 | 3 50 3 130 | 50 50 2449 131 | 4 4 11 132 | 1 50 1 133 | 5 5 23 134 | 50 2 46 135 | 4 4 10 136 | -------------------------------------------------------------------------------- /2014/qualification_round/C/C-small-practice.in: -------------------------------------------------------------------------------- 1 | 225 2 | 1 4 0 3 | 3 4 11 4 | 3 5 9 5 | 5 4 17 6 | 3 3 5 7 | 4 5 7 8 | 3 5 11 9 | 4 4 7 10 | 1 5 2 11 | 5 5 23 12 | 3 5 12 13 | 4 4 12 14 | 3 3 1 15 | 4 3 10 16 | 5 3 13 17 | 5 3 9 18 | 4 4 10 19 | 4 3 9 20 | 3 1 1 21 | 2 2 3 22 | 5 4 15 23 | 3 5 2 24 | 4 3 1 25 | 5 4 12 26 | 5 4 16 27 | 2 4 0 28 | 3 4 0 29 | 4 4 1 30 | 3 2 2 31 | 5 4 8 32 | 5 4 2 33 | 5 4 7 34 | 2 3 5 35 | 5 5 10 36 | 5 4 4 37 | 3 5 14 38 | 3 4 8 39 | 4 2 6 40 | 4 5 2 41 | 4 5 17 42 | 3 3 8 43 | 2 4 5 44 | 5 4 5 45 | 4 5 16 46 | 3 5 4 47 | 4 1 1 48 | 4 5 12 49 | 4 3 0 50 | 3 5 6 51 | 2 5 8 52 | 3 5 7 53 | 4 5 13 54 | 2 4 1 55 | 5 5 22 56 | 5 5 0 57 | 4 2 3 58 | 4 4 11 59 | 5 4 13 60 | 2 3 1 61 | 2 5 2 62 | 4 5 19 63 | 2 5 9 64 | 2 4 3 65 | 2 4 7 66 | 4 1 0 67 | 3 2 3 68 | 5 3 8 69 | 4 4 8 70 | 5 5 13 71 | 2 5 6 72 | 2 4 4 73 | 5 1 2 74 | 4 4 2 75 | 3 1 0 76 | 5 5 3 77 | 3 5 1 78 | 5 4 9 79 | 2 5 7 80 | 2 2 1 81 | 1 5 3 82 | 4 4 13 83 | 4 4 0 84 | 3 5 13 85 | 4 1 2 86 | 3 2 1 87 | 4 4 9 88 | 5 4 1 89 | 3 5 10 90 | 1 3 2 91 | 5 4 11 92 | 2 1 1 93 | 5 5 17 94 | 5 2 4 95 | 4 5 18 96 | 4 3 3 97 | 5 4 3 98 | 5 1 3 99 | 5 4 19 100 | 5 5 14 101 | 4 3 6 102 | 4 3 2 103 | 4 3 4 104 | 5 2 7 105 | 5 4 10 106 | 5 3 3 107 | 5 4 18 108 | 4 5 0 109 | 3 5 3 110 | 3 4 3 111 | 4 3 5 112 | 3 4 1 113 | 1 2 0 114 | 5 5 19 115 | 5 5 5 116 | 5 2 9 117 | 5 5 2 118 | 2 3 0 119 | 5 5 8 120 | 5 2 5 121 | 2 4 6 122 | 4 4 3 123 | 2 1 0 124 | 5 2 6 125 | 4 4 14 126 | 1 4 2 127 | 4 2 7 128 | 4 3 8 129 | 3 2 5 130 | 5 3 14 131 | 4 2 1 132 | 1 4 1 133 | 1 1 0 134 | 2 5 5 135 | 4 2 0 136 | 2 5 4 137 | 5 5 1 138 | 3 3 4 139 | 3 5 5 140 | 3 3 7 141 | 3 3 3 142 | 3 3 0 143 | 3 1 2 144 | 4 5 14 145 | 5 3 0 146 | 3 4 10 147 | 5 3 5 148 | 5 2 3 149 | 5 4 6 150 | 4 4 5 151 | 5 1 1 152 | 1 4 3 153 | 3 3 6 154 | 5 2 2 155 | 5 2 1 156 | 5 4 14 157 | 5 5 7 158 | 5 5 4 159 | 4 5 5 160 | 4 5 6 161 | 4 4 4 162 | 1 5 1 163 | 4 1 3 164 | 4 2 4 165 | 2 2 2 166 | 2 5 3 167 | 1 3 1 168 | 5 3 4 169 | 3 4 4 170 | 5 3 10 171 | 2 5 0 172 | 5 1 0 173 | 2 4 2 174 | 4 5 8 175 | 1 5 4 176 | 1 2 1 177 | 5 4 0 178 | 5 5 24 179 | 3 4 7 180 | 5 3 1 181 | 4 4 6 182 | 5 3 7 183 | 5 5 21 184 | 2 3 3 185 | 4 3 11 186 | 5 5 6 187 | 4 4 15 188 | 5 5 11 189 | 4 5 1 190 | 3 5 8 191 | 4 5 3 192 | 3 2 4 193 | 5 2 0 194 | 5 5 9 195 | 5 1 4 196 | 1 5 0 197 | 4 2 2 198 | 4 2 5 199 | 5 3 12 200 | 3 4 9 201 | 2 3 2 202 | 4 5 10 203 | 3 4 6 204 | 4 5 11 205 | 4 5 4 206 | 2 5 1 207 | 5 5 20 208 | 4 3 7 209 | 5 5 12 210 | 5 3 2 211 | 1 3 0 212 | 4 5 15 213 | 3 4 2 214 | 5 5 18 215 | 4 5 9 216 | 3 5 0 217 | 5 5 15 218 | 3 2 0 219 | 5 3 6 220 | 5 2 8 221 | 2 3 4 222 | 3 4 5 223 | 5 3 11 224 | 5 5 16 225 | 3 3 2 226 | 2 2 0 227 | -------------------------------------------------------------------------------- /2014/qualification_round/C/input_dbg: -------------------------------------------------------------------------------- 1 | 6 2 | 3 4 11 3 | 3 4 10 4 | 3 5 4 5 | 3 5 2 6 | 4 4 3 7 | 4 8 23 -------------------------------------------------------------------------------- /2014/qualification_round/C/input_example: -------------------------------------------------------------------------------- 1 | 5 2 | 5 5 23 3 | 3 1 1 4 | 2 2 1 5 | 4 7 3 6 | 10 10 82 -------------------------------------------------------------------------------- /2014/qualification_round/C/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 2 | Impossible 3 | Case #2: 4 | c 5 | . 6 | * 7 | Case #3: 8 | Impossible 9 | Case #4: 10 | ......* 11 | .c....* 12 | ....... 13 | ..*.... 14 | Case #5: 15 | ********** 16 | ********** 17 | ********** 18 | ****....** 19 | ***.....** 20 | ***.c...** 21 | ***....*** 22 | ********** 23 | ********** 24 | ********** 25 | -------------------------------------------------------------------------------- /2014/qualification_round/D/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: 4 1 2 | Case #2: 236 16 3 | Case #3: 976 43 4 | Case #4: 948 18 5 | Case #5: 965 31 6 | Case #6: 888 29 7 | Case #7: 1000 1000 8 | Case #8: 230 230 9 | Case #9: 0 0 10 | Case #10: 656 656 11 | Case #11: 346 10 12 | Case #12: 944 13 13 | Case #13: 978 35 14 | Case #14: 841 36 15 | Case #15: 310 13 16 | Case #16: 0 0 17 | Case #17: 964 20 18 | Case #18: 149 12 19 | Case #19: 661 19 20 | Case #20: 969 20 21 | Case #21: 0 0 22 | Case #22: 0 0 23 | Case #23: 352 35 24 | Case #24: 982 42 25 | Case #25: 256 6 26 | Case #26: 991 45 27 | Case #27: 0 0 28 | Case #28: 114 11 29 | Case #29: 144 2 30 | Case #30: 0 0 31 | Case #31: 821 821 32 | Case #32: 756 31 33 | Case #33: 962 25 34 | Case #34: 992 49 35 | Case #35: 879 35 36 | Case #36: 243 4 37 | Case #37: 786 26 38 | Case #38: 966 10 39 | Case #39: 0 0 40 | Case #40: 148 16 41 | Case #41: 948 6 42 | Case #42: 0 0 43 | Case #43: 676 676 44 | Case #44: 202 12 45 | Case #45: 953 13 46 | Case #46: 67 7 47 | Case #47: 689 30 48 | Case #48: 985 27 49 | Case #49: 964 29 50 | Case #50: 954 24 51 | -------------------------------------------------------------------------------- /2014/qualification_round/D/input_dbg: -------------------------------------------------------------------------------- 1 | 4 2 | 5 3 | 0.5 0.6 0.7 0.8 0.9 4 | 0.1 0.2 0.3 0.4 0.99 5 | 1 6 | 0.1 7 | 0.2 8 | 3 9 | 0.1 0.7 0.99 10 | 0.2 0.8 0.9 11 | 3 12 | 0.2 0.8 0.9 13 | 0.1 0.7 0.99 14 | -------------------------------------------------------------------------------- /2014/qualification_round/D/input_example: -------------------------------------------------------------------------------- 1 | 4 2 | 1 3 | 0.5 4 | 0.6 5 | 2 6 | 0.7 0.2 7 | 0.8 0.3 8 | 3 9 | 0.5 0.1 0.9 10 | 0.6 0.4 0.3 11 | 9 12 | 0.186 0.389 0.907 0.832 0.959 0.557 0.300 0.992 0.899 13 | 0.916 0.728 0.271 0.520 0.700 0.521 0.215 0.341 0.458 -------------------------------------------------------------------------------- /2014/qualification_round/D/output_dbg: -------------------------------------------------------------------------------- 1 | Case #1: 4 4 2 | Case #2: 0 0 3 | Case #3: 2 1 4 | Case #4: 2 1 -------------------------------------------------------------------------------- /2014/qualification_round/D/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 0 0 2 | Case #2: 1 0 3 | Case #3: 2 1 4 | Case #4: 8 4 5 | -------------------------------------------------------------------------------- /2014/round-1a/A/0-kai-1/log: -------------------------------------------------------------------------------- 1 | 1 1 : 1 2 | 2 1 : 2 3 | 3 1 : 3 4 | c_size++ 5 | 4 2 : 1 2 6 | 5 2 : 1 3 7 | 6 2 : 2 3 8 | c_size++ 9 | 7 3 : 1 2 3 10 | Case #1: 0 11 | 1 1 : 1 12 | 2 1 : 2 13 | c_size++ 14 | 3 2 : 1 2 15 | Case #2: 0 16 | 1 1 : 1 17 | 2 1 : 2 18 | c_size++ 19 | 3 2 : 1 2 20 | Case #3: 0 21 | -------------------------------------------------------------------------------- /2014/round-1a/A/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: 1 2 | Case #2: 7 3 | Case #3: 5 4 | Case #4: 4 5 | Case #5: 1 6 | Case #6: 7 7 | Case #7: 2 8 | Case #8: NOT POSSIBLE 9 | Case #9: 3 10 | Case #10: 6 11 | Case #11: 2 12 | Case #12: 4 13 | Case #13: 6 14 | Case #14: 2 15 | Case #15: 1 16 | Case #16: 4 17 | Case #17: 1 18 | Case #18: 4 19 | Case #19: 2 20 | Case #20: 4 21 | Case #21: 3 22 | Case #22: 7 23 | Case #23: 5 24 | Case #24: 4 25 | Case #25: 6 26 | Case #26: 2 27 | Case #27: 6 28 | Case #28: 3 29 | Case #29: 1 30 | Case #30: 4 31 | Case #31: 1 32 | Case #32: 2 33 | Case #33: 1 34 | Case #34: 3 35 | Case #35: NOT POSSIBLE 36 | Case #36: 4 37 | Case #37: NOT POSSIBLE 38 | Case #38: 4 39 | Case #39: 2 40 | Case #40: NOT POSSIBLE 41 | Case #41: 6 42 | Case #42: 3 43 | Case #43: 6 44 | Case #44: 3 45 | Case #45: 2 46 | Case #46: 1 47 | Case #47: 6 48 | Case #48: 7 49 | Case #49: NOT POSSIBLE 50 | Case #50: 7 51 | Case #51: 3 52 | Case #52: NOT POSSIBLE 53 | Case #53: NOT POSSIBLE 54 | Case #54: NOT POSSIBLE 55 | Case #55: 4 56 | Case #56: 5 57 | Case #57: NOT POSSIBLE 58 | Case #58: NOT POSSIBLE 59 | Case #59: 5 60 | Case #60: 2 61 | Case #61: 6 62 | Case #62: NOT POSSIBLE 63 | Case #63: 2 64 | Case #64: 7 65 | Case #65: 1 66 | Case #66: NOT POSSIBLE 67 | Case #67: 6 68 | Case #68: 4 69 | Case #69: 1 70 | Case #70: NOT POSSIBLE 71 | Case #71: 0 72 | Case #72: NOT POSSIBLE 73 | Case #73: 2 74 | Case #74: NOT POSSIBLE 75 | Case #75: 1 76 | Case #76: 4 77 | Case #77: 5 78 | Case #78: NOT POSSIBLE 79 | Case #79: 0 80 | Case #80: NOT POSSIBLE 81 | Case #81: 2 82 | Case #82: 3 83 | Case #83: 6 84 | Case #84: 7 85 | Case #85: NOT POSSIBLE 86 | Case #86: 3 87 | Case #87: 6 88 | Case #88: 4 89 | Case #89: NOT POSSIBLE 90 | Case #90: 5 91 | Case #91: 5 92 | Case #92: 1 93 | Case #93: 4 94 | Case #94: 7 95 | Case #95: 3 96 | Case #96: 1 97 | Case #97: 5 98 | Case #98: 3 99 | Case #99: NOT POSSIBLE 100 | Case #100: 1 101 | -------------------------------------------------------------------------------- /2014/round-1a/A/0-kai-1/out_small: -------------------------------------------------------------------------------- 1 | Case #1: 1 2 | Case #2: 7 3 | Case #3: 5 4 | Case #4: 4 5 | Case #5: 1 6 | Case #6: 7 7 | Case #7: 2 8 | Case #8: NOT POSSIBLE 9 | Case #9: 3 10 | Case #10: 6 11 | Case #11: 2 12 | Case #12: 4 13 | Case #13: 6 14 | Case #14: 2 15 | Case #15: 1 16 | Case #16: 4 17 | Case #17: 1 18 | Case #18: 4 19 | Case #19: 2 20 | Case #20: 4 21 | Case #21: 3 22 | Case #22: 7 23 | Case #23: 5 24 | Case #24: 4 25 | Case #25: 6 26 | Case #26: 2 27 | Case #27: 6 28 | Case #28: 3 29 | Case #29: 1 30 | Case #30: 4 31 | Case #31: 1 32 | Case #32: 2 33 | Case #33: 1 34 | Case #34: 3 35 | Case #35: NOT POSSIBLE 36 | Case #36: 4 37 | Case #37: NOT POSSIBLE 38 | Case #38: 4 39 | Case #39: 2 40 | Case #40: NOT POSSIBLE 41 | Case #41: 6 42 | Case #42: 3 43 | Case #43: 6 44 | Case #44: 3 45 | Case #45: 2 46 | Case #46: 1 47 | Case #47: 6 48 | Case #48: 7 49 | Case #49: NOT POSSIBLE 50 | Case #50: 7 51 | Case #51: 3 52 | Case #52: NOT POSSIBLE 53 | Case #53: NOT POSSIBLE 54 | Case #54: NOT POSSIBLE 55 | Case #55: 4 56 | Case #56: 5 57 | Case #57: NOT POSSIBLE 58 | Case #58: NOT POSSIBLE 59 | Case #59: 5 60 | Case #60: 2 61 | Case #61: 6 62 | Case #62: NOT POSSIBLE 63 | Case #63: 2 64 | Case #64: 7 65 | Case #65: 1 66 | Case #66: NOT POSSIBLE 67 | Case #67: 6 68 | Case #68: 4 69 | Case #69: 1 70 | Case #70: NOT POSSIBLE 71 | Case #71: 0 72 | Case #72: NOT POSSIBLE 73 | Case #73: 2 74 | Case #74: NOT POSSIBLE 75 | Case #75: 1 76 | Case #76: 4 77 | Case #77: 5 78 | Case #78: NOT POSSIBLE 79 | Case #79: 0 80 | Case #80: NOT POSSIBLE 81 | Case #81: 2 82 | Case #82: 3 83 | Case #83: 6 84 | Case #84: 7 85 | Case #85: NOT POSSIBLE 86 | Case #86: 3 87 | Case #87: 6 88 | Case #88: 4 89 | Case #89: NOT POSSIBLE 90 | Case #90: 5 91 | Case #91: 5 92 | Case #92: 1 93 | Case #93: 4 94 | Case #94: 7 95 | Case #95: 3 96 | Case #96: 1 97 | Case #97: 5 98 | Case #98: 3 99 | Case #99: NOT POSSIBLE 100 | Case #100: 1 101 | -------------------------------------------------------------------------------- /2014/round-1a/A/0-kai-large/out: -------------------------------------------------------------------------------- 1 | Case #1: 8 2 | Case #2: 7 3 | Case #3: NOT POSSIBLE 4 | Case #4: NOT POSSIBLE 5 | Case #5: 19 6 | Case #6: NOT POSSIBLE 7 | Case #7: 8 8 | Case #8: NOT POSSIBLE 9 | Case #9: NOT POSSIBLE 10 | Case #10: NOT POSSIBLE 11 | Case #11: 3 12 | Case #12: 20 13 | Case #13: 13 14 | Case #14: 21 15 | Case #15: 15 16 | Case #16: 17 17 | Case #17: 27 18 | Case #18: NOT POSSIBLE 19 | Case #19: NOT POSSIBLE 20 | Case #20: 6 21 | Case #21: 19 22 | Case #22: 4 23 | Case #23: 20 24 | Case #24: 6 25 | Case #25: 22 26 | Case #26: 18 27 | Case #27: 20 28 | Case #28: 18 29 | Case #29: 13 30 | Case #30: NOT POSSIBLE 31 | Case #31: 3 32 | Case #32: 10 33 | Case #33: 19 34 | Case #34: NOT POSSIBLE 35 | Case #35: 19 36 | Case #36: 27 37 | Case #37: 24 38 | Case #38: 18 39 | Case #39: 21 40 | Case #40: 20 41 | Case #41: 26 42 | Case #42: 16 43 | Case #43: 1 44 | Case #44: 6 45 | Case #45: 7 46 | Case #46: NOT POSSIBLE 47 | Case #47: NOT POSSIBLE 48 | Case #48: NOT POSSIBLE 49 | Case #49: 21 50 | Case #50: NOT POSSIBLE 51 | Case #51: 14 52 | Case #52: NOT POSSIBLE 53 | Case #53: 4 54 | Case #54: 14 55 | Case #55: 21 56 | Case #56: 23 57 | Case #57: NOT POSSIBLE 58 | Case #58: 21 59 | Case #59: 6 60 | Case #60: NOT POSSIBLE 61 | Case #61: NOT POSSIBLE 62 | Case #62: 2 63 | Case #63: 27 64 | Case #64: 4 65 | Case #65: 9 66 | Case #66: 7 67 | Case #67: 13 68 | Case #68: NOT POSSIBLE 69 | Case #69: 14 70 | Case #70: 12 71 | Case #71: NOT POSSIBLE 72 | Case #72: NOT POSSIBLE 73 | Case #73: NOT POSSIBLE 74 | Case #74: 15 75 | Case #75: 22 76 | Case #76: 12 77 | Case #77: NOT POSSIBLE 78 | Case #78: 10 79 | Case #79: NOT POSSIBLE 80 | Case #80: 11 81 | Case #81: 18 82 | Case #82: NOT POSSIBLE 83 | Case #83: NOT POSSIBLE 84 | Case #84: NOT POSSIBLE 85 | Case #85: NOT POSSIBLE 86 | Case #86: 14 87 | Case #87: 23 88 | Case #88: 9 89 | Case #89: 6 90 | Case #90: 10 91 | Case #91: 6 92 | Case #92: NOT POSSIBLE 93 | Case #93: NOT POSSIBLE 94 | Case #94: 20 95 | Case #95: 24 96 | Case #96: 4 97 | Case #97: 11 98 | Case #98: 22 99 | Case #99: 20 100 | Case #100: NOT POSSIBLE 101 | -------------------------------------------------------------------------------- /2014/round-1a/A/input_dbg: -------------------------------------------------------------------------------- 1 | 4 2 | 3 | 1 10 4 | 1111111111 5 | 0000000000 6 | 7 | 2 10 8 | 1111111111 1111111011 9 | 0000000000 0000000100 10 | 11 | 1 2 12 | 11 13 | 01 14 | 15 | 10 10 16 | 0000101111 1010001100 1101011001 1111110010 0100111011 1110000101 0110000100 0001110100 1001101011 0011010010 17 | 0000000100 1010111101 1001000000 0110011101 0100110110 0011100011 1101010100 1111101011 1000011011 0111101010 18 | 19 | -------------------------------------------------------------------------------- /2014/round-1a/A/input_example: -------------------------------------------------------------------------------- 1 | 3 2 | 3 2 3 | 01 11 10 4 | 11 00 10 5 | 2 3 6 | 101 111 7 | 010 001 8 | 2 2 9 | 01 10 10 | 10 01 -------------------------------------------------------------------------------- /2014/round-1a/A/output_dbg: -------------------------------------------------------------------------------- 1 | Case #1: 10 2 | Case #2: 9 3 | Case #3: 1 4 | -------------------------------------------------------------------------------- /2014/round-1a/A/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 1 2 | Case #2: NOT POSSIBLE 3 | Case #3: 0 4 | -------------------------------------------------------------------------------- /2014/round-1a/B/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: 2 2 | Case #2: 31 3 | Case #3: 955 4 | Case #4: 15 5 | Case #5: 34 6 | Case #6: 955 7 | Case #7: 9 8 | Case #8: 0 9 | Case #9: 953 10 | Case #10: 949 11 | Case #11: 1 12 | Case #12: 957 13 | Case #13: 1 14 | Case #14: 955 15 | Case #15: 945 16 | Case #16: 997 17 | Case #17: 19 18 | Case #18: 17 19 | Case #19: 931 20 | Case #20: 945 21 | Case #21: 18 22 | Case #22: 941 23 | Case #23: 941 24 | Case #24: 16 25 | Case #25: 0 26 | Case #26: 949 27 | Case #27: 7 28 | Case #28: 10 29 | Case #29: 2 30 | Case #30: 12 31 | Case #31: 11 32 | Case #32: 8 33 | Case #33: 2 34 | Case #34: 957 35 | Case #35: 1 36 | Case #36: 923 37 | Case #37: 947 38 | Case #38: 8 39 | Case #39: 927 40 | Case #40: 5 41 | Case #41: 953 42 | Case #42: 963 43 | Case #43: 26 44 | Case #44: 939 45 | Case #45: 33 46 | Case #46: 1 47 | Case #47: 4 48 | Case #48: 941 49 | Case #49: 941 50 | Case #50: 26 51 | Case #51: 963 52 | Case #52: 937 53 | Case #53: 21 54 | Case #54: 973 55 | Case #55: 21 56 | Case #56: 27 57 | Case #57: 23 58 | Case #58: 945 59 | Case #59: 13 60 | Case #60: 20 61 | Case #61: 931 62 | Case #62: 861 63 | Case #63: 7 64 | Case #64: 959 65 | Case #65: 8 66 | Case #66: 945 67 | Case #67: 1 68 | Case #68: 949 69 | Case #69: 947 70 | Case #70: 18 71 | Case #71: 955 72 | Case #72: 23 73 | Case #73: 36 74 | Case #74: 947 75 | Case #75: 9 76 | Case #76: 6 77 | Case #77: 26 78 | Case #78: 22 79 | Case #79: 945 80 | Case #80: 953 81 | Case #81: 10 82 | Case #82: 961 83 | Case #83: 959 84 | Case #84: 4 85 | Case #85: 963 86 | Case #86: 953 87 | Case #87: 941 88 | Case #88: 23 89 | Case #89: 997 90 | Case #90: 26 91 | Case #91: 17 92 | Case #92: 931 93 | Case #93: 20 94 | Case #94: 947 95 | Case #95: 951 96 | Case #96: 955 97 | Case #97: 955 98 | Case #98: 19 99 | Case #99: 943 100 | Case #100: 941 101 | -------------------------------------------------------------------------------- /2014/round-1a/B/input_dbg: -------------------------------------------------------------------------------- 1 | 3 2 | 3 | 10 4 | 1 2 5 | 2 3 6 | 3 4 7 | 4 5 8 | 5 6 9 | 6 7 10 | 7 8 11 | 8 9 12 | 9 10 13 | 14 | 6 15 | 1 2 16 | 1 3 17 | 1 4 18 | 1 5 19 | 1 6 20 | 21 | 2 22 | 1 2 -------------------------------------------------------------------------------- /2014/round-1a/B/input_example: -------------------------------------------------------------------------------- 1 | 3 2 | 3 3 | 2 1 4 | 1 3 5 | 7 6 | 4 5 7 | 4 2 8 | 1 2 9 | 3 1 10 | 6 4 11 | 3 7 12 | 4 13 | 1 2 14 | 2 3 15 | 3 4 -------------------------------------------------------------------------------- /2014/round-1a/B/output_dbg: -------------------------------------------------------------------------------- 1 | Case #1: 7 2 | Case #2: 3 3 | Case #3: 1 4 | -------------------------------------------------------------------------------- /2014/round-1a/B/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 0 2 | Case #2: 2 3 | Case #3: 1 4 | -------------------------------------------------------------------------------- /2014/round-1a/B/problem.org: -------------------------------------------------------------------------------- 1 | * Problem B. Full Binary Tree 2 | 3 | 4 | ** Problem 5 | 6 | A tree is a connected graph with no cycles. 7 | 8 | A _rooted tree_ is a tree in which one special vertex is called the root. 9 | 10 | If there is an edge between X and Y in a _rooted tree_ 11 | we say that Y is a _child_ of X if X is _closer to the root_ than Y 12 | (in other words, the shortest path from the root to X is shorter than the shortest path from the root to Y). 13 | 14 | 15 | A _full binary tree_ is a 16 | 17 | _rooted tree_ 18 | every node has either exactly _2_ children or _0_ children. 19 | 20 | 21 | You are given a tree _G_ with _N_ nodes (numbered from 1 to N). 22 | 23 | You are allowed to _delete_ some of the nodes. 24 | 25 | When a node is deleted, _the edges connected to the deleted node are also deleted_ 26 | 27 | Your task is to _delete as few nodes as possible_ so that the _remaining nodes_ form a 28 | _full binary tree_ for _some choice of the root from the remaining nodes_ 29 | 30 | 31 | ** Input 32 | 33 | The first line of the input gives the number of test cases, T. 34 | T test cases follow. 35 | 36 | The first line of each test case contains a single integer _N_, 37 | the number of nodes in the tree. 38 | 39 | The following _N-1_ lines each one will contain two space-separated integers: 40 | Xi Yi, indicating that G contains an undirected edge between Xi and Yi. 41 | 42 | 43 | ** Output 44 | 45 | For each test case, output one line containing "Case #x: y", 46 | where x is the test case number (starting from 1) and 47 | 48 | y is the _minimum number of nodes to delete from G to make a full binary tree_ 49 | 50 | 51 | ** Limits 52 | 53 | 1 ≤ T ≤ 100. 54 | 1 ≤ Xi, Yi ≤ N 55 | 56 | Each test case will form a valid connected tree. 57 | 58 | 59 | *** Small dataset 60 | 61 | 2 ≤ N ≤ 15. 62 | 63 | 64 | *** Large dataset 65 | 66 | 2 ≤ N ≤ 1000. 67 | 68 | ** Sample 69 | 70 | 71 | *** Input 72 | 73 | 3 74 | 75 | 3 76 | 2 1 77 | 1 3 78 | 79 | 7 80 | 4 5 81 | 4 2 82 | 1 2 83 | 3 1 84 | 6 4 85 | 3 7 86 | 87 | 4 88 | 1 2 89 | 2 3 90 | 3 4 91 | 92 | 93 | *** Output 94 | 95 | Case #1: 0 96 | Case #2: 2 97 | Case #3: 1 98 | 99 | 100 | In the first case, G is already a full binary tree 101 | (if we consider node 1 as the root), so we don't need to do anything. 102 | 103 | In the second case, we may delete nodes 3 and 7; 104 | then 2 can be the root of a full binary tree. 105 | 106 | In the third case, we may delete node 1; 107 | then 3 will become the root of a full binary tree 108 | (we could also have deleted node 4; then we could have made 2 the root). 109 | 110 | -------------------------------------------------------------------------------- /2014/round-1a/C/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: BAD 2 | Case #2: GOOD 3 | Case #3: BAD 4 | Case #4: GOOD 5 | Case #5: BAD 6 | Case #6: BAD 7 | Case #7: BAD 8 | Case #8: BAD 9 | Case #9: GOOD 10 | Case #10: BAD 11 | Case #11: BAD 12 | Case #12: GOOD 13 | Case #13: GOOD 14 | Case #14: BAD 15 | Case #15: BAD 16 | Case #16: GOOD 17 | Case #17: BAD 18 | Case #18: BAD 19 | Case #19: GOOD 20 | Case #20: GOOD 21 | Case #21: BAD 22 | Case #22: BAD 23 | Case #23: GOOD 24 | Case #24: BAD 25 | Case #25: GOOD 26 | Case #26: BAD 27 | Case #27: GOOD 28 | Case #28: BAD 29 | Case #29: BAD 30 | Case #30: BAD 31 | Case #31: GOOD 32 | Case #32: BAD 33 | Case #33: GOOD 34 | Case #34: BAD 35 | Case #35: BAD 36 | Case #36: BAD 37 | Case #37: BAD 38 | Case #38: BAD 39 | Case #39: BAD 40 | Case #40: GOOD 41 | Case #41: BAD 42 | Case #42: GOOD 43 | Case #43: BAD 44 | Case #44: GOOD 45 | Case #45: BAD 46 | Case #46: GOOD 47 | Case #47: GOOD 48 | Case #48: GOOD 49 | Case #49: GOOD 50 | Case #50: GOOD 51 | Case #51: GOOD 52 | Case #52: GOOD 53 | Case #53: BAD 54 | Case #54: BAD 55 | Case #55: GOOD 56 | Case #56: BAD 57 | Case #57: BAD 58 | Case #58: BAD 59 | Case #59: BAD 60 | Case #60: GOOD 61 | Case #61: BAD 62 | Case #62: GOOD 63 | Case #63: GOOD 64 | Case #64: BAD 65 | Case #65: BAD 66 | Case #66: GOOD 67 | Case #67: BAD 68 | Case #68: GOOD 69 | Case #69: BAD 70 | Case #70: GOOD 71 | Case #71: BAD 72 | Case #72: GOOD 73 | Case #73: GOOD 74 | Case #74: GOOD 75 | Case #75: GOOD 76 | Case #76: BAD 77 | Case #77: BAD 78 | Case #78: GOOD 79 | Case #79: GOOD 80 | Case #80: GOOD 81 | Case #81: BAD 82 | Case #82: GOOD 83 | Case #83: GOOD 84 | Case #84: BAD 85 | Case #85: BAD 86 | Case #86: GOOD 87 | Case #87: BAD 88 | Case #88: GOOD 89 | Case #89: GOOD 90 | Case #90: BAD 91 | Case #91: GOOD 92 | Case #92: BAD 93 | Case #93: GOOD 94 | Case #94: GOOD 95 | Case #95: BAD 96 | Case #96: BAD 97 | Case #97: GOOD 98 | Case #98: GOOD 99 | Case #99: BAD 100 | Case #100: BAD 101 | Case #101: BAD 102 | Case #102: BAD 103 | Case #103: GOOD 104 | Case #104: GOOD 105 | Case #105: GOOD 106 | Case #106: GOOD 107 | Case #107: BAD 108 | Case #108: BAD 109 | Case #109: GOOD 110 | Case #110: GOOD 111 | Case #111: GOOD 112 | Case #112: BAD 113 | Case #113: GOOD 114 | Case #114: GOOD 115 | Case #115: GOOD 116 | Case #116: GOOD 117 | Case #117: BAD 118 | Case #118: GOOD 119 | Case #119: GOOD 120 | Case #120: BAD 121 | -------------------------------------------------------------------------------- /2014/round-1a/C/0-kai-1/sol.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | 6 | using std::cin; 7 | using std::cout; 8 | using std::endl; 9 | 10 | 11 | // ====== Defines ====== 12 | 13 | #define N_SIZE 1000 14 | 15 | // ------ Defines ------ 16 | 17 | 18 | // ====== Types ====== 19 | 20 | 21 | // ------ Types ------ 22 | 23 | 24 | // ====== Global Variables ====== 25 | 26 | int N; 27 | int arr[N_SIZE]; 28 | int lisl_count_arr[N_SIZE]; 29 | 30 | // ------ Global Variables ------ 31 | 32 | 33 | int init_only_once() 34 | { 35 | return 0; 36 | } 37 | 38 | int handle_input() 39 | { 40 | cin >> N; 41 | 42 | for (int i = 0; i < N; i++) { 43 | cin >> arr[i]; 44 | } 45 | 46 | return 0; 47 | } 48 | 49 | int init_per_case() 50 | { 51 | return 0; 52 | } 53 | 54 | int get_longest_increase_sub_list_count() 55 | { 56 | for (int i = 0; i < N; i++) 57 | lisl_count_arr[i] = 0; 58 | 59 | lisl_count_arr[0] = 1; 60 | 61 | int longest_count = 0; 62 | 63 | for (int iii = 1; iii < N; iii++) { 64 | 65 | int longest = 1; 66 | 67 | for (int jjj = iii - 1; jjj >= 0; jjj--) { 68 | if (arr[iii] > arr[jjj]) 69 | longest = std::max(longest, 1 + lisl_count_arr[jjj]); 70 | } 71 | 72 | lisl_count_arr[iii] = longest; 73 | longest_count = std::max(longest_count, longest); 74 | } 75 | 76 | return longest_count; 77 | } 78 | 79 | int run() 80 | { 81 | // return get_longest_increase_sub_list_count(); 82 | 83 | int count = 0; 84 | for (int iii = 0; iii < N; iii++) { 85 | if (arr[iii] > iii) 86 | count++; 87 | } 88 | 89 | // cout << count << endl; 90 | 91 | return count < (N / 2 + 16); 92 | } 93 | 94 | int main() 95 | { 96 | init_only_once(); 97 | 98 | int total_cases_count = 0; 99 | cin >> total_cases_count; 100 | 101 | int run_ret = 0; 102 | 103 | int good_count = 0; 104 | 105 | for (int tt = 1; tt <= total_cases_count; tt++) { 106 | 107 | handle_input(); 108 | 109 | init_per_case(); 110 | 111 | run_ret = run(); 112 | 113 | cout << "Case #" << tt << ": "; 114 | 115 | if (0 == run_ret) 116 | cout << "BAD" << endl; 117 | else { 118 | good_count++; 119 | cout << "GOOD" << endl; 120 | } 121 | } 122 | 123 | // cout << good_count << endl; 124 | 125 | return 0; 126 | } 127 | 128 | -------------------------------------------------------------------------------- /2014/round-1a/C/input_example: -------------------------------------------------------------------------------- 1 | 2 2 | 3 | 3 4 | 0 1 2 5 | 6 | 3 7 | 2 0 1 -------------------------------------------------------------------------------- /2014/round-1a/C/output_example: -------------------------------------------------------------------------------- 1 | Case #1: BAD 2 | Case #2: GOOD 3 | -------------------------------------------------------------------------------- /2014/round-1b/A/0-kai-1/log.txt: -------------------------------------------------------------------------------- 1 | >>main() 2 | 3 | >>>>init_only_once() 4 | <<< 2 | #include 3 | #include 4 | #include 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | 14 | using std::cin; 15 | using std::cout; 16 | using std::endl; 17 | 18 | 19 | // ====== Defines ====== 20 | 21 | 22 | // ------ Defines ------ 23 | 24 | 25 | // ====== Types ====== 26 | 27 | 28 | // ------ Types ------ 29 | 30 | 31 | // ====== Global Variables ====== 32 | 33 | std::fstream log_fs; 34 | 35 | 36 | // ------ Global Variables ------ 37 | 38 | 39 | // ====== Function declarations ====== 40 | 41 | 42 | // ------ Function declarations ------ 43 | 44 | 45 | int init_only_once() 46 | { 47 | log_fs << ">>>>init_only_once()" << endl; 48 | log_fs << "<<<>>>>>handle_input()" << endl; 56 | log_fs << "<<<<<>>>>>init_per_case()" << endl; 64 | 65 | log_fs << "<<<<<>>>>>run()" << endl; 73 | 74 | int ans = 0; 75 | 76 | 77 | log_fs << "<<<<<>main()" << endl << endl; 85 | 86 | init_only_once(); 87 | 88 | int total_cases_count = 0; 89 | cin >> total_cases_count; 90 | 91 | int run_ret = 0; 92 | 93 | for (int tt = 1; tt <= total_cases_count; tt++) { 94 | 95 | handle_input(); 96 | 97 | init_per_case(); 98 | 99 | run_ret = run(); 100 | 101 | cout << "Case #" << tt << ": "; 102 | 103 | 104 | cout << endl; 105 | 106 | log_fs << "Case #" << tt << ": " << run_ret << endl; 107 | } 108 | 109 | 110 | log_fs << "< 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | using namespace std; 13 | 14 | int get() 15 | { 16 | char c; 17 | while(c=getchar(),(c<'0'||c>'9')&&(c!='-')); 18 | bool flag=(c=='-'); 19 | if(flag) 20 | c=getchar(); 21 | int x=0; 22 | while(c>='0'&&c<='9') 23 | { 24 | x=x*10+c-48; 25 | c=getchar(); 26 | } 27 | return flag?-x:x; 28 | } 29 | 30 | void output(int x) 31 | { 32 | if(x<0) 33 | { 34 | putchar('-'); 35 | x=-x; 36 | } 37 | int len=0,data[10]; 38 | while(x) 39 | { 40 | data[len++]=x%10; 41 | x/=10; 42 | } 43 | if(!len) 44 | data[len++]=0; 45 | while(len--) 46 | putchar(data[len]+48); 47 | putchar('\n'); 48 | } 49 | 50 | int a[30],b[30],c[30]; 51 | bool flag[30][2][2][2]; 52 | long long f[30][2][2][2]; 53 | 54 | long long dp(int n,bool fx,bool fy,bool fz) 55 | { 56 | if(n<0) 57 | return fx&&fy&&fz; 58 | if(flag[n][fx][fy][fz]) 59 | return f[n][fx][fy][fz]; 60 | long long ans=0; 61 | for(int x=0;x<2;x++) 62 | for(int y=0;y<2;y++) 63 | { 64 | if(!fx&&x&&!a[n]) 65 | continue; 66 | if(!fy&&y&&!b[n]) 67 | continue; 68 | if(!fz&&x&&y&&!c[n]) 69 | continue; 70 | ans+=dp(n-1,fx||(x 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | using namespace std; 13 | 14 | int get() 15 | { 16 | char c; 17 | while(c=getchar(),(c<'0'||c>'9')&&(c!='-')); 18 | bool flag=(c=='-'); 19 | if(flag) 20 | c=getchar(); 21 | int x=0; 22 | while(c>='0'&&c<='9') 23 | { 24 | x=x*10+c-48; 25 | c=getchar(); 26 | } 27 | return flag?-x:x; 28 | } 29 | 30 | void output(int x) 31 | { 32 | if(x<0) 33 | { 34 | putchar('-'); 35 | x=-x; 36 | } 37 | int len=0,data[10]; 38 | while(x) 39 | { 40 | data[len++]=x%10; 41 | x/=10; 42 | } 43 | if(!len) 44 | data[len++]=0; 45 | while(len--) 46 | putchar(data[len]+48); 47 | putchar('\n'); 48 | } 49 | 50 | int a[30],b[30],c[30]; 51 | bool flag[30][2][2][2]; 52 | long long f[30][2][2][2]; 53 | 54 | long long dp(int n,bool fx,bool fy,bool fz) 55 | { 56 | if(n<0) 57 | return fx && fy && fz; 58 | 59 | if (flag[n][fx][fy][fz]) 60 | return f[n][fx][fy][fz]; 61 | 62 | long long ans=0; 63 | for (int x = 0; x < 2; x++) 64 | for (int y = 0; y < 2; y++) 65 | { 66 | if(!fx && x && !a[n]) 67 | continue; 68 | if(!fy && y && !b[n]) 69 | continue; 70 | if(!fz && x && y && !c[n]) 71 | continue; 72 | ans += dp(n-1, fx || (x < a[n]), 73 | fy || (y < b[n]), fz || ((x&y) < c[n])); 74 | } 75 | 76 | flag[n][fx][fy][fz]=true; 77 | return f[n][fx][fy][fz] = ans; 78 | } 79 | 80 | int main() 81 | { 82 | freopen("B.in","r",stdin); 83 | //freopen("B.out","w",stdout); 84 | int totaltest=get(); 85 | for(int test=1;test<=totaltest;test++) 86 | { 87 | int x=get(),y=get(),z=get(); 88 | for(int i=0;i<30;i++) 89 | { 90 | a[i]=x%2;x/=2; 91 | b[i]=y%2;y/=2; 92 | c[i]=z%2;z/=2; 93 | } 94 | memset(flag,0,sizeof(flag)); 95 | printf("Case #%d: ",test); 96 | cout<>main() 2 | 3 | >>>>init_only_once() 4 | <<< 2 | #include 3 | #include 4 | #include 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | 14 | using std::cin; 15 | using std::cout; 16 | using std::endl; 17 | 18 | 19 | // ====== Defines ====== 20 | 21 | 22 | // ------ Defines ------ 23 | 24 | 25 | // ====== Types ====== 26 | 27 | 28 | // ------ Types ------ 29 | 30 | 31 | // ====== Global Variables ====== 32 | 33 | std::fstream log_fs; 34 | 35 | 36 | // ------ Global Variables ------ 37 | 38 | 39 | // ====== Function declarations ====== 40 | 41 | 42 | // ------ Function declarations ------ 43 | 44 | 45 | int init_only_once() 46 | { 47 | log_fs << ">>>>init_only_once()" << endl; 48 | log_fs << "<<<>>>>>handle_input()" << endl; 56 | log_fs << "<<<<<>>>>>init_per_case()" << endl; 64 | 65 | log_fs << "<<<<<>>>>>run()" << endl; 73 | 74 | int ans = 0; 75 | 76 | 77 | log_fs << "<<<<<>main()" << endl << endl; 85 | 86 | init_only_once(); 87 | 88 | int total_cases_count = 0; 89 | cin >> total_cases_count; 90 | 91 | int run_ret = 0; 92 | 93 | for (int tt = 1; tt <= total_cases_count; tt++) { 94 | 95 | handle_input(); 96 | 97 | init_per_case(); 98 | 99 | run_ret = run(); 100 | 101 | cout << "Case #" << tt << ": "; 102 | 103 | 104 | cout << endl; 105 | 106 | log_fs << "Case #" << tt << ": " << run_ret << endl; 107 | } 108 | 109 | 110 | log_fs << "< 2 | 3 | #include 4 | 5 | 6 | using std::cin; 7 | using std::cout; 8 | using std::endl; 9 | 10 | 11 | #define MAX_SIZE 1001 12 | 13 | #define SHY_COUNT(i) (shy_aud_count[i] - '0') 14 | 15 | // ====== Global Variables ====== 16 | 17 | int S_max; 18 | char shy_aud_count[MAX_SIZE]; 19 | 20 | 21 | // ------ Global Variables ------ 22 | 23 | 24 | 25 | int init_only_once() 26 | { 27 | 28 | return 0; 29 | } 30 | 31 | 32 | int init_per_case() 33 | { 34 | 35 | return 0; 36 | } 37 | 38 | int handle_input() 39 | { 40 | scanf("%d", &S_max); 41 | scanf("%s", shy_aud_count); 42 | 43 | // printf("S_max=%d\n", S_max); 44 | // printf("shy_aud_count=%s\n", shy_aud_count); 45 | 46 | return 0; 47 | } 48 | 49 | 50 | int run() 51 | { 52 | int standed_count = 0; 53 | int invited_count = 0; 54 | 55 | standed_count = SHY_COUNT(0); 56 | 57 | for (int i = 1; i <= S_max; i++) { 58 | if (standed_count < i) { 59 | invited_count += i - standed_count; 60 | standed_count += i - standed_count; 61 | } 62 | standed_count += SHY_COUNT(i); 63 | 64 | if (standed_count >= S_max) 65 | break; 66 | } 67 | 68 | return invited_count; 69 | } 70 | 71 | 72 | int main() 73 | { 74 | init_only_once(); 75 | 76 | int total_cases_count = 0; 77 | cin >> total_cases_count; 78 | 79 | int run_ret = 0; 80 | 81 | for (int tt = 1; tt <= total_cases_count; tt++) { 82 | 83 | handle_input(); 84 | 85 | init_per_case(); 86 | 87 | run_ret = run(); 88 | 89 | cout << "Case #" << tt << ": " << run_ret << endl; 90 | 91 | } 92 | 93 | 94 | return 0; 95 | } 96 | 97 | -------------------------------------------------------------------------------- /2015/qualification_round/A/A-small-attempt0.in: -------------------------------------------------------------------------------- 1 | 100 2 | 6 9999999 3 | 6 8168777 4 | 2 808 5 | 1 02 6 | 6 8005027 7 | 3 0001 8 | 0 1 9 | 6 0000007 10 | 6 3007001 11 | 6 2012222 12 | 6 0000081 13 | 1 27 14 | 6 3300001 15 | 6 0800801 16 | 6 2120121 17 | 6 5060031 18 | 2 301 19 | 6 0061001 20 | 4 12102 21 | 5 067387 22 | 4 11111 23 | 6 1000001 24 | 6 5000009 25 | 6 0000001 26 | 6 1112211 27 | 3 1221 28 | 1 01 29 | 6 8600111 30 | 1 22 31 | 3 7001 32 | 3 0001 33 | 6 1222111 34 | 3 0536 35 | 6 8000001 36 | 6 0006001 37 | 6 8525855 38 | 0 1 39 | 5 800006 40 | 6 0000001 41 | 6 1012001 42 | 6 3080001 43 | 6 5006001 44 | 5 000071 45 | 6 1980001 46 | 6 0300001 47 | 3 4896 48 | 6 5000021 49 | 2 001 50 | 6 2220021 51 | 6 0012101 52 | 6 9239887 53 | 6 7000706 54 | 6 0000061 55 | 6 0875856 56 | 6 3000101 57 | 1 46 58 | 6 3559221 59 | 3 0001 60 | 6 1000221 61 | 6 3395878 62 | 6 3200019 63 | 6 0221211 64 | 1 09 65 | 0 1 66 | 6 6760911 67 | 0 9 68 | 3 0004 69 | 5 110011 70 | 6 0000001 71 | 6 1220202 72 | 6 0000102 73 | 6 8585683 74 | 4 87476 75 | 5 050091 76 | 6 6094201 77 | 6 3967531 78 | 3 0001 79 | 4 06001 80 | 1 22 81 | 6 8288711 82 | 6 0000061 83 | 3 0087 84 | 2 121 85 | 0 1 86 | 1 01 87 | 6 2001202 88 | 6 2063003 89 | 1 01 90 | 6 0000001 91 | 6 0004001 92 | 6 2288089 93 | 3 0701 94 | 1 22 95 | 4 11112 96 | 6 3006091 97 | 4 11111 98 | 6 1111111 99 | 6 0000009 100 | 6 4480001 101 | 6 0000301 102 | -------------------------------------------------------------------------------- /2015/qualification_round/A/input_dbg: -------------------------------------------------------------------------------- 1 | 2 2 | 11 90000000003 3 | 1 01 -------------------------------------------------------------------------------- /2015/qualification_round/A/input_example: -------------------------------------------------------------------------------- 1 | 4 2 | 4 11111 3 | 1 09 4 | 5 110011 5 | 0 1 -------------------------------------------------------------------------------- /2015/qualification_round/A/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 0 2 | Case #2: 1 3 | Case #3: 2 4 | Case #4: 0 5 | -------------------------------------------------------------------------------- /2015/qualification_round/B/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: 3 2 | Case #2: 2 3 | Case #3: 3 4 | Case #4: 997 5 | Case #5: 6 6 | Case #6: 5 7 | Case #7: 188 8 | Case #8: 5 9 | Case #9: 159 10 | Case #10: 956 11 | Case #11: 7 12 | Case #12: 100 13 | Case #13: 6 14 | Case #14: 5 15 | Case #15: 8 16 | Case #16: 433 17 | Case #17: 100 18 | Case #18: 7 19 | Case #19: 992 20 | Case #20: 6 21 | Case #21: 6 22 | Case #22: 153 23 | Case #23: 982 24 | Case #24: 6 25 | Case #25: 417 26 | Case #26: 997 27 | Case #27: 2 28 | Case #28: 203 29 | Case #29: 100 30 | Case #30: 7 31 | Case #31: 8 32 | Case #32: 174 33 | Case #33: 100 34 | Case #34: 1000 35 | Case #35: 4 36 | Case #36: 7 37 | Case #37: 453 38 | Case #38: 973 39 | Case #39: 414 40 | Case #40: 422 41 | Case #41: 8 42 | Case #42: 5 43 | Case #43: 185 44 | Case #44: 973 45 | Case #45: 4 46 | Case #46: 984 47 | Case #47: 8 48 | Case #48: 7 49 | Case #49: 4 50 | Case #50: 8 51 | Case #51: 8 52 | Case #52: 986 53 | Case #53: 404 54 | Case #54: 6 55 | Case #55: 6 56 | Case #56: 985 57 | Case #57: 100 58 | Case #58: 9 59 | Case #59: 965 60 | Case #60: 987 61 | Case #61: 100 62 | Case #62: 100 63 | Case #63: 5 64 | Case #64: 6 65 | Case #65: 6 66 | Case #66: 7 67 | Case #67: 970 68 | Case #68: 196 69 | Case #69: 159 70 | Case #70: 1 71 | Case #71: 986 72 | Case #72: 8 73 | Case #73: 7 74 | Case #74: 182 75 | Case #75: 3 76 | Case #76: 7 77 | Case #77: 9 78 | Case #78: 5 79 | Case #79: 8 80 | Case #80: 100 81 | Case #81: 5 82 | Case #82: 5 83 | Case #83: 3 84 | Case #84: 9 85 | Case #85: 977 86 | Case #86: 995 87 | Case #87: 100 88 | Case #88: 983 89 | Case #89: 178 90 | Case #90: 196 91 | Case #91: 415 92 | Case #92: 996 93 | Case #93: 995 94 | Case #94: 986 95 | Case #95: 424 96 | Case #96: 8 97 | Case #97: 100 98 | Case #98: 186 99 | Case #99: 427 100 | Case #100: 425 101 | -------------------------------------------------------------------------------- /2015/qualification_round/B/0-kai-large/out: -------------------------------------------------------------------------------- 1 | Case #1: 3 2 | Case #2: 2 3 | Case #3: 3 4 | Case #4: 997 5 | Case #5: 979 6 | Case #6: 8 7 | Case #7: 100 8 | Case #8: 100 9 | Case #9: 154 10 | Case #10: 4 11 | Case #11: 988 12 | Case #12: 974 13 | Case #13: 991 14 | Case #14: 7 15 | Case #15: 984 16 | Case #16: 100 17 | Case #17: 9 18 | Case #18: 965 19 | Case #19: 8 20 | Case #20: 8 21 | Case #21: 100 22 | Case #22: 7 23 | Case #23: 7 24 | Case #24: 5 25 | Case #25: 987 26 | Case #26: 4 27 | Case #27: 100 28 | Case #28: 163 29 | Case #29: 9 30 | Case #30: 6 31 | Case #31: 6 32 | Case #32: 993 33 | Case #33: 8 34 | Case #34: 183 35 | Case #35: 5 36 | Case #36: 2 37 | Case #37: 5 38 | Case #38: 181 39 | Case #39: 6 40 | Case #40: 100 41 | Case #41: 7 42 | Case #42: 389 43 | Case #43: 6 44 | Case #44: 1000 45 | Case #45: 978 46 | Case #46: 5 47 | Case #47: 7 48 | Case #48: 8 49 | Case #49: 420 50 | Case #50: 969 51 | Case #51: 136 52 | Case #52: 973 53 | Case #53: 984 54 | Case #54: 982 55 | Case #55: 376 56 | Case #56: 5 57 | Case #57: 172 58 | Case #58: 1 59 | Case #59: 169 60 | Case #60: 8 61 | Case #61: 985 62 | Case #62: 402 63 | Case #63: 389 64 | Case #64: 978 65 | Case #65: 158 66 | Case #66: 394 67 | Case #67: 8 68 | Case #68: 5 69 | Case #69: 7 70 | Case #70: 4 71 | Case #71: 3 72 | Case #72: 3 73 | Case #73: 100 74 | Case #74: 992 75 | Case #75: 5 76 | Case #76: 6 77 | Case #77: 6 78 | Case #78: 100 79 | Case #79: 1000 80 | Case #80: 140 81 | Case #81: 6 82 | Case #82: 7 83 | Case #83: 178 84 | Case #84: 398 85 | Case #85: 166 86 | Case #86: 383 87 | Case #87: 6 88 | Case #88: 406 89 | Case #89: 100 90 | Case #90: 8 91 | Case #91: 980 92 | Case #92: 5 93 | Case #93: 145 94 | Case #94: 6 95 | Case #95: 7 96 | Case #96: 9 97 | Case #97: 100 98 | Case #98: 8 99 | Case #99: 377 100 | Case #100: 995 101 | -------------------------------------------------------------------------------- /2015/qualification_round/B/0-kai-large/sol.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | 8 | using std::cin; 9 | using std::cout; 10 | using std::endl; 11 | 12 | #define ARR_MAX_SIZE 1010 13 | 14 | 15 | // ====== Global Variables ====== 16 | 17 | int arr[ARR_MAX_SIZE]; 18 | int D; 19 | 20 | int largest_p; 21 | 22 | // ------ Global Variables ------ 23 | 24 | int init_only_once() 25 | { 26 | return 0; 27 | } 28 | 29 | int handle_input() 30 | { 31 | largest_p = 0; 32 | 33 | cin >> D; 34 | for (int i = 0; i < D; i++) { 35 | cin >> arr[i]; 36 | largest_p = std::max(largest_p, arr[i]); 37 | } 38 | 39 | return 0; 40 | } 41 | 42 | int init_per_case() 43 | { 44 | return 0; 45 | } 46 | 47 | void print_arr() 48 | { 49 | cout << "===print_arr=" << endl; 50 | for (int i = 0; i < D; i++) 51 | cout << arr[i] << " "; 52 | cout << endl; 53 | } 54 | 55 | int run() 56 | { 57 | // cout << "largest_p=" << largest_p << endl; 58 | if (3 >= largest_p) 59 | return largest_p; 60 | 61 | int total_minutes; 62 | int smallest_total_minutes = largest_p; 63 | 64 | for (int iii = 2; iii <= largest_p; iii++) { 65 | int count_diners = 0; 66 | for (int jjj = 0; jjj < D; jjj++) { 67 | count_diners += arr[jjj] / iii; 68 | if (0 != arr[jjj] % iii) 69 | count_diners++; 70 | } 71 | total_minutes = (count_diners - D) + iii; 72 | smallest_total_minutes = std::min(smallest_total_minutes, total_minutes); 73 | // cout << "iii=" << iii << " count_diners=" << count_diners 74 | // << " total_minutes=" << total_minutes 75 | // << " smallest_total_minutes=" << smallest_total_minutes << endl; 76 | if (iii >= smallest_total_minutes) 77 | break; 78 | } 79 | 80 | return smallest_total_minutes; 81 | } 82 | 83 | 84 | int main() 85 | { 86 | init_only_once(); 87 | 88 | int total_cases_count = 0; 89 | cin >> total_cases_count; 90 | 91 | int run_ret = 0; 92 | 93 | for (int tt = 1; tt <= total_cases_count; tt++) { 94 | 95 | handle_input(); 96 | 97 | init_per_case(); 98 | 99 | run_ret = run(); 100 | 101 | cout << "Case #" << tt << ": " << run_ret << endl; 102 | } 103 | 104 | 105 | return 0; 106 | } 107 | 108 | -------------------------------------------------------------------------------- /2015/qualification_round/B/B-small-attempt0.in: -------------------------------------------------------------------------------- 1 | 100 2 | 1 3 | 3 4 | 4 5 | 1 2 1 2 6 | 1 7 | 4 8 | 3 9 | 3 2 1 10 | 4 11 | 3 9 2 2 12 | 4 13 | 7 5 3 4 14 | 2 15 | 7 7 16 | 6 17 | 3 3 5 5 9 9 18 | 3 19 | 6 8 1 20 | 6 21 | 5 5 5 5 9 9 22 | 3 23 | 2 7 9 24 | 4 25 | 9 3 2 7 26 | 4 27 | 8 8 8 8 28 | 2 29 | 5 5 30 | 2 31 | 9 7 32 | 3 33 | 2 8 3 34 | 5 35 | 5 1 4 1 4 36 | 6 37 | 2 9 9 9 3 3 38 | 3 39 | 8 8 8 40 | 1 41 | 9 42 | 6 43 | 6 6 6 6 9 9 44 | 3 45 | 1 1 5 46 | 1 47 | 1 48 | 4 49 | 9 1 1 1 50 | 5 51 | 4 5 6 8 6 52 | 6 53 | 5 6 9 6 9 6 54 | 4 55 | 9 4 2 6 56 | 6 57 | 6 5 4 3 2 1 58 | 5 59 | 5 4 3 2 1 60 | 3 61 | 9 9 9 62 | 3 63 | 2 8 1 64 | 3 65 | 8 5 2 66 | 4 67 | 8 2 2 2 68 | 2 69 | 9 8 70 | 2 71 | 9 6 72 | 4 73 | 3 3 6 2 74 | 3 75 | 6 9 7 76 | 1 77 | 5 78 | 3 79 | 6 2 9 80 | 3 81 | 9 5 4 82 | 4 83 | 1 2 3 6 84 | 4 85 | 8 9 4 6 86 | 3 87 | 6 5 4 88 | 3 89 | 5 8 8 90 | 5 91 | 1 4 3 1 2 92 | 6 93 | 7 7 7 7 7 9 94 | 4 95 | 8 4 3 7 96 | 2 97 | 9 9 98 | 5 99 | 2 5 2 1 1 100 | 4 101 | 8 9 5 6 102 | 3 103 | 9 5 1 104 | 4 105 | 9 9 9 9 106 | 5 107 | 3 4 3 2 4 108 | 5 109 | 8 8 8 8 8 110 | 3 111 | 5 3 7 112 | 5 113 | 5 3 2 1 5 114 | 2 115 | 9 9 116 | 4 117 | 7 1 7 4 118 | 2 119 | 2 1 120 | 3 121 | 2 4 5 122 | 4 123 | 8 4 5 8 124 | 3 125 | 8 4 3 126 | 1 127 | 4 128 | 5 129 | 9 9 9 9 9 130 | 4 131 | 7 5 1 6 132 | 6 133 | 3 6 6 6 9 9 134 | 5 135 | 5 5 2 5 2 136 | 3 137 | 9 1 4 138 | 3 139 | 7 5 3 140 | 3 141 | 7 8 6 142 | 6 143 | 1 1 5 5 9 9 144 | 5 145 | 5 1 2 4 1 146 | 2 147 | 8 4 148 | 4 149 | 3 1 4 8 150 | 3 151 | 9 6 1 152 | 4 153 | 2 6 6 4 154 | 2 155 | 6 6 156 | 2 157 | 4 8 158 | 4 159 | 5 1 3 1 160 | 1 161 | 7 162 | 3 163 | 8 3 4 164 | 5 165 | 2 3 4 5 1 166 | 5 167 | 3 5 1 1 1 168 | 4 169 | 4 3 2 1 170 | 6 171 | 9 9 9 9 9 9 172 | 5 173 | 1 3 2 2 4 174 | 3 175 | 5 2 7 176 | 4 177 | 8 9 3 6 178 | 6 179 | 5 5 5 9 9 9 180 | 4 181 | 4 9 7 3 182 | 3 183 | 2 7 1 184 | 2 185 | 4 9 186 | 5 187 | 6 2 3 6 5 188 | 3 189 | 1 9 8 190 | 4 191 | 5 1 1 6 192 | 5 193 | 3 5 2 5 3 194 | 1 195 | 6 196 | 2 197 | 8 8 198 | 1 199 | 8 200 | 3 201 | 7 4 2 202 | -------------------------------------------------------------------------------- /2015/qualification_round/B/B-small-attempt1.in: -------------------------------------------------------------------------------- 1 | 100 2 | 1 3 | 3 4 | 4 5 | 1 2 1 2 6 | 1 7 | 4 8 | 5 9 | 6 6 4 6 9 10 | 5 11 | 8 8 8 8 8 12 | 3 13 | 1 7 3 14 | 3 15 | 6 6 5 16 | 2 17 | 5 5 18 | 3 19 | 1 7 7 20 | 6 21 | 6 5 4 3 2 1 22 | 5 23 | 1 5 4 5 4 24 | 4 25 | 1 5 4 4 26 | 4 27 | 2 2 1 1 28 | 6 29 | 9 9 9 9 9 9 30 | 3 31 | 4 8 2 32 | 6 33 | 3 6 6 6 9 9 34 | 6 35 | 6 6 6 6 9 9 36 | 3 37 | 9 5 1 38 | 3 39 | 1 7 9 40 | 6 41 | 2 9 9 9 3 3 42 | 2 43 | 2 1 44 | 3 45 | 6 3 8 46 | 3 47 | 5 5 9 48 | 2 49 | 8 8 50 | 3 51 | 8 3 4 52 | 5 53 | 4 1 2 2 5 54 | 6 55 | 7 7 7 7 7 9 56 | 4 57 | 3 4 2 7 58 | 5 59 | 9 9 9 9 9 60 | 2 61 | 4 9 62 | 5 63 | 5 2 8 8 5 64 | 2 65 | 9 7 66 | 2 67 | 6 6 68 | 3 69 | 2 8 6 70 | 4 71 | 4 1 6 4 72 | 3 73 | 1 6 5 74 | 5 75 | 1 5 5 5 3 76 | 3 77 | 3 2 1 78 | 4 79 | 1 9 2 4 80 | 4 81 | 6 9 6 5 82 | 6 83 | 3 3 5 5 9 9 84 | 1 85 | 5 86 | 5 87 | 5 5 3 2 5 88 | 1 89 | 4 90 | 4 91 | 5 4 2 6 92 | 5 93 | 5 4 3 2 1 94 | 5 95 | 1 3 2 4 2 96 | 4 97 | 8 1 4 1 98 | 3 99 | 1 3 3 100 | 3 101 | 4 9 4 102 | 1 103 | 9 104 | 3 105 | 7 5 3 106 | 4 107 | 8 1 2 5 108 | 1 109 | 6 110 | 5 111 | 3 1 1 3 3 112 | 4 113 | 1 1 8 3 114 | 4 115 | 9 3 7 2 116 | 2 117 | 9 9 118 | 4 119 | 2 9 3 8 120 | 6 121 | 5 5 5 5 9 9 122 | 6 123 | 1 1 5 5 9 9 124 | 3 125 | 3 7 6 126 | 4 127 | 8 8 8 8 128 | 3 129 | 6 6 6 130 | 4 131 | 4 3 2 1 132 | 2 133 | 9 8 134 | 5 135 | 2 2 3 2 1 136 | 5 137 | 1 5 1 4 4 138 | 3 139 | 9 1 5 140 | 3 141 | 3 1 4 142 | 3 143 | 7 6 1 144 | 3 145 | 8 5 2 146 | 5 147 | 1 5 1 4 5 148 | 4 149 | 4 6 4 9 150 | 5 151 | 4 2 5 9 2 152 | 2 153 | 8 4 154 | 4 155 | 6 7 3 3 156 | 2 157 | 7 7 158 | 5 159 | 5 2 5 5 1 160 | 3 161 | 9 9 9 162 | 4 163 | 2 6 1 5 164 | 3 165 | 1 2 7 166 | 6 167 | 5 6 9 6 9 6 168 | 3 169 | 6 5 4 170 | 2 171 | 9 6 172 | 3 173 | 8 8 8 174 | 4 175 | 4 6 7 2 176 | 4 177 | 4 5 8 2 178 | 6 179 | 5 5 5 9 9 9 180 | 3 181 | 6 8 6 182 | 3 183 | 9 6 4 184 | 1 185 | 8 186 | 2 187 | 4 8 188 | 1 189 | 1 190 | 4 191 | 5 3 4 8 192 | 4 193 | 1 1 6 8 194 | 4 195 | 9 9 9 9 196 | 1 197 | 7 198 | 2 199 | 9 9 200 | 4 201 | 2 9 9 2 202 | -------------------------------------------------------------------------------- /2015/qualification_round/B/input_dbg: -------------------------------------------------------------------------------- 1 | 10 2 | 3 | 10 4 | 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 5 | 6 | 6 7 | 9 9 9 9 9 9 8 | 9 | 6 10 | 9 1 1 1 1 1 11 | 12 | 2 13 | 9 3 14 | 15 | 1 16 | 8 17 | 18 | 2 19 | 8 8 20 | 21 | 3 22 | 20 18 5 23 | 24 | 3 25 | 19 17 4 26 | 27 | 1 28 | 33 29 | 30 | 7 31 | 99 77 65 34 2 1 1 -------------------------------------------------------------------------------- /2015/qualification_round/B/input_example: -------------------------------------------------------------------------------- 1 | 3 2 | 1 3 | 3 4 | 4 5 | 1 2 1 2 6 | 1 7 | 4 -------------------------------------------------------------------------------- /2015/qualification_round/B/output_dbg: -------------------------------------------------------------------------------- 1 | Case #1: 190 2 | Case #2: 9 3 | Case #3: 5 4 | Case #4: 5 5 | Case #5: 5 6 | Case #6: 6 7 | Case #7: 11 8 | Case #8: 11 9 | Case #9: 11 10 | Case #10: 30 11 | -------------------------------------------------------------------------------- /2015/qualification_round/B/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 3 2 | Case #2: 2 3 | Case #3: 3 4 | -------------------------------------------------------------------------------- /2015/qualification_round/C/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: NO 2 | Case #2: YES 3 | Case #3: NO 4 | Case #4: NO 5 | Case #5: NO 6 | Case #6: NO 7 | Case #7: NO 8 | Case #8: YES 9 | Case #9: NO 10 | Case #10: NO 11 | Case #11: NO 12 | Case #12: NO 13 | Case #13: YES 14 | Case #14: NO 15 | Case #15: NO 16 | Case #16: NO 17 | Case #17: YES 18 | Case #18: NO 19 | Case #19: NO 20 | Case #20: NO 21 | Case #21: NO 22 | Case #22: YES 23 | Case #23: NO 24 | Case #24: NO 25 | Case #25: NO 26 | Case #26: NO 27 | Case #27: YES 28 | Case #28: NO 29 | Case #29: YES 30 | Case #30: YES 31 | Case #31: YES 32 | Case #32: YES 33 | Case #33: YES 34 | Case #34: NO 35 | Case #35: YES 36 | Case #36: YES 37 | Case #37: YES 38 | Case #38: YES 39 | Case #39: YES 40 | Case #40: NO 41 | Case #41: NO 42 | Case #42: NO 43 | Case #43: YES 44 | Case #44: YES 45 | Case #45: NO 46 | Case #46: YES 47 | Case #47: NO 48 | Case #48: YES 49 | Case #49: NO 50 | Case #50: YES 51 | Case #51: YES 52 | Case #52: NO 53 | Case #53: NO 54 | Case #54: YES 55 | Case #55: NO 56 | Case #56: NO 57 | Case #57: NO 58 | Case #58: NO 59 | Case #59: NO 60 | Case #60: YES 61 | Case #61: YES 62 | Case #62: YES 63 | Case #63: NO 64 | Case #64: YES 65 | Case #65: YES 66 | Case #66: NO 67 | Case #67: NO 68 | Case #68: NO 69 | Case #69: NO 70 | Case #70: YES 71 | Case #71: NO 72 | Case #72: NO 73 | Case #73: NO 74 | Case #74: NO 75 | Case #75: NO 76 | Case #76: NO 77 | Case #77: NO 78 | Case #78: NO 79 | Case #79: NO 80 | Case #80: NO 81 | Case #81: YES 82 | Case #82: NO 83 | Case #83: YES 84 | Case #84: NO 85 | Case #85: NO 86 | Case #86: NO 87 | Case #87: YES 88 | Case #88: NO 89 | Case #89: NO 90 | Case #90: YES 91 | Case #91: YES 92 | Case #92: NO 93 | Case #93: NO 94 | Case #94: YES 95 | Case #95: NO 96 | Case #96: NO 97 | Case #97: NO 98 | Case #98: YES 99 | Case #99: YES 100 | Case #100: NO 101 | -------------------------------------------------------------------------------- /2015/qualification_round/C/0-kai-large/out: -------------------------------------------------------------------------------- 1 | Case #1: NO 2 | Case #2: YES 3 | Case #3: YES 4 | Case #4: YES 5 | Case #5: YES 6 | Case #6: YES 7 | Case #7: NO 8 | Case #8: NO 9 | Case #9: NO 10 | Case #10: YES 11 | Case #11: NO 12 | Case #12: NO 13 | Case #13: NO 14 | Case #14: NO 15 | Case #15: YES 16 | Case #16: YES 17 | Case #17: NO 18 | Case #18: YES 19 | Case #19: NO 20 | Case #20: NO 21 | Case #21: NO 22 | Case #22: YES 23 | Case #23: YES 24 | Case #24: NO 25 | Case #25: YES 26 | Case #26: YES 27 | Case #27: NO 28 | Case #28: NO 29 | Case #29: YES 30 | Case #30: NO 31 | Case #31: YES 32 | Case #32: YES 33 | Case #33: NO 34 | Case #34: NO 35 | Case #35: NO 36 | Case #36: YES 37 | Case #37: NO 38 | Case #38: YES 39 | Case #39: YES 40 | Case #40: NO 41 | Case #41: NO 42 | Case #42: YES 43 | Case #43: YES 44 | Case #44: YES 45 | Case #45: NO 46 | Case #46: NO 47 | Case #47: NO 48 | Case #48: YES 49 | Case #49: NO 50 | Case #50: NO 51 | Case #51: NO 52 | Case #52: YES 53 | Case #53: YES 54 | Case #54: YES 55 | Case #55: YES 56 | Case #56: YES 57 | Case #57: NO 58 | Case #58: YES 59 | Case #59: NO 60 | Case #60: YES 61 | Case #61: YES 62 | Case #62: YES 63 | Case #63: YES 64 | Case #64: YES 65 | Case #65: NO 66 | Case #66: NO 67 | Case #67: NO 68 | Case #68: YES 69 | Case #69: YES 70 | Case #70: NO 71 | Case #71: YES 72 | Case #72: YES 73 | Case #73: NO 74 | Case #74: NO 75 | Case #75: NO 76 | Case #76: NO 77 | Case #77: NO 78 | Case #78: NO 79 | Case #79: NO 80 | Case #80: NO 81 | Case #81: NO 82 | Case #82: NO 83 | Case #83: YES 84 | Case #84: YES 85 | Case #85: NO 86 | Case #86: YES 87 | Case #87: YES 88 | Case #88: NO 89 | Case #89: NO 90 | Case #90: YES 91 | Case #91: NO 92 | Case #92: NO 93 | Case #93: NO 94 | Case #94: YES 95 | Case #95: NO 96 | Case #96: NO 97 | Case #97: NO 98 | Case #98: NO 99 | Case #99: YES 100 | Case #100: YES 101 | -------------------------------------------------------------------------------- /2015/qualification_round/C/Untitled Document~: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2015/qualification_round/C/Untitled Document~ -------------------------------------------------------------------------------- /2015/qualification_round/C/input_dbg: -------------------------------------------------------------------------------- 1 | 7 2 | 2 1000000000000 3 | ij 4 | 2 999999999998 5 | ij 6 | 3 2 7 | ijkijk 8 | 3 3 9 | ijk 10 | 3 10000 11 | ijk 12 | 3 10001 13 | ijk 14 | 7 1323 15 | kikkiij 16 | -------------------------------------------------------------------------------- /2015/qualification_round/C/input_example: -------------------------------------------------------------------------------- 1 | 5 2 | 2 1 3 | ik 4 | 3 1 5 | ijk 6 | 3 1 7 | kji 8 | 2 6 9 | ji 10 | 1 10000 11 | i -------------------------------------------------------------------------------- /2015/qualification_round/C/output_example: -------------------------------------------------------------------------------- 1 | Case #1: NO 2 | Case #2: YES 3 | Case #3: NO 4 | Case #4: YES 5 | Case #5: NO 6 | -------------------------------------------------------------------------------- /2015/qualification_round/D/0-kai-1/D-small-attempt1.in: -------------------------------------------------------------------------------- 1 | 2 2 2 G 2 | 2 1 3 R 3 | 4 4 1 R 4 | 3 2 3 G 5 | 1 3 1 G 6 | 3 2 2 R 7 | 1 1 4 G 8 | 2 2 4 G 9 | 1 1 3 G 10 | 4 2 4 R 11 | 3 3 3 R 12 | 4 1 2 R 13 | 2 4 3 G 14 | 3 3 2 G 15 | 1 1 1 G 16 | 2 2 3 G 17 | 3 4 4 R 18 | 1 4 1 G 19 | 1 3 3 G 20 | 1 2 3 G 21 | 2 4 1 G 22 | 2 3 4 G 23 | 3 4 3 G 24 | 4 1 1 R 25 | 1 1 2 G 26 | 3 3 1 R 27 | 2 1 2 G 28 | 3 1 1 R 29 | 1 4 3 G 30 | 4 4 2 R 31 | 4 2 3 R 32 | 3 4 1 R 33 | 2 4 2 G 34 | 2 1 1 R 35 | 2 4 4 G 36 | 1 2 1 G 37 | 4 3 4 R 38 | 4 3 2 R 39 | 2 1 4 G 40 | 4 1 3 R 41 | 3 2 4 R 42 | 4 1 4 R 43 | 4 2 1 R 44 | 4 2 2 R 45 | 1 3 4 G 46 | 1 4 2 G 47 | 2 3 2 G 48 | 4 3 1 R 49 | 4 3 3 R 50 | 1 4 4 G 51 | 3 4 2 R 52 | 1 3 2 G 53 | 3 1 3 R 54 | 4 4 3 R 55 | 2 3 3 R 56 | 3 1 4 R 57 | 3 1 2 R 58 | 3 2 1 R 59 | 1 2 2 G 60 | 3 3 4 G 61 | 2 2 1 G 62 | 2 3 1 R 63 | 1 2 4 G 64 | 4 4 4 R 65 | -------------------------------------------------------------------------------- /2015/qualification_round/D/0-kai-1/new_out: -------------------------------------------------------------------------------- 1 | Case #1: GABRIEL 2 | Case #2: RICHARD 3 | Case #3: RICHARD 4 | Case #4: GABRIEL 5 | Case #5: GABRIEL 6 | Case #6: RICHARD 7 | Case #7: GABRIEL 8 | Case #8: GABRIEL 9 | Case #9: GABRIEL 10 | Case #10: RICHARD 11 | Case #11: RICHARD 12 | Case #12: RICHARD 13 | Case #13: GABRIEL 14 | Case #14: GABRIEL 15 | Case #15: GABRIEL 16 | Case #16: GABRIEL 17 | Case #17: RICHARD 18 | Case #18: GABRIEL 19 | Case #19: GABRIEL 20 | Case #20: GABRIEL 21 | Case #21: GABRIEL 22 | Case #22: GABRIEL 23 | Case #23: GABRIEL 24 | Case #24: RICHARD 25 | Case #25: GABRIEL 26 | Case #26: RICHARD 27 | Case #27: GABRIEL 28 | Case #28: RICHARD 29 | Case #29: GABRIEL 30 | Case #30: RICHARD 31 | Case #31: RICHARD 32 | Case #32: RICHARD 33 | Case #33: GABRIEL 34 | Case #34: RICHARD 35 | Case #35: GABRIEL 36 | Case #36: GABRIEL 37 | Case #37: RICHARD 38 | Case #38: RICHARD 39 | Case #39: GABRIEL 40 | Case #40: RICHARD 41 | Case #41: RICHARD 42 | Case #42: RICHARD 43 | Case #43: RICHARD 44 | Case #44: RICHARD 45 | Case #45: GABRIEL 46 | Case #46: GABRIEL 47 | Case #47: GABRIEL 48 | Case #48: RICHARD 49 | Case #49: RICHARD 50 | Case #50: GABRIEL 51 | Case #51: RICHARD 52 | Case #52: GABRIEL 53 | Case #53: RICHARD 54 | Case #54: RICHARD 55 | Case #55: RICHARD 56 | Case #56: RICHARD 57 | Case #57: RICHARD 58 | Case #58: RICHARD 59 | Case #59: GABRIEL 60 | Case #60: GABRIEL 61 | Case #61: GABRIEL 62 | Case #62: RICHARD 63 | Case #63: GABRIEL 64 | Case #64: RICHARD 65 | -------------------------------------------------------------------------------- /2015/qualification_round/D/0-kai-1/old_out: -------------------------------------------------------------------------------- 1 | Case #1: GABRIEL 2 | Case #2: RICHARD 3 | Case #3: RICHARD 4 | Case #4: GABRIEL 5 | Case #5: GABRIEL 6 | Case #6: RICHARD 7 | Case #7: GABRIEL 8 | Case #8: GABRIEL 9 | Case #9: GABRIEL 10 | Case #10: RICHARD 11 | Case #11: RICHARD 12 | Case #12: RICHARD 13 | Case #13: GABRIEL 14 | Case #14: GABRIEL 15 | Case #15: GABRIEL 16 | Case #16: GABRIEL 17 | Case #17: RICHARD 18 | Case #18: GABRIEL 19 | Case #19: GABRIEL 20 | Case #20: GABRIEL 21 | Case #21: GABRIEL 22 | Case #22: GABRIEL 23 | Case #23: GABRIEL 24 | Case #24: RICHARD 25 | Case #25: GABRIEL 26 | Case #26: RICHARD 27 | Case #27: GABRIEL 28 | Case #28: RICHARD 29 | Case #29: GABRIEL 30 | Case #30: RICHARD 31 | Case #31: RICHARD 32 | Case #32: RICHARD 33 | Case #33: GABRIEL 34 | Case #34: RICHARD 35 | Case #35: GABRIEL 36 | Case #36: GABRIEL 37 | Case #37: RICHARD 38 | Case #38: RICHARD 39 | Case #39: GABRIEL 40 | Case #40: RICHARD 41 | Case #41: RICHARD 42 | Case #42: RICHARD 43 | Case #43: RICHARD 44 | Case #44: RICHARD 45 | Case #45: GABRIEL 46 | Case #46: GABRIEL 47 | Case #47: GABRIEL 48 | Case #48: RICHARD 49 | Case #49: RICHARD 50 | Case #50: GABRIEL 51 | Case #51: RICHARD 52 | Case #52: GABRIEL 53 | Case #53: RICHARD 54 | Case #54: RICHARD 55 | Case #55: RICHARD 56 | Case #56: RICHARD 57 | Case #57: RICHARD 58 | Case #58: RICHARD 59 | Case #59: GABRIEL 60 | Case #60: GABRIEL 61 | Case #61: GABRIEL 62 | Case #62: RICHARD 63 | Case #63: GABRIEL 64 | Case #64: RICHARD 65 | -------------------------------------------------------------------------------- /2015/qualification_round/D/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: GABRIEL 2 | Case #2: RICHARD 3 | Case #3: RICHARD 4 | Case #4: GABRIEL 5 | Case #5: RICHARD 6 | Case #6: GABRIEL 7 | Case #7: GABRIEL 8 | Case #8: GABRIEL 9 | Case #9: GABRIEL 10 | Case #10: GABRIEL 11 | Case #11: RICHARD 12 | Case #12: GABRIEL 13 | Case #13: GABRIEL 14 | Case #14: RICHARD 15 | Case #15: GABRIEL 16 | Case #16: GABRIEL 17 | Case #17: GABRIEL 18 | Case #18: GABRIEL 19 | Case #19: GABRIEL 20 | Case #20: RICHARD 21 | Case #21: RICHARD 22 | Case #22: RICHARD 23 | Case #23: GABRIEL 24 | Case #24: GABRIEL 25 | Case #25: GABRIEL 26 | Case #26: RICHARD 27 | Case #27: RICHARD 28 | Case #28: RICHARD 29 | Case #29: GABRIEL 30 | Case #30: RICHARD 31 | Case #31: GABRIEL 32 | Case #32: RICHARD 33 | Case #33: RICHARD 34 | Case #34: GABRIEL 35 | Case #35: RICHARD 36 | Case #36: RICHARD 37 | Case #37: GABRIEL 38 | Case #38: GABRIEL 39 | Case #39: GABRIEL 40 | Case #40: GABRIEL 41 | Case #41: RICHARD 42 | Case #42: GABRIEL 43 | Case #43: GABRIEL 44 | Case #44: GABRIEL 45 | Case #45: GABRIEL 46 | Case #46: GABRIEL 47 | Case #47: RICHARD 48 | Case #48: GABRIEL 49 | Case #49: RICHARD 50 | Case #50: GABRIEL 51 | Case #51: RICHARD 52 | Case #52: RICHARD 53 | Case #53: GABRIEL 54 | Case #54: RICHARD 55 | Case #55: GABRIEL 56 | Case #56: RICHARD 57 | Case #57: RICHARD 58 | Case #58: GABRIEL 59 | Case #59: RICHARD 60 | Case #60: RICHARD 61 | Case #61: GABRIEL 62 | Case #62: GABRIEL 63 | Case #63: RICHARD 64 | Case #64: RICHARD 65 | -------------------------------------------------------------------------------- /2015/qualification_round/D/0-kai-1/sol.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | 6 | 7 | using std::cin; 8 | using std::cout; 9 | using std::endl; 10 | 11 | 12 | // ====== Global Variables ====== 13 | 14 | int X, R, C; 15 | 16 | 17 | // ------ Global Variables ------ 18 | 19 | 20 | 21 | int init_only_once() 22 | { 23 | 24 | return 0; 25 | } 26 | 27 | 28 | int init_per_case() 29 | { 30 | 31 | return 0; 32 | } 33 | 34 | int handle_input() 35 | { 36 | cin >> X >> R >> C; 37 | 38 | return 0; 39 | } 40 | 41 | 42 | // Return 0 if GABRIEL 43 | // Return 1 if RICHARD 44 | // 45 | // 1. Return 1 if (X > R && X > C) 46 | // 47 | // 2. Return 1 if (0 != (R * C) % X), since there is no way to fill 48 | // completely 49 | // 50 | // 3. Return 0 if 1 == X or 2 == X or 3 == X 51 | // 52 | // 4. When 4 == X 53 | // 54 | // 4.1 Return 1 if 1 == R or 1 == C or 2 == R or 2 == C 55 | // 56 | // 4.2 Return 0 57 | // 58 | // 59 | int run() 60 | { 61 | if (X > R && X > C) 62 | return 1; 63 | 64 | if (0 != (R * C) % X) 65 | return 1; 66 | 67 | if (1 == X || 2 == X) 68 | return 0; 69 | else if (3 == X) { 70 | if (1 == R || 1 == C) 71 | return 1; 72 | return 0; 73 | } else if (4 == X) { 74 | if (1 == R || 1 == C || 2 == R || 2 == C) 75 | return 1; 76 | return 0; 77 | } else { 78 | abort(); 79 | return 1; 80 | } 81 | } 82 | 83 | int main() 84 | { 85 | init_only_once(); 86 | 87 | int total_cases_count = 0; 88 | cin >> total_cases_count; 89 | 90 | int run_ret = 0; 91 | 92 | for (int tt = 1; tt <= total_cases_count; tt++) { 93 | 94 | handle_input(); 95 | 96 | init_per_case(); 97 | 98 | run_ret = run(); 99 | 100 | // if (3 == X) 101 | // cout << "X=" << X << " R=" << R << " C=" << C << endl; 102 | 103 | cout << "Case #" << tt << ": "; 104 | 105 | if (0 == run_ret) 106 | cout << "GABRIEL" << endl; 107 | else 108 | cout << "RICHARD" << endl; 109 | } 110 | 111 | 112 | return 0; 113 | } 114 | 115 | -------------------------------------------------------------------------------- /2015/qualification_round/D/0-kai-large/out: -------------------------------------------------------------------------------- 1 | Case #1: GABRIEL 2 | Case #2: RICHARD 3 | Case #3: RICHARD 4 | Case #4: GABRIEL 5 | Case #5: RICHARD 6 | Case #6: RICHARD 7 | Case #7: GABRIEL 8 | Case #8: GABRIEL 9 | Case #9: RICHARD 10 | Case #10: GABRIEL 11 | Case #11: RICHARD 12 | Case #12: RICHARD 13 | Case #13: RICHARD 14 | Case #14: RICHARD 15 | Case #15: RICHARD 16 | Case #16: RICHARD 17 | Case #17: GABRIEL 18 | Case #18: RICHARD 19 | Case #19: RICHARD 20 | Case #20: GABRIEL 21 | Case #21: RICHARD 22 | Case #22: RICHARD 23 | Case #23: GABRIEL 24 | Case #24: RICHARD 25 | Case #25: RICHARD 26 | Case #26: GABRIEL 27 | Case #27: RICHARD 28 | Case #28: RICHARD 29 | Case #29: RICHARD 30 | Case #30: RICHARD 31 | Case #31: RICHARD 32 | Case #32: GABRIEL 33 | Case #33: RICHARD 34 | Case #34: RICHARD 35 | Case #35: RICHARD 36 | Case #36: RICHARD 37 | Case #37: RICHARD 38 | Case #38: RICHARD 39 | Case #39: RICHARD 40 | Case #40: RICHARD 41 | Case #41: GABRIEL 42 | Case #42: GABRIEL 43 | Case #43: RICHARD 44 | Case #44: RICHARD 45 | Case #45: RICHARD 46 | Case #46: RICHARD 47 | Case #47: RICHARD 48 | Case #48: RICHARD 49 | Case #49: GABRIEL 50 | Case #50: RICHARD 51 | Case #51: RICHARD 52 | Case #52: RICHARD 53 | Case #53: GABRIEL 54 | Case #54: RICHARD 55 | Case #55: RICHARD 56 | Case #56: GABRIEL 57 | Case #57: RICHARD 58 | Case #58: RICHARD 59 | Case #59: RICHARD 60 | Case #60: RICHARD 61 | Case #61: RICHARD 62 | Case #62: GABRIEL 63 | Case #63: RICHARD 64 | Case #64: RICHARD 65 | Case #65: RICHARD 66 | Case #66: RICHARD 67 | Case #67: RICHARD 68 | Case #68: RICHARD 69 | Case #69: RICHARD 70 | Case #70: GABRIEL 71 | Case #71: RICHARD 72 | Case #72: RICHARD 73 | Case #73: GABRIEL 74 | Case #74: GABRIEL 75 | Case #75: RICHARD 76 | Case #76: GABRIEL 77 | Case #77: RICHARD 78 | Case #78: GABRIEL 79 | Case #79: RICHARD 80 | Case #80: RICHARD 81 | Case #81: GABRIEL 82 | Case #82: GABRIEL 83 | Case #83: GABRIEL 84 | Case #84: RICHARD 85 | Case #85: RICHARD 86 | Case #86: GABRIEL 87 | Case #87: RICHARD 88 | Case #88: RICHARD 89 | Case #89: RICHARD 90 | Case #90: RICHARD 91 | Case #91: RICHARD 92 | Case #92: GABRIEL 93 | Case #93: RICHARD 94 | Case #94: RICHARD 95 | Case #95: GABRIEL 96 | Case #96: RICHARD 97 | Case #97: GABRIEL 98 | Case #98: GABRIEL 99 | Case #99: GABRIEL 100 | Case #100: RICHARD 101 | -------------------------------------------------------------------------------- /2015/qualification_round/D/D-large.in: -------------------------------------------------------------------------------- 1 | 100 2 | 2 2 2 3 | 2 1 3 4 | 4 4 1 5 | 3 2 3 6 | 5 3 5 7 | 7 2 7 8 | 5 4 15 9 | 6 12 12 10 | 5 7 7 11 | 5 6 10 12 | 8 8 8 13 | 7 14 4 14 | 10 5 20 15 | 4 3 2 16 | 7 4 7 17 | 16 8 8 18 | 2 4 4 19 | 14 7 8 20 | 6 3 20 21 | 6 6 5 22 | 5 4 4 23 | 3 1 3 24 | 2 1 4 25 | 7 7 7 26 | 4 1 4 27 | 5 10 5 28 | 6 10 3 29 | 5 3 8 30 | 8 4 4 31 | 7 14 5 32 | 12 12 2 33 | 6 6 6 34 | 4 3 3 35 | 7 5 7 36 | 3 2 2 37 | 8 10 11 38 | 10 10 10 39 | 11 11 11 40 | 5 2 20 41 | 7 3 7 42 | 6 4 9 43 | 5 10 10 44 | 3 4 4 45 | 18 15 18 46 | 5 20 1 47 | 8 16 6 48 | 17 4 5 49 | 6 6 3 50 | 5 5 6 51 | 5 5 3 52 | 2 3 3 53 | 7 1 7 54 | 5 10 7 55 | 6 4 20 56 | 18 12 15 57 | 5 20 20 58 | 7 14 20 59 | 5 2 5 60 | 7 6 7 61 | 2 1 1 62 | 19 19 19 63 | 6 18 18 64 | 19 19 10 65 | 4 2 4 66 | 5 15 2 67 | 18 6 9 68 | 6 3 8 69 | 20 17 14 70 | 18 3 6 71 | 4 4 3 72 | 6 5 5 73 | 6 18 1 74 | 5 15 3 75 | 1 1 1 76 | 19 19 1 77 | 5 20 4 78 | 5 5 1 79 | 4 4 4 80 | 20 20 20 81 | 6 9 2 82 | 2 4 1 83 | 5 10 4 84 | 5 3 20 85 | 9 9 9 86 | 13 16 10 87 | 5 20 5 88 | 18 9 12 89 | 6 3 4 90 | 10 10 1 91 | 6 20 20 92 | 10 15 5 93 | 5 4 5 94 | 20 10 16 95 | 8 7 1 96 | 3 3 4 97 | 5 2 10 98 | 5 3 10 99 | 6 4 6 100 | 5 5 5 101 | 15 10 9 102 | -------------------------------------------------------------------------------- /2015/qualification_round/D/D-small-attempt0.in: -------------------------------------------------------------------------------- 1 | 64 2 | 2 2 2 3 | 2 1 3 4 | 4 4 1 5 | 3 2 3 6 | 2 3 1 7 | 4 3 1 8 | 3 4 2 9 | 4 2 1 10 | 1 4 4 11 | 3 4 4 12 | 1 3 4 13 | 2 2 4 14 | 3 1 3 15 | 3 2 4 16 | 2 3 3 17 | 4 1 3 18 | 1 2 1 19 | 2 2 1 20 | 2 3 2 21 | 4 4 2 22 | 3 3 4 23 | 1 2 4 24 | 2 1 4 25 | 4 4 4 26 | 1 1 2 27 | 4 4 3 28 | 2 2 3 29 | 2 1 1 30 | 4 1 4 31 | 2 3 4 32 | 1 1 4 33 | 1 4 2 34 | 3 1 2 35 | 3 1 1 36 | 1 1 1 37 | 1 2 2 38 | 3 3 1 39 | 1 4 1 40 | 3 4 1 41 | 1 4 3 42 | 4 1 1 43 | 4 3 4 44 | 1 3 2 45 | 4 2 4 46 | 4 1 2 47 | 2 4 2 48 | 3 2 2 49 | 4 3 2 50 | 3 2 1 51 | 3 3 3 52 | 2 4 4 53 | 3 4 3 54 | 1 1 3 55 | 3 3 2 56 | 2 4 3 57 | 1 3 1 58 | 4 3 3 59 | 2 1 2 60 | 1 3 3 61 | 3 1 4 62 | 4 2 2 63 | 1 2 3 64 | 4 2 3 65 | 2 4 1 66 | -------------------------------------------------------------------------------- /2015/qualification_round/D/D-small-attempt1.in: -------------------------------------------------------------------------------- 1 | 64 2 | 2 2 2 3 | 2 1 3 4 | 4 4 1 5 | 3 2 3 6 | 1 3 1 7 | 3 2 2 8 | 1 1 4 9 | 2 2 4 10 | 1 1 3 11 | 4 2 4 12 | 3 3 3 13 | 4 1 2 14 | 2 4 3 15 | 3 3 2 16 | 1 1 1 17 | 2 2 3 18 | 3 4 4 19 | 1 4 1 20 | 1 3 3 21 | 1 2 3 22 | 2 4 1 23 | 2 3 4 24 | 3 4 3 25 | 4 1 1 26 | 1 1 2 27 | 3 3 1 28 | 2 1 2 29 | 3 1 1 30 | 1 4 3 31 | 4 4 2 32 | 4 2 3 33 | 3 4 1 34 | 2 4 2 35 | 2 1 1 36 | 2 4 4 37 | 1 2 1 38 | 4 3 4 39 | 4 3 2 40 | 2 1 4 41 | 4 1 3 42 | 3 2 4 43 | 4 1 4 44 | 4 2 1 45 | 4 2 2 46 | 1 3 4 47 | 1 4 2 48 | 2 3 2 49 | 4 3 1 50 | 4 3 3 51 | 1 4 4 52 | 3 4 2 53 | 1 3 2 54 | 3 1 3 55 | 4 4 3 56 | 2 3 3 57 | 3 1 4 58 | 3 1 2 59 | 3 2 1 60 | 1 2 2 61 | 3 3 4 62 | 2 2 1 63 | 2 3 1 64 | 1 2 4 65 | 4 4 4 66 | -------------------------------------------------------------------------------- /2015/qualification_round/D/D-small-attempt2.in: -------------------------------------------------------------------------------- 1 | 64 2 | 2 2 2 3 | 2 1 3 4 | 4 4 1 5 | 3 2 3 6 | 3 2 2 7 | 1 1 3 8 | 3 3 3 9 | 3 3 4 10 | 3 3 2 11 | 1 2 2 12 | 2 3 3 13 | 2 1 4 14 | 1 1 2 15 | 3 2 1 16 | 2 2 4 17 | 1 4 3 18 | 2 3 4 19 | 2 2 3 20 | 1 4 2 21 | 4 1 2 22 | 2 3 1 23 | 4 2 3 24 | 2 2 1 25 | 2 4 3 26 | 4 4 4 27 | 3 4 2 28 | 2 1 1 29 | 4 3 1 30 | 1 4 4 31 | 3 1 1 32 | 1 2 3 33 | 4 2 2 34 | 3 2 4 35 | 2 1 2 36 | 3 1 4 37 | 3 1 3 38 | 3 4 3 39 | 4 4 3 40 | 1 3 2 41 | 2 3 2 42 | 4 3 3 43 | 4 3 4 44 | 1 3 1 45 | 2 4 4 46 | 1 1 1 47 | 2 4 2 48 | 4 2 1 49 | 2 4 1 50 | 4 1 4 51 | 1 2 1 52 | 4 1 1 53 | 4 3 2 54 | 1 2 4 55 | 4 1 3 56 | 1 4 1 57 | 3 4 4 58 | 3 3 1 59 | 1 3 4 60 | 3 4 1 61 | 4 2 4 62 | 1 1 4 63 | 1 3 3 64 | 3 1 2 65 | 4 4 2 66 | -------------------------------------------------------------------------------- /2015/qualification_round/D/input_dbg: -------------------------------------------------------------------------------- 1 | 9 2 | 1 99 99 3 | 2 99 99 4 | 2 100 100 5 | 3 1 2 6 | 3 1 3 7 | 3 2 3 8 | 3 3 3 9 | 4 123 123123 10 | 4 2 2 11 | -------------------------------------------------------------------------------- /2015/qualification_round/D/input_example: -------------------------------------------------------------------------------- 1 | 4 2 | 2 2 2 3 | 2 1 3 4 | 4 4 1 5 | 3 2 3 -------------------------------------------------------------------------------- /2015/qualification_round/D/output_dbg: -------------------------------------------------------------------------------- 1 | Case #1: GABRIEL 2 | Case #2: RICHARD 3 | Case #3: GABRIEL 4 | Case #4: RICHARD 5 | Case #5: RICHARD 6 | Case #6: GABRIEL 7 | Case #7: RICHARD 8 | Case #8: RICHARD 9 | Case #9: RICHARD 10 | -------------------------------------------------------------------------------- /2015/qualification_round/D/output_example: -------------------------------------------------------------------------------- 1 | Case #1: GABRIEL 2 | Case #2: RICHARD 3 | Case #3: RICHARD 4 | Case #4: GABRIEL 5 | -------------------------------------------------------------------------------- /2015/round_1a/A/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: 15 25 2 | Case #2: 0 0 3 | Case #3: 81 567 4 | Case #4: 181 244 5 | Case #5: 0 0 6 | Case #6: 5000000 5000000 7 | Case #7: 10000 9990000 8 | Case #8: 15838 18541 9 | Case #9: 10524 24010 10 | Case #10: 15399 32947 11 | Case #11: 13428 29908 12 | Case #12: 15682 32807 13 | Case #13: 16435 45398 14 | Case #14: 16304 58031 15 | Case #15: 29079 45728 16 | Case #16: 20110 45916 17 | Case #17: 21853 57062 18 | Case #18: 26456 55819 19 | Case #19: 16754 80750 20 | Case #20: 24039 72335 21 | Case #21: 21139 67793 22 | Case #22: 26807 83204 23 | Case #23: 23964 83553 24 | Case #24: 37013 95166 25 | Case #25: 29325 108159 26 | Case #26: 43940 111183 27 | Case #27: 37407 97004 28 | Case #28: 33431 123410 29 | Case #29: 38305 132687 30 | Case #30: 37715 105215 31 | Case #31: 46492 118432 32 | Case #32: 52022 113610 33 | Case #33: 46626 146626 34 | Case #34: 52513 127286 35 | Case #35: 52598 173012 36 | Case #36: 51924 153607 37 | Case #37: 45922 166285 38 | Case #38: 48485 170373 39 | Case #39: 46847 142320 40 | Case #40: 58260 183316 41 | Case #41: 64599 165118 42 | Case #42: 57336 211717 43 | Case #43: 64737 156727 44 | Case #44: 66619 207147 45 | Case #45: 73641 216296 46 | Case #46: 70409 209337 47 | Case #47: 52113 175760 48 | Case #48: 69266 168581 49 | Case #49: 67951 210297 50 | Case #50: 62794 192406 51 | Case #51: 70840 244069 52 | Case #52: 70468 244323 53 | Case #53: 72180 234279 54 | Case #54: 1618533 4983363 55 | Case #55: 1708897 4823314 56 | Case #56: 1588473 4849010 57 | Case #57: 1633822 4960983 58 | Case #58: 1703202 4995800 59 | Case #59: 1784058 4939146 60 | Case #60: 1660038 4947149 61 | Case #61: 1609529 5078460 62 | Case #62: 1707527 4955790 63 | Case #63: 1602956 4943241 64 | Case #64: 1660534 4882592 65 | Case #65: 1685143 5001612 66 | Case #66: 1698598 5047009 67 | Case #67: 1698810 5046979 68 | Case #68: 1718545 4929950 69 | Case #69: 1641197 4869611 70 | Case #70: 1685283 5048108 71 | Case #71: 1760396 4947953 72 | Case #72: 1615332 4933522 73 | Case #73: 1611434 5024065 74 | Case #74: 1673937 4943480 75 | Case #75: 1675119 5037153 76 | Case #76: 1673192 5021661 77 | Case #77: 1666757 5193257 78 | Case #78: 1693374 5202624 79 | Case #79: 1673133 4829299 80 | Case #80: 1654816 4995225 81 | Case #81: 1686491 4972282 82 | Case #82: 1748391 4921893 83 | Case #83: 1647213 4968542 84 | Case #84: 1580439 4927482 85 | Case #85: 1660109 4858715 86 | Case #86: 1721271 4927126 87 | Case #87: 1690080 5001796 88 | Case #88: 1628079 5022513 89 | Case #89: 1633476 4835428 90 | Case #90: 1651882 4972938 91 | Case #91: 1699924 4995266 92 | Case #92: 1664055 5024164 93 | Case #93: 1732967 5182160 94 | Case #94: 1700413 4904401 95 | Case #95: 1644976 4899403 96 | Case #96: 1675585 4870719 97 | Case #97: 1652871 4909555 98 | Case #98: 1644208 4978113 99 | Case #99: 1743486 4944730 100 | Case #100: 1736005 5030296 101 | -------------------------------------------------------------------------------- /2015/round_1a/A/0-kai-1/out_e: -------------------------------------------------------------------------------- 1 | Case #1: 15 25 2 | Case #2: 0 0 3 | Case #3: 81 567 4 | Case #4: 181 244 5 | -------------------------------------------------------------------------------- /2015/round_1a/A/0-kai-1/out_l: -------------------------------------------------------------------------------- 1 | Case #1: 15 25 2 | Case #2: 0 0 3 | Case #3: 81 567 4 | Case #4: 181 244 5 | Case #5: 0 0 6 | Case #6: 5000000 5000000 7 | Case #7: 10000 9990000 8 | Case #8: 15838 18541 9 | Case #9: 10524 24010 10 | Case #10: 15399 32947 11 | Case #11: 13428 29908 12 | Case #12: 15682 32807 13 | Case #13: 16435 45398 14 | Case #14: 16304 58031 15 | Case #15: 29079 45728 16 | Case #16: 20110 45916 17 | Case #17: 21853 57062 18 | Case #18: 26456 55819 19 | Case #19: 16754 80750 20 | Case #20: 24039 72335 21 | Case #21: 21139 67793 22 | Case #22: 26807 83204 23 | Case #23: 23964 83553 24 | Case #24: 37013 95166 25 | Case #25: 29325 108159 26 | Case #26: 43940 111183 27 | Case #27: 37407 97004 28 | Case #28: 33431 123410 29 | Case #29: 38305 132687 30 | Case #30: 37715 105215 31 | Case #31: 46492 118432 32 | Case #32: 52022 113610 33 | Case #33: 46626 146626 34 | Case #34: 52513 127286 35 | Case #35: 52598 173012 36 | Case #36: 51924 153607 37 | Case #37: 45922 166285 38 | Case #38: 48485 170373 39 | Case #39: 46847 142320 40 | Case #40: 58260 183316 41 | Case #41: 64599 165118 42 | Case #42: 57336 211717 43 | Case #43: 64737 156727 44 | Case #44: 66619 207147 45 | Case #45: 73641 216296 46 | Case #46: 70409 209337 47 | Case #47: 52113 175760 48 | Case #48: 69266 168581 49 | Case #49: 67951 210297 50 | Case #50: 62794 192406 51 | Case #51: 70840 244069 52 | Case #52: 70468 244323 53 | Case #53: 72180 234279 54 | Case #54: 1618533 4983363 55 | Case #55: 1708897 4823314 56 | Case #56: 1588473 4849010 57 | Case #57: 1633822 4960983 58 | Case #58: 1703202 4995800 59 | Case #59: 1784058 4939146 60 | Case #60: 1660038 4947149 61 | Case #61: 1609529 5078460 62 | Case #62: 1707527 4955790 63 | Case #63: 1602956 4943241 64 | Case #64: 1660534 4882592 65 | Case #65: 1685143 5001612 66 | Case #66: 1698598 5047009 67 | Case #67: 1698810 5046979 68 | Case #68: 1718545 4929950 69 | Case #69: 1641197 4869611 70 | Case #70: 1685283 5048108 71 | Case #71: 1760396 4947953 72 | Case #72: 1615332 4933522 73 | Case #73: 1611434 5024065 74 | Case #74: 1673937 4943480 75 | Case #75: 1675119 5037153 76 | Case #76: 1673192 5021661 77 | Case #77: 1666757 5193257 78 | Case #78: 1693374 5202624 79 | Case #79: 1673133 4829299 80 | Case #80: 1654816 4995225 81 | Case #81: 1686491 4972282 82 | Case #82: 1748391 4921893 83 | Case #83: 1647213 4968542 84 | Case #84: 1580439 4927482 85 | Case #85: 1660109 4858715 86 | Case #86: 1721271 4927126 87 | Case #87: 1690080 5001796 88 | Case #88: 1628079 5022513 89 | Case #89: 1633476 4835428 90 | Case #90: 1651882 4972938 91 | Case #91: 1699924 4995266 92 | Case #92: 1664055 5024164 93 | Case #93: 1732967 5182160 94 | Case #94: 1700413 4904401 95 | Case #95: 1644976 4899403 96 | Case #96: 1675585 4870719 97 | Case #97: 1652871 4909555 98 | Case #98: 1644208 4978113 99 | Case #99: 1743486 4944730 100 | Case #100: 1736005 5030296 101 | -------------------------------------------------------------------------------- /2015/round_1a/A/0-kai-1/sol.cc: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | #include 5 | 6 | 7 | using std::cin; 8 | using std::cout; 9 | using std::endl; 10 | 11 | 12 | // ====== Defines ====== 13 | 14 | #define N_MAX_SIZE 1001 15 | 16 | // ------ Defines ------ 17 | 18 | 19 | // ====== Types ====== 20 | 21 | 22 | // ------ Types ------ 23 | 24 | 25 | // ====== Global Variables ====== 26 | 27 | int N; 28 | int arr[N_MAX_SIZE]; 29 | 30 | int max_speed; 31 | long long ret1, ret2; 32 | 33 | // ------ Global Variables ------ 34 | 35 | 36 | int init_only_once() 37 | { 38 | return 0; 39 | } 40 | 41 | int handle_input() 42 | { 43 | cin >> N; 44 | 45 | for (int i = 1; i <= N; i++) 46 | cin >> arr[i]; 47 | 48 | return 0; 49 | } 50 | 51 | int init_per_case() 52 | { 53 | return 0; 54 | } 55 | 56 | void get_first_result() 57 | { 58 | int speed = 0; 59 | ret1 = 0; 60 | max_speed = 0; 61 | 62 | for (int i = 2; i <= N; i++) { 63 | speed = arr[i - 1] - arr[i]; 64 | if (0 < speed) { 65 | ret1 += speed; 66 | max_speed = std::max(max_speed, speed); 67 | } 68 | } 69 | } 70 | 71 | void get_second_result() 72 | { 73 | int add = 0; 74 | ret2 = 0; 75 | 76 | for (int i = 1; i <= N - 1; i++) { 77 | if (arr[i] <= max_speed) 78 | ret2 += arr[i]; 79 | else 80 | ret2 += max_speed; 81 | } 82 | } 83 | 84 | int run() 85 | { 86 | get_first_result(); 87 | get_second_result(); 88 | 89 | return 0; 90 | } 91 | 92 | int main() 93 | { 94 | init_only_once(); 95 | 96 | int total_cases_count = 0; 97 | cin >> total_cases_count; 98 | 99 | int run_ret = 0; 100 | 101 | for (int tt = 1; tt <= total_cases_count; tt++) { 102 | 103 | handle_input(); 104 | 105 | init_per_case(); 106 | 107 | run_ret = run(); 108 | 109 | cout << "Case #" << tt << ": " << ret1 << " " << ret2 << endl; 110 | } 111 | 112 | 113 | return 0; 114 | } 115 | 116 | -------------------------------------------------------------------------------- /2015/round_1a/A/input_dbg: -------------------------------------------------------------------------------- 1 | 3 2 | 3 | 5 4 | 1 1 1 1 1 5 | 6 | 5 7 | 1 2 3 4 5 8 | 9 | 5 10 | 5 4 3 2 1 11 | 12 | 13 | -------------------------------------------------------------------------------- /2015/round_1a/A/input_example: -------------------------------------------------------------------------------- 1 | 4 2 | 4 3 | 10 5 15 5 4 | 2 5 | 100 100 6 | 8 7 | 81 81 81 81 81 81 81 0 8 | 6 9 | 23 90 40 0 100 9 10 | -------------------------------------------------------------------------------- /2015/round_1a/A/output_dbg: -------------------------------------------------------------------------------- 1 | Case #1: 0 0 2 | Case #2: 0 0 3 | Case #3: 4 4 4 | -------------------------------------------------------------------------------- /2015/round_1a/A/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 15 25 2 | Case #2: 0 0 3 | Case #3: 81 567 4 | Case #4: 181 244 5 | -------------------------------------------------------------------------------- /2015/round_1a/B/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: 1 2 | Case #2: 3 3 | Case #3: 2 4 | Case #4: 5 5 | Case #5: 2 6 | Case #6: 5 7 | Case #7: 1 8 | Case #8: 4 9 | Case #9: 3 10 | Case #10: 3 11 | Case #11: 2 12 | Case #12: 1 13 | Case #13: 5 14 | Case #14: 2 15 | Case #15: 2 16 | Case #16: 2 17 | Case #17: 2 18 | Case #18: 4 19 | Case #19: 4 20 | Case #20: 5 21 | Case #21: 5 22 | Case #22: 4 23 | Case #23: 2 24 | Case #24: 3 25 | Case #25: 4 26 | Case #26: 2 27 | Case #27: 5 28 | Case #28: 1 29 | Case #29: 4 30 | Case #30: 5 31 | Case #31: 1 32 | Case #32: 5 33 | Case #33: 1 34 | Case #34: 1 35 | Case #35: 1 36 | Case #36: 1 37 | Case #37: 4 38 | Case #38: 1 39 | Case #39: 1 40 | Case #40: 1 41 | Case #41: 2 42 | Case #42: 1 43 | Case #43: 2 44 | Case #44: 1 45 | Case #45: 1 46 | Case #46: 2 47 | Case #47: 2 48 | Case #48: 2 49 | Case #49: 5 50 | Case #50: 1 51 | Case #51: 1 52 | Case #52: 1 53 | Case #53: 3 54 | Case #54: 1 55 | Case #55: 3 56 | Case #56: 3 57 | Case #57: 2 58 | Case #58: 2 59 | Case #59: 1 60 | Case #60: 3 61 | Case #61: 1 62 | Case #62: 2 63 | Case #63: 2 64 | Case #64: 2 65 | Case #65: 2 66 | Case #66: 3 67 | Case #67: 1 68 | Case #68: 4 69 | Case #69: 4 70 | Case #70: 1 71 | Case #71: 2 72 | Case #72: 4 73 | Case #73: 4 74 | Case #74: 4 75 | Case #75: 5 76 | Case #76: 5 77 | Case #77: 2 78 | Case #78: 1 79 | Case #79: 1 80 | Case #80: 5 81 | Case #81: 5 82 | Case #82: 2 83 | Case #83: 3 84 | Case #84: 3 85 | Case #85: 2 86 | Case #86: 2 87 | Case #87: 4 88 | Case #88: 5 89 | Case #89: 4 90 | Case #90: 1 91 | Case #91: 4 92 | Case #92: 2 93 | Case #93: 2 94 | Case #94: 1 95 | Case #95: 2 96 | Case #96: 1 97 | Case #97: 1 98 | Case #98: 3 99 | Case #99: 2 100 | Case #100: 1 101 | -------------------------------------------------------------------------------- /2015/round_1a/B/0-kai-large/out: -------------------------------------------------------------------------------- 1 | Case #1: 1 2 | Case #2: 3 3 | Case #3: 2 4 | Case #4: 1000 5 | Case #5: 2 6 | Case #6: 5 7 | Case #7: 1 8 | Case #8: 4 9 | Case #9: 53 10 | Case #10: 768 11 | Case #11: 882 12 | Case #12: 61 13 | Case #13: 160 14 | Case #14: 117 15 | Case #15: 432 16 | Case #16: 157 17 | Case #17: 637 18 | Case #18: 19 19 | Case #19: 339 20 | Case #20: 485 21 | Case #21: 825 22 | Case #22: 284 23 | Case #23: 272 24 | Case #24: 708 25 | Case #25: 814 26 | Case #26: 437 27 | Case #27: 380 28 | Case #28: 411 29 | Case #29: 169 30 | Case #30: 25 31 | Case #31: 411 32 | Case #32: 750 33 | Case #33: 536 34 | Case #34: 53 35 | Case #35: 2 36 | Case #36: 23 37 | Case #37: 57 38 | Case #38: 34 39 | Case #39: 115 40 | Case #40: 773 41 | Case #41: 6 42 | Case #42: 95 43 | Case #43: 2 44 | Case #44: 98 45 | Case #45: 17 46 | Case #46: 125 47 | Case #47: 1 48 | Case #48: 2 49 | Case #49: 65 50 | Case #50: 1 51 | Case #51: 1 52 | Case #52: 9 53 | Case #53: 68 54 | Case #54: 95 55 | Case #55: 83 56 | Case #56: 208 57 | Case #57: 3 58 | Case #58: 4 59 | Case #59: 931 60 | Case #60: 636 61 | Case #61: 992 62 | Case #62: 596 63 | Case #63: 105 64 | Case #64: 331 65 | Case #65: 821 66 | Case #66: 28 67 | Case #67: 978 68 | Case #68: 857 69 | Case #69: 741 70 | Case #70: 548 71 | Case #71: 475 72 | Case #72: 509 73 | Case #73: 554 74 | Case #74: 613 75 | Case #75: 843 76 | Case #76: 889 77 | Case #77: 402 78 | Case #78: 31 79 | Case #79: 541 80 | Case #80: 323 81 | Case #81: 541 82 | Case #82: 634 83 | Case #83: 418 84 | Case #84: 41 85 | Case #85: 93 86 | Case #86: 971 87 | Case #87: 180 88 | Case #88: 726 89 | Case #89: 120 90 | Case #90: 656 91 | Case #91: 40 92 | Case #92: 33 93 | Case #93: 889 94 | Case #94: 681 95 | Case #95: 834 96 | Case #96: 211 97 | Case #97: 921 98 | Case #98: 109 99 | Case #99: 448 100 | Case #100: 229 101 | -------------------------------------------------------------------------------- /2015/round_1a/B/input_dbg: -------------------------------------------------------------------------------- 1 | 6 2 | 3 | 7 5 4 | 10 5 4 3 2 7 9 5 | 6 | 7 7 7 | 10 5 4 3 2 7 9 8 | 9 | 5 1000000000 10 | 25 25 25 25 25 11 | 12 | 5 714724053 13 | 10 10 10 10 10 14 | 15 | 1 15234523 16 | 2342 17 | 18 | 5 1000000000 19 | 25 24 23 19 17 20 | 21 | -------------------------------------------------------------------------------- /2015/round_1a/B/input_example: -------------------------------------------------------------------------------- 1 | 3 2 | 3 | 2 4 4 | 10 5 5 | 6 | 3 12 7 | 7 7 7 8 | 9 | 3 8 10 | 4 2 1 -------------------------------------------------------------------------------- /2015/round_1a/B/output_dbg: -------------------------------------------------------------------------------- 1 | Case #1: 5 2 | Case #2: 7 3 | Case #3: 5 4 | Case #4: 3 5 | Case #5: 1 6 | -------------------------------------------------------------------------------- /2015/round_1a/B/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 1 2 | Case #2: 3 3 | Case #3: 1 4 | -------------------------------------------------------------------------------- /2015/round_1a/B/problem.org: -------------------------------------------------------------------------------- 1 | * Problem B. Haircut 2 | 3 | 4 | ** Problem 5 | 6 | You are waiting in a long line to get a haircut at a trendy barber shop. 7 | The shop has _B_ barbers on duty, and they are numbered 1 through B. 8 | It always takes the _kth_ barber exactly _Mk_ minutes to cut a customer's hair, 9 | and a barber can only cut one customer's hair at a time. 10 | Once a barber finishes cutting hair, he is immediately free to help another customer. 11 | 12 | While the shop is open, the customer at the head of the queue always goes 13 | to the lowest-numbered barber who is available. When no barber is available, 14 | that customer waits until at least one becomes available. 15 | 16 | You are the _Nth_ person in line, and the shop has just opened. 17 | 18 | Which barber will cut your hair? 19 | 20 | 21 | ** Input 22 | 23 | The first line of the input gives the number of test cases, T. 24 | T test cases follow; 25 | each consists of two lines. 26 | The first contains two space-separated integers B and N -- the number of barbers and your place in line. 27 | The customer at the head of the line is number 1, the next one is number 2, and so on. 28 | The second line contains M1, M2, ..., MB. 29 | 30 | 31 | 32 | ** Output 33 | 34 | For each test case, output one line containing "Case #x: y", 35 | where x is the test case number (starting from 1) and 36 | 37 | y is the number of the barber who will cut your hair. 38 | 39 | 40 | ** Limits 41 | 42 | 1 ≤ T ≤ 100. 43 | 1 ≤ N ≤ 109. 44 | 45 | 46 | *** Small dataset 47 | 48 | 1 ≤ B ≤ 5. 49 | 1 ≤ Mk ≤ 25. 50 | 51 | *** Large dataset 52 | 53 | 1 ≤ B ≤ 1000. 54 | 1 ≤ Mk ≤ 100000. 55 | 56 | ** Sample 57 | 58 | *** Input 59 | 60 | 3 61 | 2 4 62 | 10 5 63 | 3 12 64 | 7 7 7 65 | 3 8 66 | 4 2 1 67 | 68 | *** Output 69 | 70 | Case #1: 1 71 | Case #2: 3 72 | Case #3: 1 73 | 74 | In Case #1, you are the fourth person in line, and barbers 1 and 2 take 10 and 5 minutes, 75 | respectively, to cut hair. When the shop opens, the first customer immediately has the 76 | choice of barbers 1 and 2, and she will choose the lowest-numbered barber, 1. 77 | The second customer will immediately be served by barber 2. 78 | The third customer will wait since there are no more free barbers. 79 | After 5 minutes, barber 2 will finish cutting the second customer's hair, 80 | and will serve the third customer. 81 | After 10 minutes, both barbers 1 and 2 will finish; 82 | you are next in line, and you will have the choice of barbers 1 and 2, and will choose 1. 83 | -------------------------------------------------------------------------------- /2015/round_1a/C/1-Burrunduk1/Burunduk1_2_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2015/round_1a/C/1-Burrunduk1/Burunduk1_2_0.zip -------------------------------------------------------------------------------- /2015/round_1a/C/1-Burrunduk1/Burunduk1_2_1.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2015/round_1a/C/1-Burrunduk1/Burunduk1_2_1.zip -------------------------------------------------------------------------------- /2015/round_1a/C/1-Burrunduk1/c.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Author: Sergey Kopeliovich (Burunduk30@gmail.com) 3 | * Date: 2015.04.18 4 | */ 5 | 6 | #include 7 | 8 | using namespace std; 9 | 10 | #define forn(i, n) for (int i = 0; i < (int)(n); i++) 11 | 12 | long double eps = 1e-15; 13 | 14 | void solve() 15 | { 16 | int n; 17 | cin >> n; 18 | int x[n], y[n]; 19 | forn(i, n) 20 | cin >> x[i] >> y[i]; 21 | 22 | long double a[2 * n]; 23 | 24 | forn(i, n) { 25 | int an = 0, ans = n - 1; 26 | forn(j, n) 27 | if (j != i) 28 | a[an++] = atan2l(y[j] - y[i], x[j] - x[i]); 29 | sort(a, a + an); 30 | forn(i, an) 31 | a[i + an] = a[i] + 2 * M_PI; 32 | /* 33 | forn(i, 2 * an) 34 | printf("%.3f ", (double)a[i]); 35 | puts(""); 36 | */ 37 | int l = 0, r = 0; 38 | forn(i, an) { 39 | while (l + 1 < 2 * an && a[l] - a[i] < eps) 40 | l++; 41 | while (r < 2 * an && a[r] - a[i] < M_PI - eps) 42 | r++; 43 | ans = min(ans, r - l); 44 | } 45 | printf("%d\n", ans); 46 | } 47 | } 48 | 49 | int main() 50 | { 51 | int tn; 52 | scanf("%d", &tn); 53 | forn(t, tn) { 54 | printf("Case #%d:\n", t + 1); 55 | solve(); 56 | } 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /2015/round_1a/C/1-Burrunduk1/c.cpp.back: -------------------------------------------------------------------------------- 1 | /** 2 | * Author: Sergey Kopeliovich (Burunduk30@gmail.com) 3 | * Date: 2015.04.18 4 | */ 5 | 6 | #include 7 | 8 | using namespace std; 9 | 10 | #define forn(i, n) for (int i = 0; i < (int)(n); i++) 11 | 12 | long double eps = 1e-15; 13 | 14 | void solve() { 15 | int n; 16 | cin >> n; 17 | int x[n], y[n]; 18 | forn(i, n) 19 | cin >> x[i] >> y[i]; 20 | long double a[2 * n]; 21 | forn(i, n) { 22 | int an = 0, ans = n - 1; 23 | forn(j, n) 24 | if (j != i) 25 | a[an++] = atan2l(y[j] - y[i], x[j] - x[i]); 26 | sort(a, a + an); 27 | forn(i, an) 28 | a[i + an] = a[i] + 2 * M_PI; 29 | /* 30 | forn(i, 2 * an) 31 | printf("%.3f ", (double)a[i]); 32 | puts(""); 33 | */ 34 | int l = 0, r = 0; 35 | forn(i, an) { 36 | while (l + 1 < 2 * an && a[l] - a[i] < eps) 37 | l++; 38 | while (r < 2 * an && a[r] - a[i] < M_PI - eps) 39 | r++; 40 | ans = min(ans, r - l); 41 | } 42 | printf("%d\n", ans); 43 | } 44 | } 45 | 46 | int main() { 47 | int tn; 48 | scanf("%d", &tn); 49 | forn(t, tn) { 50 | printf("Case #%d:\n", t + 1); 51 | solve(); 52 | } 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /2015/round_1a/C/input_dbg: -------------------------------------------------------------------------------- 1 | 5 2 | 3 | 1 4 | 1 1 5 | 6 | 2 7 | 1 1 8 | 1 0 9 | 10 | 2 11 | 1 1 12 | 0 1 13 | 14 | 3 15 | 0 0 16 | 1 0 17 | 1 1 18 | 19 | 4 20 | 1 1 21 | 1 2 22 | 1 3 23 | 1 4 24 | -------------------------------------------------------------------------------- /2015/round_1a/C/input_example: -------------------------------------------------------------------------------- 1 | 2 2 | 5 3 | 0 0 4 | 10 0 5 | 10 10 6 | 0 10 7 | 5 5 8 | 9 9 | 0 0 10 | 5 0 11 | 10 0 12 | 0 5 13 | 5 5 14 | 10 5 15 | 0 10 16 | 5 10 17 | 10 10 18 | -------------------------------------------------------------------------------- /2015/round_1a/C/output_dbg: -------------------------------------------------------------------------------- 1 | Case #1: 2 | 0 3 | Case #2: 4 | 0 5 | 0 6 | Case #3: 7 | 0 8 | 0 9 | Case #4: 10 | 0 11 | 0 12 | 0 13 | Case #5: 14 | 0 15 | 0 16 | 0 17 | 0 18 | -------------------------------------------------------------------------------- /2015/round_1a/C/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 2 | 0 3 | 0 4 | 0 5 | 0 6 | 1 7 | Case #2: 8 | 0 9 | 0 10 | 0 11 | 0 12 | 3 13 | 0 14 | 0 15 | 0 16 | 0 17 | -------------------------------------------------------------------------------- /2015/round_1a/C/problem.org: -------------------------------------------------------------------------------- 1 | * Problem C. Logging 2 | 3 | 4 | ** Problem 5 | 6 | A certain forest consists of _N trees_ , each of which is _inhabited by a squirrel_. 7 | 8 | The _boundary_ of the forest is the _convex polygon of smallest area which contains every tree_ , 9 | as if a giant rubber band had been stretched around the outside of the forest. 10 | 11 | Formally, every tree is a single point in two-dimensional space with unique coordinates (Xi, Yi), 12 | and the _boundary_ is the convex hull of those points. 13 | 14 | 15 | Some trees are on the _boundary_ of the forest, 16 | which means they are on an _edge_ or a _corner_ of the polygon. 17 | 18 | The squirrels wonder _how close their trees are to being on the boundary of the forest_ 19 | 20 | 21 | One at a time, each squirrel climbs down from its tree, examines the forest, 22 | 23 | and _determines the minimum number of trees that would need to be cut down for its own tree to be on the boundary_ 24 | 25 | It then writes that number down on a log. 26 | 27 | Determine the list of numbers written on the log. 28 | 29 | 30 | ** Input 31 | 32 | The first line of the input gives the number of test cases, T. 33 | T test cases follow; 34 | 35 | each consists of a single line with an integer _N_ , the number of trees, 36 | followed by _N_ lines with two space-separated integers Xi and Yi, 37 | the coordinates of each tree. 38 | 39 | No two trees will have the same coordinates. 40 | 41 | 42 | ** Output 43 | 44 | For each test case, output one line containing "Case #x:", 45 | 46 | followed by N lines with one integer each, 47 | where line i contains the number of trees that the squirrel living in tree i would need to cut down. 48 | 49 | ** Limits 50 | 51 | -10^6 ≤ Xi, Yi ≤ 10^6. 52 | 53 | 54 | *** Small dataset 55 | 56 | 1 ≤ T ≤ 100. 57 | 1 ≤ N ≤ 15. 58 | 59 | *** Large dataset 60 | 61 | 1 ≤ T ≤ 14. 62 | 1 ≤ N ≤ 3000. 63 | 64 | ** Sample 65 | 66 | 67 | *** Input 68 | 69 | 2 70 | 71 | 5 72 | 0 0 73 | 10 0 74 | 10 10 75 | 0 10 76 | 5 5 77 | 78 | 9 79 | 0 0 80 | 5 0 81 | 10 0 82 | 0 5 83 | 5 5 84 | 10 5 85 | 0 10 86 | 5 10 87 | 10 10 88 | 89 | 90 | *** Output 91 | 92 | 93 | Case #1: 94 | 0 95 | 0 96 | 0 97 | 0 98 | 1 99 | Case #2: 100 | 0 101 | 0 102 | 0 103 | 0 104 | 3 105 | 0 106 | 0 107 | 0 108 | 0 109 | 110 | 111 | In the first sample case, there are four trees forming a square, 112 | and a fifth tree inside the square. 113 | 114 | Since the first four trees are already on the boundary, 115 | the squirrels for those trees each write down 0. 116 | 117 | Since one tree needs to be cut down for the fifth tree to be on the boundary, 118 | the fifth squirrel writes down 1. 119 | 120 | -------------------------------------------------------------------------------- /2015/round_1b/A/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: 1 2 | Case #2: 19 3 | Case #3: 15 4 | Case #4: 343535 5 | Case #5: 1199985 6 | Case #6: 2999984 7 | Case #7: 29411 8 | Case #8: 2152207 9 | Case #9: 134433 10 | Case #10: 24444427 11 | Case #11: 3537 12 | Case #12: 24399 13 | Case #13: 23474 14 | Case #14: 34444419 15 | Case #15: 15436 16 | Case #16: 26665549 17 | Case #17: 259957 18 | Case #18: 1522207 19 | Case #19: 24444427 20 | Case #20: 6909893 21 | Case #21: 144636 22 | Case #22: 17888871 23 | Case #23: 3129846 24 | Case #24: 119987 25 | Case #25: 2816263 26 | Case #26: 29999982 27 | Case #27: 14433 28 | Case #28: 34444418 29 | Case #29: 28618415 30 | Case #30: 7373615 31 | Case #31: 3425 32 | Case #32: 24444427 33 | Case #33: 15435 34 | Case #34: 275492 35 | Case #35: 14444431 36 | Case #36: 29988 37 | Case #37: 22223305 38 | Case #38: 44434 39 | Case #39: 3436 40 | Case #40: 34436 41 | Case #41: 1522208 42 | Case #42: 299986 43 | Case #43: 113980 44 | Case #44: 23408399 45 | Case #45: 23881413 46 | Case #46: 1459207 47 | Case #47: 24555539 48 | Case #48: 74751 49 | Case #49: 144424 50 | Case #50: 15555540 51 | Case #51: 11999983 52 | Case #52: 20011093 53 | Case #53: 16666649 54 | Case #54: 17888871 55 | Case #55: 3232633 56 | Case #56: 1522208 57 | Case #57: 3412207 58 | Case #58: 32222205 59 | Case #59: 44433 60 | Case #60: 16666649 61 | Case #61: 3441207 62 | Case #62: 912953 63 | Case #63: 54592 64 | Case #64: 14444427 65 | Case #65: 14434 66 | Case #66: 20011093 67 | Case #67: 1674835 68 | Case #68: 3435 69 | Case #69: 34444426 70 | Case #70: 28877761 71 | Case #71: 1459208 72 | Case #72: 1674836 73 | Case #73: 278882 74 | Case #74: 2152208 75 | Case #75: 1452208 76 | Case #76: 3433 77 | Case #77: 1310786 78 | Case #78: 15434 79 | Case #79: 306652 80 | Case #80: 5232106 81 | Case #81: 32222205 82 | Case #82: 364736 83 | Case #83: 14444429 84 | Case #84: 3426 85 | Case #85: 1178142 86 | Case #86: 3424 87 | Case #87: 2152208 88 | Case #88: 3434 89 | Case #89: 1354735 90 | Case #90: 3052207 91 | Case #91: 13435 92 | Case #92: 24444427 93 | Case #93: 24434 94 | Case #94: 26665549 95 | Case #95: 34444427 96 | Case #96: 35435 97 | Case #97: 14444428 98 | Case #98: 30999983 99 | Case #99: 30999983 100 | Case #100: 10364467 101 | -------------------------------------------------------------------------------- /2015/round_1b/A/A-large.in: -------------------------------------------------------------------------------- 1 | 100 2 | 1 3 | 19 4 | 23 5 | 3020000000 6 | 77777777777 7 | 777777777777 8 | 16777216 9 | 777700700000 10 | 100100000 11 | 89012345678901 12 | 1010001 13 | 33554432 14 | 67108864 15 | 20000000000000 16 | 10010001 17 | 21098765432109 18 | 1073741824 19 | 777700070000 20 | 65432109876543 21 | 2199023255552 22 | 3020000001 23 | 87654321098765 24 | 274877906944 25 | 777777777 26 | 549755813888 27 | 77777777777777 28 | 9999999 29 | 19999999999999 30 | 17592186044416 31 | 8796093022208 32 | 999990 33 | 34567890123456 34 | 10001001 35 | 2147483648 36 | 20000000000001 37 | 77777777 38 | 78901234567890 39 | 100010001 40 | 1000001 41 | 200000001 42 | 777700070001 43 | 7777777777 44 | 536870912 45 | 70368744177664 46 | 35184372088832 47 | 777700007000 48 | 11111110000000 49 | 268435456 50 | 200000000 51 | 11111110000001 52 | 7777777777777 53 | 67890123456789 54 | 45678901234567 55 | 56789012345678 56 | 137438953472 57 | 777770000001 58 | 777770000000 59 | 54321098765432 60 | 100010000 61 | 76543210987654 62 | 777700000000 63 | 68719476736 64 | 134217728 65 | 9999999999999 66 | 10000000 67 | 98765432109876 68 | 504030200000 69 | 1000000 70 | 99999999999999 71 | 32109876543210 72 | 777700007001 73 | 504030200001 74 | 8589934592 75 | 777707000001 76 | 777700000001 77 | 999998 78 | 17179869184 79 | 10001000 80 | 4294967296 81 | 1099511627776 82 | 23456789012345 83 | 40302000001 84 | 10000000000001 85 | 999991 86 | 34359738368 87 | 999989 88 | 777700700001 89 | 999999 90 | 40302000000 91 | 777707000000 92 | 1010000 93 | 10987654321098 94 | 10010000 95 | 90123456789012 96 | 100000000000000 97 | 100100001 98 | 10000000000000 99 | 12345678901234 100 | 43210987654321 101 | 4398046511104 102 | -------------------------------------------------------------------------------- /2015/round_1b/A/A-small-attempt0.in: -------------------------------------------------------------------------------- 1 | 100 2 | 1 3 | 19 4 | 23 5 | 99 6 | 9999 7 | 10999 8 | 999998 9 | 110 10 | 2100 11 | 990000 12 | 30 13 | 10001 14 | 1998 15 | 1099 16 | 900001 17 | 10000 18 | 21 19 | 989999 20 | 900 21 | 654321 22 | 2201 23 | 29 24 | 19 25 | 9 26 | 11100 27 | 999001 28 | 11000 29 | 20 30 | 999000 31 | 998999 32 | 999 33 | 31 34 | 123456 35 | 999999 36 | 77 37 | 64 38 | 543210 39 | 999989 40 | 990001 41 | 100000 42 | 524288 43 | 11011 44 | 10111 45 | 2001 46 | 10 47 | 32 48 | 111 49 | 101000 50 | 11010 51 | 900000 52 | 199 53 | 101001 54 | 901 55 | 999901 56 | 91 57 | 999900 58 | 90 59 | 10011 60 | 1001 61 | 99001 62 | 100 63 | 1999 64 | 12 65 | 1100 66 | 2002 67 | 2200 68 | 11 69 | 65536 70 | 10101 71 | 1111 72 | 1101 73 | 899999 74 | 101 75 | 10010 76 | 128 77 | 432109 78 | 201 79 | 11110 80 | 10100 81 | 11101 82 | 1000 83 | 2101 84 | 12000 85 | 200 86 | 999990 87 | 8192 88 | 22 89 | 11111 90 | 901234 91 | 1110 92 | 1000000 93 | 999899 94 | 999991 95 | 11001 96 | 102 97 | 100001 98 | 12001 99 | 10110 100 | 2000 101 | 99000 102 | -------------------------------------------------------------------------------- /2015/round_1b/A/input_dbg: -------------------------------------------------------------------------------- 1 | 2 2 | 8081 3 | 10001 -------------------------------------------------------------------------------- /2015/round_1b/A/input_example: -------------------------------------------------------------------------------- 1 | 3 2 | 1 3 | 19 4 | 23 -------------------------------------------------------------------------------- /2015/round_1b/A/output_dbg: -------------------------------------------------------------------------------- 1 | Case #1: 227 2 | Case #2: 338 -------------------------------------------------------------------------------- /2015/round_1b/A/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 1 2 | Case #2: 19 3 | Case #3: 15 4 | -------------------------------------------------------------------------------- /2015/round_1b/A/problem.org: -------------------------------------------------------------------------------- 1 | * Problem 2 | 3 | 4 | ** Problem 5 | 6 | In the Counting Poetry Slam, a performer takes the microphone, 7 | chooses a number N, and counts aloud from 1 to N. 8 | 9 | That is, she _starts by saying 1_ , and then repeatedly says the number 10 | that is _1 greater than the previous number she said_ stopping after she has said _N_ 11 | 12 | 13 | It's your turn to perform, but you find this process tedious, 14 | and you want to add a twist to speed it up: 15 | sometimes, _instead of adding 1 to the previous number_ , 16 | you might _reverse the digits of the number_ 17 | (removing any leading zeroes that this creates). 18 | 19 | For example, after saying "16", you could next say either "17" or "61"; 20 | after saying "2300", you could next say either "2301" or "32". 21 | You may reverse as many times as you want (or not at all) within a performance. 22 | 23 | The first number you say must be 1; 24 | 25 | _what is the fewest number of numbers you will need to say in order to reach the number N?_ 26 | 27 | 1 and N count toward this total. 28 | 29 | If you say the same number multiple times, each of those times counts separately. 30 | 31 | 32 | 33 | 34 | 35 | ** Input 36 | 37 | 38 | ** Output 39 | 40 | 41 | ** Limits 42 | 43 | 44 | *** Small dataset 45 | 46 | 47 | *** Large dataset 48 | 49 | 50 | 51 | ** Sample 52 | 53 | 54 | *** Input 55 | 56 | 57 | 58 | *** Output 59 | 60 | 61 | 62 | -------------------------------------------------------------------------------- /2015/round_1b/B/B-small-attempt0.in: -------------------------------------------------------------------------------- 1 | 100 2 | 6 2 8 3 | 3 5 7 4 | 3 5 9 5 | 1 16 8 6 | 7 2 4 7 | 3 3 7 8 | 5 3 8 9 | 1 16 16 10 | 2 7 14 11 | 1 15 15 12 | 15 1 0 13 | 5 3 1 14 | 2 5 9 15 | 3 4 12 16 | 5 3 10 17 | 2 2 2 18 | 7 2 12 19 | 2 7 10 20 | 1 12 3 21 | 2 8 13 22 | 3 5 13 23 | 1 15 0 24 | 2 5 3 25 | 1 1 1 26 | 3 5 12 27 | 15 1 6 28 | 3 5 8 29 | 2 5 10 30 | 16 1 1 31 | 4 4 16 32 | 2 6 11 33 | 3 5 1 34 | 5 3 0 35 | 5 3 12 36 | 1 16 0 37 | 1 16 7 38 | 4 4 9 39 | 16 1 7 40 | 1 16 9 41 | 3 5 5 42 | 4 2 6 43 | 2 7 0 44 | 16 1 16 45 | 1 4 1 46 | 8 2 7 47 | 15 1 7 48 | 3 5 2 49 | 1 15 7 50 | 3 5 15 51 | 5 3 7 52 | 8 2 16 53 | 3 5 10 54 | 9 1 6 55 | 1 16 12 56 | 15 1 1 57 | 3 5 0 58 | 3 5 4 59 | 5 3 14 60 | 16 1 8 61 | 16 1 9 62 | 1 15 8 63 | 4 4 0 64 | 5 3 9 65 | 16 1 0 66 | 2 5 8 67 | 5 3 6 68 | 5 3 13 69 | 3 3 4 70 | 3 5 14 71 | 4 4 7 72 | 3 4 6 73 | 3 4 7 74 | 7 2 8 75 | 5 3 3 76 | 2 7 12 77 | 2 7 11 78 | 14 1 11 79 | 3 5 3 80 | 5 3 5 81 | 3 2 0 82 | 5 3 11 83 | 15 1 8 84 | 3 5 11 85 | 4 3 12 86 | 1 4 4 87 | 4 4 1 88 | 5 3 4 89 | 1 9 6 90 | 5 2 9 91 | 4 4 8 92 | 1 15 6 93 | 1 16 1 94 | 3 3 6 95 | 5 3 15 96 | 3 5 6 97 | 5 3 2 98 | 1 15 1 99 | 2 8 14 100 | 15 1 15 101 | 1 1 0 102 | -------------------------------------------------------------------------------- /2015/round_1b/B/B-small-practice.in: -------------------------------------------------------------------------------- 1 | 100 2 | 5 2 8 3 | 3 5 14 4 | 1 16 1 5 | 3 5 1 6 | 8 2 12 7 | 16 1 1 8 | 3 3 6 9 | 2 6 12 10 | 15 1 0 11 | 5 3 7 12 | 4 3 5 13 | 3 5 11 14 | 7 2 13 15 | 15 1 6 16 | 15 1 15 17 | 4 4 9 18 | 5 3 8 19 | 3 5 6 20 | 16 1 7 21 | 1 15 7 22 | 4 3 12 23 | 5 3 13 24 | 2 4 5 25 | 5 3 5 26 | 16 1 16 27 | 2 5 8 28 | 5 3 4 29 | 5 3 10 30 | 4 4 7 31 | 3 5 9 32 | 4 2 2 33 | 4 4 15 34 | 2 2 4 35 | 5 3 11 36 | 4 4 8 37 | 1 16 9 38 | 4 4 16 39 | 1 15 6 40 | 15 1 8 41 | 5 3 6 42 | 16 1 9 43 | 3 5 15 44 | 1 15 1 45 | 1 15 0 46 | 2 5 9 47 | 3 5 10 48 | 1 15 15 49 | 3 2 0 50 | 5 3 2 51 | 5 3 1 52 | 5 2 4 53 | 3 5 4 54 | 2 7 13 55 | 3 3 0 56 | 7 2 11 57 | 4 4 0 58 | 1 1 0 59 | 2 6 9 60 | 3 5 3 61 | 5 3 15 62 | 5 2 6 63 | 3 4 12 64 | 2 3 6 65 | 1 1 1 66 | 15 1 1 67 | 1 16 16 68 | 2 2 2 69 | 3 3 9 70 | 16 1 8 71 | 9 1 6 72 | 5 3 12 73 | 2 2 3 74 | 3 5 7 75 | 7 2 0 76 | 4 3 6 77 | 2 3 4 78 | 1 15 8 79 | 16 1 0 80 | 5 3 9 81 | 15 1 7 82 | 2 4 6 83 | 1 16 7 84 | 3 5 12 85 | 1 16 8 86 | 4 4 1 87 | 3 5 0 88 | 3 5 8 89 | 1 16 0 90 | 5 3 3 91 | 5 3 0 92 | 1 13 9 93 | 3 5 2 94 | 1 9 6 95 | 6 2 12 96 | 4 3 8 97 | 3 5 5 98 | 5 3 14 99 | 4 3 7 100 | 6 2 4 101 | 3 5 13 102 | -------------------------------------------------------------------------------- /2015/round_1b/B/input_dbg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2015/round_1b/B/input_dbg -------------------------------------------------------------------------------- /2015/round_1b/B/input_example: -------------------------------------------------------------------------------- 1 | 4 2 | 2 3 6 3 | 4 1 2 4 | 3 3 8 5 | 5 2 0 -------------------------------------------------------------------------------- /2015/round_1b/B/output_dbg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2015/round_1b/B/output_dbg -------------------------------------------------------------------------------- /2015/round_1b/B/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 7 2 | Case #2: 0 3 | Case #3: 8 4 | Case #4: 0 5 | -------------------------------------------------------------------------------- /2015/round_1b/B/problem.org: -------------------------------------------------------------------------------- 1 | * Problem 2 | 3 | 4 | ** Problem 5 | 6 | You are a landlord who owns a building that is an _R x C_ grid of apartments; 7 | each apartment is a unit square cell with _four walls_ 8 | 9 | You want to rent out _N_ of these apartments to tenants, 10 | with exactly one tenant per apartment, and leave the others empty. 11 | 12 | Unfortunately, all of your potential tenants are noisy, 13 | so whenever any two occupied apartments share a wall (and not just a corner), 14 | this will add _one point of unhappiness_ to the building. 15 | 16 | For example, a 2x2 building in which every apartment is occupied has four walls 17 | that are shared by neighboring tenants, and so the building's unhappiness score is 4. 18 | 19 | If you place your N tenants optimally, _what is the minimum unhappiness value for your building_ ? 20 | 21 | 22 | ** Input 23 | 24 | each contains three space-separated integers: R, C, and N. 25 | 26 | ** Output 27 | 28 | 29 | 30 | ** Limits 31 | 32 | 1 ≤ T ≤ 1000. 33 | 0 ≤ N ≤ R*C. 34 | 35 | *** Small dataset 36 | 37 | 1 ≤ R*C ≤ 16. 38 | 39 | 40 | *** Large dataset 41 | 42 | 1 ≤ R*C ≤ 10000. 43 | 44 | 45 | ** Sample 46 | 47 | 48 | *** Input 49 | 50 | 4 51 | 2 3 6 52 | 4 1 2 53 | 3 3 8 54 | 5 2 0 55 | 56 | 57 | *** Output 58 | 59 | Case #1: 7 60 | Case #2: 0 61 | Case #3: 8 62 | Case #4: 0 63 | 64 | -------------------------------------------------------------------------------- /2015/round_1b/C/0-kai-1/dbg.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | g++ sol.cc -DDBG && ./a.out < $1 && emacs log.txt 5 | else 6 | g++ sol.cc -DDBG && ./a.out < ../input_example && emacs log.txt 7 | fi 8 | -------------------------------------------------------------------------------- /2015/round_1b/C/0-kai-1/oooooo: -------------------------------------------------------------------------------- 1 | Case #1: 996 2 | Case #2: 94 3 | Case #3: 86 4 | Case #4: 85 5 | Case #5: 83 6 | Case #6: 90 7 | Case #7: 0 8 | Case #8: 999 9 | Case #9: 993 10 | Case #10: 993 11 | Case #11: 1 12 | Case #12: 88 13 | Case #13: 10 14 | Case #14: 94 15 | Case #15: 99 16 | Case #16: 14 17 | Case #17: 86 18 | Case #18: 488461 19 | Case #19: 0 20 | Case #20: 93 21 | Case #21: 84 22 | Case #22: 79 23 | Case #23: 94 24 | Case #24: 948 25 | Case #25: 89 26 | Case #26: 98 27 | Case #27: 93 28 | Case #28: 951 29 | Case #29: 97 30 | Case #30: 95 31 | Case #31: 999 32 | Case #32: 948 33 | Case #33: 94 34 | Case #34: 95 35 | Case #35: 13 36 | Case #36: 96 37 | Case #37: 94 38 | Case #38: 979 39 | Case #39: 87 40 | Case #40: 986 41 | Case #41: 46699 42 | Case #42: 987 43 | Case #43: 86 44 | Case #44: 480821 45 | Case #45: 79 46 | Case #46: 949 47 | Case #47: 84 48 | Case #48: 978 49 | Case #49: 88 50 | Case #50: 97 51 | Case #51: 99 52 | Case #52: 91 53 | Case #53: 982 54 | Case #54: 98 55 | Case #55: 0 56 | Case #56: 499960 57 | Case #57: 925 58 | Case #58: 65 59 | Case #59: 985 60 | Case #60: 82 61 | Case #61: 94 62 | Case #62: 84 63 | Case #63: 82 64 | Case #64: 93 65 | Case #65: 87 66 | Case #66: 71 67 | Case #67: 84 68 | Case #68: 23 69 | Case #69: 94 70 | Case #70: 480821 71 | Case #71: 81 72 | Case #72: 95 73 | Case #73: 91 74 | Case #74: 85 75 | Case #75: 1 76 | Case #76: 0 77 | Case #77: 85 78 | Case #78: 16 79 | Case #79: 959 80 | Case #80: 81 81 | Case #81: 92 82 | Case #82: 1 83 | Case #83: 98 84 | Case #84: 99 85 | Case #85: 966 86 | Case #86: 499998 87 | Case #87: 90 88 | Case #88: 9 89 | Case #89: 94 90 | Case #90: 4 91 | Case #91: 99 92 | Case #92: 89 93 | Case #93: 78 94 | Case #94: 88 95 | Case #95: 972 96 | Case #96: 21 97 | Case #97: 979 98 | Case #98: 0 99 | Case #99: 80 100 | Case #100: 0 101 | -------------------------------------------------------------------------------- /2015/round_1b/C/0-kai-1/run.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | g++ sol.cc && ./a.out < $1 5 | else 6 | g++ sol.cc && ./a.out < ../input_example 7 | fi 8 | -------------------------------------------------------------------------------- /2015/round_1b/C/1-vepifanov/dbg.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | g++ sol.cc && ./a.out < $1 && emacs log.txt 5 | else 6 | g++ sol.cc && ./a.out < ../input_example && emacs log.txt 7 | fi 8 | -------------------------------------------------------------------------------- /2015/round_1b/C/1-vepifanov/log.txt: -------------------------------------------------------------------------------- 1 | ====Case 1 2 | t= 3 | t[0]=12 t[1]=12 t[2]=12 t[3]=12 4 | 5 | print_all() 6 | 12 1 7 | 24 3 8 | 4296 2 9 | 4308 0 10 | 11 | x=12 12 | y=1 13 | 14 | print_all() 15 | 24 3 16 | 4296 2 17 | 4308 0 18 | 4332 1 19 | 20 | x=24 21 | y=3 22 | 23 | print_all() 24 | 4296 2 25 | 4308 0 26 | 4332 1 27 | 4344 3 28 | 29 | x=4296 30 | y=2 31 | 32 | print_all() 33 | 4308 0 34 | 4332 1 35 | 4344 3 36 | 8616 2 37 | 38 | x=4308 39 | y=0 40 | 41 | print_all() 42 | 4332 1 43 | 4344 3 44 | 8616 2 45 | 8628 0 46 | 47 | x=4332 48 | y=1 49 | 50 | print_all() 51 | 4344 3 52 | 8616 2 53 | 8628 0 54 | 8652 1 55 | 56 | x=4344 57 | y=3 58 | 59 | print_all() 60 | 8616 2 61 | 8628 0 62 | 8652 1 63 | 8664 3 64 | 65 | x=8616 66 | y=2 67 | 68 | print_all() 69 | 8628 0 70 | 8652 1 71 | 8664 3 72 | 12936 2 73 | 74 | x=8628 75 | y=0 76 | 77 | print_all() 78 | 8652 1 79 | 8664 3 80 | 12936 2 81 | 12948 0 82 | 83 | x=8652 84 | y=1 85 | 86 | print_all() 87 | 8664 3 88 | 12936 2 89 | 12948 0 90 | 12972 1 91 | 92 | x=8664 93 | y=3 94 | 95 | print_all() 96 | 12936 2 97 | 12948 0 98 | 12972 1 99 | 12984 3 100 | 101 | x=12936 102 | y=2 103 | 104 | print_all() 105 | 12948 0 106 | 12972 1 107 | 12984 3 108 | 17256 2 109 | 110 | x=12948 111 | y=0 112 | 113 | print_all() 114 | 12972 1 115 | 12984 3 116 | 17256 2 117 | 17268 0 118 | 119 | x=12972 120 | y=1 121 | 122 | Case #1: 0 123 | 124 | 125 | ====Case 2 126 | t= 127 | t[0]=100000 t[1]=1 128 | 129 | print_all() 130 | 180 1 131 | 18000000 0 132 | 133 | x=180 134 | y=1 135 | 136 | print_all() 137 | 540 1 138 | 18000000 0 139 | 140 | x=540 141 | y=1 142 | 143 | print_all() 144 | 900 1 145 | 18000000 0 146 | 147 | x=900 148 | y=1 149 | 150 | print_all() 151 | 1260 1 152 | 18000000 0 153 | 154 | x=1260 155 | y=1 156 | 157 | print_all() 158 | 1620 1 159 | 18000000 0 160 | 161 | x=1620 162 | y=1 163 | 164 | Case #2: 1 165 | 166 | 167 | ====Case 3 168 | t= 169 | t[0]=1 t[1]=2 170 | 171 | print_all() 172 | 180 0 173 | 360 1 174 | 175 | x=180 176 | y=0 177 | 178 | print_all() 179 | 360 1 180 | 540 0 181 | 182 | x=360 183 | y=1 184 | 185 | print_all() 186 | 540 0 187 | 1080 1 188 | 189 | x=540 190 | y=0 191 | 192 | print_all() 193 | 900 0 194 | 1080 1 195 | 196 | x=900 197 | y=0 198 | 199 | print_all() 200 | 1080 1 201 | 1260 0 202 | 203 | x=1080 204 | y=1 205 | 206 | print_all() 207 | 1260 0 208 | 1800 1 209 | 210 | x=1260 211 | y=0 212 | 213 | print_all() 214 | 1620 0 215 | 1800 1 216 | 217 | x=1620 218 | y=0 219 | 220 | Case #3: 0 221 | 222 | 223 | -------------------------------------------------------------------------------- /2015/round_1b/C/1-vepifanov/orig_sol.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | using namespace std; 18 | 19 | #define mp make_pair 20 | #define pb push_back 21 | #define rep(i,n) for(int i = 0; i < (n); i++) 22 | #define re return 23 | #define fi first 24 | #define se second 25 | #define sz(x) ((int) (x).size()) 26 | #define all(x) (x).begin(), (x).end() 27 | #define sqr(x) ((x) * (x)) 28 | #define sqrt(x) sqrt(abs(x)) 29 | #define y0 y3487465 30 | #define y1 y8687969 31 | #define fill(x,y) memset(x,y,sizeof(x)) 32 | #define prev PREV 33 | 34 | typedef vector vi; 35 | typedef long long ll; 36 | typedef long double ld; 37 | typedef double D; 38 | typedef pair ii; 39 | typedef vector vii; 40 | typedef vector vs; 41 | typedef vector vvi; 42 | 43 | template T abs(T x) { re x > 0 ? x : -x; } 44 | 45 | int n; 46 | int m; 47 | 48 | int d[500000]; 49 | int t[500000]; 50 | int was[500000]; 51 | 52 | set > all; 53 | 54 | int main () { 55 | int tt; 56 | cin >> tt; 57 | for (int it = 1; it <= tt; it++) { 58 | scanf ("%d", &n); 59 | int o = 0; 60 | for (int i = 0; i < n; i++) { 61 | int d, h, m; 62 | scanf ("%d%d%d", &d, &h, &m); 63 | for (int j = 0; j < h; j++) { 64 | ::d[o] = d; 65 | ::t[o] = m + j; 66 | was[o] = 0; 67 | o++; 68 | } 69 | } 70 | all.clear (); 71 | int cur = o, ans = o; 72 | for (int i = 0; i < o; i++) all.insert (mp ((ll)(360 - d[i]) * t[i], i)); 73 | ll last = 0; 74 | while (cur <= 2 * o) { 75 | ll x = all.begin ()->fi; 76 | int y = all.begin ()->se; 77 | all.erase (all.begin ()); 78 | if (x > last) ans = min (ans, cur); 79 | last = x; 80 | if (was[y]) cur++; else cur--; 81 | // printf ("%I64d %d : %d %d\n", x, y, cur, was[y]); 82 | was[y] = 1; 83 | all.insert (mp (x + (ll)360 * t[y], y)); 84 | } 85 | cout << "Case #" << it << ": " << ans; 86 | cout << endl; 87 | fprintf (stderr, "%d / %d = %.2f | %.2f\n", it, tt, (double)clock () / CLOCKS_PER_SEC, ((double)clock () / it * tt) / CLOCKS_PER_SEC); 88 | } 89 | return 0; 90 | } -------------------------------------------------------------------------------- /2015/round_1b/C/1-vepifanov/vepifanov_2_0.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2015/round_1b/C/1-vepifanov/vepifanov_2_0.zip -------------------------------------------------------------------------------- /2015/round_1b/C/input_dbg: -------------------------------------------------------------------------------- 1 | 3 2 | 3 | 2 4 | 326 1 374058623 5 | 286 1 120061280 6 | 7 | 2 8 | 180 1 10 9 | 180 1 30 10 | 11 | 2 12 | 180 1 30 13 | 180 1 10 14 | -------------------------------------------------------------------------------- /2015/round_1b/C/input_example: -------------------------------------------------------------------------------- 1 | 3 2 | 4 3 | 1 1 12 4 | 359 1 12 5 | 2 1 12 6 | 358 1 12 7 | 2 8 | 180 1 100000 9 | 180 1 1 10 | 1 11 | 180 2 1 -------------------------------------------------------------------------------- /2015/round_1b/C/output_dbg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2015/round_1b/C/output_dbg -------------------------------------------------------------------------------- /2015/round_1b/C/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 0 2 | Case #2: 1 3 | Case #3: 0 4 | -------------------------------------------------------------------------------- /2015/round_1b/C/problem.org: -------------------------------------------------------------------------------- 1 | * Problem 2 | 3 | 4 | ** Problem 5 | 6 | 7 | ** Input 8 | 9 | 10 | ** Output 11 | 12 | 13 | ** Limits 14 | 15 | 16 | *** Small dataset 17 | 18 | 19 | *** Large dataset 20 | 21 | 22 | 23 | ** Sample 24 | 25 | 26 | *** Input 27 | 28 | 29 | 30 | *** Output 31 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/A-large-practice.in: -------------------------------------------------------------------------------- 1 | 100 2 | 110773079607528314 3 | 921976714047386993 4 | 926824651452863172 5 | 220907335980956618 6 | 308229087299038867 7 | 197444121743978715 8 | 902040548566321775 9 | 14662732068232557 10 | 65536 11 | 468238102262455028 12 | 348795165802724217 13 | 927600165742984913 14 | 950798452134347929 15 | 222023730031175322 16 | 766900509380973895 17 | 906150500548593491 18 | 99655578006285358 19 | 450573916311764153 20 | 996155824001560464 21 | 83173248616541424 22 | 488722182881896796 23 | 327756357474013835 24 | 1 25 | 937158698414834064 26 | 538590989955253094 27 | 159221872792272221 28 | 587316270490900800 29 | 657668829706564498 30 | 938648259060513111 31 | 200295802849766052 32 | 487027631163506751 33 | 1048576 34 | 96086727781502983 35 | 213268763501272893 36 | 72509132486752463 37 | 701423430127567170 38 | 933316130260347144 39 | 702195489465000574 40 | 433282897669858872 41 | 96147144910202586 42 | 290230743191618968 43 | 147306299227931159 44 | 988025655809758761 45 | 369019691512967127 46 | 939966740662343102 47 | 525934838531140283 48 | 976884073177363898 49 | 746828985221632181 50 | 2 51 | 510137061014023235 52 | 138519679747505275 53 | 1125899906842624 54 | 67108864 55 | 983519591351818189 56 | 145067091417600476 57 | 2048 58 | 902359661886634617 59 | 252744280122344403 60 | 247986068076325302 61 | 23056579049984289 62 | 971059756203841619 63 | 951247985468017175 64 | 992273534419644154 65 | 900601595336575449 66 | 929577411320295678 67 | 139887494091628462 68 | 952151839225287005 69 | 943763438281410393 70 | 723465622850877794 71 | 10 72 | 513669080823341780 73 | 434869574230812696 74 | 47825696483849359 75 | 459374002876393854 76 | 51117733750700920 77 | 928749845405193630 78 | 974175173028696919 79 | 254453264770975249 80 | 566542081050530992 81 | 980060082571540885 82 | 128 83 | 714572554914529963 84 | 101903442019805000 85 | 910509714262410539 86 | 833489384530960683 87 | 159806432260827185 88 | 599430948824562660 89 | 416229355035355584 90 | 600530898088096052 91 | 129701620520798275 92 | 182569867050215829 93 | 690156135907083793 94 | 3 95 | 652925727356047591 96 | 977654328359551304 97 | 180249799688771941 98 | 829276186673698544 99 | 956338826697503847 100 | 571776495202099089 101 | 119840089723460280 102 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/A-large.in: -------------------------------------------------------------------------------- 1 | 100 2 | 2 3 | 382562008710055652 4 | 124554508779797786 5 | 621392279541421396 6 | 122456786504187597 7 | 73347935012811039 8 | 77868298860334728 9 | 807495029921712378 10 | 884641749329491286 11 | 21381332574490832 12 | 444922341965583662 13 | 790936079036556942 14 | 434915668514812062 15 | 145487607486089996 16 | 950788308922581639 17 | 933612160059647561 18 | 917508850002137313 19 | 1 20 | 132652653582359511 21 | 989990307470937464 22 | 510523905673178173 23 | 734005866941881841 24 | 78891990627873833 25 | 55725425954114768 26 | 268435456 27 | 32768 28 | 236436164721454957 29 | 956527854797393196 30 | 900683371760614823 31 | 787255268602457426 32 | 924196566429589773 33 | 9397478666590673 34 | 942740829990861733 35 | 664834488169858122 36 | 972404935449220733 37 | 980204760356123881 38 | 12321329597412301 39 | 985429212391542876 40 | 566411034000587080 41 | 232819147379783748 42 | 158401371436033692 43 | 59327639913677984 44 | 13060604717068142 45 | 51024161147977610 46 | 137438953472 47 | 45437349280742274 48 | 232214399183688165 49 | 372800120418084943 50 | 954881718404154763 51 | 75097220501993099 52 | 659022686169180033 53 | 742654642436912671 54 | 903589321164655290 55 | 905168138138454259 56 | 513319364345442099 57 | 745119826961971714 58 | 564711640436290280 59 | 125983434537440825 60 | 797500591408438885 61 | 1048576 62 | 953385143366607510 63 | 99047989170156258 64 | 652012790004187261 65 | 660283424823235315 66 | 700569163189251038 67 | 198053706757929628 68 | 604330717170620369 69 | 900834541149077813 70 | 775052221113615279 71 | 785920358421776187 72 | 264896334021726801 73 | 418775851692725226 74 | 960010899855980408 75 | 385701433673033525 76 | 730151404689479497 77 | 976924932426899401 78 | 533755720130511788 79 | 658835545704312622 80 | 521099056388047608 81 | 340906632519243330 82 | 466331053006723247 83 | 144115188075855872 84 | 880365704741577455 85 | 834868104489165968 86 | 748861747892277672 87 | 634204325102328048 88 | 653009837786520290 89 | 337842401213780388 90 | 3 91 | 904541764983009392 92 | 930201083058672450 93 | 494133140522382457 94 | 10 95 | 906594949710808696 96 | 963134506223653884 97 | 955874932364432144 98 | 313183988873187446 99 | 844827745086021583 100 | 35184372088832 101 | 295630694768708763 102 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/A-larget-practice.exp_output: -------------------------------------------------------------------------------- 1 | Case #1: 0 2 | Case #2: 0 3 | Case #3: 0 4 | Case #4: 0 5 | Case #5: 1 6 | Case #6: 1 7 | Case #7: 1 8 | Case #8: 0 9 | Case #9: 0 10 | Case #10: 0 11 | Case #11: 0 12 | Case #12: 0 13 | Case #13: 0 14 | Case #14: 0 15 | Case #15: 1 16 | Case #16: 1 17 | Case #17: 1 18 | Case #18: 0 19 | Case #19: 0 20 | Case #20: 1 21 | Case #21: 1 22 | Case #22: 1 23 | Case #23: 0 24 | Case #24: 0 25 | Case #25: 1 26 | Case #26: 0 27 | Case #27: 0 28 | Case #28: 0 29 | Case #29: 1 30 | Case #30: 0 31 | Case #31: 1 32 | Case #32: 0 33 | Case #33: 1 34 | Case #34: 0 35 | Case #35: 1 36 | Case #36: 0 37 | Case #37: 0 38 | Case #38: 1 39 | Case #39: 1 40 | Case #40: 0 41 | Case #41: 1 42 | Case #42: 1 43 | Case #43: 0 44 | Case #44: 1 45 | Case #45: 1 46 | Case #46: 1 47 | Case #47: 0 48 | Case #48: 0 49 | Case #49: 0 50 | Case #50: 1 51 | Case #51: 1 52 | Case #52: 0 53 | Case #53: 0 54 | Case #54: 0 55 | Case #55: 1 56 | Case #56: 0 57 | Case #57: 0 58 | Case #58: 1 59 | Case #59: 1 60 | Case #60: 0 61 | Case #61: 1 62 | Case #62: 1 63 | Case #63: 0 64 | Case #64: 0 65 | Case #65: 1 66 | Case #66: 1 67 | Case #67: 0 68 | Case #68: 0 69 | Case #69: 0 70 | Case #70: 0 71 | Case #71: 0 72 | Case #72: 1 73 | Case #73: 1 74 | Case #74: 1 75 | Case #75: 1 76 | Case #76: 1 77 | Case #77: 1 78 | Case #78: 0 79 | Case #79: 1 80 | Case #80: 0 81 | Case #81: 0 82 | Case #82: 1 83 | Case #83: 0 84 | Case #84: 1 85 | Case #85: 1 86 | Case #86: 0 87 | Case #87: 0 88 | Case #88: 1 89 | Case #89: 0 90 | Case #90: 1 91 | Case #91: 0 92 | Case #92: 0 93 | Case #93: 1 94 | Case #94: 1 95 | Case #95: 0 96 | Case #96: 0 97 | Case #97: 1 98 | Case #98: 1 99 | Case #99: 0 100 | Case #100: 1 101 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/A-larget.exp_output: -------------------------------------------------------------------------------- 1 | Case #1: 0 2 | Case #2: 0 3 | Case #3: 0 4 | Case #4: 0 5 | Case #5: 0 6 | Case #6: 1 7 | Case #7: 0 8 | Case #8: 0 9 | Case #9: 1 10 | Case #10: 0 11 | Case #11: 1 12 | Case #12: 1 13 | Case #13: 1 14 | Case #14: 1 15 | Case #15: 1 16 | Case #16: 0 17 | Case #17: 0 18 | Case #18: 0 19 | Case #19: 1 20 | Case #20: 1 21 | Case #21: 0 22 | Case #22: 0 23 | Case #23: 0 24 | Case #24: 0 25 | Case #25: 0 26 | Case #26: 0 27 | Case #27: 0 28 | Case #28: 1 29 | Case #29: 1 30 | Case #30: 0 31 | Case #31: 0 32 | Case #32: 0 33 | Case #33: 0 34 | Case #34: 0 35 | Case #35: 0 36 | Case #36: 0 37 | Case #37: 0 38 | Case #38: 1 39 | Case #39: 0 40 | Case #40: 0 41 | Case #41: 1 42 | Case #42: 0 43 | Case #43: 1 44 | Case #44: 0 45 | Case #45: 0 46 | Case #46: 0 47 | Case #47: 0 48 | Case #48: 1 49 | Case #49: 1 50 | Case #50: 1 51 | Case #51: 0 52 | Case #52: 1 53 | Case #53: 0 54 | Case #54: 1 55 | Case #55: 1 56 | Case #56: 0 57 | Case #57: 0 58 | Case #58: 0 59 | Case #59: 0 60 | Case #60: 0 61 | Case #61: 1 62 | Case #62: 0 63 | Case #63: 0 64 | Case #64: 1 65 | Case #65: 1 66 | Case #66: 1 67 | Case #67: 0 68 | Case #68: 0 69 | Case #69: 1 70 | Case #70: 1 71 | Case #71: 0 72 | Case #72: 0 73 | Case #73: 1 74 | Case #74: 0 75 | Case #75: 0 76 | Case #76: 0 77 | Case #77: 1 78 | Case #78: 1 79 | Case #79: 1 80 | Case #80: 0 81 | Case #81: 1 82 | Case #82: 0 83 | Case #83: 1 84 | Case #84: 0 85 | Case #85: 0 86 | Case #86: 1 87 | Case #87: 0 88 | Case #88: 0 89 | Case #89: 1 90 | Case #90: 1 91 | Case #91: 0 92 | Case #92: 0 93 | Case #93: 0 94 | Case #94: 1 95 | Case #95: 1 96 | Case #96: 0 97 | Case #97: 1 98 | Case #98: 1 99 | Case #99: 0 100 | Case #100: 1 101 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/A-small-attempt0.exp_output: -------------------------------------------------------------------------------- 1 | Case #1: 1 2 | Case #2: 1 3 | Case #3: 1 4 | Case #4: 1 5 | Case #5: 0 6 | Case #6: 0 7 | Case #7: 1 8 | Case #8: 1 9 | Case #9: 0 10 | Case #10: 0 11 | Case #11: 0 12 | Case #12: 1 13 | Case #13: 0 14 | Case #14: 0 15 | Case #15: 0 16 | Case #16: 0 17 | Case #17: 0 18 | Case #18: 0 19 | Case #19: 1 20 | Case #20: 1 21 | Case #21: 0 22 | Case #22: 1 23 | Case #23: 0 24 | Case #24: 1 25 | Case #25: 0 26 | Case #26: 0 27 | Case #27: 0 28 | Case #28: 1 29 | Case #29: 0 30 | Case #30: 0 31 | Case #31: 0 32 | Case #32: 0 33 | Case #33: 1 34 | Case #34: 0 35 | Case #35: 0 36 | Case #36: 1 37 | Case #37: 0 38 | Case #38: 0 39 | Case #39: 0 40 | Case #40: 1 41 | Case #41: 0 42 | Case #42: 1 43 | Case #43: 0 44 | Case #44: 0 45 | Case #45: 0 46 | Case #46: 0 47 | Case #47: 0 48 | Case #48: 0 49 | Case #49: 0 50 | Case #50: 0 51 | Case #51: 0 52 | Case #52: 0 53 | Case #53: 1 54 | Case #54: 0 55 | Case #55: 1 56 | Case #56: 0 57 | Case #57: 1 58 | Case #58: 0 59 | Case #59: 1 60 | Case #60: 1 61 | Case #61: 1 62 | Case #62: 0 63 | Case #63: 1 64 | Case #64: 1 65 | Case #65: 0 66 | Case #66: 1 67 | Case #67: 0 68 | Case #68: 1 69 | Case #69: 1 70 | Case #70: 1 71 | Case #71: 1 72 | Case #72: 1 73 | Case #73: 0 74 | Case #74: 0 75 | Case #75: 0 76 | Case #76: 1 77 | Case #77: 1 78 | Case #78: 0 79 | Case #79: 1 80 | Case #80: 1 81 | Case #81: 1 82 | Case #82: 0 83 | Case #83: 0 84 | Case #84: 0 85 | Case #85: 1 86 | Case #86: 1 87 | Case #87: 1 88 | Case #88: 0 89 | Case #89: 1 90 | Case #90: 1 91 | Case #91: 1 92 | Case #92: 0 93 | Case #93: 0 94 | Case #94: 0 95 | Case #95: 0 96 | Case #96: 1 97 | Case #97: 0 98 | Case #98: 1 99 | Case #99: 0 100 | Case #100: 1 101 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/A-small-attempt0.in: -------------------------------------------------------------------------------- 1 | 100 2 | 93151 3 | 41804 4 | 62671 5 | 91096 6 | 4 7 | 63786 8 | 94222 9 | 78867 10 | 43553 11 | 92578 12 | 80580 13 | 21491 14 | 77033 15 | 81137 16 | 2 17 | 91812 18 | 91394 19 | 17577 20 | 13207 21 | 88304 22 | 13746 23 | 70019 24 | 97749 25 | 48822 26 | 92276 27 | 71442 28 | 95705 29 | 35102 30 | 512 31 | 92313 32 | 89172 33 | 66321 34 | 96303 35 | 128 36 | 50810 37 | 92190 38 | 14042 39 | 32914 40 | 26329 41 | 72750 42 | 94221 43 | 14919 44 | 256 45 | 17540 46 | 41257 47 | 24106 48 | 57412 49 | 91265 50 | 4096 51 | 1 52 | 19122 53 | 1024 54 | 52382 55 | 55530 56 | 6527 57 | 2292 58 | 25891 59 | 10 60 | 91102 61 | 35372 62 | 44927 63 | 91525 64 | 93271 65 | 3 66 | 51496 67 | 95507 68 | 34453 69 | 63494 70 | 93115 71 | 90126 72 | 7955 73 | 27159 74 | 7240 75 | 89172 76 | 27673 77 | 90803 78 | 92494 79 | 89521 80 | 97487 81 | 14463 82 | 95067 83 | 91876 84 | 36629 85 | 97236 86 | 30646 87 | 758 88 | 93302 89 | 17972 90 | 94583 91 | 17275 92 | 91475 93 | 50401 94 | 29178 95 | 43501 96 | 69588 97 | 26215 98 | 1021 99 | 59768 100 | 36532 101 | 17920 102 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/A-small-practice.in: -------------------------------------------------------------------------------- 1 | 100 2 | 28314 3 | 86993 4 | 93172 5 | 56618 6 | 38867 7 | 78715 8 | 91775 9 | 32557 10 | 4096 11 | 55028 12 | 24217 13 | 94913 14 | 47929 15 | 75322 16 | 73895 17 | 93491 18 | 85358 19 | 64153 20 | 90464 21 | 41424 22 | 96796 23 | 13835 24 | 1 25 | 34064 26 | 53094 27 | 72221 28 | 800 29 | 64498 30 | 13111 31 | 66052 32 | 6751 33 | 4096 34 | 2983 35 | 72893 36 | 52463 37 | 67170 38 | 47144 39 | 574 40 | 58872 41 | 2586 42 | 18968 43 | 31159 44 | 98761 45 | 67127 46 | 43102 47 | 40283 48 | 93898 49 | 32181 50 | 2 51 | 23235 52 | 5275 53 | 1024 54 | 32768 55 | 98189 56 | 476 57 | 4 58 | 94617 59 | 44403 60 | 25302 61 | 84289 62 | 41619 63 | 97175 64 | 94154 65 | 95449 66 | 95678 67 | 28462 68 | 97005 69 | 90393 70 | 77794 71 | 10 72 | 41780 73 | 12696 74 | 49359 75 | 93854 76 | 920 77 | 93630 78 | 96919 79 | 75249 80 | 30992 81 | 90885 82 | 4096 83 | 29963 84 | 5000 85 | 10539 86 | 60683 87 | 27185 88 | 62660 89 | 55584 90 | 96052 91 | 98275 92 | 15829 93 | 83793 94 | 3 95 | 47591 96 | 91304 97 | 71941 98 | 98544 99 | 93847 100 | 99089 101 | 60280 102 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/A-small-pratice.exp_output: -------------------------------------------------------------------------------- 1 | Case #1: 0 2 | Case #2: 0 3 | Case #3: 0 4 | Case #4: 0 5 | Case #5: 1 6 | Case #6: 1 7 | Case #7: 1 8 | Case #8: 0 9 | Case #9: 0 10 | Case #10: 0 11 | Case #11: 0 12 | Case #12: 0 13 | Case #13: 0 14 | Case #14: 0 15 | Case #15: 1 16 | Case #16: 1 17 | Case #17: 1 18 | Case #18: 0 19 | Case #19: 1 20 | Case #20: 0 21 | Case #21: 1 22 | Case #22: 1 23 | Case #23: 0 24 | Case #24: 0 25 | Case #25: 1 26 | Case #26: 0 27 | Case #27: 0 28 | Case #28: 0 29 | Case #29: 1 30 | Case #30: 0 31 | Case #31: 1 32 | Case #32: 0 33 | Case #33: 1 34 | Case #34: 0 35 | Case #35: 1 36 | Case #36: 0 37 | Case #37: 0 38 | Case #38: 1 39 | Case #39: 1 40 | Case #40: 0 41 | Case #41: 1 42 | Case #42: 1 43 | Case #43: 0 44 | Case #44: 1 45 | Case #45: 1 46 | Case #46: 1 47 | Case #47: 0 48 | Case #48: 0 49 | Case #49: 0 50 | Case #50: 1 51 | Case #51: 1 52 | Case #52: 0 53 | Case #53: 0 54 | Case #54: 0 55 | Case #55: 1 56 | Case #56: 0 57 | Case #57: 0 58 | Case #58: 1 59 | Case #59: 1 60 | Case #60: 0 61 | Case #61: 1 62 | Case #62: 1 63 | Case #63: 0 64 | Case #64: 0 65 | Case #65: 1 66 | Case #66: 1 67 | Case #67: 0 68 | Case #68: 0 69 | Case #69: 0 70 | Case #70: 0 71 | Case #71: 0 72 | Case #72: 1 73 | Case #73: 1 74 | Case #74: 1 75 | Case #75: 1 76 | Case #76: 1 77 | Case #77: 1 78 | Case #78: 0 79 | Case #79: 0 80 | Case #80: 0 81 | Case #81: 0 82 | Case #82: 1 83 | Case #83: 0 84 | Case #84: 1 85 | Case #85: 1 86 | Case #86: 0 87 | Case #87: 0 88 | Case #88: 0 89 | Case #89: 0 90 | Case #90: 1 91 | Case #91: 0 92 | Case #92: 0 93 | Case #93: 1 94 | Case #94: 1 95 | Case #95: 0 96 | Case #96: 0 97 | Case #97: 1 98 | Case #98: 1 99 | Case #99: 0 100 | Case #100: 1 101 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/dbg.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | clang++ sol.cc -DDBG && ./a.out < $1 && emacs log.txt 5 | else 6 | clang++ sol.cc -DDBG && ./a.out < ../input_example && emacs log.txt 7 | fi 8 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/ooooooooooooooooooooo: -------------------------------------------------------------------------------- 1 | Case #1: 0 2 | Case #2: 0 3 | Case #3: 0 4 | Case #4: 0 5 | Case #5: 1 6 | Case #6: 1 7 | Case #7: 1 8 | Case #8: 0 9 | Case #9: 0 10 | Case #10: 0 11 | Case #11: 0 12 | Case #12: 0 13 | Case #13: 0 14 | Case #14: 0 15 | Case #15: 1 16 | Case #16: 1 17 | Case #17: 1 18 | Case #18: 0 19 | Case #19: 0 20 | Case #20: 1 21 | Case #21: 1 22 | Case #22: 1 23 | Case #23: 0 24 | Case #24: 0 25 | Case #25: 1 26 | Case #26: 0 27 | Case #27: 0 28 | Case #28: 0 29 | Case #29: 1 30 | Case #30: 0 31 | Case #31: 1 32 | Case #32: 0 33 | Case #33: 1 34 | Case #34: 0 35 | Case #35: 1 36 | Case #36: 0 37 | Case #37: 0 38 | Case #38: 1 39 | Case #39: 1 40 | Case #40: 0 41 | Case #41: 1 42 | Case #42: 1 43 | Case #43: 0 44 | Case #44: 1 45 | Case #45: 1 46 | Case #46: 1 47 | Case #47: 0 48 | Case #48: 0 49 | Case #49: 0 50 | Case #50: 1 51 | Case #51: 1 52 | Case #52: 0 53 | Case #53: 0 54 | Case #54: 0 55 | Case #55: 1 56 | Case #56: 0 57 | Case #57: 0 58 | Case #58: 1 59 | Case #59: 1 60 | Case #60: 0 61 | Case #61: 1 62 | Case #62: 1 63 | Case #63: 0 64 | Case #64: 0 65 | Case #65: 1 66 | Case #66: 1 67 | Case #67: 0 68 | Case #68: 0 69 | Case #69: 0 70 | Case #70: 0 71 | Case #71: 0 72 | Case #72: 1 73 | Case #73: 1 74 | Case #74: 1 75 | Case #75: 1 76 | Case #76: 1 77 | Case #77: 1 78 | Case #78: 0 79 | Case #79: 1 80 | Case #80: 0 81 | Case #81: 0 82 | Case #82: 1 83 | Case #83: 0 84 | Case #84: 1 85 | Case #85: 1 86 | Case #86: 0 87 | Case #87: 0 88 | Case #88: 1 89 | Case #89: 0 90 | Case #90: 1 91 | Case #91: 0 92 | Case #92: 0 93 | Case #93: 1 94 | Case #94: 1 95 | Case #95: 0 96 | Case #96: 0 97 | Case #97: 1 98 | Case #98: 1 99 | Case #99: 0 100 | Case #100: 1 101 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/run.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | clang++ sol.cc && ./a.out < $1 5 | else 6 | clang++ sol.cc && ./a.out < ../input_example 7 | fi 8 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/sol.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | 16 | #include "utils.h" 17 | 18 | using std::cin; 19 | using std::cout; 20 | using std::endl; 21 | using std::map; 22 | using std::stack; 23 | using std::string; 24 | using std::vector; 25 | 26 | 27 | long long K; 28 | int ANS; 29 | 30 | void handle_input() 31 | { 32 | cin >> K; 33 | } 34 | 35 | // 1234567 8 9 15 36 | // S4 = "0010011" "0" "0011011" 37 | // ^ ^ 38 | // ^ ^ 39 | // 40 | // s4[9] = -1 * s4[7] 41 | // 42 | 43 | void recursively_run(const int n, const long long kkk, const int swit) 44 | { 45 | // cout << "recursively_run(" << n << ", " << kkk << ", " << swit << ")" << endl; 46 | if (n == 1) { 47 | if (swit == -1) 48 | ANS = 1; 49 | else 50 | ANS = 0; 51 | return; 52 | } 53 | 54 | // Here must add (long long) before pow(), it dangerous 55 | const long long total = (long long)pow(2.0, n) - 1; 56 | const long long mid = (total + 1) / 2; 57 | 58 | if (kkk < mid) { 59 | return recursively_run(n - 1, kkk, swit); 60 | } else if (kkk == mid) { 61 | if (swit == -1) 62 | ANS = 1; 63 | else 64 | ANS = 0; 65 | return; 66 | } else if (kkk > total) { 67 | assert(false); 68 | } else { 69 | return recursively_run(n - 1, total + 1 - kkk, -1 * swit); 70 | } 71 | } 72 | 73 | long long run() 74 | { 75 | int ans = 0; 76 | 77 | recursively_run(62, K, 1); 78 | 79 | return ans; 80 | } 81 | 82 | int main() 83 | { 84 | int total_cases_count = 0; 85 | cin >> total_cases_count; 86 | 87 | long long run_ret = 0; 88 | 89 | for (int tt = 1; tt <= total_cases_count; tt++) { 90 | 91 | handle_input(); 92 | 93 | run_ret = run(); 94 | 95 | cout << "Case #" << tt << ": " << ANS << endl; 96 | } 97 | return 0; 98 | } 99 | -------------------------------------------------------------------------------- /2016/round_1a/A/0-kai-1/utils.h: -------------------------------------------------------------------------------- 1 | #ifndef _UTILS_H_ 2 | #define _UTILS_H_ 3 | 4 | #include 5 | #include 6 | 7 | using std::cout; 8 | using std::endl; 9 | using std::vector; 10 | 11 | template 12 | void print_vector(const vector &_nums, const int _n = 10) 13 | { 14 | cout << "[vector] nums=" << endl; 15 | cout << "\t"; 16 | for (int iii = 0; iii < _nums.size(); iii++) { 17 | cout << _nums[iii] << ", "; 18 | if (0 == (iii + 1) % _n) 19 | cout << endl << "\t"; 20 | } 21 | 22 | cout << endl; 23 | } 24 | 25 | template 26 | void print_matrix(const vector > &_matrix) 27 | { 28 | cout << "[vector] matrix=" << endl; 29 | 30 | for (int iii = 0; iii < _matrix.size(); iii++) { 31 | cout << "\t"; 32 | for (int jjj = 0; jjj < _matrix[iii].size(); jjj++) { 33 | cout << _matrix[iii][jjj] << ", "; 34 | } 35 | cout << endl; 36 | } 37 | cout << endl; 38 | } 39 | 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /2016/round_1a/A/input_dbg: -------------------------------------------------------------------------------- 1 | 1 2 | 1000000000000000000 3 | -------------------------------------------------------------------------------- /2016/round_1a/A/input_example: -------------------------------------------------------------------------------- 1 | 4 2 | 1 3 | 2 4 | 3 5 | 10 -------------------------------------------------------------------------------- /2016/round_1a/A/output_dbg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2016/round_1a/A/output_dbg -------------------------------------------------------------------------------- /2016/round_1a/A/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 0 2 | Case #2: 0 3 | Case #3: 1 4 | Case #4: 0 5 | -------------------------------------------------------------------------------- /2016/round_1a/B/0-kai-1/dbg.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | clang++ sol.cc -DDBG && ./a.out < $1 && emacs log.txt 5 | else 6 | clang++ sol.cc -DDBG && ./a.out < ../input_example && emacs log.txt 7 | fi 8 | -------------------------------------------------------------------------------- /2016/round_1a/B/0-kai-1/out: -------------------------------------------------------------------------------- 1 | Case #1: 2 | 1.000000000 3 | 2.000000000 4 | Case #2: 5 | 1.414213562 6 | 2.449489743 7 | -------------------------------------------------------------------------------- /2016/round_1a/B/0-kai-1/run.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | clang++ sol.cc && ./a.out < $1 5 | else 6 | clang++ sol.cc && ./a.out < ../input_example 7 | fi 8 | -------------------------------------------------------------------------------- /2016/round_1a/B/0-kai-1/sol.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include "utils.h" 16 | 17 | using std::cin; 18 | using std::cout; 19 | using std::endl; 20 | using std::map; 21 | using std::stack; 22 | using std::string; 23 | using std::vector; 24 | 25 | #define N_MAX_SIZE 1001 26 | #define M_MAX_SIZE 101 27 | 28 | int N; 29 | int N_arr[N_MAX_SIZE]; 30 | int M; 31 | int M_arr[M_MAX_SIZE][2]; 32 | 33 | void handle_input() 34 | { 35 | cin >> N >> M; 36 | 37 | for (int iii = 0; iii < N; iii++) { 38 | cin >> N_arr[iii]; 39 | } 40 | 41 | for (int iii = 0; iii < M; iii++) { 42 | cin >> M_arr[iii][0] >> M_arr[iii][1]; 43 | } 44 | } 45 | 46 | long long run() 47 | { 48 | int ans = 0; 49 | 50 | for (int iii = 0; iii < M; iii++) { 51 | 52 | long double total_v = 1.0; 53 | const int left = M_arr[iii][0]; 54 | const int right = M_arr[iii][1]; 55 | const int step = right - left + 1; 56 | 57 | for (int jjj = left; jjj <= right; jjj++) { 58 | total_v *= (pow(N_arr[jjj], 1.0 / step)); 59 | } 60 | 61 | // cout << "step==" << step << endl; 62 | // cout << "total_v==" << total_v << endl; 63 | 64 | printf("%.9Lf\n", total_v); 65 | } 66 | 67 | return ans; 68 | } 69 | 70 | int main() 71 | { 72 | int total_cases_count = 0; 73 | cin >> total_cases_count; 74 | 75 | long long run_ret = 0; 76 | 77 | for (int tt = 1; tt <= total_cases_count; tt++) { 78 | 79 | handle_input(); 80 | 81 | cout << "Case #" << tt << ":" << endl; 82 | 83 | run_ret = run(); 84 | } 85 | 86 | return 0; 87 | } 88 | -------------------------------------------------------------------------------- /2016/round_1a/B/0-kai-1/utils.h: -------------------------------------------------------------------------------- 1 | #ifndef _UTILS_H_ 2 | #define _UTILS_H_ 3 | 4 | #include 5 | #include 6 | 7 | using std::cout; 8 | using std::endl; 9 | using std::vector; 10 | 11 | template 12 | void print_vector(const vector &_nums, const int _n = 10) 13 | { 14 | cout << "[vector] nums=" << endl; 15 | cout << "\t"; 16 | for (int iii = 0; iii < _nums.size(); iii++) { 17 | cout << _nums[iii] << ", "; 18 | if (0 == (iii + 1) % _n) 19 | cout << endl << "\t"; 20 | } 21 | 22 | cout << endl; 23 | } 24 | 25 | template 26 | void print_matrix(const vector > &_matrix) 27 | { 28 | cout << "[vector] matrix=" << endl; 29 | 30 | for (int iii = 0; iii < _matrix.size(); iii++) { 31 | cout << "\t"; 32 | for (int jjj = 0; jjj < _matrix[iii].size(); jjj++) { 33 | cout << _matrix[iii][jjj] << ", "; 34 | } 35 | cout << endl; 36 | } 37 | cout << endl; 38 | } 39 | 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /2016/round_1a/B/input_dbg: -------------------------------------------------------------------------------- 1 | 2 2 | 4 2 3 | 1 1 1 1 4 | 0 1 5 | 0 3 6 | -------------------------------------------------------------------------------- /2016/round_1a/B/input_example: -------------------------------------------------------------------------------- 1 | 2 2 | 2 2 3 | 1 4 4 | 0 0 5 | 0 1 6 | 3 2 7 | 1 2 3 8 | 0 1 9 | 1 2 10 | -------------------------------------------------------------------------------- /2016/round_1a/B/output_dbg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2016/round_1a/B/output_dbg -------------------------------------------------------------------------------- /2016/round_1a/B/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 2 | 1.000000000 3 | 2.000000000 4 | Case #2: 5 | 1.414213562 6 | 2.449489743 7 | -------------------------------------------------------------------------------- /2016/round_1a/C/0-kai-1/C-small-practice.in.expected_output: -------------------------------------------------------------------------------- 1 | Case #1: 2 | Case #2: 3 | 77 4 | Case #3: 5 | 7 6 | Case #4: 7 | 7 8 | Case #5: 9 | Case #6: 10 | Case #7: 11 | Case #8: 12 | Case #9: 13 | 45 14 | Case #10: 15 | 83 16 | -------------------------------------------------------------------------------- /2016/round_1a/C/0-kai-1/cebrusfs_2_1.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2016/round_1a/C/0-kai-1/cebrusfs_2_1.zip -------------------------------------------------------------------------------- /2016/round_1a/C/0-kai-1/dbg.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | clang++ sol.cc -DDBG && ./a.out < $1 && emacs log.txt 5 | else 6 | clang++ sol.cc -DDBG && ./a.out < ../input_example && emacs log.txt 7 | fi 8 | -------------------------------------------------------------------------------- /2016/round_1a/C/0-kai-1/run.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | clang++ sol.cc && ./a.out < $1 5 | else 6 | clang++ sol.cc && ./a.out < ../input_example 7 | fi 8 | -------------------------------------------------------------------------------- /2016/round_1a/C/0-kai-1/utils.h: -------------------------------------------------------------------------------- 1 | #ifndef _UTILS_H_ 2 | #define _UTILS_H_ 3 | 4 | #include 5 | #include 6 | 7 | using std::cout; 8 | using std::endl; 9 | using std::vector; 10 | 11 | template 12 | void print_vector(const vector &_nums, const int _n = 10) 13 | { 14 | cout << "[vector] nums=" << endl; 15 | cout << "\t"; 16 | for (int iii = 0; iii < _nums.size(); iii++) { 17 | cout << _nums[iii] << ", "; 18 | if (0 == (iii + 1) % _n) 19 | cout << endl << "\t"; 20 | } 21 | 22 | cout << endl; 23 | } 24 | 25 | template 26 | void print_matrix(const vector > &_matrix) 27 | { 28 | cout << "[vector] matrix=" << endl; 29 | 30 | for (int iii = 0; iii < _matrix.size(); iii++) { 31 | cout << "\t"; 32 | for (int jjj = 0; jjj < _matrix[iii].size(); jjj++) { 33 | cout << _matrix[iii][jjj] << ", "; 34 | } 35 | cout << endl; 36 | } 37 | cout << endl; 38 | } 39 | 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /2016/round_1a/C/input_example: -------------------------------------------------------------------------------- 1 | 2 2 | 3 3 3 | 0 1 10 4 | 1 2 3 5 | 2 0 3 6 | 3 3 7 | 0 1 10 8 | 1 2 3 9 | 2 1 3 10 | -------------------------------------------------------------------------------- /2016/round_1a/C/output_dbg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2016/round_1a/C/output_dbg -------------------------------------------------------------------------------- /2016/round_1a/C/output_example: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2016/round_1a/C/output_example -------------------------------------------------------------------------------- /2016/round_1a/D/0-kai-1/D-large-practice.in.expected_output: -------------------------------------------------------------------------------- 1 | Case #1: 50112 2 | Case #2: 130920 3 | Case #3: 174321 4 | Case #4: 176432 5 | Case #5: 175902 6 | Case #6: 175383 7 | Case #7: 78005 8 | Case #8: 175089 9 | Case #9: 174408 10 | Case #10: 183251 11 | -------------------------------------------------------------------------------- /2016/round_1a/D/0-kai-1/D-small-practice.in.expected_output: -------------------------------------------------------------------------------- 1 | Case #1: 207 2 | Case #2: 356 3 | Case #3: 295 4 | Case #4: 301 5 | Case #5: 335 6 | Case #6: 208 7 | Case #7: 212 8 | Case #8: 201 9 | Case #9: 250 10 | Case #10: 203 11 | -------------------------------------------------------------------------------- /2016/round_1a/D/0-kai-1/dbg.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | clang++ sol.cc -DDBG && ./a.out < $1 && emacs log.txt 5 | else 6 | clang++ sol.cc -DDBG && ./a.out < ../input_example && emacs log.txt 7 | fi 8 | -------------------------------------------------------------------------------- /2016/round_1a/D/0-kai-1/run.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | clang++ sol.cc && ./a.out < $1 5 | else 6 | clang++ sol.cc && ./a.out < ../input_example 7 | fi 8 | -------------------------------------------------------------------------------- /2016/round_1a/D/0-kai-1/utils.h: -------------------------------------------------------------------------------- 1 | #ifndef _UTILS_H_ 2 | #define _UTILS_H_ 3 | 4 | #include 5 | #include 6 | 7 | using std::cout; 8 | using std::endl; 9 | using std::vector; 10 | 11 | template 12 | void print_vector(const vector &_nums, const int _n = 10) 13 | { 14 | cout << "[vector] nums=" << endl; 15 | cout << "\t"; 16 | for (int iii = 0; iii < _nums.size(); iii++) { 17 | cout << _nums[iii] << ", "; 18 | if (0 == (iii + 1) % _n) 19 | cout << endl << "\t"; 20 | } 21 | 22 | cout << endl; 23 | } 24 | 25 | template 26 | void print_matrix(const vector > &_matrix) 27 | { 28 | cout << "[vector] matrix=" << endl; 29 | 30 | for (int iii = 0; iii < _matrix.size(); iii++) { 31 | cout << "\t"; 32 | for (int jjj = 0; jjj < _matrix[iii].size(); jjj++) { 33 | cout << _matrix[iii][jjj] << ", "; 34 | } 35 | cout << endl; 36 | } 37 | cout << endl; 38 | } 39 | 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /2016/round_1a/D/input_dbg: -------------------------------------------------------------------------------- 1 | 1 2 | 3 | 100 100 100 4 | 5 | 1 R 6 | 10 L 7 | 12 R 8 | 20 L 9 | 22 R 10 | 24 L 11 | 30 R 12 | 33 L 13 | 36 R 14 | 38 L 15 | 43 R 16 | 49 L 17 | 55 R 18 | 57 L 19 | 68 R 20 | 74 L 21 | 81 R 22 | 86 L 23 | 89 R 24 | 99 L 25 | 108 R 26 | 115 L 27 | 121 R 28 | 131 L 29 | 134 R 30 | 144 L 31 | 147 R 32 | 149 L 33 | 155 R 34 | 164 L 35 | 172 R 36 | 181 L 37 | 184 R 38 | 189 L 39 | 194 R 40 | 205 L 41 | 216 R 42 | 223 L 43 | 227 R 44 | 233 L 45 | 236 R 46 | 244 L 47 | 254 R 48 | 265 L 49 | 273 R 50 | 280 L 51 | 288 R 52 | 294 L 53 | 302 R 54 | 310 L 55 | 317 R 56 | 322 L 57 | 328 R 58 | 335 L 59 | 345 R 60 | 354 L 61 | 363 R 62 | 370 L 63 | 376 R 64 | 383 L 65 | 394 R 66 | 398 L 67 | 407 R 68 | 415 L 69 | 425 R 70 | 427 L 71 | 433 R 72 | 435 L 73 | 445 R 74 | 452 L 75 | 460 R 76 | 468 L 77 | 479 R 78 | 483 L 79 | 492 R 80 | 497 L 81 | 505 R 82 | 508 L 83 | 511 R 84 | 516 L 85 | 527 R 86 | 538 L 87 | 541 R 88 | 543 L 89 | 554 R 90 | 556 L 91 | 560 R 92 | 567 L 93 | 571 R 94 | 582 L 95 | 591 R 96 | 594 L 97 | 601 R 98 | 610 L 99 | 619 R 100 | 630 L 101 | 634 R 102 | 638 L 103 | 643 R 104 | 645 L 105 | -------------------------------------------------------------------------------- /2016/round_1a/D/input_example: -------------------------------------------------------------------------------- 1 | 2 2 | 3 3 3 3 | 1 R 4 | 2 L 5 | 3 R 6 | 5 3 3 7 | 2 R 8 | 4 R 9 | 6 R 10 | 7 R 11 | 8 R 12 | -------------------------------------------------------------------------------- /2016/round_1a/D/output_dbg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/2016/round_1a/D/output_dbg -------------------------------------------------------------------------------- /2016/round_1a/D/output_example: -------------------------------------------------------------------------------- 1 | Case #1: 3 2 | Case #2: 5 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | This is my code jam solution -------------------------------------------------------------------------------- /demo/0-kai-1/dbg.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ $# == 1 ]; then 4 | clang++ sol.cc -DDBG && ./a.out < $1 && emacs log.txt 5 | else 6 | clang++ sol.cc -DDBG && ./a.out < ../input_example && emacs log.txt 7 | fi 8 | -------------------------------------------------------------------------------- /demo/0-kai-1/log.txt: -------------------------------------------------------------------------------- 1 | >>main() 2 | 3 | >>>>init_only_once() 4 | <<< 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include "utils.h" 16 | 17 | using std::cin; 18 | using std::cout; 19 | using std::endl; 20 | using std::map; 21 | using std::stack; 22 | using std::string; 23 | using std::vector; 24 | 25 | void init_only_once(); 26 | void clear_global_variables(); 27 | void init_per_case(); 28 | 29 | 30 | 31 | 32 | void handle_input() 33 | { 34 | } 35 | 36 | long long run() 37 | { 38 | long long ans = 0; 39 | 40 | 41 | 42 | return ans; 43 | } 44 | 45 | int main() 46 | { 47 | init_only_once(); 48 | 49 | int total_cases_count = 0; 50 | cin >> total_cases_count; 51 | 52 | long long run_ret = 0; 53 | 54 | for (int tt = 1; tt <= total_cases_count; tt++) { 55 | 56 | clear_global_variables(); 57 | 58 | handle_input(); 59 | 60 | init_per_case(); 61 | 62 | run_ret = run(); 63 | 64 | cout << "Case #" << tt << ": " << run_ret << endl; 65 | 66 | } 67 | 68 | return 0; 69 | } 70 | 71 | void init_only_once() 72 | { 73 | } 74 | 75 | void clear_global_variables() 76 | { 77 | } 78 | 79 | void init_per_case() 80 | { 81 | } 82 | -------------------------------------------------------------------------------- /demo/0-kai-1/utils.h: -------------------------------------------------------------------------------- 1 | #ifndef _UTILS_H_ 2 | #define _UTILS_H_ 3 | 4 | #include 5 | #include 6 | 7 | using std::cout; 8 | using std::endl; 9 | using std::vector; 10 | 11 | template 12 | void print_vector(const vector &_nums, const int _n = 10) 13 | { 14 | cout << "[vector] nums=" << endl; 15 | cout << "\t"; 16 | for (int iii = 0; iii < _nums.size(); iii++) { 17 | cout << _nums[iii] << ", "; 18 | if (0 == (iii + 1) % _n) 19 | cout << endl << "\t"; 20 | } 21 | 22 | cout << endl; 23 | } 24 | 25 | template 26 | void print_matrix(const vector > &_matrix) 27 | { 28 | cout << "[vector] matrix=" << endl; 29 | 30 | for (int iii = 0; iii < _matrix.size(); iii++) { 31 | cout << "\t"; 32 | for (int jjj = 0; jjj < _matrix[iii].size(); jjj++) { 33 | cout << _matrix[iii][jjj] << ", "; 34 | } 35 | cout << endl; 36 | } 37 | cout << endl; 38 | } 39 | 40 | 41 | #endif 42 | -------------------------------------------------------------------------------- /demo/input_dbg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/demo/input_dbg -------------------------------------------------------------------------------- /demo/input_example: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/demo/input_example -------------------------------------------------------------------------------- /demo/output_dbg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/demo/output_dbg -------------------------------------------------------------------------------- /demo/output_example: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/loverszhaokai/CodeJam/a078dc56f42fd9dc4ef4e8836db8e79a7088ab32/demo/output_example --------------------------------------------------------------------------------