Piet Souris

The solution that I hinted to works even when there are duplicates and more than one missing. For instance:
public static void main(String... args) {     int[] a = {1,1,4,5,5,7,10};     int missing[] = determineMissing(a, 12);     System.out.println(Arrays.toString(missing)); } private static int[] determineMissing(int[] a, int n) {     boolean[] present = new boolean[n];     for (int i: a) present[i] = true;     // now, it would take one line of code to return the required array using a java 8 stream,     // but proceed with an arraylist and an array like you do at the moment     ... }

Perhaps you could simplify the game a little, by calculating all the rolls for a player upfront. Not only makes that the code a little easier, but you have all the information before the game starts. For instance
private static List<Integer> rollsNeeded() {         List<Integer> casts = new ArrayList<>();         Set<Integer> uniques = new HashSet<>();         while (uniques.size() < 6) {             int roll = die.Roll();             casts.add(roll);             uniques.add(roll);         }         return casts;     }

A linear time solution: create an Object[] the size of n, then for every present value i put an Object in Object[i]. In the end, some Object[x] will not have a value.

hi Tuan,

since the upper limit is only 100.000, I would probably do this brute force. The question is then only how to discover the number of beautiful digits, like Campbel writes.

Another way to look at this is: if the upper limit consists of N digits, then consider the numbers 000... (N zeroes) - 999... (N nines). For each of the N digits, we draw a random digit. The number we get, has a Binomial distribution, with N as the number of trials, and a chance of success of (F / 9), where F is the number of beautiful digits.
For instance, let the product numbers be between 0 and 99 (inclusive), and let the beautiful digits be 5 and 7. The chance of getting two beautiful numbers is now: 2! / (2! * 0!) * (2/10)^2 * (8 / 10) ^0 = 0.04, giving a total of 0.04 * 100 = 4.

Unfortunately, then there is the problem of dropping the outcomes that are outside of the bounds. So, this way may be interesting, but not for the faints of heart.

It kind of remembers me of an interesting topic, that also dealt with a number of permutations within a certain interval (where the max could be a whopping 10 ^100). Don't remember whether it is relevant in any way, but it sure was fun:

problem: digit products

But objarray is an array of raw ArrayLists, so you are giving up all compilers type checking. For instance
ArrayList[] objarray = new ArrayList[10]; objarray[1] = Arrays.asList("List", "is", "an", "abstract and interface").stream().collect(toCollection(ArrayList::new)); ((List<Point>) objarray[1]).add(new Point()); System.out.println(objarray[1]);
What are you trying to prove?

A clear way is to create a Map<Character, String>, with the key being the char to be replaced, and the value the string (could be more than one character) that is the replacement.
If you read in a line, put it in a StringBuilder (like Carey advised), and, going from end to start, check if the char is present in the map and if so, replace it by the value. Return the toString of the StringBuilder as result.

Thanks, Stephan.

At the time I experimented wit this, I did not have java 8, and so never applied it to interfaces and what consequences this would have. Interesting...

Then I haven't got a clue what you mean, but I don't mind keeping it that way.

The idea a couple of years ago was to try to mimic Scala's 'type A = B' (or C's typedef), but I'm always in for some better suggestions (but not in this topic, it is polluted enough already).

Perhaps a little more clear is writing the ternary aa follows:
int x = arr[i] > 0 ? pCount++ :         arr[i] < 0 ? nCount++ :         zCount++ ;

yep, the result of the ternary needs to be assigned to something...

Yes, but it needs not be assigned to a variable. For instance
String c = ""; System.out.println(c == null ? "Null String" : c == "" ? "Empty String" : c);

Well, if it was only for one instance, it would not save any typing or copying. But I sometimes have a generic class with a pretty big type collection, and needing a couple of instance or in an enhanced for-loop. I was happy with my way of doing as described above. It did save on typing and copying. I wish I could apply it to Map.Entry<list of horribly long types>, but unfortunately, that class is abstract, so I could not extend it into something concrete.

But your reference to Gullivers Travels seems to indicate a different experience. Can you elaborate about your experience?

hi Carey,

whether you will use the SumCount.collect in parallel or not, you must provide a non-null adder of two SumCounts. Now, given the SumCount, it is hard to say what the "sum"of two SumCounts should do, but as you write, it is not being used, so it really doesn't matter.

