Minimum adjacent swaps of digits required to make N divisible by K

// Java program for the above approach

import java.util.*;

public class MapPr {

    // Function for next permutation
    static char[] next_permutation(char[] arr)
    {

        // Find the length of the array
        int n = arr.length;

        // Start from the right most digit and
        // find the first digit that is smaller
        // than the digit next to it.
        int k = n - 2;
        while (k >= 0) {
            if (arr[k] < arr[k + 1])
                break;

            k -= 1;
        }
        int l;
        // Reverse the list if the digit that
        // is smaller than the digit next to
        // it is not found.
        if (k < 0)
            Collections.reverse(Arrays.asList(arr));
        else {
            // Find the first greatest element
            // than arr[k] from the end of the list
            for (l = n - 1; l > k; l--) {
                if (arr[l] > arr[k])
                    break;
            }

            // Swap the elements at arr[k] and arr[l]
            char temp = arr[l];
            arr[l] = arr[k];
            arr[k] = temp;
        }
        // Reverse the list from k + 1 to the end
        // to find the most nearest greater number
        // to the given input number

        int mid = (k + 1) + (arr.length - k - 1) / 2;
        int pos = arr.length - 1;
        for (int i = k + 1; i < mid; i++) {
            char temp = arr[i];
            arr[i] = arr[pos];
            arr[pos--] = temp;
        }

        return arr;
    }

    // Function to find minimum number of
    // swaps requires to convert s1 to s2
    static int CountSteps(char[] s1, char[] s2, int size)
    {
        int i = 0;
        int j = 0;
        int result = 0;

        // Iterate over the first string
        // and convert every element
        while (i < size) {
            j = i;
            // Find index element of which
            // is equal to the ith element
            while (s1[j] != s2[i])
                j += 1;

            // Swap adjacent elements in
            // the first string
            while (i < j) {
                // Swap elements
                char temp = s1[j];
                s1[j] = s1[j - 1];
                s1[j - 1] = temp;
                j -= 1;
                result += 1;
            }
            i += 1;
        }
        return result;
    }

    // Function to find minimum number of adjacent
    // swaps required to make N divisible by K
    static int swapDigits(int N, int K)
    {
        // Convert the integer into string
        char[] st = (String.valueOf(N)).toCharArray();
        char[] st2 = (String.valueOf(N)).toCharArray();

        // Sort the elements of the string
        Arrays.sort(st);
        Arrays.sort(st2);

        String st2s = new String(st2);

        // Stores the count of swaps
        int ans = Integer.MAX_VALUE;

        // Iterate over all permutations
        // of the given string
        // If the current integer
        // is divisible by K
        while (true) {
            st = next_permutation(st);
            String sts = new String(st);
            int sti = Integer.parseInt(sts);
            if (sti % K == 0) {
                ans = Math.min(
                    ans,
                    CountSteps(
                        (String.valueOf(N)).toCharArray(),
                        st, st.length));
            }
            if (sts.equals(st2s))
                break;
        }

        // Return Answer
        return ans;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int N = 10203456;
        int K = 100;
        System.out.println(swapDigits(N, K));
    }
}

// This code is contributed by phasing17