topcoder/src/KingSort.java at master · yuki2006/topcoder · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.Comparator;

// Paste me into the FileEdit configuration dialog

publicclassKingSortimplementsComparator<String> {
classMaps {
publicMaps(Stringstr, intnumber) {
super();
this.key = str;
this.value = number;
 }

Stringkey;
intvalue;
	}

ArrayList<Maps> mChars = newArrayList<Maps>() {
/**
 *
 */
privatestaticfinallongserialVersionUID = 1L;

 {
add(newMaps("IV", 4));
add(newMaps("V", 5));
add(newMaps("IX", 9));
add(newMaps("XL", 40));

add(newMaps("X", 10));
add(newMaps("L", 50));
add(newMaps("I", 1));
 }

	};

publicString[] getSortedList(String[] kings) {
Arrays.sort(kings, this);
returnkings;

	}

publicintcompare(Stringo1, Stringo2) {
String[] split1 = o1.split(" ");
String[] split2 = o2.split(" ");

if (split1[0].compareTo(split2[0]) == 0) {
inti1 = getRomaNumber(split1[1]);
inti2 = getRomaNumber(split2[1]);
returni1 == i2 ? 0 : i1 > i2 ? 1 : -1;
 }

returnsplit1[0].compareTo(split2[0]);
	}

privateintgetRomaNumber(Stringsplit1) {
intnumber = 0;
for (inti = 0; i < split1.length();) {
for (Mapshash : mChars) {
if (split1.substring(i).matches("^" + hash.key + ".*")) {
number += hash.value;
i += hash.key.length();
break;
 }
 }
 }
returnnumber;
	}

// BEGIN CUT HERE
publicstaticvoidmain(String[] args) {
if (args.length == 0) {
KingSortHarness.run_test(-1);
 } else {
for (inti = 0; i < args.length; ++i)
KingSortHarness.run_test(Integer.valueOf(args[i]));
 }
	}
// END CUT HERE
}

