Return to Question

See the previous iteration.

At this point, I have

1. "digit group" length assumed to be always 3
2. the user can pass the delimiter character of his/her own
3. handles (seems to handle) the minus sign gracefully
4. hacked away a test in a conditional

import java.util.Scanner;
public class Main {
 /**
 * Handles <b>most</b> locales.
 */
 private static final int GROUP_LENGTH = 3;
 private static final char DEFAULT_DELIMITER_CHAR = ' ';
 public static String neatify(final long number,
 final char delimiter) {
 final char[] charArray = Long.toString(number).toCharArray();
 final StringBuilder sb = new StringBuilder();
 int index;
 if (charArray[0] == '-') {
 sb.append('-');
 index = 1;
 } else {
 index = 0;
 }
 sb.append(charArray[index++]);
 for (; index < charArray.length; ++index) {
 if ((charArray.length - index) % GROUP_LENGTH == 0) {
 sb.append(delimiter);
 }
 sb.append(charArray[index]);
 }
 return sb.toString();
 }
 public static String neatify(final long number) {
 return neatify(number, DEFAULT_DELIMITER_CHAR);
 }
 public static void main(final String... args) {
 final Scanner scanner = new Scanner(System.in);
 while (scanner.hasNextLong()) {
 System.out.println(neatify(scanner.nextLong()));
 }
 }
}

By default, performance is important for me. If you know how to squeeze just a little bit more of that, let me know!

See the previous iteration.

At this point, I have

1. "digit group" length assumed to be always 3
2. the user can pass the delimiter character of his/her own
3. handles (seems to handle) the minus sign gracefully
4. hacked away a test in a conditional

import java.util.Scanner;
public class Main {
 /**
 * Handles <b>most</b> locales.
 */
 private static final int GROUP_LENGTH = 3;
 private static final char DEFAULT_DELIMITER_CHAR = ' ';
 public static String neatify(final long number,
 final char delimiter) {
 final char[] charArray = Long.toString(number).toCharArray();
 final StringBuilder sb = new StringBuilder();
 int index;
 if (charArray[0] == '-') {
 sb.append('-');
 index = 1;
 } else {
 index = 0;
 }
 sb.append(charArray[index++]);
 for (; index < charArray.length; ++index) {
 if ((charArray.length - index) % GROUP_LENGTH == 0) {
 sb.append(delimiter);
 }
 sb.append(charArray[index]);
 }
 return sb.toString();
 }
 public static String neatify(final long number) {
 return neatify(number, DEFAULT_DELIMITER_CHAR);
 }
 public static void main(final String... args) {
 final Scanner scanner = new Scanner(System.in);
 while (scanner.hasNextLong()) {
 System.out.println(neatify(scanner.nextLong()));
 }
 }
}

By default, performance is important for me. If you know how to squeeze just a little bit more of that, let me know!

See the previous iteration.

At this point, I have

1. "digit group" length assumed to be always 3
2. the user can pass the delimiter character of his/her own
3. handles (seems to handle) the minus sign gracefully
4. hacked away a test in a conditional

import java.util.Scanner;
public class Main {
 /**
 * Handles <b>most</b> locales.
 */
 private static final int GROUP_LENGTH = 3;
 private static final char DEFAULT_DELIMITER_CHAR = ' ';
 public static String neatify(final long number,
 final char delimiter) {
 final char[] charArray = Long.toString(number).toCharArray();
 final StringBuilder sb = new StringBuilder();
 int index;
 if (charArray[0] == '-') {
 sb.append('-');
 index = 1;
 } else {
 index = 0;
 }
 sb.append(charArray[index++]);
 for (; index < charArray.length; ++index) {
 if ((charArray.length - index) % GROUP_LENGTH == 0) {
 sb.append(delimiter);
 }
 sb.append(charArray[index]);
 }
 return sb.toString();
 }
 public static String neatify(final long number) {
 return neatify(number, DEFAULT_DELIMITER_CHAR);
 }
 public static void main(final String... args) {
 final Scanner scanner = new Scanner(System.in);
 while (scanner.hasNextLong()) {
 System.out.println(neatify(scanner.nextLong()));
 }
 }
}

