Gyakorlati alapok
A Pénzes-féle bináris skálakatalógus rendezéssel
Ezen fejezet előzménye az előző, a Pénzes-féle bináris skálakatalógus című fejezetben tanulmányozható. A benne foglaltak megértése, illetve annak felfedezése, hogy mennyiben volt újdonság ez a zeneelméletben, középszintű zeneelméleti ismereteket is igényel, éppen ezért ezt most nem részletezem, hiszen zenei honlapomon (www.gitariskola.hu) kellő mélységű és mennyiségű információ áll rendelkezésre.
Ebben a fejezetben az eredetileg csak "ömlesztett" bináris számokat speciális rendezési elv szerint osztályozzuk: legyen ez most az 1-2-3-4...stb. hangos csoportok egymástól elkülönített listázása.
Tehát elvárt eredményünk ilyesféle:
1 hangból álló hangcsoport:
1. - 000000000001
2. - 000000000010
3. - 000000000100
4. - 000000001000
5. - 000000010000
6. - 000000100000
7. - 000001000000
8. - 000010000000
9. - 000100000000
10. - 001000000000
11. - 010000000000
12. - 100000000000
2 hangból álló hangcsoport:
13. - 000000000011
14. - 000000000101
15. - 000000000110
16. - 000000001001
17. - 000000001010
18. - 000000001100
19. - 000000010001
20. - 000000010010
21. - 000000010100
22. - 000000011000
23. - 000000100001
24. - 000000100010
25. - 000000100100
26. - 000000101000
27. - 000000110000
28. - 000001000001
29. - 000001000010
30. - 000001000100
31. - 000001001000
32. - 000001010000
33. - 000001100000
34. - 000010000001
35. - 000010000010
36. - 000010000100
37. - 000010001000
38. - 000010010000
39. - 000010100000
40. - 000011000000
41. - 000100000001
42. - 000100000010
43. - 000100000100
44. - 000100001000
45. - 000100010000
46. - 000100100000
47. - 000101000000
48. - 000110000000
49. - 001000000001
50. - 001000000010
51. - 001000000100
52. - 001000001000
53. - 001000010000
54. - 001000100000
55. - 001001000000
56. - 001010000000
57. - 001100000000
58. - 010000000001
59. - 010000000010
60. - 010000000100
61. - 010000001000
62. - 010000010000
63. - 010000100000
64. - 010001000000
65. - 010010000000
66. - 010100000000
67. - 011000000000
68. - 100000000001
69. - 100000000010
70. - 100000000100
71. - 100000001000
72. - 100000010000
73. - 100000100000
74. - 100001000000
75. - 100010000000
76. - 100100000000
77. - 101000000000
78. - 110000000000
...
11 hangból álló hangcsoport:
4083. - 011111111111
4084. - 101111111111
4085. - 110111111111
4086. - 111011111111
4087. - 111101111111
4088. - 111110111111
4089. - 111111011111
4090. - 111111101111
4091. - 111111110111
4092. - 111111111011
4093. - 111111111101
4094. - 111111111110
12 hangból álló hangcsoport:
4095. - 111111111111
Ezen speciális rendezés nem oldható meg csak olyan módon, ha az elemeket ideiglenes tárolókba helyezzük. Programozástechnikailag a tömb erre nem alkalmas, hiszen mérete állandó és nem változtatható, másrészről nem látjuk előre az elemek számát sem, ám pontosan ilyen helyzetekre találták ki a tömblistát (arraylist).
Azt is megjegyezném, hogy a probléma megoldására lenne elegánsabb megoldás is a 12-szintű egybeágyazott for ciklusnál (bár hozzáteszem, a jelen megoldás éppen egyszerűsége miatt hatékony). Legyen ennek implementációja a Tisztelt Olvasó házi feladata!
Nézzük meg a futtatható Java-kódot:
import
java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<String> store1 = new ArrayList<String>();
ArrayList<String> store2 = new ArrayList<String>();
ArrayList<String> store3 = new ArrayList<String>();
ArrayList<String> store4 = new ArrayList<String>();
ArrayList<String> store5 = new ArrayList<String>();
ArrayList<String> store6 = new ArrayList<String>();
ArrayList<String> store7 = new ArrayList<String>();
ArrayList<String> store8 = new ArrayList<String>();
ArrayList<String> store9 = new ArrayList<String>();
ArrayList<String> store10 = new ArrayList<String>();
ArrayList<String> store11 = new ArrayList<String>();
ArrayList<String> store12 = new ArrayList<String>();
int count = 1;
int countGroups = 1;
for (int a = 0; a <= 1; a++){
for (int b = 0; b <= 1; b++){
for (int c =
0; c <= 1; c++){
for (int d = 0; d <= 1; d++){
for (int e = 0; e <= 1; e++){
for (int f = 0; f <= 1; f++){
for (int g = 0; g <= 1; g++){
for (int h = 0; h <= 1; h++){
for (int i = 0; i <= 1; i++){
for (int j = 0; j <= 1; j++){
for (int k = 0; k <= 1; k++){
for (int l = 0; l <= 1; l++){
String str_a = Integer.toString(a);
String str_b = Integer.toString(b);
String str_c = Integer.toString(c);
String str_d = Integer.toString(d);
String str_e = Integer.toString(e);
String str_f = Integer.toString(f);
String str_g = Integer.toString(g);
String str_h = Integer.toString(h);
String str_i = Integer.toString(i);
String str_j = Integer.toString(j);
String str_k = Integer.toString(k);
String str_l = Integer.toString(l);
String store = str_a + str_b + str_c + str_d + str_e + str_f
+ str_g + str_h + str_i + str_j + str_k + str_l;
int numberBits = 0;
for(int iterator = 0; iterator < store.length(); iterator++) {
char result = store.charAt(iterator);
if(result == '1'){
numberBits++;
}
}
switch (numberBits) {
case (1): store1.add(store); break;
case (2): store2.add(store); break;
case (3): store3.add(store); break;
case (4): store4.add(store); break;
case (5): store5.add(store); break;
case (6): store6.add(store); break;
case (7): store7.add(store); break;
case (8): store8.add(store); break;
case (9): store9.add(store); break;
case (10): store10.add(store); break;
case (11): store11.add(store); break;
case (12): store12.add(store); break;
}
}
}
}
}
}
}
}
}
}
}
}
}
System.out.println(countGroups + " hangból álló hangcsoport:");
for(int i = 0; i < store1.size(); i++) {
System.out.println(count++ + ". - " +
store1.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store2.size(); i++) {
System.out.println(count++ + ". - " +
store2.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store3.size(); i++) {
System.out.println(count++ + ". - " +
store3.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store4.size(); i++) {
System.out.println(count++ + ". - " +
store4.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store5.size(); i++) {
System.out.println(count++ + ". - " +
store5.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store6.size(); i++) {
System.out.println(count++ + ". - " +
store6.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store7.size(); i++) {
System.out.println(count++ + ". - " +
store7.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store8.size(); i++) {
System.out.println(count++ + ". - " +
store8.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store9.size(); i++) {
System.out.println(count++ + ". - " +
store9.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store10.size(); i++) {
System.out.println(count++ + ". - " +
store10.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store11.size(); i++) {
System.out.println(count++ + ". - " +
store11.get(i));
}
System.out.println();
System.out.println(++countGroups + " hangból álló
hangcsoport:");
for(int i = 0; i < store12.size(); i++) {
System.out.println(count++ + ". - " +
store12.get(i));
}
}
}
Eredménylistája - annak standard 4096 db-os hossza miatt-, a következő fejezetben tanulmányozható.