From 43688b22372a2914d6d981c06da7b14d52682530 Mon Sep 17 00:00:00 2001 From: rec0de Date: Tue, 24 Apr 2018 20:55:46 +0200 Subject: [PATCH] Add QuickSort skeleton project --- QuickSort/.classpath | 7 + QuickSort/.project | 17 ++ QuickSort/TestFile1_r_200 | 200 +++++++++++++ QuickSort/TestFile2_a_200 | 200 +++++++++++++ QuickSort/TestFile3_d_200 | 200 +++++++++++++ .../AllTests$QuickSortAComplexityTest.class | Bin 0 -> 4950 bytes .../AllTests$QuickSortASortingTest.class | Bin 0 -> 4156 bytes .../AllTests$QuickSortBComplexityTest.class | Bin 0 -> 4553 bytes .../AllTests$QuickSortBSortingTest.class | Bin 0 -> 4157 bytes .../frame/AllTests$TestFileProvider$1.class | Bin 0 -> 1051 bytes .../frame/AllTests$TestFileProvider$2.class | Bin 0 -> 951 bytes .../bin/frame/AllTests$TestFileProvider.class | Bin 0 -> 2635 bytes QuickSort/bin/frame/AllTests.class | Bin 0 -> 1684 bytes QuickSort/bin/frame/LibraryFileReader.class | Bin 0 -> 1480 bytes QuickSort/bin/frame/SortArray.class | Bin 0 -> 2001 bytes QuickSort/bin/frame/SortingLab.class | Bin 0 -> 1133 bytes QuickSort/bin/lab/QuickSort.class | Bin 0 -> 305 bytes QuickSort/bin/lab/QuickSortA.class | Bin 0 -> 433 bytes QuickSort/bin/lab/QuickSortB.class | Bin 0 -> 433 bytes QuickSort/bin/lab/SortingItem.class | Bin 0 -> 530 bytes QuickSort/src/frame/AllTests.java | 271 ++++++++++++++++++ QuickSort/src/frame/LibraryFileReader.java | 67 +++++ QuickSort/src/frame/SortArray.java | 103 +++++++ QuickSort/src/frame/SortingLab.java | 61 ++++ QuickSort/src/lab/QuickSort.java | 17 ++ QuickSort/src/lab/QuickSortA.java | 28 ++ QuickSort/src/lab/QuickSortB.java | 29 ++ QuickSort/src/lab/SortingItem.java | 29 ++ 28 files changed, 1229 insertions(+) create mode 100755 QuickSort/.classpath create mode 100755 QuickSort/.project create mode 100755 QuickSort/TestFile1_r_200 create mode 100755 QuickSort/TestFile2_a_200 create mode 100755 QuickSort/TestFile3_d_200 create mode 100644 QuickSort/bin/frame/AllTests$QuickSortAComplexityTest.class create mode 100644 QuickSort/bin/frame/AllTests$QuickSortASortingTest.class create mode 100644 QuickSort/bin/frame/AllTests$QuickSortBComplexityTest.class create mode 100644 QuickSort/bin/frame/AllTests$QuickSortBSortingTest.class create mode 100644 QuickSort/bin/frame/AllTests$TestFileProvider$1.class create mode 100644 QuickSort/bin/frame/AllTests$TestFileProvider$2.class create mode 100644 QuickSort/bin/frame/AllTests$TestFileProvider.class create mode 100644 QuickSort/bin/frame/AllTests.class create mode 100644 QuickSort/bin/frame/LibraryFileReader.class create mode 100644 QuickSort/bin/frame/SortArray.class create mode 100644 QuickSort/bin/frame/SortingLab.class create mode 100644 QuickSort/bin/lab/QuickSort.class create mode 100644 QuickSort/bin/lab/QuickSortA.class create mode 100644 QuickSort/bin/lab/QuickSortB.class create mode 100644 QuickSort/bin/lab/SortingItem.class create mode 100755 QuickSort/src/frame/AllTests.java create mode 100755 QuickSort/src/frame/LibraryFileReader.java create mode 100755 QuickSort/src/frame/SortArray.java create mode 100755 QuickSort/src/frame/SortingLab.java create mode 100755 QuickSort/src/lab/QuickSort.java create mode 100755 QuickSort/src/lab/QuickSortA.java create mode 100755 QuickSort/src/lab/QuickSortB.java create mode 100755 QuickSort/src/lab/SortingItem.java diff --git a/QuickSort/.classpath b/QuickSort/.classpath new file mode 100755 index 0000000..d5d7ce9 --- /dev/null +++ b/QuickSort/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/QuickSort/.project b/QuickSort/.project new file mode 100755 index 0000000..55d172b --- /dev/null +++ b/QuickSort/.project @@ -0,0 +1,17 @@ + + + QuickSort + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/QuickSort/TestFile1_r_200 b/QuickSort/TestFile1_r_200 new file mode 100755 index 0000000..528429f --- /dev/null +++ b/QuickSort/TestFile1_r_200 @@ -0,0 +1,200 @@ +E465L;ZPOE;OK +1L1L4;UX8H;Error +8RPUZ;XCTV;OK +JZXHZ;FCB6;Error +FMF1Q;TZ0Q;Error +KC83O;JVA8;Error +NXM6F;6UWJ;Error +3JJG5;VRZE;OK +VM22T;8ESM;Error +L2Z74;99YH;Error +DP56R;7OTD;OK +Q7ZTQ;89QL;OK +86KFC;JR4C;Error +VXNZ7;8ZUK;OK +U36TU;Q5NO;Error +F719A;EV11;Error +EU67U;U9A3;OK +LG932;LEB6;Error +0P5HI;2DMR;OK +0NCJZ;D3CV;OK +1STNG;9LVC;OK +DRRJ7;Q5NO;OK +SAVV1;5KY4;Error +0KQVF;A2B2;OK +9CU9S;2DMR;Error +PAV4X;FJM7;OK +K38C6;FVNX;Error +ZOFOB;XX3N;Error +BSN3X;8AHW;OK +14ST0;1GLP;OK +XBL3V;EGBN;OK +0RC82;WVH9;OK +CLXEN;80QC;Error +JQ83G;L5WJ;OK +BXYWG;YXB1;OK +CO5LB;99YH;OK +K927G;RGU0;OK +NEWII;80QC;OK +NOKXR;2PRB;OK +O1RX0;9LVC;OK +9GRZ6;ZPOE;OK +3W314;H2J2;OK +GFV8X;4TT0;Error +EDG34;09VY;OK +9OZGG;CD24;Error +FMO3R;6UWJ;Error +9OZGG;SF97;OK +8ENSQ;EGV9;OK +YMUEM;9LVC;Error +IUS3K;395W;OK +5IWA9;IAT7;OK +FJCWM;XH85;Error +HS8YT;7V0S;OK +4OVZB;RS9F;OK +9BTCH;8AHW;Error +VUVLP;Y15Z;Error +SYXNL;6YLW;Error +OQZMH;U9A3;OK +G0BSD;EV11;OK +UXF2K;6GIK;OK +7L3ML;7A9L;OK +HRR27;B6JY;Error +REHE6;W3BW;Error +VRDJ7;ATFM;OK +E7A1M;44EK;OK +BGVDD;DD7Y;OK +C5YJW;D6D6;OK +77OJY;WVH9;OK +QRAUS;EV11;Error +H7QMX;ATFM;Error +ZOMQF;YH0E;OK +319BC;WVH9;OK +9CX82;C34A;OK +XHWDP;TP5Y;OK +E95U6;FVNX;Error +TY4L8;P0D3;OK +F719A;XCTV;OK +1JA7N;25C0;Error +LVHB1;T5OJ;OK +OHPOU;KMF6;Error +JRW9L;7A9L;Error +VME7Y;JFE8;OK +5IWA9;8ZUK;OK +BGE1D;4MXI;OK +YQHNJ;0KX3;OK +A7QI4;YXB1;OK +H6H1P;YTB6;OK +DFTPB;ZPOE;Error +CQZ7H;IAT7;OK +LHVNE;VRZE;Error +GFITE;ZJ32;OK +P16DM;YJJ2;Error +CWBC4;Y894;Error +WS23I;WVH9;OK +BQSM1;3P9C;OK +DYBGI;S0SQ;Error +2LX2P;KT7P;Error +8RPUZ;395W;Error +ZSIF7;4Y5Z;Error +SGI9T;5KY4;Error +3DOZW;3ASN;Error +DVOMX;JAQR;OK +CLFZW;9NLE;OK +I7PV7;D6D6;Error +8P8MH;TZ0Q;Error +RQPFF;YH0E;Error +Q5IUI;859T;OK +UJ2HT;D6D6;OK +3FFRR;DN7A;OK +MKO7P;KT7P;OK +ZZ10T;OHGC;OK +TKGOS;DDHF;OK +M4306;5GGN;Error +ESVJM;RJND;Error +WS23I;RGU0;Error +W0KBB;1RE7;Error +9WO9L;P0D3;Error +6O38S;Q50L;OK +BMLKQ;YTB6;Error +2YLSD;9LVC;OK +LKEH0;L2PF;OK +XTIHK;TP5Y;Error +3PY3A;WVH9;Error +3UI43;37J5;OK +YQHNJ;LR7M;Error +OTYAH;43JX;Error +BFC57;0I1Y;Error +UJ2HT;EEDR;OK +8B7N3;OJT3;OK +6KMH1;4Y5Z;OK +I38QI;GSPH;OK +94IJ3;LE63;OK +E9NT6;L5WJ;Error +YC7T3;09VY;OK +QXBAY;Q2L2;OK +G5FWT;XCTV;OK +94IJ3;LEB6;Error +SSG24;YXB1;Error +268AS;2DMR;Error +E465L;F9NB;Error +UXF2K;KT7P;OK +CF16I;4TT0;OK +W1D9U;I014;OK +HHOVE;395W;Error +1JA7N;8ESM;OK +OMH2W;X3M0;OK +3XFEY;5GGN;Error +BUW0P;KT7P;OK +O4SPF;GSPH;OK +A9YFG;CZON;OK +7NMOR;3ID1;Error +USDYV;1RE7;OK +7UAEP;6D24;Error +6XVNR;P0D3;OK +UM6PE;LJ7N;Error +FVLCW;RMHO;OK +YLHFB;R8UM;OK +743OD;MY1V;OK +AUC77;RGU0;Error +Q49RP;DN7A;OK +NH4W8;1RE7;Error +KB7Q0;18FN;Error +6CQWQ;JDDK;OK +ZUU35;DDHF;Error +PIRKE;7A9L;OK +UPTGF;45PZ;OK +M4PKR;VRZE;OK +0JUH1;WVH9;Error +WU7BL;KPAC;OK +T4OJG;O4WO;OK +YNIN7;VWE3;OK +DJTA5;H2J2;OK +KR3V0;X4Q1;Error +DWIK3;KMF6;Error +ZXMUT;RM6U;Error +SFV4O;CTDU;OK +ZE5XG;0KX3;Error +MMHH2;LE63;Error +8PWH0;RM6U;OK +26P62;10KK;OK +S16LO;8ZUK;OK +7GBHX;T5OJ;Error +DVFJ8;SW7O;OK +BBXGH;21W7;Error +B2QM1;OHGC;Error +OA825;7A9L;Error +61AK8;99YH;OK +TC61Z;Q4MB;OK +TZ3WA;6D24;OK +2LIZC;IUS0;Error +IB757;TP5Y;Error +CLFZW;MOM3;OK +CGIT9;A2B2;OK +4H6NB;7OTD;OK +PCAGI;5GGN;OK +L5NTH;RJND;OK +9JELP;37J5;OK +EZPWS;CTDU;OK +QGH3K;43JX;Error +LEYIS;8AHW;Error \ No newline at end of file diff --git a/QuickSort/TestFile2_a_200 b/QuickSort/TestFile2_a_200 new file mode 100755 index 0000000..a9aaf28 --- /dev/null +++ b/QuickSort/TestFile2_a_200 @@ -0,0 +1,200 @@ +0GBP3;86AY;OK +0GBP3;IKXE;OK +0GW45;P2N9;Error +0H6SX;H0JJ;Error +0L064;O8WM;OK +0L064;R0BI;Error +0L064;XSO7;Error +0PJTO;VGA6;OK +0YSKM;DPN4;Error +115BB;WKSI;OK +158A8;JFUE;OK +158A8;KCTK;OK +16RXS;ZM5F;Error +1PEVQ;607G;Error +1PHZC;78TV;OK +2480H;KN8K;Error +2BK6V;W6HR;Error +2ISFI;OCSN;OK +2QYYE;T4BM;Error +2V6VD;HMID;OK +2VN7R;MXRS;OK +32684;T4BM;Error +3581M;9NGF;Error +3GRZ4;CXZV;Error +3QAJU;E8NL;Error +3UPMM;Z6NO;OK +43MZ2;6WM8;Error +448J1;CXQY;OK +448J1;SIS8;OK +5WZS6;6VQ6;Error +5ZO9A;333M;Error +622NT;F56J;OK +624YF;YM29;OK +68VMT;WKSI;OK +6IW9W;T4BM;OK +6SH7N;7JUA;Error +6WVE6;H8JW;Error +706JA;2WXD;OK +74D28;KIRS;Error +7FUNA;WKSI;OK +7Q0TC;E8NL;OK +7Q0TC;ZHO1;Error +7WZDW;8ZRU;Error +87MLJ;IA89;OK +87VBJ;XP7N;Error +8FM9E;WLKL;OK +8K618;O8WM;Error +8MF0K;HEO6;OK +93R1Y;VGA6;Error +979S5;KUMO;Error +98QRU;JMKP;OK +9FKI0;JFUE;Error +9HMDJ;HMID;Error +A46CS;5CAD;Error +AE33P;6EYV;OK +AE33P;8FFE;Error +AVQ1T;IKXE;Error +AYCAP;46XX;OK +B30HO;867Q;Error +B30HO;QUGA;Error +BFJIO;B6BP;OK +BHODM;QUGA;Error +BS1GQ;CXQY;OK +BTMJH;H0JJ;Error +C2DOT;66SO;OK +CA60V;XV31;OK +D0BDA;F9CG;OK +DAXXS;XSO7;Error +DQGZE;IMWN;Error +DSBXK;FLN4;OK +E89EM;4XKA;OK +EDBHN;89BA;OK +EU2Z3;N2AT;Error +F8RPY;Q10Z;OK +FBJ9M;2WXD;OK +FCWQI;WZWB;Error +FJ4JQ;9MMM;Error +FJ4JQ;XSO7;Error +FLKIJ;1JL0;Error +G2LWD;YUIF;OK +G50I2;D05O;OK +G5YES;Z4W7;OK +GETRN;30EP;OK +GHYZV;KCTK;OK +GMCZF;LIDE;Error +GRA1E;ETGA;Error +GSDXS;CJ0G;Error +GWF8H;YM29;Error +H8OQT;HZTZ;OK +HDLS4;FLN4;Error +HJMUK;JTJS;Error +HKJ4Z;OS6Z;OK +HN5WE;A5P1;Error +HPHF4;61U6;Error +HSIK6;XP7N;OK +I4O34;CJ0G;OK +I9NRE;2WXD;Error +ICCT0;CJ0G;Error +IEH2K;2JMX;Error +IV6NS;67X6;Error +J2FHK;6IPE;OK +J2RNK;G9E7;OK +J7BT1;9UPZ;OK +JAEOM;CXZV;Error +JGJMZ;7JUA;Error +JMBBU;67X6;Error +JRWU2;5C3H;Error +JTIKF;FT5L;Error +K2B5N;9RHT;OK +KDT7R;C1HD;Error +KSMOX;HEBA;OK +LI5TN;6WRG;OK +M57DW;JFUE;OK +MAGNO;931H;Error +MGZ00;9UPZ;Error +MGZ00;H8JW;OK +MM1ZE;W6HR;Error +NJZY4;WZGX;OK +NNXXC;W5XD;OK +O3SEP;B10O;OK +O6LPS;A5P1;Error +OBQLI;IA89;OK +OBUQF;PUZ3;Error +OPMJA;2IMJ;Error +OPO09;4XKA;OK +P0A51;C7HC;OK +P0Y4G;XOS3;OK +P6WIR;CXQY;OK +PNUK7;HW49;Error +PNUK7;OLPS;Error +PPT4H;Y4IB;OK +PXUVB;ZVKD;OK +Q6PZO;C7HC;Error +Q6PZO;FX4R;OK +Q7RQX;9RHT;OK +Q8SVP;OL0C;OK +QASS0;46XX;Error +QYHC7;89BA;OK +QYHC7;Q10Z;OK +QYISW;JMKP;Error +R5LG4;1THF;Error +R9G7S;2ENY;OK +RC4IT;36S5;OK +RCOAW;61U6;Error +REN4L;H8JW;OK +RJ4X0;CTX6;Error +RPR1U;8JUJ;Error +RUDFB;7K54;OK +RZSGI;C1HD;Error +SF6HV;320A;Error +SHABI;2IMJ;Error +SKE83;SWZK;Error +SZHCN;Y4IB;OK +T2HR0;86AY;OK +T30ZM;4XKA;OK +TA2ZX;78TV;OK +TI5R3;IKXE;Error +TOBKY;XM2T;Error +TWPJ8;OT1T;Error +TWYGA;477Z;OK +U50BS;R86R;Error +UD0NQ;XM2T;OK +UFPVF;H0JJ;OK +UKB3Z;O8WM;Error +UN9GX;3D6Z;Error +UU7BT;BIDX;OK +UWPYB;W6HR;OK +V0RWP;OS6Z;OK +VF1XC;547O;Error +VL0MR;YOV8;Error +VNSLE;290Y;OK +VPXT7;8FFE;Error +VTLGW;OCGQ;OK +W0YTD;HEBA;OK +W208H;2IMJ;Error +W7EWC;B10O;Error +W9H9D;KN8K;OK +W9O8U;4FHE;OK +WP90I;28KA;Error +WWO8T;WLKL;Error +X51DD;HW49;Error +XD4W2;B6BP;Error +XKDG4;TT2A;Error +XRIP2;O8WM;Error +Y0NFF;30EP;Error +Y206X;2W1J;Error +Y3WZQ;H6KD;Error +Y8SLN;6641;OK +YJ05T;6D3Y;Error +YMLBK;RUNT;OK +YSKQ7;TIEF;OK +YYJ1D;H0JJ;Error +Z1TEX;78TV;Error +ZDYG9;61U6;OK +ZEZ6Z;78TV;Error +ZFQS2;YF49;OK +ZOW24;6IPE;OK +ZP83Z;MXRS;OK +ZREO5;I2MV;OK +ZREO5;T4BM;Error \ No newline at end of file diff --git a/QuickSort/TestFile3_d_200 b/QuickSort/TestFile3_d_200 new file mode 100755 index 0000000..8383af9 --- /dev/null +++ b/QuickSort/TestFile3_d_200 @@ -0,0 +1,200 @@ +ZO1DU;GDBX;Error +ZM6P0;OXS5;Error +ZJ295;MSF2;Error +Z0LWK;V6Q8;Error +YU5Z3;SCFY;OK +YTXJ6;5IMY;OK +YKYMG;2HLI;Error +YGUXQ;3A2Q;OK +YA5YS;LEDT;Error +Y96AD;ZUVS;OK +XYEE7;V05Q;Error +XRTJ4;SZ51;OK +XPJ1I;NUNP;Error +XODKE;R0GS;Error +XH100;SDGS;OK +XFDA0;4MEA;Error +XB7KM;BTR6;OK +X6VO7;WUUF;OK +X2Z08;LEDT;Error +X0YIQ;MEHI;Error +WO4CA;N1IP;Error +WGS8F;EPS3;Error +WCQIY;ZFNL;OK +W74FU;X0ZB;OK +VUW9Q;W4KH;OK +V8HBK;29NW;Error +V5J1T;ZFNL;OK +V1GG0;ICWE;OK +UUNDE;EXV3;OK +UPX7E;PFBH;Error +UGKXM;5JZN;OK +U9UG9;2882;OK +TSE8O;XRG2;Error +TQQIB;SI92;OK +TLLVS;ARTY;OK +TKMV6;QRU2;OK +TH2QA;R0GS;Error +TB5RR;NBKW;OK +T66SV;D8YG;OK +SQ13L;TX35;Error +SMSDM;F4N4;Error +SI3WP;2HLI;Error +SDERI;QVNH;Error +SBLLT;5BF2;Error +S4NUJ;FWAK;Error +RVEWD;YMA9;OK +RRSA0;HU2H;Error +RGDSE;DWUE;Error +R6DIW;GSV9;Error +R3AGO;PYDN;Error +R1C6R;7BNX;Error +QOTSI;MEHI;Error +QMM5X;XPD9;Error +QH8MK;BC31;Error +Q5H11;QVNH;Error +Q3FE0;SDGS;OK +PU3JF;S2MI;Error +PU3JF;FX7J;OK +PRF4N;TQUJ;Error +PHBAF;PRW7;OK +PB6G5;EIPO;Error +P8ZJ5;3A2Q;OK +P34UA;W4KH;OK +OZNJS;SP8I;OK +OYFZZ;5EYM;Error +OO9YN;CE4Q;Error +OEZY2;D29M;OK +O1D4G;S41M;Error +N62UY;ICWE;OK +MWYVH;C8Z2;Error +MRVHM;PFBH;Error +MJ13E;VKF3;Error +ME6BN;W4KH;OK +LWQ1L;TQUJ;OK +LW02D;4DDN;OK +LVLC1;O6WN;Error +LVE40;PYDN;Error +LQH6F;YCRZ;OK +LMQ27;DWUE;OK +L8CZE;RTXJ;OK +L6RT3;TX35;Error +L2QHP;B2QZ;OK +KOJKH;2DPE;OK +KOEK2;XHJP;Error +K3YSH;JEQS;OK +JR6B8;SZ51;Error +JIS9P;BTR6;OK +J6O2J;AII4;OK +IY2EI;P25G;Error +IR9XI;XPD9;OK +IFCGL;SQS8;OK +I49PQ;SZ51;OK +GVJL4;XNXZ;OK +GSR9K;55V3;Error +GORER;B69I;OK +GMERC;YCRZ;OK +GJAWO;PRW7;Error +G5EM7;PBQ5;OK +FYADB;V05Q;Error +FQEVM;8DED;OK +FN2ZA;ICWE;Error +FMY2D;4MEA;Error +EUQ1M;TVVU;Error +ESRAF;0T71;OK +ER3JT;VCD8;OK +EJHHA;ACYP;OK +EFPW5;9X4V;OK +EC1YV;M284;Error +E24VL;24TG;OK +DZEQJ;MSF2;OK +DX3TN;V05Q;Error +DJO3L;SJPV;OK +DIXZD;YMA9;Error +DIGB5;EDII;OK +DFGMB;EHND;Error +D34C2;YCRZ;OK +COTWD;WFK8;OK +CN37J;FOAM;OK +CMBIK;LM9M;Error +CJLIM;ZFNL;OK +C95YJ;4PKB;Error +C5FQR;DWUE;OK +C3QHX;WUUF;Error +BYG1U;2882;OK +BUE8Q;FARW;Error +BT7XY;SZ51;Error +BHFY0;29NW;OK +B4VTE;64PV;OK +B2SLO;D29M;Error +AZRTF;FOAM;Error +AYNQO;T4V4;Error +AQKL0;AII4;OK +AQJH9;QVNH;Error +AO5ZW;PRJA;OK +AO5ZW;9X4V;OK +AMBLP;MEHI;Error +9UKTM;FOAM;OK +9SC2K;X7S3;Error +9POHW;9X4V;OK +990B1;SCFY;OK +97KG6;U1D1;OK +91KC1;QK0I;Error +8YC3S;ICWE;Error +8NM3T;RTXJ;OK +8L88L;NGZ9;Error +8HWP6;SDGS;OK +8AJ9T;86II;Error +8A8FT;55V3;Error +83P67;0N2X;OK +7RP8O;6C3I;OK +7PAZY;SZ51;OK +7PAZY;D8YG;OK +7L3K6;W4KH;OK +74FE7;TX35;Error +74BDS;2V2J;Error +712AV;FVPH;OK +70SQB;SZXV;Error +6Q51I;PRW7;OK +6PW1Z;ML9P;Error +6CAGY;EHND;Error +6359P;02LG;OK +5XNOX;0FX7;OK +5MHY8;RTXJ;OK +5M350;LM9M;Error +5I6ZW;SI92;OK +5I6ZW;BTR6;Error +5GPJ9;SZ51;OK +5FWYC;LM9M;Error +583CX;B51W;OK +573GG;XPD9;Error +4YLPA;PH7F;Error +4RY8Y;2HLI;Error +4ONGU;H44A;Error +4NB1R;FVPH;Error +4GI7V;NBKW;Error +3RRU3;V05Q;OK +3Q5O4;BC31;OK +3OUOJ;3A2Q;Error +3EN9P;VKF3;Error +3EN9P;29NW;Error +3DX9I;NZW9;Error +3CGFX;YM99;OK +3BHYG;LEDT;OK +2Z70A;7AJW;Error +2TDAX;OF8A;OK +2TDAX;NZW9;Error +2P5B1;OXS5;OK +2P0RS;F4N4;OK +2CA7C;5JZN;Error +2BCKD;QMWG;Error +2AUCZ;FU3M;Error +1PXRN;XPD9;OK +1G0XB;VCD8;OK +1D08J;SDGS;OK +1D08J;OXS5;Error +1AJRT;6S6G;OK +16Z41;EXFN;OK +0X1VU;ICWE;OK +0N3JO;IMPQ;Error +0BOFM;ZHMP;Error diff --git a/QuickSort/bin/frame/AllTests$QuickSortAComplexityTest.class b/QuickSort/bin/frame/AllTests$QuickSortAComplexityTest.class new file mode 100644 index 0000000000000000000000000000000000000000..ac101eb29411e8b9b5bdbaa73df6896bf1f2fa96 GIT binary patch literal 4950 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 As{jB1 literal 0 HcmV?d00001 diff --git a/QuickSort/bin/frame/AllTests$QuickSortASortingTest.class b/QuickSort/bin/frame/AllTests$QuickSortASortingTest.class new file mode 100644 index 0000000000000000000000000000000000000000..6341e7e9944db07ea192a9627a9fba0b76899ce9 GIT binary patch literal 4156 zcmb7H340UQ6+L4FBP(MgTu2H5IwnqH8ylHGXo^xA+mOUmu^r^%0!d*kJ=tT+Gh$|B z141{T=;!?#u|uwhZa#Pot-|+TU4#kaGQaR*p$Ksv>DLRu3e}Y$3a*LL8W2)iK-LW^XjDS+cY-l zIBsACw(HPVXU_GeGqY80vP1m>6gK+PL4(aCt-DiLkVh5XuXX56!#ARlP+Eo+^gdr(%j^@fo}8=PDL!19Xjcbyo6b#3+6W~WG4eq@E#)vI(YGr(uP8p0yOxf7d#kAGQ5T z*;*Q9h0^}U1*=?T9c&b^)M;OnQx%Kl>}SU1OEF>gQ>rN2c|758O2fT%gl3$SFj{lb z4rWZ-sZ@i*=EZ?$G#pspe#LVaY^FOi=uKDWl@s`Rx9SxHW#{TjtWi52p9!mH%)mGv zC(}}dq5ii<$&%lhqg5{~#;k!nCb&yoP=#th^havVq=CRDFr{2eRi_{oojDdBmY$LA zVCOqwU=r_T*-a~!-DJ(+%{yRrjg+#n2C9KwuKUVYE0waXJbKb_GKDjEQpXdls^%?a z(DxPVf^EmZ`*4)TSSxLE^pD6`^X-H9@k zC-tTLYQNJIF3hnCds-6APg~ZMuvIjrp*1Wf=_+z}t!|hs6`gkkO%dXjH3WpKR*}}( zdKSfOG%Q>5Q$IJvt%)?MPA;usP0SRJ1iW6o%CF1n)NOcq3@_M zMk;8lHJN>am9ec;yrWVWMJl9goehFv#PI{m3489oH?gfNXO~oAslYBsX^tN|adtR2 zn9q~9Fq>hmoAP9;nff8u4gA2fDvzmP#w}76Kf^C{{9MDHx{_^Y!JSi?T&PKIv`SVX zaJ?l1zr?TjYR4<6Hl^W>#!8M)M#dktoFcDY2J6mMD@|H$L-DLQII&bwjoaV+V&wAX zXB%Y^TOPK`s;pTws&>$sN2 za6I>#fp2kc6Mn}z%4@`Nls8a1Locjc}a87RbHMR)==(+8XcL#&5AU%sDx;rS~#Y8?NB?OW4`5 zXBk~}qwOJ_B9c%vTxu}B<%aRz6~_0*#?K%T8tW8YN_h@;E6eHr(499qT$ zmyng=5e}E}&$Yh}{c#@JdN=eg z<3ow!HGFuo4lm-_qhkEfHPw}Fky@ky(MXBMMR5abc=$BKkNI52XP5Eij<0bh;-cdl zFY`>K%MMxq0s^g~m*4$ZXvpY56ePj3)?=STG34EiJ_-JTj&C>h5XEqjBs^VU0~2#_<^TWy literal 0 HcmV?d00001 diff --git a/QuickSort/bin/frame/AllTests$QuickSortBComplexityTest.class b/QuickSort/bin/frame/AllTests$QuickSortBComplexityTest.class new file mode 100644 index 0000000000000000000000000000000000000000..4aec976044919715476cff6fc96dd736b670876c GIT binary patch literal 4553 zcmb7HX>=P`75<(rdlYrzIL2v~CSlSft>oB|(~Z*{@+WF0k{#r(@>{yZPqhqtz=&=H*OXD!mitjc6w&a_5A(;cQ&81PTT&xywMO* zXg+DqnaP~#OeIGqPg-eTq0yhV3%fe`F16fKH{ac2JGS4W@T~aCmx&35$bg%%)XlPQXkBh;&lKS3rf19d(!+>AP)MwZQFAFo z77<_yn~xS9-=4K5?1D{yeU9V$rf<6r-R(%Z-c<5rk%qkHZQt^eX5LQrTUpn$n6K_N z*oe&p2;ifuPJ z>e-Gz=6jYo+a1MDh23Mm>G`%ZWdt=UNR5p2QjrW_>bE0?-MCi6HB5RHPdegA5LsTF z=N!h1hXI3{G8)}?OX{P(WqO0|DVi8H6494sN+b^&IutgRsS&#AFWR|`x0u zf|Xf?)?g|tR?}s~(2jk=frN~%*Kq@GB#+E|-f}VuTjN8CRd`E*n55?rx4|?TZZ`0A zv&`>O=%}{Hntr6Lx9E7TlyL14ZzL=9KV;{uLKFv>yD-r)0obRb9|MvtH(azrYkW0A z5^jCDP~y(=`YF9dRfydBJkOl(UInUqC@~Sk^Dw00Rth5I*^<4E!+1U^HD&psOh&Rp zWE9y;0S(14j1dh-$j@?dhE0E3$0%;2P0pR76yk%4!Ny*;1o><1Z4C!8+>T=!UcmZS z*FhgEN;*<2I*#KGg_zXX^T)j+g&K(;PfX~z6E9*M!c*8+y9h59~EaF`MAe-c4rM~4cdi#&YVBO z&P>n^b7oF*+91p!vi2&o@+RAOAvr2Hi}bSZu`*)L=@EyI6xzyISL)C>W&6`ckeV*z z-p>0JuCE;;@40g}g`Mp4ri!zc;}^!=M9=( zYgh^So*XQCK?m;EaW7s>E9q*gpn^*IKJrW zvfEx2MV9nkgM%%o!%Kv;uh8*Iyo!5FNfzN^M?K4$&HMJ8m17D{l!&r?<^RW`E+Yr& z9Iw%FMw&z`Re01gGwkpqc`HnEA;zSZvQ)XaCvoYe6UKFA(f7GaQ|vRT;whq%A3d{)ls zby0joVLR&(@|s`_p-v{)^i0{0Wefcn9@g-2Hn^a_E#sDsPvDb;K`xB3Pdd^kxm6sN z&Fs^%TYg41*~6==RNiDiM?6MhadIpazlfYIa#2ouB{GrLVDb^>-pa6H?5bfP#Tjx6 zzUc&gW$!aE+m*7jR(d{7rL)bC9z1$tAk{ZE#uH8jv&!^kiTYjFFZiCBAGZ8yH$yF4 z#3c=1QnmlbMHXbz5 zN=|8FwSjl>Ho#{xXMNi_#OlxE%Cp$oa`ggsm7O*PaQ;95f289-RXAV21#aPV;Li;I7bJLZ$6qUg zca(zH$u7h&vYH=rZ5r>xdlqo$rpSiK8U9~Hsuf3hb!S>JK67)!wg;g_9!8}8A||$- z+0=0V1Eufnmv919^Id}R7(qtvVn!qr^+9^K1m*Y}uYc#yvVRcNKXCy6K?+X=zuEkt?GMKQ!fvY$YHir zwr!l{@QGVM9(Qx#6;OaLPtqs`>wk#uBxeW0B+qd{_W^BtF5zXeu9vqj;MF~C?R&Oe zz-t$4@_N>U>Du4&#wsP)F6mVKeXSbM%KJtY!&Y?#e^%<~QEP)$w}l~>R(&8?tB~qI zu>Lx1#m;cm%`s6v5lgWSbDmgjUqtd&VTT}j`x26tcRoUkklZ01o@C5_VH2KY?*1Lb zrx@s$-Gg@b(^|Z~H;AyW6k%;!J^dbvWG>?Ux0i_>lY*!SbS_R5BaZ5%<&*$sIbD?2 zxd?D6RUan6Qi>Pw(FJ^}<+HURt43^48rpd8P|+Y#sLjq&$|CrD5dD!rom*ID!FZM^ zTnk^sxy7oV#{!=leE$`GzKU<)o5AQ?_%6N|jJ}U2@I(BFR^o-{GAaW234VrOU^9M+ KU*osEoBs#zbJQ*X literal 0 HcmV?d00001 diff --git a/QuickSort/bin/frame/AllTests$QuickSortBSortingTest.class b/QuickSort/bin/frame/AllTests$QuickSortBSortingTest.class new file mode 100644 index 0000000000000000000000000000000000000000..efbd230d7befdc8e6aa3bed85c5a60ddb228e01c GIT binary patch literal 4157 zcmb7H3wsph6@CYn%x0a0WeZvm=meupLc#_?YFSH70&3`*L^dS_v^d%QHkq)Q+0M=; zL~HFud$YFH-Vn9kO0{>T5Gc0xezW#p^mp{>duC?YO|k*|^CoRuzF&QyAI zaz^ES4K4n(UFq!ST6U?K4A<_m9os*k;R9XE7rT#Yhz+>~)d~$a7+8mv1lFR>fR1(z zYrAB_`mF7!k?QQE^2V*nlG2dMx_PT~)beck9Zkjrf`;3c`Dh*oVZ{WMhRsK+j&IMZ zqjtrnu>r?%eap99hqgMht~ZsQsd6KqW!qO?+A7=WK~;1;MW!;XxCxted{9IC(zp$5 z!Oa@$r_HH#u&g3*CfM7K9 zL3f^8%vGWvD3S*WUPqsXo9bc+%?wuUQbBofq%~|C3d3)NE1>DEvfoUg7rQ0Z-7?x^ zU@z{VT&!|gIRy<{yN0`0fQ+n@j*k$mNy1FG7+CtKoZqjZuUTZP+K~j_W#D6ythNzv zv?waS$1bT#93LlPA-f3yIACB9Lqd@oMyg?B*GhzxR=cF6o*{~|38qM=Qd|R`XDtNu z-?9ql2klC^WG#%aLTP{9oK>o_4%P`+>a@4Xsj|g#uB6B0OEF>gBdQ?Vc|7KDN<&v2 zp=m~03Bon!ZGYOdopRORZ$8@pn1(&8J1BeZoXvcv2fV53taAKH&aHZRf!VRV6l>g$ zMQ4KY88tA52S~M4VNd`Y!)(d#^uekZRAa_K4&&UVPOE&?C;S7oZqmSD6PQx3#j2B+ zl1?8A4olO>q}ck77?{APSa(y3bvIEncfz^8GNjmZjT#zR)dJf&vKzCEW(3mQ&FdRj`+{}Fu{!zzHg ziPl11$0VC?*w(IcY@h&=zmbd`QC5M4JX%&^iYP=j>|r@OWnj9tZNjsq-s{^EEV&s2 zr%+0h564I@IZWth*M9hr=#omb!dpAs=;U| zlM`{wvoSri->fw@*Q543OyR;DEwib`!ThvkObJ_sQyN->Vv@EZm)G)+$x_jINzfD_ zZdgG;uxb@(oxNvX%!b2~H9J|b6I{6O1r{lY%IAC~5aTxeMen7koF-NK$ zp_*zvERFp+xjD|tg>!hN>-vTB0)d;A@NgVIq%uUcX3=6=3%tE+QQaQLD=Zv>o$y>| ziuEoMq3^IUhAL>QHJM$4m9ec-ydzQ=1uCR-l?{Sn*s1uI6ZG6&?_*nM)-J02LY`fa z(i}T<-rVnv?f7&fj6+go-bo^Yyj=GXwO+^NB!;57cMQD5xfcA6bClPx<0x;aBt462-BeFblp9ICj=yNQbwwVUv8m&4 z)Y-MS^7SjEUdKQAUeWxjYLr}EOFI5VMO^;`C3jVSeC=f!@+Q`jNqPC_NDn@7&bM;3 z7i;(jBzksUIxA78;ozbYP@HO@tu+J6Nm-I`)KrS^d3v?x`cjl zbOARm;`Y?OMcjEF85thna1nPeahwR^e1`4l*#@V5SDhZjp(vtlgm@2K-CMzZ80O$` z1)o4xX7ac{2=qV1vW~cBLjNPZSMW)oXXh0h11{ru?;;*Pz(;XkOm=W&bIp~tat*#u z_&W(SHOI#`fqj~TO)-u_>~iuLgNr>(ChH9D!VUC%25mUY1f1bz{}Q(1W$eH!*n@M} zhaVHgIXsBhVdIS;*u5dzC|KggBX~4ma|WNqV+?#NM({b@%+Pl*>c=^XB@B#Z z3HM(LV&5I*p{-|a&mx|T6)xke6LokY&(BdYX9L$%S8|QiA`OT}iaaig>tDgcw;6uK z=OUh6#F^CdoC&!|z4#{2gt|=80`NS6zJMNn_u<8cjP{2?5c6WwOS0c@M?hIwLtY-NYsz``y4&otH}84HOahzpK#vf`kVZ`g$uYCj4t5{ l-VR2;#qaS4{E@rF3jf2ypE&+A{))e2GyZ{h@!s8={|6yfbm0I1 literal 0 HcmV?d00001 diff --git a/QuickSort/bin/frame/AllTests$TestFileProvider$1.class b/QuickSort/bin/frame/AllTests$TestFileProvider$1.class new file mode 100644 index 0000000000000000000000000000000000000000..b970e464584590ce36232b5276a09169f4195b1a GIT binary patch literal 1051 zcmah}U2hUW6g>l!1>ClX6+f!BwWvU8*J^D{FeVMDi3z9)O-)QpGb|%aU1o81X#6Ys z8~WmdHSxh8;EyuiSs=E)@US~GXYV<4@3|L#|M~d~z!U5`NHDB@(0m}gy&yOck%>z7 z{Xz!fjSf#_SLo8VgA_yln4fSj;Hu}n?i>r>I7l-TV^oHoWhm02)d<? zx-CA9gz^QYL&UD6t}I;4oSd{hv+n%s?xY4Xw{5upvBifIw{q=pqE37{l%Zl;EL6PCM-$M99TYY2aSF;33{@~5qgPsPw8xtTy^6+-0BZ3e2Zf)TP*%!**hrE*(Hue zuV9H*>N1KGmG=~xB&=8~Tsy;!FIcD*R?e{Y6?3W6^k028h3Hl4^^8oSy literal 0 HcmV?d00001 diff --git a/QuickSort/bin/frame/AllTests$TestFileProvider$2.class b/QuickSort/bin/frame/AllTests$TestFileProvider$2.class new file mode 100644 index 0000000000000000000000000000000000000000..8af5f4cf36f349aa301ad444eee9aa47ed8f8b2c GIT binary patch literal 951 zcmah{U279T6g`u~Y!bI^j9R~KYuB2jwSxsgOc6?mAfzg^RPb%G8IuW{*)TIH{wQC3 zP{9X(fImvSvq{iAWnp&i+&TBox#!;Be}4V~@Eklqj$!AM5o5_ulH^=kXCwcAtrGd( zq?f8MO>`8Xz)&5DOTiPN2mD=cBx4t#$gr7tRmy#YraZJeX&8!bsBH9%(sx(nZxQ%d zY2{uqMD>;E#sx#6o%UrJ3~M0*lq$$$BSaZhhJ4)vHo8j7x6^S?nsd=hBtxy6#v-{8 zM)~vHS@0woc2_+b9eI)>j^)G=yx#r4>elR(DRbtG(t}pxV+pqzN((6~xQqJ%?k%Y} z!-jZ(hYS_#gmLzRazloj^9PnwQf+-j%C0ZJPHK4FeTDxzH0MEi&(f)heOCyvw&?Mp zN0Le%9Ve+J#;4K^(|&*_3|lMO6{3MA6*8HP$B7wC$5K0z@wDDe&47=l)JytL6b%9w z6UF6cC$&|n=ADJrPPHRW387an`xYI_0hi|l&rkx0Dr48_uN?+ziEEWnc zh85d16?s}$z^YY095m@UT4hwodzGvgboQP~bN?H{<`1lY%`n%zFT3&4FHxg&NHN}f z9XDvF&R}z%r9;R(`GSMmt?#(=h0Gj$ieeUWoP}@CAoFknV=E)*tsOkdQtW1t5gyZC Vz#i(@C#yzxdpN)$72qk*_ZLt0=(GR; literal 0 HcmV?d00001 diff --git a/QuickSort/bin/frame/AllTests$TestFileProvider.class b/QuickSort/bin/frame/AllTests$TestFileProvider.class new file mode 100644 index 0000000000000000000000000000000000000000..e07fb5efe41dab8ed0140da5f7d7b3414d4669c5 GIT binary patch literal 2635 zcmb_eU2_v<6n@?|$(HR_v``>?NWp?BP!`IE($qp*%9m*hq!t2*Zj)`gZL%A8H`pkC zqh5LCjo#@Mw>r+y){f|%GyVX74SqcDCflY^rZQt^vhU|P?>Wyo&pG|$@1Gw6IDsz} zGzsjUa*dLy4;G8#rssQI@_WuInwMSYj+HlE1rdSgXN)_BUNr22J~laH=6nS)fn$za z&}S;P{=E1 zOx5$vl7`*r6lg7&K4V%oUB4=@KT*Rb$Pj{J*@Y0U#w`_Fu~&xqC4r8$L?&9X4=*d& zFL2~p6DriXk zq_pvT09|1U2+Qrk3X$uJ2v5{OPBlc0<8yWWqW`=sK#RAEzb!X9T(u>k_AXLc!2~(A%qG z5T|8qM>L$nd2+gFc|@{XG*Wd&m)q5)qAUDv338m{0f&GQ%pnH`N*)aqKY zdtw8|LC@b{a91O$;Tob)yl9y?;2*V zQ@Uvls~Rn>rCmKCNv_ybkdOk~R-H7YDhX)WK*>5&A=1iU50#RS~PDZ$bYDsE2Fkjd5- zHvPj=f(_xKZJX|J(eOM|Iuj;&*t^jQ0?A*L|35VG$9~P#2F`Sjf@Ac+Jk%e9V~yWf zu-St)&b8VFJco^3Q9WLuvUbiRTx~)JXHD25)rq^5RJi_b30t%6@dfOd$DYxHi|7(~ zfCIl_-y)8%d>?;+liyn3!1ad@kmFkHPpnKjYCw*aANU)=N(Z0<-@LH%Se(*${4H4ppLPa`!#F&+ts+ z2=3xKQT%`!CGxei4|(-xEte}lE*UxUHe&;S4c literal 0 HcmV?d00001 diff --git a/QuickSort/bin/frame/AllTests.class b/QuickSort/bin/frame/AllTests.class new file mode 100644 index 0000000000000000000000000000000000000000..b2d1ca3ebb0ab856a9ac3839ad96f63683e279b7 GIT binary patch literal 1684 zcmaJ>T~`}b6y2AZWFQ@&9|>&~ZEI2TVH<6+YE!Twv>HqUBxzdl#UWg9U^0_6nXu&D zKVjGM#RvQ1i)&eQ`QQ)mCv|nT?mJ0o2-0NDoO{nXv(G*s_x}6h?|%S%f^Q6r2uy7G zR!imzj#HPNpkqK6IK5--SvkjYw{t5SJF*!Fj92`XE#+~~c4S9Dlmv{X=lh}62<(>h zy7Y^e!*A6-x778m!1mm{K=iil+QEW=mP$7S^rE*ZW6&^RB8F3AU`!JRq7gDvKP`qh zrVJzm&K?IeaUK^0#=NbXYXP%eE^k-PVTm>(+)NiCy-Z zmea6&TkZQwJ^0=x;_33y$}o%Zj^_uqyRGUVeI}dg`_!l}_`bEDPp`-D9%c+&VZ0u| zq0z+q_&~timcd;|wxk;rRK-%IblI^sa>|e3r9igwV@M%mAWe`VlZh-oB)dh=+pS3w zcX}DAWL~$e7Wjn9$8ZfF8OR-JY0qZjV_atqn_jDJ`LgZ_BvQu_(j`S@&g8r>>S$G3 zo6;{WsU$x&@fkiRH1p|kSlLqKSvz)F%?F3W^Hq1w9IF#YLKRbPa+KBuVvf}bs-e5` z9?F@e7d8uLHG{6@ymA|_1y*zSzSZvcEmrfoep9LeWvgBd^fgr!fn>Gos-bMy9hPcC7sh&j%Sq_AIAM((gR7n1{u&B zSbGDL#gmx~nGDq5z+`bCB1he{Tl;nP=v3C$*q#a z8gH^HCQ!o^>by=KU=9rw@sQd&9`XMzSG!mb6I$qz?k7b0xP?5E9HGZ;%u|j+VgX+; z&MAC{JM`Cyd=~}kB3NYXB%&`cAq=F%a}+7GJK`Cl&qzsQVAX*oet@tC_Xz%F2VbE? cMTQ8=RFt{CPq{+5N?E0>Q9ht-P(H%wfBT@E9smFU literal 0 HcmV?d00001 diff --git a/QuickSort/bin/frame/LibraryFileReader.class b/QuickSort/bin/frame/LibraryFileReader.class new file mode 100644 index 0000000000000000000000000000000000000000..2214ab46b164e2002f83a426d232d42d583b595f GIT binary patch literal 1480 zcmZ`(TTc@~7(LS#7V2^>R|U#Nfwn*qM1&R)5Ckod2*IFFL%YSrvL(yb$S?906NE$( zUrqci{sJGsGrI*+scAC%&3u>nzH`p>*X8#g04A`Z!6(p~wdH{kPno;6w2zm~obkqx z8N=2P5UAgmpJY5It-bih?!J+B1gf$Ov6v#zn7VauI<{%;B?JN)=}3WQ&sT8FTzuZP z<#Eb9a_Fw!H1{m&6l~^4%f%$$->o{!#LA>;na(UL58e%kZ1dv9e8vdEk2)RqP%q#g zjBHnfZR)5%rLvlIXsFWAA`o(0FKsV~X4DDPrA*6MFC6R|_Lkhuxr64@GPf;lQ|*g~ z0q28xB+#Dv4}k2s$|jTwQo=kKDK{;HhRS=&kcL4?t(=GHYl6ll4Q zSSVz(hHYd#PJ`$}zls_l07V#C#&aej+f|4Nh(r)E3~LxF;ol=z#|YvA6-S3TlVTVs z$3+k*Uz?Zezk4I$*17y-?S^{l1zEbSz59Hiw1SbmLM3rrh!NmtudOy!=++Nq@ zVNr&`&3wU58=lHq?mXiW1p;~~em@_*k3YTz*WydyX|-zyc`lTCxYqDwkI_DU!_jlp zM#VQYs3jDQDeD5wJLhQS{;QkZ#`V5ivT=P+%L9ygb%F3s^b`%}=t*6mZzpz+M{8f$!6`z+je}>1o?-Ou&>5cW ztpB|FP2*YY3<>2vNzqCQ_cJd}+}jgKQX4=5izL|()%P?z1vRZBPKl23Y#jak#;L(^ zO!7CytOWCtnCH5PS-ij;R;V5|*9!ko*lBSt9i#LvajIqvU>PrYZyRq|Av%5xp}uI% uaKFkd!DwZ@rj=ryUIZ@DrXj4MPebevYOYvGXmoR#S=QLMz#1ccSpN$!>rYw$ literal 0 HcmV?d00001 diff --git a/QuickSort/bin/frame/SortArray.class b/QuickSort/bin/frame/SortArray.class new file mode 100644 index 0000000000000000000000000000000000000000..7d473d042a0bd9f62bae28f72c457c027a7301df GIT binary patch literal 2001 zcmZuxT~`xV6x}zOFc1dhBcY-Q;ulE_#7ec+L=;8av>~XWP_U&=l1ms332QQGwLhhQ zpf7!B*AiH*Yjye3m;R{QeP==%lX;oBbM853@3YT2^UuG3{srI$c69^Hv~jhV6bX6oVF#JbEBG$ zRZY36a=c9o3>2(N&2*Z!6o~oxWO7xr=rXWs6_q}{#IR9Ynq?Z+4y0{5R=q~h(I0Kg z>9X}@teWL437qy#o{nz_%==zto_TECItz}?#6(v9+Jkyoh7rV=fgy|w1Y_}yFrxTK z$ArMRPoV}*W0H{#>nGMp|Lgz+&Kd}zPo2&g81zmv1`PD6Y-8%;f&m@<>hqF;%eW%Y zZ#k;ux-Bpfi+3nSZCrbL5HTcl#0AFwr*d*@;3|@2Qj@RPx5!C`j&7!PEU*fn@^xI} zNOZL$jFh69!lHpsaD(G#VR{6 zmaCV{>V`>@{B9XFXU|e&l+;uuiEMATUS2?qyB4W~NgaBKb#%n7{1{OVhzc=z#bZBk1HuOH$%-x}XH`3~{@S>g?5C$%GFHW_qJ;OF;$ z|4u9oD}3H08{i_pF7Zck8Kby@3CyvwI2MsWhWovOByyO?Iu@`)dj;3 zL(o+?s;W4fJi?RB#MT>3YtN~RDkI>QG3+|sK^S+L^qx!aycgJ}7sc1E{2Nd*Y8 ziEmm!k|b3tXOx~U*b%ngA$5%JRu$ruLYzwe)&-fzIN6>fU!{l#In#!mX+e&&_UA1~ z6O%2-6yHjb5aFhNZ6{VE0y0wxJ;_3?gaSq1;OXw*9pB)RZ}6G!VCfrNcKONw0MlQl AfdBvi literal 0 HcmV?d00001 diff --git a/QuickSort/bin/frame/SortingLab.class b/QuickSort/bin/frame/SortingLab.class new file mode 100644 index 0000000000000000000000000000000000000000..2c17c7d206d00ba01a25a9eeaa62d5348528b92a GIT binary patch literal 1133 zcma)4YfsZq7=F$+C@Y1*a9jix)Im3tdIOOe6EHDZQZ$NLLj2Tj2Pl>;IdmrcD=!Ho zlK2DsQO4)Ai<50Jerexx&ih>6%g>igZd#x)h^}T}mcF}2Vp0veZearR zq_#_mjdm1-PWYfzcqmcueX>tI%-oA1KO#Pmi6`1Q(*H;G{ zW5$EfBia^Nw)^@}tq$tVvcUM2DQ=r6Vl)eZl7%4*n^?tt1NS)oD|r^y;0R>@s0vIE z6lINulJ%BqaHNxcwzwssJm7YTs=$y64v!djYuPdIwAbQ}i4BZ0Yp>N-b(t(fuDic$ zx{X+332Cl5TdeC~lwr&@Bmv{d@s#DfCwZg6 zyQEI>U${hmp9I(3OU&%Ao@4F;3!nLrkePAPBq8~ja5@3u78aS4rN9zy$CP()w?qAb zKDBRB7xyo)@(uP^*yZ_!bCkhUOrs ZkkAH&HvcKKNug&H+WJo+!ED`yt=}pD?e+iw literal 0 HcmV?d00001 diff --git a/QuickSort/bin/lab/QuickSort.class b/QuickSort/bin/lab/QuickSort.class new file mode 100644 index 0000000000000000000000000000000000000000..7df78d9ee9c15a4d5ea93c35943e7a05f5cd41c4 GIT binary patch literal 305 zcmY+AO>4qH5Qg80(bUxML+{>f58aa|r658<2#P4)Cvn@ZjR~wtp+C!0!9#yQe^lwL zEd?*{yYs=!GyC;@`UEgUFMvmArW~tfX_D7fZi@gup|j&RRw-xCY7y^rQV?omlbPay zP#N5A2>vwR>JSyw8>pg2Xh$Z~^Ku_+yXH96gkF>8?X_r=l?p?)Sf z2m#?{5ItGmYvq6@*7EykHgj9URbJXeKN>f`_0N3oaQ!|6PVNFcc?pzgAdwO$@#@_N fu8!w&DC){Uh-=ZtZ-aOf?*10ql9hiD_0atR6QDmo literal 0 HcmV?d00001 diff --git a/QuickSort/bin/lab/QuickSortA.class b/QuickSort/bin/lab/QuickSortA.class new file mode 100644 index 0000000000000000000000000000000000000000..f921d0f8c03fb8c279b2d0e8d740642de8e20c4f GIT binary patch literal 433 zcmZWlO;5r=5PbtJm0AS+K(F4AgPc5JOo)j|lg7kgxNplMtA!>DnE10inRxIA_@j(( zD~Ul5oq6+S-}KFVe!YJHxWI9MieN8SY5#6*vZqmDSHl3Fps~dXYL{kVR#$>*_iQZi zu8WBdQAIt1kD8#Fn1#Mw&r@yhRhnzTeo|yAA1iBIy&=8T%q#`1WNZ9zAgGrHmNX#f zbd#x7bKNifSgT$JaqNB@Se+Gi!U^qvFK8;)Q>rBv_|`nkh{I8_wwb;$&QbGs$MZ+^ ztZ)kM!$SZSBJRN$uDHSuS8GV$OK@JAWn zRuY3AI`ihuzUiC!{CfWYFu<{ol3*`YasMti$yZyn(A?q#)eEyU>q|kodo~ex z*V$CpQAVwS3aWx2GE04%FJf))Rh(+Uev~CDohWNuy&=8z+^htxXlwjvD5w<%Rx}{! zbfcM73*C2quB=rr!!UHe^{q}aJLQD-zZW!>>KWA%3M$q-%!%vcEVqfiG0su&yW{zz zdR90E_u(Oc5)t=c^jYS6ot<;{f*K7r&a61U0cB}#FgSgMJN;nBi&Ehp^c^q#HsHkSOgb7fDa{} zX$uwI+;i`pJKwo8U*8{}08Y`$Atg`@rQh@7LuIUy&rHsPD9{%IR=YD4NMFTc zWy8X@g92>sFbE>GqCQAJR0bW7WH^+xW4&&s^)w)@JovLRU2E-s&Caj@9yrJ#YckhC zZk0715;E{}H@ZH@sYq)|bUnX?*Vr_9O#DvSmoIca7O44`}ThUx-UqxA*qMjHz> kHei=q0d<01LK~=|i57O3ChiKfHX)MzGHnF*cqfJZADTyAH2?qr literal 0 HcmV?d00001 diff --git a/QuickSort/src/frame/AllTests.java b/QuickSort/src/frame/AllTests.java new file mode 100755 index 0000000..7c07034 --- /dev/null +++ b/QuickSort/src/frame/AllTests.java @@ -0,0 +1,271 @@ +package frame; + +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FilenameFilter; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Stream; + +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.ArgumentsProvider; +import org.junit.jupiter.params.provider.ArgumentsSource; + +import lab.SortingItem; + +/** + * Do NOT change anything in this class! + * + * The test cases defined by this class are used to test if the input file was + * correctly sorted. This class is also responsible for outputting to the + * console. + * + */ + +@DisplayName("QuickSort tests") +class AllTests { + + protected static int NrOfTestFiles; + protected int correct = 0; + protected Duration timeout = Duration.ofSeconds(3); + + static class TestFileProvider implements ArgumentsProvider { + + @Override + public Stream provideArguments(ExtensionContext context) throws Exception { + File dir = new File(System.getProperty("user.dir")); + FilenameFilter filter; + if (context.getParent().get().getDisplayName().startsWith("QuickSortB Complexity")) { + filter = new FilenameFilter() { + public boolean accept(File dir, String name) { + return name.startsWith("TestFile") && !name.contains("_d_"); + } + }; + } else { + filter = new FilenameFilter() { + public boolean accept(File dir, String name) { + return name.startsWith("TestFile"); + } + }; + } + String[] inputFiles = dir.list(filter); + if (inputFiles == null) { + throw new FileNotFoundException("Error: No TestFiles found!"); + } else { + Arrays.sort(inputFiles); + NrOfTestFiles = inputFiles.length; + List tests = new ArrayList(); + for (int i = 0; i < inputFiles.length; i++) { + tests.add(Arguments.of(inputFiles[i], SortingLab.readFile(inputFiles[i]))); + } + return tests.stream(); + } + } + } + + protected boolean sortingTester(SortArray records) { + boolean sorted = true; + SortingItem lastRecord = records.getElementAt(0); + for (int i = 1; i < records.getNumberOfItems() && sorted; i++) { + SortingItem actualRecord = records.getElementAt(i); + sorted = (actualRecord.BookSerialNumber.compareTo(lastRecord.BookSerialNumber) > 0) + || ((actualRecord.BookSerialNumber.compareTo(lastRecord.BookSerialNumber) == 0) + && ((actualRecord.ReaderID.compareTo(lastRecord.ReaderID) > 0) + || ((actualRecord.ReaderID.compareTo(lastRecord.ReaderID) == 0)))); + lastRecord = actualRecord; + } + return sorted; + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + @DisplayName("QuickSortA Sorting") + class QuickSortASortingTest { + + @BeforeAll + public void init() { + correct = 0; + System.out.println("Starting QuicksortA tests!"); + } + + @AfterAll + public void tearDown() { + System.out.println("Correct QuicksortA sortings: " + correct + " out of " + NrOfTestFiles + " tests\n"); + } + + @DisplayName("Tests") + @ParameterizedTest(name = "QuicksortA sorting test with input: {0}") + @ArgumentsSource(TestFileProvider.class) + public void testQuicksortA(String inputFile, SortArray records) { + assertTimeoutPreemptively(timeout, () -> { + SortingLab.QuicksortA(records, 0, records.getNumberOfItems() - 1); + }, () -> { + System.out.println("QuicksortA [" + inputFile + "]: Execution timed out after: " + timeout.getSeconds() + + " seconds"); + return "Test failed!"; + }); + int readOps = records.getReadingOperations(); + int writeOps = records.getWritingOperations(); + assertTrue(sortingTester(records), () -> { + System.out.println("QuicksortA [" + inputFile + "]: Wrong order!"); + return "Test failed!"; + }); + System.out.println( + "QuicksortA [" + inputFile + "]: Correct order! Read Ops: " + readOps + "; Write Ops: " + writeOps); + correct++; + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + @DisplayName("QuickSortB Sorting") + class QuickSortBSortingTest { + + @BeforeAll + public void init() { + correct = 0; + System.out.println("Starting QuicksortB tests!"); + } + + @AfterAll + public void tearDown() { + System.out.println("Correct QuicksortB sortings: " + correct + " out of " + NrOfTestFiles + " tests\n"); + } + + @DisplayName("Tests") + @ParameterizedTest(name = "QuicksortB sorting test with input: {0}") + @ArgumentsSource(TestFileProvider.class) + public void testQuicksortB(String inputFile, SortArray records) { + assertTimeoutPreemptively(timeout, () -> { + SortingLab.QuicksortB(records, 0, records.getNumberOfItems() - 1); + }, () -> { + System.out.println("QuicksortB [" + inputFile + "]: Execution timed out after: " + timeout.getSeconds() + + " seconds"); + return "Test failed!"; + }); + int readOps = records.getReadingOperations(); + int writeOps = records.getWritingOperations(); + assertTrue(sortingTester(records), () -> { + System.out.println("QuicksortB [" + inputFile + "]: Wrong order!"); + return "Test failed!"; + }); + System.out.println( + "QuicksortB [" + inputFile + "]: Correct order! Read Ops: " + readOps + "; Write Ops: " + writeOps); + correct++; + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + @DisplayName("QuickSortA Complexity") + class QuickSortAComplexityTest { + + @BeforeAll + public void init() { + correct = 0; + System.out.println("Starting QuicksortA complexity tests!"); + } + + @AfterAll + public void tearDown() { + System.out.println( + "Passed complexity tests for QuicksortA: " + correct + " out of " + NrOfTestFiles + " tests\n"); + } + + private void complexityTesterA(SortArray records, String inputFile, int readOps) { + int n = records.getNumberOfItems(); + double nlogn = n * (Math.log(n) / Math.log(2)) * 5; + assertTrue(readOps > 0); + if (inputFile.contains("_r_")) { + assertTrue(readOps < nlogn, () -> { + System.out.println("QuickSortA complexity test failed for file: " + inputFile + + " - complexity out of allowed range: O(nlog(n)) required!"); + return "Test failed!"; + }); + } else if (inputFile.contains("_a_") || inputFile.contains("_d_")) { + assertTrue(readOps > Math.pow(n, 2) / 2, () -> { + System.out.println("QuickSortA complexity test failed for file: " + inputFile + + " - complexity out of allowed range: O(n^2) required!"); + return "Test failed!"; + }); + } + correct++; + } + + @DisplayName("Tests") + @ParameterizedTest(name = "QuicksortA complexity test with input: {0}") + @ArgumentsSource(TestFileProvider.class) + public void testQuicksortAComplexity(String inputFile, SortArray records) { + assertTimeoutPreemptively(timeout, () -> { + SortingLab.QuicksortA(records, 0, records.getNumberOfItems() - 1); + }, () -> { + System.out.println("Complexity QuicksortA [" + inputFile + "]: Execution timed out after: " + + timeout.getSeconds() + " seconds"); + return "Test failed!"; + }); + int readOps = records.getReadingOperations(); + complexityTesterA(records, inputFile, readOps); + System.out.println("Complexity QuicksortA [" + inputFile + "]: Complexity within allowed range!"); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + @DisplayName("QuickSortB Complexity") + class QuickSortBComplexityTest { + + @BeforeAll + public void init() { + correct = 0; + System.out.println("Starting QuicksortB complexity tests!"); + } + + @AfterAll + public void tearDown() { + System.out.println( + "Passed complexity tests for QuicksortB: " + correct + " out of " + NrOfTestFiles + " tests\n"); + } + + private void complexityTesterB(SortArray records, String inputFile, int readOps) { + int n = records.getNumberOfItems(); + double nlogn = n * (Math.log(n) / Math.log(2)) * 5; + + assertTrue(readOps > 0); + assertTrue(readOps < nlogn, () -> { + System.out.println("QuickSortB complexity test failed for file: " + inputFile + + " - complexity out of allowed range: O(nlog(n)) required!"); + return "Test failed!"; + }); + correct++; + } + + @DisplayName("Tests") + @ParameterizedTest(name = "QuicksortB complexity test with input: {0}") + @ArgumentsSource(TestFileProvider.class) + public void testQuicksortBComplexity(String inputFile, SortArray records) { + assertTimeoutPreemptively(timeout, () -> { + SortingLab.QuicksortB(records, 0, records.getNumberOfItems() - 1); + }, () -> { + System.out.println("Complexity QuicksortB [" + inputFile + "]: Execution timed out after: " + + timeout.getSeconds() + " seconds"); + return "Test failed!"; + }); + int readOps = records.getReadingOperations(); + complexityTesterB(records, inputFile, readOps); + System.out.println("Complexity QuicksortB [" + inputFile + "]: Complexity within allowed range!"); + } + } +} \ No newline at end of file diff --git a/QuickSort/src/frame/LibraryFileReader.java b/QuickSort/src/frame/LibraryFileReader.java new file mode 100755 index 0000000..4d7bd4b --- /dev/null +++ b/QuickSort/src/frame/LibraryFileReader.java @@ -0,0 +1,67 @@ +package frame; + +import java.io.BufferedReader; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.util.ArrayList; + +/** + * Do NOT change anything in this class! + * + * This class contains a method for reading the input files into a Vector + * structure. + * + * @author Stefan Kropp + */ +public class LibraryFileReader { + + private String filename = null; + private ArrayList data = null; + + /** + * The file should be in the same directory as the java application. if not, + * you have to provide the absolute or relative path information within the + * filename string. + * + * @param filename + * the name of the file to read + */ + public LibraryFileReader(String filename) { + this.filename = filename; + this.data = new ArrayList(); + } + + /** + * Reads a file, specified in the private field filename and returns the + * information read. The file should have the same format as specified in + * the first lab. + * + * @return Returns a Vector which holds 3-dimensional String arrays with + * following format: BookSerialNumber, ReaderID, Status. In the case + * an error occured null is returned. + */ + public ArrayList readFile() { + try { + FileReader fr = new FileReader(filename); + BufferedReader in = new BufferedReader(fr); + + String line; + while ((line = in.readLine()) != null) { + data.add(line.split(";")); + } + + in.close(); + fr.close(); + + return data; + + } catch (FileNotFoundException e) { + e.printStackTrace(); + return null; + } catch (IOException e) { + e.printStackTrace(); + return null; + } + } +} diff --git a/QuickSort/src/frame/SortArray.java b/QuickSort/src/frame/SortArray.java new file mode 100755 index 0000000..0ef5fbb --- /dev/null +++ b/QuickSort/src/frame/SortArray.java @@ -0,0 +1,103 @@ +package frame; + +import java.util.ArrayList; + +import lab.SortingItem; + +/** + * Do NOT change anything in this class! + * + * The SortArray class provides simple basic functions, to store a list of + * sortingItems to track the number of operations. + * + * This class contains two members (readingOperations and writingOperations) + * that act as counters for the number of accesses to the arrays to be sorted. + * These are used by the JUnit tests to construct the output. The methods + * provided in this class should be sufficient for you to sort the records of + * the input files. + * + * @author Stefan Kropp + */ + +public class SortArray { + + private int numberOfItems; + + private ArrayList listOfItems; + + private int readingOperations; + private int writingOperations; + + /** + * @param numberOfItems + * number of items to hold + */ + public SortArray(ArrayList items) { + numberOfItems = items.size(); + readingOperations = 0; + writingOperations = 0; + listOfItems = new ArrayList<>(); + + for (String[] element : items) { + SortingItem s = new SortingItem(); + s.BookSerialNumber = element[0]; + s.ReaderID = element[1]; + s.Status = element[2]; + listOfItems.add(s); + } + } + + /** + * sets the elements at index. if index is >= numberOfItems or less then + * zero an IndexOutOfBoundException will occur. + * + * @param index + * the index of the Elements to set + * @param record + * a 3-dimensional record which holds: BookSerialNumber, + * ReaderID, Status + */ + public void setElementAt(int index, SortingItem record) { + this.listOfItems.set(index, record); + + writingOperations++; + } + + /** + * Retrieves the information stored at position Index. if index is >= + * numberOfItems or less then zero an IndexOutOfBoundException will occur. + * + * @param index + * Index defines which elements to retrieve from the SortArray + * @return Returns a 3-dimensional String array with following format: + * BookSerialNumber, ReaderID, Status. + * + */ + public SortingItem getElementAt(int index) { + + SortingItem result = new SortingItem(this.listOfItems.get(index)); + readingOperations++; + return result; + } + + /** + * @return Returns the number of reading operations. + */ + public int getReadingOperations() { + return readingOperations; + } + + /** + * @return Returns the number of writing operations. + */ + public int getWritingOperations() { + return writingOperations; + } + + /** + * @return Returns the numberOfItems. + */ + public int getNumberOfItems() { + return numberOfItems; + } +} diff --git a/QuickSort/src/frame/SortingLab.java b/QuickSort/src/frame/SortingLab.java new file mode 100755 index 0000000..752d771 --- /dev/null +++ b/QuickSort/src/frame/SortingLab.java @@ -0,0 +1,61 @@ +package frame; + +import lab.QuickSort; +import lab.QuickSortA; +import lab.QuickSortB; + +public class SortingLab { + + /** + * Reads the file specified in filename and returns the data as a SortArray + * + * @param filename + * the path and name of the file to read + * @return Returns a SortArray filled with the data of the input file + */ + public static SortArray readFile(String filename) { + LibraryFileReader fileReader = new LibraryFileReader(filename); + return new SortArray(fileReader.readFile()); + } + + static QuickSort sortingMethod; + + /** + * Uses the Quicksort A algorithm to sort the records (the pivot is the + * first element in the list) + * + * @param records + * unsorted SortArray data + * @param left + * the left bound for the algorithm + * @param right + * the right bound for the algorithm + * @return Returns the sorted SortArray + */ + public static SortArray QuicksortA(SortArray records, int left, int right) { + + sortingMethod = new QuickSortA(); + sortingMethod.Quicksort(records, left, right); + return records; + } + + /** + * Uses the Quicksort B algorithm to sort the records (the pivot is the + * median between first, last and middle element in the list) + * + * @param records + * unsorted SortArray data + * @param left + * the left bound for the algorithm + * @param right + * the right bound for the algorithm + * @return Returns the sorted SortArray + */ + public static SortArray QuicksortB(SortArray records, int left, int right) { + + sortingMethod = new QuickSortB(); + sortingMethod.Quicksort(records, left, right); + return records; + } + +} diff --git a/QuickSort/src/lab/QuickSort.java b/QuickSort/src/lab/QuickSort.java new file mode 100755 index 0000000..006d8ac --- /dev/null +++ b/QuickSort/src/lab/QuickSort.java @@ -0,0 +1,17 @@ +package lab; + +import frame.SortArray; + +/** + * Abstract superclass for the Quicksort algorithm. + * + * @author NAJI + */ +public abstract class QuickSort { + + // DO NOT modify this method + public abstract void Quicksort(SortArray records, int left, int right); + + // You may add additional methods here + +} diff --git a/QuickSort/src/lab/QuickSortA.java b/QuickSort/src/lab/QuickSortA.java new file mode 100755 index 0000000..b16b679 --- /dev/null +++ b/QuickSort/src/lab/QuickSortA.java @@ -0,0 +1,28 @@ +package lab; + +import frame.SortArray; + +public class QuickSortA extends QuickSort { + + /** + * Quicksort algorithm implementation to sort a SorrtArray by choosing the + * pivot as the first (leftmost) element in the list + * + * @param records + * - list of elements to be sorted as a SortArray + * @param left + * - the index of the left bound for the algorithm + * @param right + * - the index of the right bound for the algorithm + * @return Returns the sorted list as SortArray + */ + @Override + public void Quicksort(SortArray records, int left, int right) { + // TODO + // implement the Quicksort A algorithm to sort the records + // (choose the pivot as the first (leftmost) element in the list) + } + + // You may add additional methods here + +} diff --git a/QuickSort/src/lab/QuickSortB.java b/QuickSort/src/lab/QuickSortB.java new file mode 100755 index 0000000..8376ddc --- /dev/null +++ b/QuickSort/src/lab/QuickSortB.java @@ -0,0 +1,29 @@ +package lab; + +import frame.SortArray; + +public class QuickSortB extends QuickSort { + + /** + * Quicksort algorithm implementation to sort a SorrtArray by choosing the + * pivot as the median of the elements at positions (left,middle,right) + * + * @param records + * - list of elements to be sorted as a SortArray + * @param left + * - the index of the left bound for the algorithm + * @param right + * - the index of the right bound for the algorithm + * @return Returns the sorted list as SortArray + */ + @Override + public void Quicksort(SortArray records, int left, int right) { + // TODO + // implement the Quicksort B algorithm to sort the records + // (choose the pivot as the median value of the elements at position + // (left (first),middle,right(last))) + } + + // You may add additional methods here + +} diff --git a/QuickSort/src/lab/SortingItem.java b/QuickSort/src/lab/SortingItem.java new file mode 100755 index 0000000..036b3bb --- /dev/null +++ b/QuickSort/src/lab/SortingItem.java @@ -0,0 +1,29 @@ +package lab; + +/** + * + * This class represents one entry of the list that has to be sorted. + * + */ +public class SortingItem { + + // DO NOT modify + public String BookSerialNumber; + public String ReaderID; + public String Status; + + // DO NOT modify + public SortingItem() { + + } + + // DO NOT modify + public SortingItem(SortingItem otherItem) { + this.BookSerialNumber = otherItem.BookSerialNumber; + this.ReaderID = otherItem.ReaderID; + this.Status = otherItem.Status; + } + + // You may add additional methods here + +}