Euler 15.2 | C# Online Compiler

Euler 15.2 by BgT1990

using System;
using System.Numerics;

namespace problem_15
{

using System.Collections.Generic;
					
public class Euler15
	{
	public static string workingString;
	public static string defaultString;
	public static int sideLength = 4;
	public static int globalStepCount = 0;
	public static int lastY;
	
	public static void Main()
		{
		
		Euler15 prg = new Euler15();
		
		workingString = new string('R', sideLength);
		for(int count = 0; count <sideLength; count++)
			{
			workingString = workingString.Insert(workingString.Length, "D");
			}
		globalStepCount+=1;
		defaultString=workingString;
		Console.WriteLine(workingString);
				Console.WriteLine(globalStepCount);
		if(sideLength>1)
		for(int N = 0; N < sideLength;N++)
			   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
			{
				workingString = SwapChars(workingString,sideLength-1+N,sideLength+N);
				//Console.WriteLine(N);
				Console.WriteLine(workingString);
				globalStepCount+=1;
			Console.WriteLine(globalStepCount);
			}
		workingString = defaultString;
		if(sideLength>2)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength);
				workingString = SwapChars(workingString,sideLength-2,sideLength-1);
								Console.WriteLine(workingString);
					globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-1;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+N,sideLength+1+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
		
		workingString = defaultString;
		if(sideLength>2)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+1);
				workingString = SwapChars(workingString,sideLength-2,sideLength);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-2;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+1+N,sideLength+2+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
		workingString = defaultString;
		if(sideLength>2)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+2);
				workingString = SwapChars(workingString,sideLength-2,sideLength+1);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-3;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+2+N,sideLength+3+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
		workingString = defaultString;
		if(sideLength>3)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+3);
				workingString = SwapChars(workingString,sideLength-2,sideLength+2);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-4;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+4+N,sideLength+5+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
		
		workingString = defaultString;
		if(sideLength>3)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength);
				workingString = SwapChars(workingString,sideLength-2,sideLength-1);
				workingString = SwapChars(workingString,sideLength-3,sideLength-2);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-1;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+N,sideLength+1+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}

				workingString = defaultString;
		if(sideLength>3)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+1);
				workingString = SwapChars(workingString,sideLength-2,sideLength);
				workingString = SwapChars(workingString,sideLength-3,sideLength-1);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-2;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+1+N,sideLength+2+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
		
				workingString = defaultString;
		if(sideLength>3)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+2);
				workingString = SwapChars(workingString,sideLength-2,sideLength+1);
				workingString = SwapChars(workingString,sideLength-3,sideLength);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-3;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+2+N,sideLength+3+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
		
				workingString = defaultString;
		if(sideLength>3)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+3);
				workingString = SwapChars(workingString,sideLength-2,sideLength+2);
				workingString = SwapChars(workingString,sideLength-3,sideLength+1);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-4;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+3+N,sideLength+4+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
//swapping to multiple spaces
			workingString = defaultString;
		if(sideLength>3)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+1);
				workingString = SwapChars(workingString,sideLength-2,sideLength);
				workingString = SwapChars(workingString,sideLength-3,sideLength-2);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-2;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+1+N,sideLength+2+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
			workingString = defaultString;
		if(sideLength>3)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+2);
				workingString = SwapChars(workingString,sideLength-2,sideLength+1);
				workingString = SwapChars(workingString,sideLength-3,sideLength-2);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-3;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+2+N,sideLength+3+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
			workingString = defaultString;
		if(sideLength>3)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+3);
				workingString = SwapChars(workingString,sideLength-2,sideLength+2);
				workingString = SwapChars(workingString,sideLength-3,sideLength-2);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-4;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+3+N,sideLength+4+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
		//double first space (RDDRDR...)
					workingString = defaultString;
		if(sideLength>3)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+2);
				workingString = SwapChars(workingString,sideLength-2,sideLength+1);
				workingString = SwapChars(workingString,sideLength-3,sideLength-1);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-3;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+2+N,sideLength+3+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
		///triple first space (RDDDRDRR)
					workingString = defaultString;
		if(sideLength>3)
			{
				workingString = SwapChars(workingString,sideLength-1,sideLength+3);
				workingString = SwapChars(workingString,sideLength-2,sideLength+2);
				workingString = SwapChars(workingString,sideLength-3,sideLength);
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-4;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+3+N,sideLength+4+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}
		
		/*///Manual >4 sidelength
					workingString = defaultString;
		
		for(int S = 0; S<sideLength; S++)
		{
			
		if(sideLength>S)
			{
			
			for(int Y = 0; Y<sideLength; Y++)
			{
			workingString = SwapChars(workingString,sideLength-(sideLength+Y+1),sideLength-(sideLength+Y));
			lastY = Y;
			}
								Console.WriteLine(workingString);
			globalStepCount+=1;
			Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-S;N++)
					{
										workingString = SwapChars(workingString,sideLength+lastY+1+N,sideLength+lastY+2+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
					}
				}
				workingString = SwapChars(workingString,sideLength-(sideLength+4),sideLength-(sideLength+3));
				workingString = SwapChars(workingString,sideLength-(sideLength+3),sideLength-(sideLength+2));
				workingString = SwapChars(workingString,sideLength-(sideLength+2),sideLength-(sideLength+1));
				workingString = SwapChars(workingString,sideLength-(sideLength+1),sideLength-(sideLength+0)); //make the number of these N, and have them created based on how many sides are present
								Console.WriteLine(workingString);
			globalStepCount+=1;
					Console.WriteLine(globalStepCount);
					for(int N = 0; N < sideLength-4;N++)
				   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
				{
					workingString = SwapChars(workingString,sideLength+3+N,sideLength+4+N);
					//Console.WriteLine(N);
					Console.WriteLine(workingString);
					globalStepCount+=1;
						Console.WriteLine(globalStepCount);
				}
			}*/


		//Console.WriteLine(workingString);
		Console.WriteLine(globalStepCount);
		Console.WriteLine("Final Total = "+2*globalStepCount);
		}
		public static string SwapChars(String str, int index1, int index2)
		{
			char[] strChar = str.ToCharArray();
			strChar[index1] = str[index2];
			strChar[index2] = str[index1];

			return new String(strChar);
		}
	}
}