By default, performance is important for me. If you know how to squeeze just a little bit more of that, let me know!

See the previous iteration.

At this point, I have

1. "digit group" length assumed to be always 3
2. the user can pass the delimiter character of his/her own
3. handles (seems to handle) the minus sign gracefully
4. hacked away a test in a conditional

import java.util.Scanner;
public class Main {
 /**
 * Handles <b>most</b> locales.
 */
 private static final int GROUP_LENGTH = 3;
 private static final char DEFAULT_DELIMITER_CHAR = ' ';
 public static String neatify(final long number,
 final char delimiter) {
 final char[] charArray = Long.toString(number).toCharArray();
 final StringBuilder sb = new StringBuilder();
 int index;
 if (charArray[0] == '-') {
 sb.append('-');
 index = 1;
 } else {
 index = 0;
 }
 sb.append(charArray[index++]);
 for (; index < charArray.length; ++index) {
 if ((charArray.length - index) % GROUP_LENGTH == 0) {
 sb.append(delimiter);
 }
 sb.append(charArray[index]);
 }
 return sb.toString();
 }
 public static String neatify(final long number) {
 return neatify(number, DEFAULT_DELIMITER_CHAR);
 }
 public static void main(final String... args) {
 final Scanner scanner = new Scanner(System.in);
 while (scanner.hasNextLong()) {
 System.out.println(neatify(scanner.nextLong()));
 }
 }
}

By default, performance is important for me. If you know how to squeeze just a little bit more of that, let me know!

1. "digit group" length assumed to be always 3,

2. the user can pass the delimiter character of his/her own,

3. handles (seems to handle) the minus sign gracefully,

4. hacked away a test in a conditional.

   import java.util.Scanner;
   public class Main {
    /**
    * Handles <b>most</b> locales.
    */
    private static final int GROUP_LENGTH = 3;
    private static final char DEFAULT_DELIMITER_CHAR = ' ';
    public static String neatify(final long number,
    final char delimiter) {
    final char[] charArray = Long.toString(number).toCharArray();
    final StringBuilder sb = new StringBuilder();
    int index;
    if (charArray[0] == '-') {
    sb.append('-');
    index = 1;
    } else {
    index = 0;
    }
    sb.append(charArray[index++]);
    for (; index < charArray.length; ++index) {
    if ((charArray.length - index) % GROUP_LENGTH == 0) {
    sb.append(delimiter);
    }
    sb.append(charArray[index]);
    }
    return sb.toString();
    }
    public static String neatify(final long number) {
    return neatify(number, DEFAULT_DELIMITER_CHAR);
    }
    public static void main(final String... args) {
    final Scanner scanner = new Scanner(System.in);
    while (scanner.hasNextLong()) {
    System.out.println(neatify(scanner.nextLong()));
    }
    }
   }
   

1. "digit group" length assumed to be always 3
2. the user can pass the delimiter character of his/her own
3. handles (seems to handle) the minus sign gracefully
4. hacked away a test in a conditional

import java.util.Scanner;
public class Main {
 /**
 * Handles <b>most</b> locales.
 */
 private static final int GROUP_LENGTH = 3;
 private static final char DEFAULT_DELIMITER_CHAR = ' ';
 public static String neatify(final long number,
 final char delimiter) {
 final char[] charArray = Long.toString(number).toCharArray();
 final StringBuilder sb = new StringBuilder();
 int index;
 if (charArray[0] == '-') {
 sb.append('-');
 index = 1;
 } else {
 index = 0;
 }
 sb.append(charArray[index++]);
 for (; index < charArray.length; ++index) {
 if ((charArray.length - index) % GROUP_LENGTH == 0) {
 sb.append(delimiter);
 }
 sb.append(charArray[index]);
 }
 return sb.toString();
 }
 public static String neatify(final long number) {
 return neatify(number, DEFAULT_DELIMITER_CHAR);
 }
 public static void main(final String... args) {
 final Scanner scanner = new Scanner(System.in);
 while (scanner.hasNextLong()) {
 System.out.println(neatify(scanner.nextLong()));
 }
 }
}