Challenge for YOU : create a shorter algorithm than the one below!

Man what you got there is some Neo level shizz, I love it 😂

hahaha, not really. That just looks more weird than it is in reality. I combine two streams. One is 0,1,2 and the second random 5 numbers between 0 and 2. Then depending on the value I create a stream returning one value that either is 0-9, a-z or A-Z and save that resulting stream in an array. Over that array I loop and add its content to the DataOutputStream and return the baos. Nearly the same than you did. When I convert that down to Java 8 and make the order match the requirements it looks as follows:

private static int getInt(int start, int end) {
    return ThreadLocalRandom.current().ints(1, start, end).findFirst().getAsInt();
}

public static ByteArrayOutputStream getPassword() throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    DataOutputStream out = new DataOutputStream(baos);
    for (int e : IntStream.concat(IntStream.range(0,3), ThreadLocalRandom.current().ints(5, 0, 3))
            .map(e -> {int n = 0; switch (e) {
                case (0): n = getInt('0', '9' + 1); break;
                case (1): n = getInt('a', 'z' + 1); break;
                default : n = getInt('A', 'Z' + 1);
            } return n;})
            .toArray()) {
        out.write(e);
    }
    return baos;
}

When I reach lvl. 32 I'll try to validate that solution :)

validates ;) and I also have a new approach. It is more random (and it is a little bit shorter, too).

// alternative using BigInteger and replacing one random lowercase char to an uppercase one
public static ByteArrayOutputStream getPassword()  throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    String p = null, rp;
    do {
        rp = new BigInteger(String.valueOf(ThreadLocalRandom.current().nextLong(100000000000000L, Long.MAX_VALUE))).toString(36).substring(0, 8);
        int i = (int) (Math.random() * 8);
        if (Character.isLowerCase(rp.charAt(i)))
            rp = rp.substring(0, i) + Character.toUpperCase(rp.charAt(i)) + rp.substring(i + 1);

        if (rp.matches(".*[0-9].*") && rp.matches(".*[a-z].*") && rp.matches(".*[A-Z].*"))
            p = rp;
    } while (p == null);

    baos.write(p.getBytes());
    return baos;
}

Because I just saw a new question to this task I thought I'd try a new shorter yet simpler approach...

private static ByteArrayOutputStream getPassword() {
    String v = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

    ByteArrayOutputStream p = new ByteArrayOutputStream();
    while (!p.toString().matches("^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).*$")) {
        p.reset();
        for (int i = 0; i < 8; i++)
            p.write(v.charAt(ThreadLocalRandom.current().nextInt(v.length())));
    }
    return p;
}

Again no clue if it'll validate.

Here is what I came up. It basically is just simplifying what Andrei came up with:

public static ByteArrayOutputStream getPassword() {
   ArrayList<Integer> password = new ArrayList<>();

   // one of each to satisfy conditions
   password.add(getRand(26, 'a'));
   password.add(getRand(26, 'A'));
   password.add(getRand(10, '0'));

   // 5 bytes chosen at random
   for(int i = 0; i < 5; i++)
      switch (getRand(3,0)){
         case 0:
            password.add(getRand(26, 'a'));
            break;
         case 1:
            password.add(getRand(26, 'A'));
            break;
         default:
            password.add(getRand(10, '0'));
            break;
      }

   ByteArrayOutputStream retVal = new ByteArrayOutputStream();

   //shuffle
   while(!password.isEmpty())
      retVal.write(password.remove(getRand(password.size(), 0)));

   return retVal;
}

static int getRand(int max, int mod){
   return (int)(Math.random() * max + mod);
}

It should work fast as it doesn't invalidate any of the random numbers in the algorithm. Andrei's code between lines 52 through 58 could loop numerous times unnecessarily if a valid number isn't chosen.

and I was wrong. Math.Random * bound + digit is very slow compared to a random number generator

That was pretty much what I did in my first approach. But I gave that up for real random and now accept that several attempts can be made. Mainly because it's shorter. Random and Math.random are not 100% random, so ThreadLocalRandom (even if I waste a few characters).

Amazing solutions Thomas. Were you on some additional Streams course?

Guadalupe thanks for info about performance. Now I can try avoid Math.Random if it's slow.

I was interested in streams, lambdas, method references, functional interfaces (remember the tree example?) at one point. So I looked into that and used it where possible to learn it ;)

Yes, I see that you're able to use it very efficiently :) For me, it's still a bit like black magic, so I prefer reading it rather than writing it myself. (not counting really easy ones) I suppose that using streams it's welcome in java profesional world and more neatly when we talking about clean code?

It has its benefits. If you're used the the streams API it's easy to read. It's functionality is thoroughly tested and, if it is possible for your data, you can process your stream that data parallel with just calling one method. On the other hand it has an overhead and usually is not the fastest solution and you can make utterly easy problems more complex :)

I don't work professionally as a programmer, so don't know what the industry prefers; however I like to write code that is understandable AND fast. A lot of times I will solve a task and then write code to test its speed. This typically means putting it in a method and then calling that method thousands of times and timing how long it takes to complete; then repeating that a few times to get an average. Here is an example of how I tested this task code:

public static void main(String[] args) {
   long[] temp = new long[10];
   long start, finish;

   for(int i = 0; i < 10; i++){
      start = System.currentTimeMillis();
      for(int j = 0; j < 100000; j++)
         getPassword();
      finish = System.currentTimeMillis();

      temp[i] = finish - start;
   }

   System.out.println("All the times recorded in milliseconds:\n\t" + Arrays.toString(temp));
   long average = temp[0];
   for(int i = 1; i < 10; i++) average += temp[i];
   System.out.println("Average time: " + (average/10) + " ms");
}

Then I will make more methods such as getPassword1(), getPassword2() etc to try the different things out. All you need to do is plug in the method you want to test into the testing code to see the results.

With this test code Andrei's solve shows (on my computer) completing the task in an average of ~60ms while the code I did using Math.random() does the same in an average of ~100ms. The way that Math.random() works is it returns a decimal that is greater than or equal to 0 but less than 1. I don't think that the Math.random() method is slow by itself, but that my code then needs to multiply the returned value by the next number that is the cause of the slowdown.

I've seen a couple of times that you like to check performance. I should start doing it too. It's a big waste that you're not programming professionally.

Coming back here once again looking at what I have done in the month before :) Hmm, a little rework can be done and I rely more on regex and let the CPU do some more work in favor of shorter code.

private static ByteArrayOutputStream getPassword() {
    ByteArrayOutputStream p = new ByteArrayOutputStream();
    while (!p.toString().matches("(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)[\\da-zA-Z]+")) {
        p.reset();
        for (int i = 0; i < 8; i++)
            p.write(ThreadLocalRandom.current().nextInt(48, 123));
    }
    return p;
}

as usual I have no clue if it'll validate and that solution is ~90 chars smaller than the last

nicceeeeeee 🔝🔝💪 thanks!