/*
from top left to bottom right

2x2
right right down down
right down right down
right down down right
down right right down
down right down right
down down right right

so 2x2 = 4 steps
each path is n+n, so 4+4=8 steps
number of paths for 2x2 is 6

//which is number of steps plus side length? 4 + 2?
//so 4x4 would be 8+4=12?
4x4 number of paths = 50 so not sure of the formula
f0 1 2 2 (1*2=2)
f1 2 4 6 (2*3=6) 2x2 = 4 -1 (half the previous number of paths)
f2 4 8 52 (4*13=52) 4x4=16 -3 = 13 [[[52 IS WRONG]]]
f3 8 16  (8*38=304) 8x8=64 - 52/2=26 = 38

f2 4 8 68 (4*17=68)

you have n rights and n downs
to get all the combos you need to try R in all the locations and D in all the locations

4x4

R R R R D D D D 1 RRRR

R R R D R D D D 2 RRR (move 1 R to the right)
R R R D D R D D 3 (Move than same R until its at the last place)
R R R D D D R D 4
R R R D D D D R 5

R R D R R D D D 6 RRDR (go back to the default then move 2 Rs to the right 1 space)
R R D R D R D D 7 (move the first R of the 2)
R R D R D D R D 8 (move that first R until it reaches the end)
R R D R D D D R 9

R R D D R R D D 10 RRDDR (go back to default then move 2 Rs again, but move them both 2 spaces)
R R D D R D R D 11 (move the first R until it reaches the end)
R R D D R D D R 12

R R D D D R R D 13 RRDDDR (go back to default then move the 2 Rs 3 spaces)
R R D D D R D R 14 (then one to the end)

R R D D D D R R 15 RRDDDDR (default then 2 4 spaces)

R D R R R D D D 16 RDRRR default then 3 1 space
R D R R D R D D 17
R D R R D D R D 18
R D R R D D D R 19

R D D R R R D D 20 RDDRR default then 3 2 spaces
R D D R R D R D 21
R D D R R D D R 22

R D D D R R R D 23 RDDDRR defailt then 3 3 spaces
R D D D R R D R 24

R D D D D R R R 25 RDDDDRRR default then 3 4 spaces

R D R D R R D D 26 RDRDR default then 3 1 space, then 2 1 space (if the intial move is >2)
R D R D R D R D 27
R D R D R D D R 28

R D R D D R R D 29 RDRDDR
R D R D D R D R 30

R D R D D D R R 31 RDRDDDR <<< working to here so far, but using hardcoded values

R D D R D R R D 32 RDDRDR
R D D R D R D R 33

R D D D R D R R 34 RDDDRDR



+34 beginning with D
Steps
1) for an nxn grid take a string of length 2n where the first half of the string is R chars and the second half is D chars
2) start with a counter of 1
3) move the last R by 1 to the right 
4) increase the counter for every move
5) move the R again until its at the last position of the strings length
6) now put start with 2 Rs a D and another R at the start of the string with a gap of 1 D to the next 2 Rs

OR JUST DO THE MATH LOL SEE ABOVE
*/

​x
 
using System;
using System.Numerics;
​
namespace problem_15
{
​
using System.Collections.Generic;
                    
public class Euler15
    {
    public static string workingString;
    public static string defaultString;
    public static int sideLength = 4;
    public static int globalStepCount = 0;
    public static int lastY;
    
