SHARE
TWEET

Untitled

a guest Mar 21st, 2019 95 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.math.BigInteger;
  2. import java.util.Collections;
  3. import java.util.HashMap;
  4. import java.util.LinkedHashMap;
  5. import java.util.Map;
  6.  
  7. import java.util.stream.IntStream;
  8.  
  9. public class NumberTest {
  10.     static BigInteger TWO = new BigInteger("2");
  11.     static BigInteger SEVEN = new BigInteger("7");
  12.     static BigInteger EIGHT = new BigInteger("8");
  13.     static BigInteger NINE = new BigInteger("9");
  14.     private static int MAX_SIZE = 20;
  15.     static Map<Integer, BigInteger> powerCache2 = Collections.synchronizedMap(new LRUCache<>());
  16.     static Map<Integer, BigInteger> powerCache7 = Collections.synchronizedMap(new LRUCache<>());
  17.     static Map<Integer, BigInteger> powerCache8 = Collections.synchronizedMap(new LRUCache<>());
  18.    
  19.    
  20.    
  21.     public static class LRUCache<A,B> extends LinkedHashMap<A, B> {
  22.        
  23.         /**
  24.          *
  25.          */
  26.         private static final long serialVersionUID = 1L;
  27.  
  28.         public LRUCache() {
  29.             super(2,0.75f, true);
  30.            
  31.         }
  32.        
  33.         @Override
  34.         protected boolean removeEldestEntry(java.util.Map.Entry<A, B> eldest) {
  35.             return size() > MAX_SIZE;
  36.         }
  37.     }
  38.    
  39.     public static void main(String[] args) {
  40.         //testNumber(1,6,6,2);
  41.        
  42.         IntStream.iterate(4, i -> i + 1).parallel().forEach(NumberTest::generateNumber);
  43.     }
  44.    
  45.     public static int generateNumber(int numDigets) {
  46.         for (int i2 = 0;i2 <= numDigets;i2++) {
  47.             for (int i7 = 0; i7 <= numDigets-i2;i7++) {
  48.                 if (numDigets-i2 == 0) {
  49.                     testNumber(i2, i7, 0, 0);
  50.                 }else {
  51.                     for (int i8 = 0;i8 <= numDigets-i2-i7;i8++) {
  52.                         testNumber(i2, i7, i8, numDigets-i2-i7-i8);
  53.                     }
  54.                 }
  55.             }
  56.         }
  57.        
  58.         return 0;
  59.     }
  60.    
  61.     public static BigInteger getPowerCache2(BigInteger p, Integer exp) {
  62.         return powerCache2.computeIfAbsent(exp, (k) -> {return p.pow(k);});
  63.     }
  64.    
  65.     public static BigInteger getPowerCache7(BigInteger p, Integer exp) {
  66.         return powerCache7.computeIfAbsent(exp, (k) -> {return p.pow(k);});
  67.     }
  68.    
  69.     public static BigInteger getPowerCache8(BigInteger p, Integer exp) {
  70.         return powerCache8.computeIfAbsent(exp, (k) -> {return p.pow(k);});
  71.     }
  72.    
  73.     public static BigInteger getPowerCache(Integer i, Integer exp) {
  74.         if (i.equals(2))
  75.             return getPowerCache2(TWO, exp);
  76.         if (i.equals(7))
  77.             return getPowerCache7(SEVEN, exp);
  78.         if (i.equals(8))
  79.             return getPowerCache8(EIGHT, exp);
  80.         return new BigInteger(Integer.toString(i)).pow(exp);
  81.     }
  82.    
  83.    
  84.    
  85.     public static int testNumber(int numberTwos, int numberSevens, int numberEights, int numberNines) {
  86.        
  87.         HashMap<Integer, Integer> map = new HashMap<>();
  88.        
  89.         map.put(2, numberTwos);
  90.         map.put(7, numberSevens);
  91.         map.put(8, numberEights);
  92.         map.put(9, numberNines);
  93.        
  94.         BigInteger num = map.entrySet().parallelStream().map((v) -> {return getPowerCache(v.getKey(), v.getValue());}).reduce(BigInteger.ONE, (a, b) -> {return a.multiply(b);});
  95.        
  96.         int count = calculateProductOfDigets(num);
  97.        
  98.         if (count > 5)
  99.             System.out.println(count + " = " + numberTwos + "-" + numberSevens + "-" + numberEights + "-" + numberNines);
  100.  
  101.         return 0;
  102.        
  103.     }
  104.    
  105.     public static int calculateProductOfDigets(BigInteger number) {
  106.        
  107.         // This is step 2 of the iteration as testNumber does the first step
  108.        
  109.         int count = 1;
  110.         while (number.compareTo(BigInteger.TEN) > 0) {
  111.             String actualNumber = number.toString();
  112.            
  113.             number = new BigInteger("1");
  114.            
  115.             for(int i =0;i < actualNumber.length();i++) {
  116.        
  117.                 char c= actualNumber.charAt(i);
  118.                
  119.                 // anything multiplied by 0 is 0 so this is the last number in the iteration
  120.                 if (c == '0')
  121.                     return count+1;
  122.                
  123.                 number = number.multiply(new BigInteger(Character.toString(c)));
  124.             }
  125.            
  126.             count++;
  127.         }
  128.        
  129.         return count;
  130.     }
  131.  
  132. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top