# Square-1 Yoyleberry Method



## TyeDye (May 12, 2017)

I found this method just searching around the wiki a few days ago and I thought that it was very interesting. It was created by Cary Huang (Cube Roll on YouTube) and he made a video explanation of it as well here: 



It is pretty much based on the fact that when a square-1 is not in cubeshape, you can control parity easier based on the fact that parity occurs when a square-1 is brought out of cubeshape.

*Steps:*

1.) Cubeshape - Yeah, I know I just said that it doesn't use cubeshape but it only needs it for a second. Honestly, you might be able to bypass it by grouping the edges a certain way but for now, cubeshape is the way to go.​
2.) Edge Orientation - Just worrying about the edges, get all of your top and bottom colors on their respective faces together.​
3.) Barrel/Barrel - Go back to barrel/barrel shape w/ either /(3,3)/ or /(-3,-3)/ From here, your edges should be grouped in four pairs with opposite colors together in the same orientation on all pairs (yellow edge on left, white edge on right). From now on you have to think of your edge pair as one piece. Do not split any of the edge pairs up as this will mess it up.​
4.) Quadruplets - This is the meat of the solve. You are going to solve what is called a "quadruplet" of pieces. It is two corners and two edges (one edge pair). It should look like half of a barrel shape split symmetrically.​
a.) Solve two quadruplets intuitively - Without breaking up your edge pairs, you want to match the corners up to both of the edges on one of your edge pairs. This will create a corner-edge pair-corner "quadruplet". This is generally done intuitively. Same way that you started out with square-1 and when you were learning cubeshape, they told you to just mess around with it until you got familiar with it, that's pretty much what you're gonna have to do here. Once you have one quadruplet, you can put it on the bottom left and create another on the top using a second edge pair. The way that I handle this is by treating the bottom as bandaged where I can't move the first solved quadruplet on the bottom left and only using slice moves and the U layer, I pair the corners. This also takes some practice but after a while is very easy and fast. Once you have your second quadruplet, place it on the bottom layer across from your other quadruplet. Your bottom layer should be in a barrel shape.
b.) Solve the third and fourth quadruplets - This is where the algorithms come in. In the video, he uses one swap algorithm to swap two pieces in the top left. _The notation for yoyleberry is different as an edge pair is treated as one piece. With this in mind, we can use U, D, and slice moves to show the algorithms._ The algorithm is this / U D' / U2' / D2' / U' / D2' / D' / D / . However, a 2-look algorithm set was proposed by Cale Schoon in the comments of the original video. http://bit.do/sq1noparity This splits the last two quadruplets up into turning the top layer into a barrel shape with similar colored corners across from each other (if it is not already) and then permutes the corners into their correct positions. The first step is fairly easy to understand and execute but the second step does have some things that make it a little confusing. With practice, it gets easier to understand the second step.​5 or 6.) Turn the cube back into cube shape

