개발이 하고 싶어요

 #69  Weight for weight

My friend John and I are members of the "Fat to Fit Club (FFC)". John is worried because each month a list with the weights of members is published and each month he is the last on the list which means he is the heaviest.

I am the one who establishes the list so I told him: "Don't worry any more, I will modify the order of the list". It was decided to attribute a "weight" to numbers. The weight of a number will be from now on the sum of its digits.

For example 99 will have "weight" 18, 100 will have "weight" 1 so in the list 100 will come before 99. Given a string with the weights of FFC members in normal order can you give this string ordered by "weights" of these numbers?

Example:

"56 65 74 100 99 68 86 180 90" ordered by numbers weights becomes: "100 180 90 56 65 74 68 86 99"

When two numbers have the same "weight", let us class them as if they were strings and not numbers: 100 is before 180 because its "weight" (1) is less than the one of 180 (9) and 180 is before 90 since, having the same "weight" (9) it comes before as a string.

All numbers in the list are positive numbers and the list can be empty.

	
import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.Collectors;

public class WeightSort {

	public static int getWeight(String strng) {
		return Arrays.stream(strng.split("")).mapToInt(Integer::parseInt).sum();
	}

	public static String orderWeight(String strng) {
		return Arrays.stream(strng.split(" "))
				.sorted(Comparator.comparing(WeightSort::getWeight).thenComparing(String::compareTo))
				.collect(Collectors.joining(" "));
	}
}

 #63 Sort two arrays

When no more interesting kata can be resolved, I just choose to create the new kata, to solve their own, to enjoy the process --myjinxin2015 said

Description:

Give you two arrays arr1 and arr2. They have the same length(length>=2). The elements of two arrays always be integer.

Sort arr1 according to the ascending order of arr2; Sort arr2 according to the ascending order of arr1. Description is not easy to understand, for example:

 arr1=[5,4,3,2,1], 

 arr2=[6,5,7,8,9]

Let us try to sorting arr1. First, we need know the ascending order of arr2:

 [5,6,7,8,9]

We can see, after sort arr2 to ascending order, some elements' index are changed:

 unsort arr2      ascending order arr2

 [6,5,7,8,9]--->      [5,6,7,8,9]

 index0(6)  --->      index1

 index1(5)  --->      index0

 index2(7)            index2(no change)

 index3(8)            index3(no change)

 index4(9)            index4(no change)

So, wo need according to these changes to sorting arr1:

 unsort arr1          sorted arr1

 [5,4,3,2,1]--->      [4,5,3,2,1]

 index0(5)  --->      index1

 index1(4)  --->      index0

 index2(3)            index2(no change)

 index3(2)            index3(no change)

 index4(1)            index4(no change)

 So: sorted arr1= [4,5,3,2,1]

And then, we sorting arr2 with the same process:

 unsort arr1      ascending order arr1

 [5,4,3,2,1]--->      [1,2,3,4,5]

 index0(5)  --->      index4

 index1(4)  --->      index3

 index2(3)            index2(no change)

 index3(2)  --->      index1

 index4(1)  --->      index0

 unsort arr2          sorted arr2

 [6,5,7,8,9]--->      [9,8,7,5,6]

 index0(6)  --->      index4

 index1(5)  --->      index3

 index2(7)            index2(no change)

 index3(8)  --->      index1

 index4(9)  --->      index0

 So: sorted arr2= [9,8,7,5,6]

Finally, returns the sorted arrays by a 2D array: [sorted arr1, sorted arr2]

Note: In ascending order sorting process(not the final sort), if some elements have same value, sort them according to their index; You can modify the original array, but I advise you not to do that. ;-)

Some Examples and explain

sortArrays([5,4,3,2,1],[6,5,7,8,9]) should return

[[4,5,3,2,1],[9,8,7,5,6]]

sortArrays([2,1,3,4,5],[5,6,7,8,9]) should return

[[2,1,3,4,5],[6,5,7,8,9]]

sortArrays([5,6,9,2,6,5],[3,6,7,4,8,1]) should return

[[5,5,2,6,9,6],[4,3,1,6,8,7]]

import java.util.Comparator;
import java.util.stream.IntStream;

public class ArraySorter {
	
	private static int [] sort(int [] target, int [] sortby ) {
		return IntStream.range(0, target.length).boxed()
			   .sorted(Comparator.comparing(i->sortby[i]))
			   .mapToInt(i->target[i]).toArray();
	}
	public static int[][] sortTwoArrays(int[] arr1, int[] arr2) {
		return new int [][] {sort(arr1,arr2),sort(arr2,arr1)};
	}
}

#58 My Languages 

Your task

Given a list of languages and your respective test results, return the list of languages where your test score is at least 60, in descending order of the results.

Note: There will be no duplicate values.

Examples

{"Java" => 10, "Ruby" => 80, "Python" => 65}  --> ["Ruby", "Python"]

{"Hindi" => 60, "Dutch" => 93, "Greek" => 71} --> ["Dutch", "Greek", "Hindi"]

{"C++" => 50, "ASM" => 10, "Haskell" => 20}   --> []

package com.codewars.anter69;

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class MyLanguages {
  public static List<String> myLanguages(final Map<String, Integer> results) {
  		return results.entrySet().stream().filter(x->x.getValue()>=60)
            .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
			      .map(x -> x.getKey()).collect(Collectors.toList());
  }
}

 #45 Sort - one, three, two

Hey You !

Sort these integers for me ...

By name ...

Do it now !

Input

Range is 0-999

There may be duplicates

The array may be empty

import java.util.Arrays;
import java.util.Comparator;

public class Dinglemouse {

	private static final String[] tens = { "", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy",
			"eighty", "ninety" };

	private static final String[] nums = { "", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
			"ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen",
			"nineteen" };

	public static String convert(int n) {
		if (n == 0)
			return "zero";
		String result;
		if (n % 100 < 20) {
			result = nums[n % 100];
			n /= 100;
		} else {
			result = nums[n % 10];
			n /= 10;
			result = tens[n % 10] + result;
			n /= 10;
		}
		if (n == 0)
			return result;
		return nums[n] + " hundred" + result;
	}

	public static int[] sort(final int array[]) {
		return Arrays.stream(array).boxed()
			   .sorted(Comparator.comparing(Dinglemouse::convert)).map(String::valueOf)
			   .mapToInt(Integer::valueOf).toArray();
	}
}

# 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;
  }
}