개발이 하고 싶어요

#Large Factorials

In mathematics, the factorial of integer n is written as n!. It is equal to the product of n and every integer preceding it. For example: 5! = 1 x 2 x 3 x 4 x 5 = 120

Your mission is simple: write a function that takes an integer n and returns the value of n!.

You are guaranteed an integer argument. For any values outside the non-negative range, return null, nil or None (return an empty string "" in C and C++). For non-negative numbers a full length number is expected for example, return 25! = "15511210043330985984000000" as a string.

For more on factorials, see http://en.wikipedia.org/wiki/Factorial

import java.math.BigInteger;

public class Kata
{

  public static String Factorial(int n) {
      BigInteger result = BigInteger.valueOf(1);
      for (int i = 1; i <= n; i++)
          result = result.multiply(BigInteger.valueOf(i));
      return result.toString();
  }

}

# Middle Permutation

Task

You are given a string s. Every letter in s appears once.

Consider all strings formed by rearranging the letters in s. After ordering these strings in dictionary order, return the middle term. (If the sequence has a even length n, define its middle term to be the (n/2)th term.)

Example

For s = "abc", the result should be "bac".

The permutations in order are:

"abc", "acb", "bac", "bca", "cab", "cba"

So, The middle term is "bac".

Input/Output

[input] string s

unique letters (2 <= length <= 26)

[output] a string

middle permutation.

	public static List<String> generater(String input) {
		List<String> reslut = new ArrayList<String>();
		MiddlePermutation.permutation("", input, reslut);
		return reslut;
	}

	private static void permutation(String chars, String input, List<String> result) {

		if (input.isEmpty()) {
			result.add(chars + input);
			return;
		}
		for (int i = 0; i < input.length(); i++) {
			permutation(chars + input.charAt(i), input.substring(0, i) + input.substring(i + 1), result);
		}
	}

	public static String findMidPerm(String strng) {
		// your code here!
		List<String> result =MiddlePermutation.generater(strng);
		Collections.sort(result);
		return result.get((result.size() / 2) - 1);
	}

	public static String findMidPerm(String strng) {
		// your code here!
		char [] temp = strng.toCharArray();
		Arrays.sort(temp);
		String sorted = new String(temp);
		
		if(sorted.length()%2==0) {
			int middle = sorted.length()/2-1;
			StringBuilder remainder = new StringBuilder(sorted.substring(0,middle)+sorted.substring(middle+1));
			return sorted.substring(middle,middle+1) + remainder.reverse().toString();
		}else {
			int middle = sorted.length()/2;
			String remainder = sorted.substring(0,middle)+sorted.substring(middle+1);
			return sorted.substring(middle,middle+1) + findMidPerm(remainder.toString());
		}
	}

# Josephus Permutation

This problem takes its name by arguably the most important event in the life of the ancient historian Josephus: according to his tale, he and his 40 soldiers were trapped in a cave by the Romans during a siege.

Refusing to surrender to the enemy, they instead opted for mass suicide, with a twist: they formed a circle and proceeded to kill one man every three, until one last man was left (and that it was supposed to kill himself to end the act).

Well, Josephus and another man were the last two and, as we now know every detail of the story, you may have correctly guessed that they didn't exactly follow through the original idea.

You are now to create a function that returns a Josephus permutation, taking as parameters the initial array/list of items to be permuted as if they were in a circle and counted out every k places until none remained.

Tips and notes: it helps to start counting from 1 up to n, instead of the usual range 0..n-1; k will always be >=1.

For example, with n=7 and k=3 josephus(7,3) should act this way.

[1,2,3,4,5,6,7] - initial sequence

[1,2,4,5,6,7] => 3 is counted out and goes into the result [3]

[1,2,4,5,7] => 6 is counted out and goes into the result [3,6]

[1,4,5,7] => 2 is counted out and goes into the result [3,6,2]

[1,4,5] => 7 is counted out and goes into the result [3,6,2,7]

[1,4] => 5 is counted out and goes into the result [3,6,2,7,5]

[4] => 1 is counted out and goes into the result [3,6,2,7,5,1]

[] => 4 is counted out and goes into the result [3,6,2,7,5,1,4]

So our final result is: josephus([1,2,3,4,5,6,7],3)==[3,6,2,7,5,1,4]

	public static <T> List<T> josephusPermutation(final List<T> items, final int k) {
		    int current = 0;
		    List<T> result= new ArrayList<T>();
		    while (items.size() > 0) {
		    	
		      current = (current-1+k)%items.size();
		      /*
  			  current+=k-1;
			  while(current > = items.size()) {
					current -= items.size();
			  }
			  */
		      result.add(items.remove(current));
		    }
		    return result;
	}

#Calculate String Rotation

Write a function that receives two strings and returns n, where n is equal to the number of characters we should shift the first string forward to match the second.

For instance, take the strings "fatigue" and "tiguefa". In this case, the first string has been rotated 5 characters forward to produce the second string, so 5 would be returned.

If the second string isn't a valid rotation of the first string, the method returns -1.

Examples:

"coffee", "eecoff" => 2

"eecoff", "coffee" => 4

"moose", "Moose" => -1

"isn't", "'tisn" => 2

"Esham", "Esham" => 0

"dog", "god" => -1

public class CalculateRotation {
  static int shiftedDiff(String first, String second){
    for(int i=0; i< second.length(); i++){
        if(second.equals(first))
            return i;
        second = second.substring(1)+second.charAt(0);
    }
    return -1;
  }
}

public class CalculateRotation {
  static int shiftedDiff(String first, String second){
    if(first.length() !=  second.length())
      return -1;
    return (second+second).indexOf(first);
  }
}

# Sort the odd

You have an array of numbers.

Your task is to sort ascending odd numbers but even numbers must be on their places.

Zero isn't an odd number and you don't need to move it. If you have an empty array, you need to return it.

Example

sortArray([5, 3, 2, 8, 1, 4]) == [1, 3, 2, 8, 5, 4]

public class Kata {
  public static int[] sortArray(int[] array) {
    
    for (int i = 0; i < array.length; i++){
        for(int j=0; j < array.length-i; j++){
            if(array[j]%2==0) continue;
            for(int k=j+1; k <array.length; k++){
                if(array[k]%2!=0){
                    if(array[j] > array[k]){
                        int temp = array[j];
                        array[j] = array[k];
                        array[k] = temp;
                    }
                    break;
                }
            }
        }
    }
    return array;
  }
}