Beautiful Number Validator
Remove redundant code


    if (s.length() &lt; 2) {
      return false;
    }



This is unnecessary.  If s.length() is less than two, then 1 &lt;= s.length() / 2 will be false, as 1/2 is 0 in integer math.  So it will drop through to the final return.  

Say what you'll do


      if (value == 0) {
        break;
      }



You could write this more readably as 

      if (value == 0) {
        return false;
      }


But it's not necessarily so that this would ever be called.  It's also not clear that this is correct behavior.  For example, this would break an octal or hexadecimal integer that is formatted with a leading zero.  

Don't repeat work


     while (sb.length() &lt; s.length() &amp;&amp; sb.toString().equals(s.substring(0, sb.length()))) {
        sb.append(++value);
      }



This doesn't require a StringBuilder.  Consider 

      int i = 0;
      while (i &lt; s.length()) {
        String number = String.valueOf(value);
        if (!s.substring(i, i + number.length()).equals(number)) {
          break;
        }
        i += number.length();
        value++;
      }


Instead of comparing two ever lengthening strings, this compares just the string representation of the current value.  

Does this matter?  You choose to parse into a long value.  That only matters if the number is more than ten digits.  Every single nine-digit value will fit into an int.  This suggests that the beautiful number can be at least twenty digits long.  

This doesn't quite fit in the logic of your original program, so I rewrote it as a helper method.  

    public static boolean isValidBeautifulNumber(String s, long prefix) {
        for (int i = 0; i &lt; s.length(); ) {
            String number = String.valueOf(prefix);
            if (!s.substring(i, i + number.length()).equals(number)) {
                return false;
            }

            i += number.length();
            prefix++;
        }

        return true;
    }

    public static boolean isValidBeautifulNumber(String s) {
        for (int substringSize = 1; substringSize &lt;= s.length() / 2; substringSize++) {
            if (isValidBeautifulNumber(s, Long.parseLong(s.substring(0, substringSize)))) {
                return true;
            }
        }

        return false;
    }


This significantly simplifies the logic.  

If each \$a_i\$ matches the original string, we make it through the loop and return true.  If any fail to match, we return false.