So add something like this to SumCount:
public void addSumCount(SumCount other) {             sum += other.sum;         }
and make this change:
SumCount result = Stream.of( test.sentence.split( "\\s+" ) )                 .map( s -> s.length() )                 .collect( () -> new SumCount(test.criteria), // SumCount::new, // *** wanted: new SubCount(test.criteria)                         SumCount::add,                         SumCount::addSumCount ) ;
and your code compiles and runs, with nothing but SUCCESSES.

However, whatever your algorithm is, it differs from my interpretation. For example, running your code, I get SUCCESS "message are", 501, -1
while my algo would give +1 (it would not do any split). But I must admit: I did hardly test my code, so a handful of bugs is not unlikely.

But most of all: will Atul still be enthousiastic about Streams?   

By the way: another way is to split the input string, as you already did, and then make a Stream with a dedicated Collector class. For an example, see the Oracle tutorial reduce and collect

So, if I have it correct, the functionality is: break the String up on spaces, such that each piece is as long as possible, but no longer than maxBreak.

Your question is if your code can be expressed using java8 Streams. Well, I did an attempt, starting from my own logic, but it is not so easy.  There are probably handier ways, and I leave it up to you to judge whether this is useless or not. Still, it makes for some nice exercise in streams! So, if you like, see if you can translate your own logic into code that employs some Streams.

My approach is:
1) determine the indices of all the spaces. For technical reasons I add an extra space at the end of the String, unless it already ends with a space.
2) check whether there are no two consecutive indices that differ more than maxBreak
3) now, apply this algorithm: if say the indices are 4, 7, 9, 12, 15, 20, 24,  ... and maxBreak is 10, then the breaks will be 9, 15, 24, ...

A problem when using Streams that need some history, is that you cannot use an ordinary variable to store that history, since then you get the error that such a variable needs to be final or effectively final. The quick and dirty solution that I use is to use an array of size 1, and store some history in array[0]. That is okay, since the content may not be final, the array itself is.
public class AtulMore {     public static void main(String... args) {         String s = "Use of Java8 Streams is not easy or handy, although it makes for some good exercise";         if (!s.endsWith(" ")) s += " ";         TreeSet<Integer> spaces = getIndicesOfSpaces(s);         int maxBreak = 10;         if (cannotBreak(spaces, maxBreak)) throw new RuntimeException("Can't break the string");         TreeSet<Integer> breaks = getBreaks(spaces, maxBreak);         System.out.println(breaks);         System.out.println("Number of breaks: " + breaks.size()); //        breaks.forEach(i -> System.out.println(s.substring(0, i)));   Why does this line not work?         for (int i: breaks) System.out.println(s.substring(0, i));     }         private static TreeSet<Integer> getIndicesOfSpaces(String s) {         TreeSet<Integer> result = IntStream.range(0, s.length())                 .filter(i -> s.charAt(i) == ' ')                 .boxed()                 .collect(Collectors.toCollection(TreeSet::new))         ;         return result;     }         private static TreeSet<Integer> getBreaks(TreeSet<Integer> set, int maxBreak) {         int[] temp = {0};         TreeSet<Integer> result = set.stream()                 .map(i -> {int p = temp[0] + maxBreak; int q = set.floor(p); temp[0] = q; return q;})                 .collect(Collectors.toCollection(TreeSet::new))         ;         return result;     }                     private static boolean cannotBreak(Set<Integer> s, int criterium) {         int[] temp = {0};         return s.stream().anyMatch(i -> {int p = temp[0]; temp[0] = i; return i - p > criterium;});     } }

Campbell Ritchie wrote:(...) and implemented it asI<String, Integer, Integer> object = (s, i) -> somethingProducingAnInteger;

But is can be economical to extend an interface to get rid of all these parameters. For instance
interface FeestNeus extends BiFunction<String, Integer, Character> {}  
so now you can say
FeestNeus piet = (a, b) -> a.charAt(b); System.out.println(piet.apply("Feestneus", 5));

hi Caiz,

great reply, and have a well deserved cow!

Caiz wrote:Also thanks Plet, I've used the .setDisabledIcon() method, it still darkens the image a bit but not so much as the default

Hmm, it is quite a while ago since I did anything like this, so maybe my memory is playing tricks. I'll have a look at it and will let you know. But maybe Rob had a better way in mind, so let's hope he will let us know.