TwistyPuzzleLib

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.objectlib.tablebases;

import java.util.Random;

///////////////////////////////////////////////////////////////////////////////////////////////////

public class TablebaseHelpers

{

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void displayTable(int[] table, String marker)

    {

    StringBuilder sb = new StringBuilder();

    for( int t : table )

      {

      sb.append(' ');

      sb.append(t);

      }

    android.util.Log.e("D", marker+" : "+sb);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private static String print(int[][] move)

    {

    StringBuilder sb = new StringBuilder();

    if( move==null )

      {

      return ("move NULL!!");

      }

    for (int[] ints : move)

      {

      sb.append(' ');

      sb.append('(');

      sb.append(ints[0]);

      sb.append(' ');

      sb.append(ints[1]);

      sb.append(' ');

      sb.append(ints[2]);

      sb.append(')');

      }

    return sb.toString();

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void test(TablebasesAbstract tb)

    {

    int size = tb.getSize();

    for(int i=0; i<size; i++)

      {

      boolean success = tb.test(i);

      if( (!success && i>0) || (success && i==0) )

        {

        android.util.Log.e("D", "--------> FAILED: "+i);

        break;

        }

      if( (i%1000)==0 )   android.util.Log.e("D", "trying "+i);

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void test2(TablebasesAbstract tb, int num)

    {

    Random rnd = new Random();

    int size = tb.getSize();

    for(int i=0; i<num; i++)

      {

      int next = rnd.nextInt(size-1);

      int[][] moves = tb.solution(next,null,null);

      String moveSeq = print(moves);

      android.util.Log.e("D", (moves==null ? 0 : moves.length)+" Trying "+next+" : "+moveSeq);

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private static int swaps(int val, int[] buffer, int len)

    {

    int ret = 0;

    for(int i=0; i<len; i++)

      {

           if( buffer[i] >val ) ret++;

      else if( buffer[i]==val ) return ret;

      }

    return -1;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static boolean permutationIsEven(int[] buffer)

    {

    int len = buffer.length;

    int numOfSwaps = 0;

    for(int i=0; i<len-1; i++) numOfSwaps += swaps(i,buffer,len);

    return (numOfSwaps%2==0);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static int computeEvenPermutationNum(int[] permutation)

    {

    int len = permutation.length-2;

    int ret = 0;

    int mul = 4;

    for(int i=0; i<len; i++)

      {

      ret += swaps(len-1-i,permutation,len+2);

      if( i<len-1 )

        {

        ret *= mul;

        mul++;

        }

      }

    return ret;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void getEvenPermutationFromNum(int[] buffer, int permNum)

    {

    int permSize = buffer.length;

    int index = permSize;

    int len = permSize-2;

    int totalSwaps = 0;

    for(int i=0; i<permSize; i++) buffer[i]=-1;

    for(int i=0; i<len; i++)

      {

      int swaps = (permNum%index);

      permNum /= index;

      index--;

      totalSwaps += swaps;

      for(int j=0; j<permSize; j++)

        {

        if( buffer[j]==-1 )

          {

          if( swaps==0 )

            {

            buffer[j] = i;

            break;

            }

          swaps--;

          }

        }

      }

    int lower, upper;

    if( (totalSwaps%2)==0 )

      {

      lower = permSize-2;

      upper = permSize-1;

      }

    else

      {

      lower = permSize-1;

      upper = permSize-2;

      }

    boolean first=true;

    for(int i=0; i<permSize; i++)

      if( buffer[i]==-1 )

        {

        if( first )

          {

          buffer[i] = lower;

          first=false;

          }

        else

          {

          buffer[i] = upper;

          break;

          }

        }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static int computePermutationNum(int[] permutation)

    {

    int len = permutation.length;

    int ret = 0;

    int mul = 3;

    for(int i=0; i<len-2; i++)

      {

      ret += swaps(len-2-i,permutation,len);

      ret *= mul;

      mul++;

      }

    ret += swaps(0,permutation,len);

    return ret;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void getPermutationFromNum(int[] buffer,int permSize, int permNum)

    {

    int index = permSize;

    int len = permSize-1;

    for(int i=0; i<permSize; i++) buffer[i]=-1;

    for(int i=0; i<len; i++)

      {

      int swaps = (permNum%index);

      permNum /= index;

      index--;

      for(int j=0; j<permSize; j++)

        {

        if( buffer[j]==-1 )

          {

          if( swaps==0 )

            {

            buffer[j] = i;

            break;

            }

          swaps--;

          }

        }

      }

    for(int i=0; i<permSize; i++)

      if( buffer[i]==-1 )

        {

        buffer[i] = permSize-1;

        break;

        }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public static void invertPermutation(int[] perm, int[] output)

    {

    int len = perm.length;

    for(int i=0; i<len; i++) output[i] = -1;

    for(int i=0; i<len; i++) output[perm[i]] = i;

    }

}