    public static void Main()
        {
        
        Euler15 prg = new Euler15();
        
        workingString = new string('R', sideLength);
        for(int count = 0; count <sideLength; count++)
            {
            workingString = workingString.Insert(workingString.Length, "D");
            }
        globalStepCount+=1;
        defaultString=workingString;
        Console.WriteLine(workingString);
                Console.WriteLine(globalStepCount);
        if(sideLength>1)
        for(int N = 0; N < sideLength;N++)
               // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
            {
                workingString = SwapChars(workingString,sideLength-1+N,sideLength+N);
                //Console.WriteLine(N);
                Console.WriteLine(workingString);
                globalStepCount+=1;
            Console.WriteLine(globalStepCount);
            }
        workingString = defaultString;
        if(sideLength>2)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength);
                workingString = SwapChars(workingString,sideLength-2,sideLength-1);
                                Console.WriteLine(workingString);
                    globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-1;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+N,sideLength+1+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
        
        workingString = defaultString;
        if(sideLength>2)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+1);
                workingString = SwapChars(workingString,sideLength-2,sideLength);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-2;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+1+N,sideLength+2+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
        workingString = defaultString;
        if(sideLength>2)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+2);
                workingString = SwapChars(workingString,sideLength-2,sideLength+1);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-3;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+2+N,sideLength+3+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
        workingString = defaultString;
        if(sideLength>3)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+3);
                workingString = SwapChars(workingString,sideLength-2,sideLength+2);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-4;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+4+N,sideLength+5+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
        
        workingString = defaultString;
        if(sideLength>3)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength);
                workingString = SwapChars(workingString,sideLength-2,sideLength-1);
                workingString = SwapChars(workingString,sideLength-3,sideLength-2);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-1;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+N,sideLength+1+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
​
                workingString = defaultString;
        if(sideLength>3)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+1);
                workingString = SwapChars(workingString,sideLength-2,sideLength);
                workingString = SwapChars(workingString,sideLength-3,sideLength-1);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-2;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+1+N,sideLength+2+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
        
                workingString = defaultString;
        if(sideLength>3)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+2);
                workingString = SwapChars(workingString,sideLength-2,sideLength+1);
                workingString = SwapChars(workingString,sideLength-3,sideLength);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-3;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+2+N,sideLength+3+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
        
                workingString = defaultString;
        if(sideLength>3)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+3);
                workingString = SwapChars(workingString,sideLength-2,sideLength+2);
                workingString = SwapChars(workingString,sideLength-3,sideLength+1);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-4;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+3+N,sideLength+4+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
//swapping to multiple spaces
            workingString = defaultString;
        if(sideLength>3)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+1);
                workingString = SwapChars(workingString,sideLength-2,sideLength);
                workingString = SwapChars(workingString,sideLength-3,sideLength-2);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-2;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+1+N,sideLength+2+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
            workingString = defaultString;
        if(sideLength>3)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+2);
                workingString = SwapChars(workingString,sideLength-2,sideLength+1);
                workingString = SwapChars(workingString,sideLength-3,sideLength-2);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-3;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+2+N,sideLength+3+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
            workingString = defaultString;
        if(sideLength>3)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+3);
                workingString = SwapChars(workingString,sideLength-2,sideLength+2);
                workingString = SwapChars(workingString,sideLength-3,sideLength-2);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-4;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+3+N,sideLength+4+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
        //double first space (RDDRDR...)
                    workingString = defaultString;
        if(sideLength>3)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+2);
                workingString = SwapChars(workingString,sideLength-2,sideLength+1);
                workingString = SwapChars(workingString,sideLength-3,sideLength-1);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-3;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+2+N,sideLength+3+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
        ///triple first space (RDDDRDRR)
                    workingString = defaultString;
        if(sideLength>3)
            {
                workingString = SwapChars(workingString,sideLength-1,sideLength+3);
                workingString = SwapChars(workingString,sideLength-2,sideLength+2);
                workingString = SwapChars(workingString,sideLength-3,sideLength);
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-4;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+3+N,sideLength+4+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }
        
        /*///Manual >4 sidelength
                    workingString = defaultString;
        
        for(int S = 0; S<sideLength; S++)
        {
            
        if(sideLength>S)
            {
            
            for(int Y = 0; Y<sideLength; Y++)
            {
            workingString = SwapChars(workingString,sideLength-(sideLength+Y+1),sideLength-(sideLength+Y));
            lastY = Y;
            }
                                Console.WriteLine(workingString);
            globalStepCount+=1;
            Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-S;N++)
                    {
                                        workingString = SwapChars(workingString,sideLength+lastY+1+N,sideLength+lastY+2+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                    }
                }
                workingString = SwapChars(workingString,sideLength-(sideLength+4),sideLength-(sideLength+3));
                workingString = SwapChars(workingString,sideLength-(sideLength+3),sideLength-(sideLength+2));
                workingString = SwapChars(workingString,sideLength-(sideLength+2),sideLength-(sideLength+1));
                workingString = SwapChars(workingString,sideLength-(sideLength+1),sideLength-(sideLength+0)); //make the number of these N, and have them created based on how many sides are present
                                Console.WriteLine(workingString);
            globalStepCount+=1;
                    Console.WriteLine(globalStepCount);
                    for(int N = 0; N < sideLength-4;N++)
                   // char at index of sidelength, then move it by 1 until it is at the length of the string (make sure to take into account the length of string moved)
                {
                    workingString = SwapChars(workingString,sideLength+3+N,sideLength+4+N);
                    //Console.WriteLine(N);
                    Console.WriteLine(workingString);
                    globalStepCount+=1;
                        Console.WriteLine(globalStepCount);
                }
            }*/
