I have sorted all previously existing 2-cycle algorithms in the following manner.
-I have numbered algorithms based on which algorithms were originally listed first. Their directly related algorithms (which might have been in the middle or even at the end of the list) have been grouped with them.
-If it wasn't in the wiki already, I have added versions of the previously existing algorithms which have no wide turns or cube rotations from every single algorithm listed in the wiki and made that the first version of related algorithms. That is, the algorithms are grouped into groups which shows which algorithms are directly related at some level or another. Advantages: Although not all of the first versions in the algorithm groups are fast, it is ideal to keep them so that people will not make the mistake of accidentally adding duplicates. In addition, people might like to add more versions to a group of algorithms from the first (non speed optimized version alg.). IN ADDITION, it's easy to link them to their decompositions.
-Speaking of decompositions, I have added commutator/conjugate decompositions of the first version alg in each group because they might give insight on how these parity algorithms can be constructed. For most even permutation algorithms, such decompositions might not be so straight forward (because it was actually easy for me to at least pinpoint --in the majority of the algorithms--where the extra quarter turn actually is executed). I will leave the decompositions of the rest of the PLL cases to others in the future.
-The first version of the algorithms is the only version which is guaranteed to solve a cube completely after executing the alg. to the corresponding case image (of course, the decompositions are decompositions of the first algorithms, so they too are guaranteed to completely solve the cube...). The rest of the versions (v2,v3,..etc.) may need U, U', U2, y, y', or y2 (or a combination of U and y) to restore the cube to the starting position and have the cube solved entirely. But I noticed this was done before for many of the algorithms, so I made an effort to omit all last U turns or y cube rotations to shorten the algs. Again, the first versions and their decompositions do not have the last U turns omitted (if the last turn involves U).
-For the symmetric J, N, and R Perms, all algorithms are now evenly distributed among each. If, for example, Ja had some additional algorithms (or additional forms of the same algorithms) which Jb didn't have, then I added those algorithms to Jb. In addition, the algorithms from Ja directly correspond to that of Jb, Na to Nb, and Ra to Rb.
How to keep these algorithms organized:
- If you add an algorithm to Ja, please add its mirror to Jb, even if you don't think it's as fast. (Same for Na and Nb). If you add an algorithm to Rb, please add its mirror + y2 cube rotation to Ra.
- If you add an entirely new algorithm to one of the 2-cycle PLL cases, do not put it in an existing group: make a separate group.
For those who wish to move algorithms around.
You may move the algorithms for a 2-cycle PLL case around in any order you wish. Just make sure that you do not exchange algorithms between groups! Keep all algorithms in their groups so that people in the future will be able to know which algorithms are directly related/only optimized differently. You may move the entire group around, though.
However, if you do move around algorithms or groups, renumber everything please. Also, if you affect Ja, Na, Ra, also affect Jb, Nb, and Ra in the same manner, so that the only main difference between algorithms in either symmetry is a mirror (mirror + y2 cube rotation for Ra between Rb...that is, unless the case image for Rb or Ra is rotated to be just the mirror of the other).