fork download
copy 
  1. import com.sun.tools.javac.util.Assert;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.HashSet;
  5. import java.util.concurrent.atomic.AtomicInteger;
  6.  
  7. @SuppressWarnings({"UnnecessaryUnboxing", "WeakerAccess", "BooleanConstructorCall",
  8.     "UnnecessaryBoxing", "UnnecessaryContinue", "StringConcatenationInLoop"})
  9. public class Main {
  10.  
  11.   public static void main(String[] args) throws Exception {
  12.  
  13.     String t1 = "1,6,2,8,3";
  14.     String t2 = "1,8,4,9,-4,2,2";
  15.     String t3 = "4,7,1,8,-2";
  16.  
  17.     Assert.check(high_and_low(t1).equals("1, 8"));
  18.     System.out.println(t1 + " \nresult: "+high_and_low(t1));
  19.  
  20.     System.out.println();
  21.     Assert.check(high_and_low(t2).equals("-4, 9"));
  22.     System.out.println(t2 + " \nresult: "+high_and_low(t2));
  23.  
  24.     System.out.println();
  25.     Assert.check(high_and_low(t3).equals("-2, 8"));
  26.     System.out.println(t3 + " \nresult: "+high_and_low(t3));
  27.   }
  28.  
  29.   public static String high_and_low(String stringToTest){
  30.  
  31.     String low = sort(splitBy(stringToTest, ',')).get(0);
  32.  
  33.     int size = sort(splitBy(stringToTest, ',')).size();
  34.     String high= sort(splitBy(stringToTest, ',')).get(size-1);
  35.  
  36.     String ret = "";
  37.     for (Character c : low.toCharArray()){
  38.       ret+=c;
  39.     }
  40.     ret +=',';
  41.     ret +=' ';
  42.     for (Character c : high.toCharArray()){
  43.       ret+=c;
  44.     }
  45.     return ret;
  46.   }
  47.  
  48.   public static ArrayList<String> splitBy(String s,Character charToFind){
  49.     boolean[] whereTheCommasAre = charBoolArray(s,charToFind);
  50.     ArrayList<String> numbers = new ArrayList<>(1);
  51.     int idx = -1;
  52.     for (int i = 0; i < whereTheCommasAre.length; i++) {
  53.       if(new Boolean(whereTheCommasAre[i]).booleanValue()){
  54.         String number = s.substring(idx+1,i);
  55.         numbers.add(number);
  56.         idx = i;
  57.       }
  58.     }
  59.     String number = s.substring(idx+1);
  60.     numbers.add(number);
  61.     return numbers;
  62.   }
  63.  
  64.   /**
  65.    * @param s the String to test
  66.    * @param charToFind the char to find
  67.    * @return boolean[] true where the char is
  68.    */
  69.   public static boolean[] charBoolArray(String s,Character charToFind){
  70.     boolean[] commas = new boolean[s.length()];
  71.     int idx = 0;
  72.  
  73.     for (int i = 0; i < s.length(); i++) {
  74.       Character c = s.toCharArray()[i];
  75.       if(c.equals(charToFind)){
  76.         commas[idx] = c.equals(charToFind);
  77.         idx++;
  78.       } else {
  79.         idx++;
  80.       }
  81.     }
  82.     return commas;
  83.   }
  84.  
  85.   public static ArrayList<String> sort(ArrayList<String> numbers){
  86.     while(!isSorted(new ArrayList<>(numbers))){
  87.       numbers = trySort(numbers);
  88.     }
  89.     return numbers;
  90.   }
  91.  
  92.   public static boolean isSorted(ArrayList<String> numbers){
  93.     long min = Long.MIN_VALUE;
  94.     for(String number : numbers){
  95.       Long l = Long.parseLong(number);
  96.       if(l<new Long(min)) return false;
  97.       else min = l;
  98.     }
  99.     return true;
  100.   }
  101.  
  102.   public static ArrayList<String> trySort(ArrayList<String> numbers){
  103.     HashSet<String> failed_combos = new HashSet<>(1);
  104.  
  105.     for (int i = 0; ; i++) {
  106.       try {
  107.         Long li = failed_combos.contains(i + " " + 0) ? 0 : Long.parseLong(numbers.get(i));
  108.  
  109.         boolean swapped = false;
  110.         for (int j = 0; j < numbers.size(); j++) {
  111.           try {
  112.             if (i > j) {
  113.               failed_combos.add(i + " " + j);
  114.               throw new Exception("i cant be bigger then j");
  115.             }
  116.             Long lj = failed_combos.contains(i + " " + j) ? 0 : Long.parseLong(numbers.get(j));
  117.             if (li > lj && !failed_combos.contains(i + " " + j) && !swapped) {
  118.               numbers = swap(numbers, new AtomicInteger(i), new AtomicInteger(j));
  119.               swapped = true;
  120.             } else {
  121.               failed_combos.add(i + " " + j);
  122.             }
  123.           } catch (Exception e) {
  124.             failed_combos.add(i + " " + j);
  125.           }
  126.         }
  127.       }catch (IndexOutOfBoundsException e){
  128.         break;
  129.       }
  130.     }
  131.     return numbers;
  132.   }
  133.  
  134.   private static ArrayList<String> swap(ArrayList<String> numbers, AtomicInteger a, AtomicInteger b) {
  135.     if(a.equals(b)) return numbers;
  136.     ArrayList<String> swapped = new ArrayList<>(1);
  137.     for (int i = 0; i < numbers.size(); i++) {
  138.       if(i == a.get()){
  139.         swapped.add(numbers.get(b.get()));
  140.       }
  141.       if(i == b.get()){
  142.         swapped.add(numbers.get(a.get()));
  143.       }
  144.       if(i != a.get() && i != b.get()) {
  145.         swapped.add(numbers.get(i));
  146.       }
  147.     }
  148.     return swapped;
  149.   }
  150. }
  151.  
Success #stdin #stdout 0.07s 2184192KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
1,6,2,8,3 
result: 1, 8

1,8,4,9,-4,2,2 
result: -4, 9

4,7,1,8,-2 
result: -2, 8
https://ideone.com/5dPSHp
language:
Java (HotSpot 12)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!