​
​
        //Console.WriteLine(workingString);
        Console.WriteLine(globalStepCount);
        Console.WriteLine("Final Total = "+2*globalStepCount);
        }
        public static string SwapChars(String str, int index1, int index2)
        {
            char[] strChar = str.ToCharArray();
            strChar[index1] = str[index2];
            strChar[index2] = str[index1];
​
            return new String(strChar);
        }
    }
}
​
/*
from top left to bottom right
​
2x2
right right down down
right down right down
right down down right
down right right down
down right down right
down down right right
​
so 2x2 = 4 steps
each path is n+n, so 4+4=8 steps
number of paths for 2x2 is 6
​
//which is number of steps plus side length? 4 + 2?
//so 4x4 would be 8+4=12?
4x4 number of paths = 50 so not sure of the formula
f0 1 2 2 (1*2=2)
f1 2 4 6 (2*3=6) 2x2 = 4 -1 (half the previous number of paths)
f2 4 8 52 (4*13=52) 4x4=16 -3 = 13 [[[52 IS WRONG]]]
f3 8 16  (8*38=304) 8x8=64 - 52/2=26 = 38
​
f2 4 8 68 (4*17=68)
​
you have n rights and n downs
to get all the combos you need to try R in all the locations and D in all the locations
​
4x4
​
R R R R D D D D 1 RRRR
​
R R R D R D D D 2 RRR (move 1 R to the right)
R R R D D R D D 3 (Move than same R until its at the last place)
R R R D D D R D 4
R R R D D D D R 5
​
R R D R R D D D 6 RRDR (go back to the default then move 2 Rs to the right 1 space)
R R D R D R D D 7 (move the first R of the 2)
R R D R D D R D 8 (move that first R until it reaches the end)
R R D R D D D R 9
​
R R D D R R D D 10 RRDDR (go back to default then move 2 Rs again, but move them both 2 spaces)
R R D D R D R D 11 (move the first R until it reaches the end)
R R D D R D D R 12
​
R R D D D R R D 13 RRDDDR (go back to default then move the 2 Rs 3 spaces)
R R D D D R D R 14 (then one to the end)
​
R R D D D D R R 15 RRDDDDR (default then 2 4 spaces)
​
R D R R R D D D 16 RDRRR default then 3 1 space
R D R R D R D D 17
R D R R D D R D 18
R D R R D D D R 19
​
R D D R R R D D 20 RDDRR default then 3 2 spaces
R D D R R D R D 21
R D D R R D D R 22
​
R D D D R R R D 23 RDDDRR defailt then 3 3 spaces
R D D D R R D R 24
​
R D D D D R R R 25 RDDDDRRR default then 3 4 spaces
​
R D R D R R D D 26 RDRDR default then 3 1 space, then 2 1 space (if the intial move is >2)
R D R D R D R D 27
R D R D R D D R 28
​
R D R D D R R D 29 RDRDDR
R D R D D R D R 30
​
R D R D D D R R 31 RDRDDDR <<< working to here so far, but using hardcoded values
​
R D D R D R R D 32 RDDRDR
R D D R D R D R 33
​
R D D D R D R R 34 RDDDRDR
​
​
​
+34 beginning with D
Steps
1) for an nxn grid take a string of length 2n where the first half of the string is R chars and the second half is D chars
2) start with a counter of 1
3) move the last R by 1 to the right 
4) increase the counter for every move
5) move the R again until its at the last position of the strings length
6) now put start with 2 Rs a D and another R at the start of the string with a gap of 1 D to the next 2 Rs
​
OR JUST DO THE MATH LOL SEE ABOVE
*/

Last Run:	8:08:33 am
Compile:	0.174s
Execute:	0s
Memory:	0b
CPU:	0.016s

View IL Code