/* * * @ Javier Felipe Toribio 2018 * * challenge * * Kaprekar's constant * * Challenge - level: Easy * Write a code which finds the Kaprekar's * constant for any four-digit number. * * Challenge - level: Medium * Write a code which finds Kaprekar's constant * for any number in the range of 101-9999, * checking if the digits of the number are not * too repetitive (no repetitions for three-digit * numbers and max 2 repetitions for four-digit * ones). * * Challenge - level: Hard * Write a code that universally finds Kaprekar's * constants and/or loop for any K-digit number. * If a sequence is found, all the numbers * comprising it have to be returned. * */ import java.util.*; import java.util.stream.Collectors; import java.util.stream.IntStream; class Search { private final int KaprekarConstant = 6174; private Integer initialNumber; private StringBuilder report; private List results; /* * constructor */ Search(Integer number) { initialNumber = number; report = new StringBuilder(); report.append("Calculation for " + number + " :\n\n"); results = new ArrayList<>(); } /* * Calculate maximum number of digit * repetitions in the number */ private int numberRepeatedDigits (Integer number) { int maxRepeatedDigits = 0; Map map = new HashMap<>(); for(Character c : number.toString().toCharArray()) { map.put(c, map.getOrDefault(c,0)+1); } for(Map.Entry item : map.entrySet()) { if(item.getValue() > maxRepeatedDigits) { maxRepeatedDigits = item.getValue(); } } return maxRepeatedDigits; } /* * Validate maximum number of digit * repetitions */ private void validate (Integer number) throws Exception { if(number < 100) throw new Exception("Number must have a number of digits greater or equal to three"); if(number >= 100 && number <= 999) { if(numberRepeatedDigits(number)>1) { throw new Exception("Number with three digits must not have repeated digits"); } } else if(number >= 1000 && number <= 9999) { if(numberRepeatedDigits(number)>2) { throw new Exception("Number with four digits must not have more than two repeated digits"); } } } /* * Rearrange number digits in ascending and * descending order and obtain the * subtraction */ private Integer nextNumber(Integer number) { List list = Arrays.asList (number.toString().split("")); List ascendingList = list.stream(). mapToInt(Integer::parseInt). boxed().sorted(). map(String::valueOf). collect(Collectors.toList()); List descendingList = new ArrayList<>(ascendingList); Collections.reverse(descendingList); Integer minInteger = Integer.parseInt (String.join("", ascendingList)); Integer maxInteger = Integer.parseInt (String.join("", descendingList)); Integer result = maxInteger - minInteger; report.append (maxInteger + " - " + minInteger + " = " + result + "\n"); return result; } /* * Perform operations until find * recurring constant */ public void calculate() throws Exception { int current = initialNumber; validate(current); while(true) { current = nextNumber(current); if(results.contains(current)) break; results.add(current); } report.append("\nConstant " + current + " found !!\n"); if(current == KaprekarConstant) report.append ("\nIt's Kaprekar's constant !!"); } /* * Obtain operations image */ public String getReport() { return report.toString(); } } public class Kapretar { public static void main(String[] args) { try { Integer n = (new Scanner(System.in)).nextInt(); Search search = new Search(n); search.calculate(); System.out.println (search.getReport()); } catch(Exception ex) { System.out.println(ex.getMessage()); } } }

[challenge] Kaprekar constant