// BEGIN CUT HERE
classKingSortHarness {
publicstaticvoidrun_test(intcasenum) {
if (casenum != -1) {
if (runTestCase(casenum) == -1)
System.err.println("Illegal input! Test case " + casenum + " does not exist.");
return;
 }

intcorrect = 0, total = 0;
for (inti = 0;; ++i) {
intx = runTestCase(i);
if (x == -1) {
if (i >= 100)
break;
continue;
 }
correct += x;
 ++total;
 }

if (total == 0) {
System.err.println("No test cases run.");
 } elseif (correct < total) {
System.err.println("Some cases FAILED (passed " + correct + " of " + total + ").");
 } else {
System.err.println("All " + total + " tests passed!");
 }
	}

staticbooleancompareOutput(String[] expected, String[] result) {
if (expected.length != result.length)
returnfalse;
for (inti = 0; i < expected.length; ++i)
if (!expected[i].equals(result[i]))
returnfalse;
returntrue;
	}

staticStringformatResult(String[] res) {
Stringret = "";
ret += "{";
for (inti = 0; i < res.length; ++i) {
if (i > 0)
ret += ",";
ret += String.format(" \"%s\"", res[i]);
 }
ret += " }";
returnret;
	}

staticintverifyCase(intcasenum, String[] expected, String[] received) {
System.err.print("Example " + casenum + "... ");
if (compareOutput(expected, received)) {
System.err.println("PASSED");
return1;
 } else {
System.err.println("FAILED");
System.err.println(" Expected: " + formatResult(expected));
System.err.println(" Received: " + formatResult(received));
return0;
 }
	}

staticintrunTestCase(intcasenum) {
switch (casenum) {
case0: {
String[] kings = { "Louis IX", "Louis VIII" };
String[] expected__ = { "Louis VIII", "Louis IX" };

returnverifyCase(casenum, expected__, newKingSort().getSortedList(kings));
 }
case1: {
String[] kings = { "Louis IX", "Philippe II" };
String[] expected__ = { "Louis IX", "Philippe II" };

returnverifyCase(casenum, expected__, newKingSort().getSortedList(kings));
 }
case2: {
String[] kings = { "Richard III", "Richard I", "Richard II" };
String[] expected__ = { "Richard I", "Richard II", "Richard III" };

returnverifyCase(casenum, expected__, newKingSort().getSortedList(kings));
 }
case3: {
String[] kings = { "John X", "John I", "John L", "John V" };
String[] expected__ = { "John I", "John V", "John X", "John L" };

returnverifyCase(casenum, expected__, newKingSort().getSortedList(kings));
 }
case4: {
String[] kings = { "Philippe VI", "Jean II", "Charles V", "Charles VI", "Charles VII", "Louis XI" };
String[] expected__ = { "Charles V", "Charles VI", "Charles VII", "Jean II", "Louis XI", "Philippe VI" };

returnverifyCase(casenum, expected__, newKingSort().getSortedList(kings));
 }
case5: {
String[] kings = { "Philippe II", "Philip II" };
String[] expected__ = { "Philip II", "Philippe II" };

returnverifyCase(casenum, expected__, newKingSort().getSortedList(kings));
 }

// custom cases

case6: {
String[] kings = { "Richard III", "Richard I", "Richard II" };
String[] expected__ = { "Richard I", "Richard II", "Richard III" };

returnverifyCase(casenum, expected__, new
KingSort().getSortedList(kings));
 }
case7: {
String[] kings = { "Carlos XIV", "Carlos XV" };
String[] expected__ = { "Carlos XIV", "Carlos XV" };;

returnverifyCase(casenum, expected__, new
KingSort().getSortedList(kings));
 }
case10: {
String[] kings = { "Carlos XXI", "Carlos IX", "Carlos XLIX", "Carlos XLIV", "Carlos XXXV", "Carlos XXIX",
"Carlos XXXIII", "Carlos XXVI", "Carlos XIII", "Carlos XLVIII", "Carlos XL", "Carlos XXXVIII",
"Carlos XI", "Carlos XXIII", "Carlos XXXVII", "Carlos XXVIII", "Carlos XXV", "Carlos XXX",
"Carlos XLII", "Carlos XVIII", "Carlos III", "Carlos XV", "Carlos VIII", "Carlos XXIV",
"Carlos XLVI", "Carlos II", "Carlos XIV", "Carlos VI", "Carlos L", "Carlos I", "Carlos XXXIX",
"Carlos XLVII", "Carlos XXXVI", "Carlos XXVII", "Carlos XX", "Carlos XXII", "Carlos XIX",
"Carlos XII", "Carlos XXXIV", "Carlos XVII", "Carlos XVI", "Carlos XXXII", "Carlos X", "Carlos V",
"Carlos XXXI", "Carlos IV", "Carlos XLIII", "Carlos XLI", "Carlos XLV", "Carlos VII" };
String[] expected__ = { "Carlos I", "Carlos II", "Carlos III", "Carlos IV", "Carlos V", "Carlos VI",
"Carlos VII", "Carlos VIII", "Carlos IX", "Carlos X", "Carlos XI", "Carlos XII", "Carlos XIII",
"Carlos XIV", "Carlos XV", "Carlos XVI", "Carlos XVII", "Carlos XVIII", "Carlos XIX", "Carlos XX",
"Carlos XXI", "Carlos XXII", "Carlos XXIII", "Carlos XXIV", "Carlos XXV", "Carlos XXVI",
"Carlos XXVII", "Carlos XXVIII", "Carlos XXIX", "Carlos XXX", "Carlos XXXI", "Carlos XXXII",
"Carlos XXXIII", "Carlos XXXIV", "Carlos XXXV", "Carlos XXXVI", "Carlos XXXVII", "Carlos XXXVIII",
"Carlos XXXIX", "Carlos XL", "Carlos XLI", "Carlos XLII", "Carlos XLIII", "Carlos XLIV",
"Carlos XLV", "Carlos XLVI", "Carlos XLVII", "Carlos XLVIII", "Carlos XLIX", "Carlos L" };

returnverifyCase(casenum, expected__, new
KingSort().getSortedList(kings));
 }

/*
 * case 8: {
 * String[] kings = ;
 * String[] expected__ = ;
 *
 * return verifyCase(casenum, expected__, new
 * KingSort().getSortedList(kings));
 * }
 */
default:
return -1;
 }
	}
}

// END CUT HERE