/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.stream.Collectors;
import java.util.Map;
import java.util.LinkedHashMap;
import java.util.HashMap;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
	static Map<String, Integer> myMap = new HashMap<>();

    static void combinationUtil(int arr[], int data[], int start,
            int end, int index, int r) {
        int sum = 0;
        StringBuilder sb = new StringBuilder();
        if (index == r) {
            for (int j = 0; j < r; j++) {

                sb.append(data[j]).append(",");
                sum += data[j];

                System.out.print(data[j] + " ");
            }
            myMap.put(sb.toString(), sum);
            sum = 0;
            sb = new StringBuilder();
            System.out.println("");
            return;
        }
        for (int i = start; i <= end && end - i + 1 >= r - index; i++) {
            data[index] = arr[i];
            combinationUtil(arr, data, i + 1, end, index + 1, r);
        }
    }

    static void printCombination(int arr[], int n, int r) {
        int data[] = new int[r];
        combinationUtil(arr, data, 0, n - 1, 0, r);
    }

    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5,6,7,8};
        int r = 3;
        int n = arr.length;
        printCombination(arr, n, r);
        myMap = sortByValue(myMap);
        System.out.println(searchClosest(myMap, 14));
    }

    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
        return map.entrySet()
                .stream()
                .sorted(Map.Entry.comparingByValue(/*Collections.reverseOrder()*/))
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue,
                        (e1, e2) -> e1,
                        LinkedHashMap::new
                ));
    }

    public static String searchClosest(Map<String, Integer> map, int value) {
        double minDistance = Double.MAX_VALUE;
        String bestString = null;

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            double distance = Math.abs(entry.getValue() - value);
            if (distance < minDistance) {
                minDistance = distance;
                bestString = entry.getKey();
            }
        }
        return bestString;
    }
}