5 or 6.) Permute both layers of the puzzle
I perform this step before turning the cube back into cubeshape. I've recognized that when you turn a solved cube into a barrel/barrel shape, it has the top two quadruplets with the same color along the sides and the bottom two quadruplets with opposite colors along the sides. I use this information to permute the layers with the square-1 algs from Sarah's website: link. Then I turn it back into cubeshape, in which it is solved (possibly with the middle layer misaligned but that's an easy fix)​I really enjoy this new method of square-1 and I would like to hear thoughts from others on it as well 


Edit: Forgot to add an example solve.
(4,-4) / (-3,3) / (0,6) / (-1,6) / (2,-4) / (-4,6) / (-2,-1) / (0,-4) / (0,-1) / (6,0) / (1,-1) / (-5,6) / (-2,-1) / (0,6) / (-2,-5) /

(2,-4)/(0,1)/(-1,0)/(-3,0)/ Cubeshape (Step 1)
(-5,6)/(-1,0) Edge Orientation (Step 2)
/(-3,-3)/ Barrel/Barrel (Step 3)

Since there are no already paired edges and corners, I just chose the UL edge pair to start with
(2,-1)/(-4,-4)/(-4,0)/(0,6) First Quadruplet put on bottom left (Step 4a)
/(-4,0)/(2,0)/(-2,0)/(2,0)/(4,0)/ Second Quadruplet on bottom right (Step 4a)

Now I use the 2-look algs for Step 4b (I used regular notation to keep things consistent but it's much easier on the eyes using U and D notation.)

(-4,0)/(-2,2)/(2,0)/(0,-2)/(0,2)/(0,-2)/ First Alg
(2,0)/(-2,0)/(4,0)/(-4,0)/(2,0)/(-4,0)/(2,0)/(-4,0)/(4,0)/(-2,0)/ Second Alg

I do permutation first

(-5,-3)/(3,-3)/(-3,-3)/(0,-3)/(-3,-3)/(0,-3)/(-3,-3)/ Permutation
(3,3)/(-3,-3)/ Cubeshape and finish


----------



## xyzzy (May 12, 2017)

I used to use this method before I learnt Vandenbergh! The coolest part is probably that you can do 4b using 3-cycle commutators, so the whole solve requires zero algorithms. (Fun fact: when I did this, I used slice moves on both the left and the right, which looked pretty weird to a classmate who was an experienced squanner.)

I think what kills the method's potential as a speed method is that you have to go into cubeshape and then pull it back out of cubeshape to do stuff. If we could somehow combine steps 1 to 3 into a single edge pairing step (along with 1-looking step 4b), it might be pretty decent. I thought of generating algs for edge pairing, but then I got lazy and ended up learning Vandenbergh instead.


----------



## Robert-Y (May 12, 2017)

Also what kills it is the inconsistent shape of the puzzle. I reckon your turning speed will reduce too much because of this.


----------



## TyeDye (May 12, 2017)

xyzzy said:


> I think what kills the method's potential as a speed method is that you have to go into cubeshape and then pull it back out of cubeshape to do stuff. If we could somehow combine steps 1 to 3 into a single edge pairing step (along with 1-looking step 4b), it might be pretty decent. I thought of generating algs for edge pairing, but then I got lazy and ended up learning Vandenbergh instead.



See, I think that finding new algorithms for combining the first three steps will really be the holy grail for this method, if people are only interested in it for speedsolving. I don't think that it would be very difficult, you just have to figure out how to pair the algorithms a certain way. Especially since when the square-1 is shapeshifted, it pairs edges very easily. Also, Cary has said that there should only be around 40 algs for one-looking step 4b. They really just need to be generated. I think that if we got these algs, it would have a shot at a speedsolving method.

But honestly, I look at it as the steps between beginners method and CFOP on 3x3. When you are just beginning, you have to learn 8 different steps to solve different pieces individually, sometimes messing with the same piece multiple times. But then you start to learn F2L and 2-look OLL and PLL. And you gradually make your way to full CFOP with all of the full algorithms. This is sort of this method. You have to learn the simple "beginners" algs and the step going into and then out of cubeshape and then (when they get generated) learn the more advanced one-look algs and solving edges before cubeshape.

If I knew how to generate algs, I would do it myself but I can start looking into intuitive edge pairing w/o cubeshape in the meantime. If anyone wants to help, that'd be great 



Robert-Y said:


> Also what kills it is the inconsistent shape of the puzzle. I reckon your turning speed will reduce too much because of this.



I look at this the same way as learning cubeshape. Professional solvers know the exact moves to perform to get a puzzle into cubeshape with no pauses or lockups. I would say that it's gonna be a lot of practice but honestly, when I'm scrambling, I can do random moves with almost no pauses, probably just because I innately know what is a move and what isn't.


----------



## Robert-Y (May 12, 2017)

But the pieces with cubeshape algs remain consistent every time you execute the alg, for each move. With this method, the shape of the puzzle is constantly changing. If for example I tried to do 2,0, I can probably easily do this if I have there's a corner on top to pull, but if there is a pair of edges then this isn't easy to do.

e.g. try to do 2,0 with these 2 scrambles after applying them to see the difference:
1. / 3,3 / -1,-2 /
2. / 3,3 / -1,-2 / 2,0


----------



## TyeDye (May 13, 2017)

Robert-Y said:


> But the pieces with cubeshape algs remain consistent every time you execute the alg, for each move. With this method, the shape of the puzzle is constantly changing. If for example I tried to do 2,0, I can probably easily do this if I have there's a corner on top to pull, but if there is a pair of edges then this isn't easy to do.
> 
> e.g. try to do 2,0 with these 2 scrambles after applying them to see the difference:
> 1. / 3,3 / -1,-2 /
> 2. / 3,3 / -1,-2 / 2,0




The thing is, with almost the entire method, you stay in a situation where you only need to do moves with a multiple of 2 and it will always work. The only problem that you will have is the very beginning when you have to do cubeshape, which is the exact same as in normal cubeshape, or if we are talking about grouping edges w/o cubeshape, you'll most likely have to create a certain shape to do so, which will also use the exact same cubeshape algs, just not completed to the end. It all comes down to a familiarity with the cubeshape step in general.


----------



## Cale S (May 13, 2017)

About a year ago I did a ton of experimenting with this method and generated lots of algs coming up with better ways of doing the edge grouping step. When you do edge grouping in 1 alg (not necessarily optimal since I fix the solved position of the edge pieces) and do barrel-barrel + CP in one step, the solutions are really nice and efficient

I also think it's a nice almost purely intuitive method


----------



## TyeDye (May 13, 2017)

Cale S said:


> About a year ago I did a ton of experimenting with this method and generated lots of algs coming up with better ways of doing the edge grouping step. When you do edge grouping in 1 alg (not necessarily optimal since I fix the solved position of the edge pieces) and do barrel-barrel + CP in one step, the solutions are really nice and efficient
> 
> I also think it's a nice almost purely intuitive method



Hey Cale, do you think that you could help me out with that? Maybe give me a walkthrough to see what I'm supposed to be looking for? Also, could you explain how you generated the algs for the 2 look so that I could maybe generate some for 1 look as well. I'd really apprieciate it.

Btw I hope you didn't mind me mentioning your name in the original post. I was just giving credit from youtube.


----------



## Cale S (May 13, 2017)

TyeDye said:


> Hey Cale, do you think that you could help me out with that? Maybe give me a walkthrough to see what I'm supposed to be looking for? Also, could you explain how you generated the algs for the 2 look so that I could maybe generate some for 1 look as well. I'd really apprieciate it.
> 
> Btw I hope you didn't mind me mentioning your name in the original post. I was just giving credit from youtube.



I don't remember much about my original method other than that I disregarded it after making a method with fewer algs and didn't involve the step of intuitively grouping the first layer which was the longest and most difficult to recognize. I'm still working on a better system for it

for algs I use ksolve


----------



## TyeDye (May 14, 2017)

Thanks


----------



## TyeDye (May 17, 2017)

Cale S said:


> I don't remember much about my original method other than that I disregarded it after making a method with fewer algs and didn't involve the step of intuitively grouping the first layer which was the longest and most difficult to recognize. I'm still working on a better system for it
> 
> for algs I use ksolve


Hey Cale, do you happen to remember what the step for the edge grouping consisted of at all? Like a certain shape that you had to use to group edges or if you had to do two edge pairs at once? I'm having trouble grouping a singular edge pair. I'll get three of the correct pairs in a few seconds and then I'll spend ten minutes trying to pair the last one whether it's flipped around or if it's two edges across from each other on the layer. I know that you said that you gave it up but do you happen to remember just a general thing that you had to do?


----------



## bobthegiraffemonkey (Jun 19, 2017)

Hey all, been planning to do this for a while now: optimal edge pairing statistics. Cases listed by depth.



Spoiler: cases



1:
kites
kite/muffin
kite/paws
muffins
muffin/paws
same paws
opp paws
T/6
T/33
T/51
T/123

2:
square/square
square/barrel
square/fists
kite/scallop
barrel/fists
scallop/muffin
scallop/fists
shield/fists
muffin/fists
same fists
fist/paw
U/411
U/51
U/123
L/411
L/42
L/33
L/51
L/123

3:
square/kite
square/scallop
square/shield
square/muffin
square/paws
kite/barrel
kite/shield
kite/fists
barrel/muffin
barrel/paws
scallop/paws
shield/muffin
shield/paws
U/33
L/6
L/222
T/411
T/42

4:
I/222
star/71
star/53



Average: 1.86 (28/15)

Count of cases by depth:

```
0  1  2  3  4
13 16 34 24  3
```

Best option for edge pairing seems to be just learning them since it's at worst 4 twists and usually no more than 3. I only looked at optimal twist counts, not how to actually solve any of the cases, someone else can do that .


----------



## dboeren (Jul 6, 2017)

Thanks for posting this. I just got a Square-1 and have been learning beginner's method but this sounds more like the kind of method I'd prefer. Will give it a test drive when I get home from work.


----------



## Marlene02 (Jul 7, 2017)

Very interesting.


----------



## Aeoluz (Jul 11, 2017)

or you could just learn parity like wut


----------



## xyzzy (Jul 11, 2017)

Aeoluz said:


> or you could just learn parity like wut



Maybe you missed the point. This method doesn't just avoid parity. It avoids _the whole EP step_.


----------



## Aeoluz (Jul 11, 2017)

xyzzy said:


> Maybe you missed the point. This method doesn't just avoid parity. It avoids _the whole EP step_.


eh.... heh... i didnt read it. Gotta admit after some reading i think i should learn yoyleberry, because in actuality i have not learnt squan yet, so should i just learn vandenbergh or learn this?


----------



## xyzzy (Jul 11, 2017)

Aeoluz said:


> eh.... heh... i didnt read it. Gotta admit after some reading i think i should learn yoyleberry, because in actuality i have not learnt squan yet, so should i just learn vandenbergh or learn this?



If you want a method that looks cool, learn this.

If you want a method that's easy to be fast with, learn Vandenbergh.

In fact, why not just learn both?


----------



## I_<3_SCS (Jul 11, 2017)

Why is Vandenbergh easier to be fast with?


----------



## xyzzy (Jul 11, 2017)

I_<3_SCS said:


> Why is Vandenbergh easier to be fast with?



Lack of resources. Also, recognising cases is hard when the colours never stay fixed across solves, and "adjacent" or "opposite" colours have no meaning until the last few moves of the solve. Also also, what I already said in the second post of this thread, and the reply right below it.


----------



## Gx Cuber (May 27, 2018)

yo carykh is awesome I cannot express my feelings!!


----------



## luizborges (Sep 11, 2018)

xyzzy said:


> I used to use this method before I learnt Vandenbergh! The coolest part is probably that you can do 4b using 3-cycle commutators, so the whole solve requires zero algorithms. (Fun fact: when I did this, I used slice moves on both the left and the right, which looked pretty weird to a classmate who was an experienced squanner.)



How do you do commutators on a Square-1? How can you create an intersection of A and B of just one piece/block?


----------



## xyzzy (Sep 11, 2018)

luizborges said:


> How do you do commutators on a Square-1? How can you create an intersection of A and B of just one piece/block?


(Notation: R = /; L = y2 / y2; U = (2, 0); D = (0, 2).) [D' L D, R] is a 3-cycle. If you expand and rewrite it to use only normal slices, it becomes D' / U / U' / D /.

If you're asking about squan commutators in general (not in the context of the Yoyleberry method), (i) this is not the right thread to ask that question and (ii) that is a lot trickier because of the bandaged nature of the puzzle. Or if you mean comms once the puzzle is in cubeshape, well, just mess around with the puzzle for a while and you'll probably find something. M2 (which is 1,0/−1,−1/0,1) is a useful primitive since it does two 2-cycles on the edges.


----------



## luizborges (Sep 11, 2018)

@xyzzy I was talking about the commutator you used. I tried it out, I understood how it worked, but I'm still baffled by the Sq-1 UNintuitiveness...

It is so hard to track pieces in it, that even your simple alg D' / U / U' / D / looks confusing when trying to swap 2 pieces (instead of doing a 3 cicle)...


----------



## Metallic Silver (Nov 6, 2018)

Cary Huang ;_;


----------



## referee (Nov 27, 2020)

Was this ever developed fully? I understand that this site's emphasis is in speed solving and Yoyleberry might be bad for it, but it looks like a really cool way of solving it, both with the double reduction and solving non-square. (Vandebergh method is fine, but notation is a bit ugh, hehe).


----------



## TyeDye (Nov 27, 2020)

referee said:


> Was this ever developed fully? I understand that this site's emphasis is in speed solving and Yoyleberry might be bad for it, but it looks like a really cool way of solving it, both with the double reduction and solving non-square. (Vandebergh method is fine, but notation is a bit ugh, hehe).



I believe that the only people that developed it, in creating alg sets and practicing with them, kept those to themselves. I have reached out to multiple people before to see if they would be interested in either sharing their previously compiled alg sets or helping with generating relavent algs for Yoyleberry, since Yoyleberry algs are pretty unique to just this method, since they are done out of cubeshape and I have never gotten responses from anyone as of yet. I am still interested in this method, not for it’s speedsolving use, but just for fun. I think it would be an interesting method if it was fleshed out further, I just do not have the resources or knowledge to achieve that by myself.


----------



## Hazel (Nov 28, 2020)

Fun fact, the name of this method is a reference to the YouTube animated series Cary co-created and continues to work on, _Battle for Dream Island._


----------



## SoundBalloon (Nov 28, 2020)

TyeDye said:


> I believe that the only people that developed it, in creating alg sets and practicing with them, kept those to themselves. I have reached out to multiple people before to see if they would be interested in either sharing their previously compiled alg sets or helping with generating relavent algs for Yoyleberry, since Yoyleberry algs are pretty unique to just this method, since they are done out of cubeshape and I have never gotten responses from anyone as of yet. (...)


Yes! Sorry for not answering, I simply haven't been online for a year. I did generate algs for Yoyleberry, more than three years ago, using a homemade software... You can find them here (the flavour text is in french but the algs are in standard notation):








Square-1 : méthode Yoyleberry


Portail francophone sur le Rubik's Cube




forum.francocube.com





Some disclaimers first:
- I am a newbie at Sq-1 (I do not know how to solve one, Yoyleberry or not )
- I struggle with domino reduction-type puzzles, and Yoyleberry is one of such.
- I suggested several methods, but most do not have any alg (yet?).

None of the variants striked me as "elegant", "intuitive" or "not alg-intensive" (like Roux L6E is, for example). I also have no idea if there is a way that involves a better look-ahead, more flexibility, and less moves.


----------



## xyzzy (Jul 30, 2021)

xyzzy said:


> If we could somehow combine steps 1 to 3 into a single edge pairing step (along with 1-looking step 4b), it might be pretty decent. I thought of generating algs for edge pairing, but then I got lazy and ended up learning Vandenbergh instead.


Sometimes it just takes four years to become less lazy, I guess. Saw this thread pop up again recently and decided to tackle this.

bobthegiraffemonkey's post earlier in the thread includes the distribution for getting to a shape where the edges are paired. This isn't enough for the Yoyleberry method, which also needs the edge pairs to be all white-yellow or all yellow-white. This is the actual distribution for directly pairing the edges into white-yellow or yellow-white pairs, weighted by frequency (slice metric):


0586164026444334648469798516558656

Obviously, no one is going to learn the 2000-ish cases, but surely there's something better than cubeshape-EO-barrels… What other intermediate shapes could we use?

This is the average number of slices for optimally going from a certain shape into the paired state:


Spoiler



How to interpret this: left column is the average number of slices _multiplied by 35_. So "94" really means 94/35 = 2.69 slices average. There are a lot of symmetrically equivalent shapes that are left in because I didn't bother taking them out.

94 barrel/barrel
99 mushroom/mushroom
100 barrel/scallop,scallop/barrel
110 peacock/24,peacock/42,barrel/shield,shield/barrel,square/barrel,24/peacock,42/peacock,barrel/square
112 r.fist/barrel,l.fist/barrel,barrel/r.fist,square/r.fist,r.fist/square,l.fist/square,barrel/l.fist,square/l.fist
114 mushroom/l.paw,l.paw/mushroom,r.paw/mushroom,mushroom/r.paw
115 badge/15,badge/51,badge/33,15/badge,51/badge,33/badge
116 kite/mushroom,mushroom/kite
117 shield/shield
118 mushroom/r.fist,r.fist/mushroom,l.fist/mushroom,mushroom/l.fist
119 scallop/scallop,r.fist/r.fist,l.fist/l.fist
120 peacock/6,6/peacock
121 shield/scallop,peacock/222,scallop/shield,222/peacock
122 r.fist/scallop,l.fist/scallop,scallop/r.fist,scallop/l.fist
123 square/scallop,scallop/square
126 r.fist/shield,l.fist/shield,shield/r.fist,kite/r.fist,kite/square,shield/l.fist,kite/l.fist,r.fist/kite,square/kite,l.fist/kite
128 kite/l.paw,kite/r.paw,l.paw/kite,r.paw/kite
129 arrow/15,arrow/51,kite/kite,15/arrow,51/arrow
130 r.fist/l.paw,l.paw/r.fist,l.fist/r.paw,r.paw/l.fist
133 peacock/114,114/peacock
134 barrel/l.paw,l.paw/barrel,r.paw/barrel,barrel/r.paw
135 arrow/24,arrow/42,square/l.paw,square/r.paw,l.paw/square,r.paw/square,24/arrow,42/arrow
136 arrow/114,peacock/123,badge/123,peacock/132,badge/132,123/peacock,132/peacock,114/arrow,123/badge,132/badge
137 l.paw/l.paw,l.fist/r.fist,r.paw/r.paw,r.fist/l.fist
138 square/square
139 badge/114,arrow/123,arrow/132,shield/l.paw,l.paw/shield,r.paw/shield,kite/shield,shield/r.paw,shield/kite,123/arrow,132/arrow,114/badge
140 peacock/15,peacock/51,arrow/33,15/peacock,51/peacock,33/arrow
141 l.fist/l.paw,r.paw/r.fist,r.fist/r.paw,l.paw/l.fist
142 l.paw/scallop,r.paw/scallop,kite/scallop,scallop/l.paw,mushroom/barrel,barrel/mushroom,scallop/r.paw,scallop/kite
143 square/shield,kite/barrel,shield/square,barrel/kite
144 arrow/6,6/arrow
145 arrow/222,222/arrow
146 square/mushroom,mushroom/square
147 star/62,star/44,62/star,44/star
149 star/8,8/star
150 peacock/33,33/peacock
151 mushroom/scallop,r.paw/l.paw,scallop/mushroom,l.paw/r.paw
152 badge/24,badge/42,24/badge,42/badge
153 mushroom/shield,shield/mushroom
159 badge/6,badge/222,6/badge,222/badge
161 star/53,53/star
163 star/71,71/star


If you start in square-square, then the optimal way to get to paired edges is EO into barrels; there's no shortcut.

On the other hand, if you directly start in barrel-barrel, 1/35 of the time the edges are already paired, 9/35 you need two slices, 24/35 you need three slices, and 1/35 you need four slices. The second-best shape to start with, mushroom-mushroom, has the distribution 4/35 one slice, 7/35 two slices, 15/35 three slices, and 9/35 four slices.

But that's assuming your scramble is already in those specific shapes; barrel-barrel and mushroom-mushroom are actually the third- and fourth-worst shapes in terms of the average optimal slices to get there (both ~3.8 slices). So what we should actually be considering is: (average move count to get into xxx shape) + (average move count to go from xxx shape to paired edges). The distribution:


Spoiler



See above spoiler box for how to interpret this. This is now on a scale of 35×3678 = 128730, so e.g. "691826" really means 691826/128730 = 5.37 slices average.

691826 r.fist/scallop
703480 peacock/24
710880 badge/15
714336 r.fist/barrel
714658 r.fist/shield
719522 mushroom/l.paw
720724 mushroom/r.fist
734600 barrel/scallop
734880 arrow/24
735842 arrow/15
741894 kite/l.paw
747728 peacock/123
750904 peacock/114
764090 r.fist/l.paw
764318 badge/123
772412 arrow/123
772922 barrel/l.paw
776510 peacock/15
785712 shield/l.paw
788130 arrow/33
788250 barrel/shield
789528 kite/mushroom
789848 l.fist/l.paw
793296 square/r.fist
794040 badge/33
796938 arrow/114
797984 square/scallop
805588 kite/r.fist
810852 r.fist/r.fist
812776 l.paw/scallop
817632 badge/114
822440 peacock/6
822456 l.paw/l.paw
824292 scallop/scallop
824466 kite/scallop
826400 square/barrel
828872 barrel/barrel
833176 shield/shield
834132 arrow/6
834868 shield/scallop
837302 kite/shield
844710 square/l.paw
847192 mushroom/mushroom
854678 peacock/222
855290 peacock/33
867000 arrow/222
867578 r.paw/l.paw
879086 l.fist/r.fist
882534 square/shield
892396 badge/24
899894 kite/barrel
922038 mushroom/scallop
922128 square/mushroom
928536 star/62
930934 mushroom/shield
934066 star/44
941292 kite/kite
942152 badge/6
944726 mushroom/barrel
964208 kite/square
971522 star/8
979678 star/53
980442 badge/222
1006984 star/71
1102844 square/square


While it's conceptually easy to do the edge pairing starting with cubeshape, it's also literally the worst possible choice in terms of efficiency. Barrel-barrel and mushroom-mushroom fall from grace (6.44, 6.52 slices resp.), with fist-scallop taking top spot (5.37 slices).

Fist-scallop is second-best in terms of getting into the shape (1.89 slices), but pretty middling in terms of pairing (3.49 slices average; 4/35 two slices, 10/35 three slices, 21/35 four slices). The lack of symmetry also means you have to learn all 35 edge pairing cases separately, and you still have to be able to mirror them since leftfist-scallop and rightfist-scallop need different algs. (TODO: generate the algs and see what they're actually like you can wait four more years for that to happen)

Barrel-scallop takes the tradeoff in the opposite direction. Getting into barrel-scallop is worse than median (2.85 slices), but doing edge pairing from there is good (2.86 slices average; 1/35 already paired, 10/35 two slices, 16/35 three slices, 8/35 four slices). The barrel side has rotational symmetry, which cuts the number of cases to 21; if we further reduce by mirrors, there are only 16 cases left.


Spoiler: algs (mirrors not included (yet))



These are for barrel on top, scallop on bottom, with the scallop edges facing you (set up with /-3,-3/0,1/0,-4/3,0). Images are generated with AlgDb's squan image generator, so the bottom face is shown from a top-down view (i.e. will look mirrored compared to tilting the cube upwards to look at the bottom face).

Cases are labelled with 8 binary digits; the first four are the edges on the barrel side, read clockwise from the front-right; the second four are the edges on the scallop side, from front-left to front-right (clockwise on the actual puzzle, anticlockwise in the AlgDb pics).

*01 01 0101*





skip!

*00 00 1111*




/ (5,0) / (0,-4) / (0,5) /
end shape: barrel-scallop

*00 01 0111*




/ (5,0) /
end shape: barrel-barrel

*00 01 1101*




(0,2) / (5,0) /
end shape: 42-peacock

*00 01 1011*




(5,0) / (0,-5) / (1,-1) /
end shape: barrel-scallop

*00 01 1110*




(-5,0) / (-1,0) / (-1,1) /
end shape: scallop-barrel

*01 10 1100*




/ (-1,1) /
end shape: scallop-barrel

*01 10 1001*




/ (5,1) / (-1,0) /
_(6,0)_ / (5,1) / (0,1) /
end shape: barrel-barrel (for both algs)

*01 10 1010*




/ (-1,0) / (1,0) /
end shape: barrel-scallop

*00 11 0011*




/ (-1,1) / (2,0) / (0,5) /
end shape: peacock-42
_(6,0)_ / (-1,1) / (-2,0) / (-5,0) /
end shape: peacock-24

*00 11 0101*




(1,0) / (-1,0) / (5,0) /
end shape: barrel-barrel

*00 11 0110*




/ (5,0) / (0,-4) / (5,0) / (note: same alg as 00 00 1111!)
end shape: barrel-scallop

*01 01 1010* (paired, but not)




(1,0) / (-1,0) / (5,1) / (-1,0) /
end shape: barrel-barrel

*01 01 0011*




/ (-1,0) / (0,1) /
end shape: scallop-barrel

*01 01 1100*




(1,0) / (-1,-4) / (0,5) /
(1,0) / (5,2) / (5,0) /
end shape: 42-peacock (both algs)

*01 01 0110*




/ (0,1) / (0,5) / (0,-1) /
end shape: barrel-barrel

*01 01 1001*




/ (-1,0) / (0,-5) / (1,0) /
end shape: barrel-barrel


----------



## abunickabhi (Aug 1, 2021)

Super interesting method. Thanks for presenting the stats, xyzzy!


----------

