# Average Movecount for Square-1



## Silky (Sep 7, 2020)

A thread to calculate average movecount, per method, for square-1. This should be done in faceturn metric, that is every slice and U or D face turns count as one move ( e.g. (3,0)/ is 2 moves and (3,3)/ is 3 moves ). This should be done separately, with and without CSP ( similar to how ZZ's movecount is calculated with and without ZBLL ). I'm primarily looking to calculate for Vandenbergh, Lin, Yoyleberry, and Skwuction, since SSS1M is very similar to Vandenbergh and Screw is very similar to Lin.


----------



## Silky (Oct 24, 2020)

Just did a few solves and wrote down the movecount.

Session 1: Slice Turn Metric with scallop kite intermediate cubeshape
Method: Lin

(1) 26 STM (2) 37 STM (3) 30 STM (4) 32 STM (5) 34 STM (6) 25 STM (7) 39 STM (8) 31 STM
Average => 32 STM

Session 2: Face Turn Metric with scallop kite intermediate cubeshape
Method: Lin

(1) 68 FTM (2) 77 FTM (3) 71 FTM (4) 64 FTM (5) 50 FTM (6) 75 FTM (7) 51 FTM (8) 48 FTM
Average => 63 FTM

I got some lucky scrambles on session 2 so there's a lot more variance in move count. The average is probably closer to 65-68 FTM. These averages weren't speedsolves so they are most likely a bit more efficient than a normal solve but still pretty doable IMO. Will have to do more averages and reconstructions of speedsolves to get a better idea. Also might do some with optimal cubeshape just to see how it comes out.


----------



## Silky (Nov 19, 2020)

A quick update:

I've recently been checking out PLL+1. It seems it makes Lin way more efficient. As long as you use CSP I believe could average in the low 20s (20-22 STM). For only learning 84 algorithms it seems like quite a worthwhile algset to learn ( 21 PLL + 72 PLL+1 ). It's basically 1LLL for Square-1.


----------



## tx789 (Nov 19, 2020)

Using Vandenberg with CSP the max is about this (averages are estimates):

7 slice for CS (average 4-6)
3 for CO (average is a little over 2)
6 for EO ( now this is more of a guess but 4-5 is probably the average)
6 for CP (JJ an NN are 3 and NJ JN are 5, the other two are 6. By a basic calulation that is possibly worng. Average is a. Bit above four.)
No idea about EP. I know it's doable in less than 10.

So solves with the more than 32 slices are bad. Average is around 23?

Honestly a proper run down is better than my guesses.


OBL and PBL change things.
Most of the time OBL would be 4-5 slice with a Max of 6 and PBL has a Max of 10
So with OBL and PBL your solutions should always be sub 21. But that is the max not average.



While PBL has got 967 algs half can be solved with combinations of CPs and RJ pbls. All of which are super simple algs. All you need to know is how to solve each PLL with those algs.


----------



## Sub1Hour (Nov 19, 2020)

tx789 said:


> Using Vandenberg with CSP the max is about this (averages are estimates):
> 
> 7 slice for CS (average 4-6)
> 3 for CO (average is a little over 2)
> ...


I'm gonna calculate the avg for EO just since it seems like the easiest to calculate.
Solved: 0, 1/70 = 0
1-1/ 6, 16/70 = 96
2-2/ 4, 16/70 = 64
M2/ 2, 4/70 = 8
3-3/ 6, 16/70 = 96
M2-2/ 6, 16/70 = 96
Double M2/ 4, 1/70 = 4
Total= 364
364/70 = 5.2

So EO is rounded to around 5. (if my math is correct but im pretty sure that it is)

I would also say ditch FTM since doing U and D moves can't accomplish anything without the slice, so the slice is kind of the only move that matters.


----------



## Silky (Jul 12, 2022)

@zzoomer This is a follow up on from the example solve thread. The question of efficiency continues to bug me so I did some more testing.

Did 20 example solves of Lin and Vandenbergh ( same scrambles ). I did not use CSP and kept the cubeshape solutions the same between solves. For Lin I used a combination of CP+DF, CMDLL, L5E, and PLL+1 and for Vandenbergh I used full EO, CP, and EP from Sarah's website. Lin averaged 24 moves where Vandenbergh averaged 26. Using CSP and PLL+1 Lin could save around 4-6 moves. I'm not sure what OBL ( if anyone has a link to OBL algs pls provide ) will save movewise for Vandenbergh. Obviously example solves are going to skew that data towards more efficient Lin solves. Thus, at best, Lin should be more efficient than Vandenbergh and, at worst, should break even.


----------



## ruffleduck (Jul 12, 2022)

Silky said:


> @zzoomer This is a follow up on from the example solve thread. The question of efficiency continues to bug me so I did some more testing.
> 
> Did 20 example solves of Lin and Vandenbergh ( same scrambles ). I did not use CSP and kept the cubeshape solutions the same between solves. For Lin I used a combination of CP+DF, CMDLL, L5E, and PLL+1 and for Vandenbergh I used full EO, CP, and EP from Sarah's website. Lin averaged 24 moves where Vandenbergh averaged 26. Using CSP and PLL+1 Lin could save around 4-6 moves. I'm not sure what OBL ( if anyone has a link to OBL algs pls provide ) will save movewise for Vandenbergh. Obviously example solves are going to skew that data towards more efficient Lin solves. Thus, at best, Lin should be more efficient than Vandenbergh and, at worst, should break even.


OBL very clearly averages less than 4 slices.

PBL is less straightforward, since no one (AFAIK) solely uses slice optimal algs. All PBL users solve the majority of their cases using a 2-alg combo, often with cancellation. Here are the base algs they use for PBL. I am not an expert sq1 solver, but I know for certain that the worst PBL could average is 12 slices since the worst base algs are 6 slices. More likely, PBL averages closer to 8-9 slices.


----------



## Silky (Jul 13, 2022)

zzoomer said:


> OBL very clearly averages less than 4 slices.
> 
> PBL is less straightforward, since no one (AFAIK) solely uses slice optimal algs. All PBL users solve the majority of their cases using a 2-alg combo, often with cancellation. Here are the base algs they use for PBL. I am not an expert sq1 solver, but I know for certain that the worst PBL could average is 12 slices since the worst base algs are 6 slices. More likely, PBL averages closer to 8-9 slices.


Neat! Wasn't aware that people were using full PBL! Definitely changes things. I believe optimal Lin should still come close.


----------

