如何将字符串分成2-4个长块？

Question

我需要将一个数字串(例如2005002193401)分割成最长为4的块。所以我做了以下工作：

String numbers = "2005002193401";
while (numbers.length() > 4) {
  System.out.print(numbers.substring(0, 4) + " ");
  numbers = numbers.substring(4);
}
System.out.println(numbers);

这给了我以下信息：2005 0021 9340 1

现在我的问题是。这些块的长度应该至少为2(最多为4)，最好不要以0开头。更像这样：200 500 219 3401或200 500 2193 401

我已经四处看过了，但什么都找不到真正的解决办法.

有人知道一个简单的方法吗？

Answer 1

有趣的任务。下面是Kotlin的解决方案：

fun main(args: Array<String>) {
    println(trickySplit("2005002193401")?.joinToString("-"))
}

fun trickySplit(s: String): LinkedList<String>? {
    if (s.isEmpty()) return LinkedList()

    return s.splitUsing(headSize = 4) ?: 
           s.splitUsing(headSize = 3) ?: 
           s.splitUsing(headSize = 2)
}

fun String.splitUsing(headSize: Int): LinkedList<String>? {
    return toHeadAndTail(headSize)
            ?.takeUnless { it.second.startsWith("0") }
            ?.let { it.first addToList trickySplit(it.second) }
}

fun String.toHeadAndTail(headSize: Int): Pair<String, String>? {
    return if (length >= headSize) take(headSize) to drop(headSize) else null
}

infix fun String.addToList(list: LinkedList<String>?): LinkedList<String>? {
    list?.push(this)
    return list;
}

输出：200-5002-193-401

而到Java的翻译则稍微冗长一些：

public class TrickySplitter {
    public static void main(String[] arg) {
        new TrickySplitter().trickySplit("2005002193401")
                            .map(it -> String.join("-", it))
                            .ifPresent(System.out::println);
    }

    public Optional<LinkedList<String>> trickySplit(String s) {
        if (s.isEmpty()) return Optional.of(new LinkedList<>());

        return splitUsing(s, 4)
                .or(() -> splitUsing(s, 3))
                .or(() -> splitUsing(s, 2));

    }

    private Optional<LinkedList<String>> splitUsing(String s, Integer headSize) {
        return toHeadAndTail(s, headSize)
                .filter(headAndTail -> !headAndTail[1].startsWith("0"))
                .map(headNTail -> addToList(headNTail[0], trickySplit(headNTail[1]).orElse(null)));

    }

    private Optional<String[]> toHeadAndTail(String s, Integer headSize) {
        if (s.length() >= headSize) {
            return Optional.of(new String[]{s.substring(0, headSize), s.substring(headSize, s.length())});
        } else {
            return Optional.empty();
        }
    }

    private LinkedList<String> addToList(String s, LinkedList<String> list) {
        if (list != null) list.push(s);
        return list;
    }
}

Answer 2

我的Java解决方案如下所示。诚然，这不是一种聪明的方法，因为它残酷地贯穿了每一种可能性，并将那些有效的方法添加到解决方案中。但很管用。如果你不明白，我可以添加评论。

private static List<List<Integer>> solutions;

private static void dfs(List<Integer> nextIndexes[], Stack<Integer> currentRecord, int currentIndex) {
    if (currentIndex == nextIndexes.length) {
        List<Integer> result = new ArrayList<>(currentRecord);
        solutions.add(result);
        return;
    }
    for (int i = nextIndexes[currentIndex].size() - 1; i >= 0; i--) {
        int endingIndex = nextIndexes[currentIndex].get(i);
        currentRecord.push(endingIndex);
        dfs(nextIndexes, currentRecord, endingIndex + 1);
        currentRecord.pop();
    }
}

public static void generateSolutions(String number) {
    ArrayList<Integer> nextIndexes[] = new ArrayList[number.length()];
    for (int i = 0; i < number.length(); i++) {
        nextIndexes[i] = new ArrayList<>();
        if (number.charAt(i) == '0') {
            continue;
        }
        for (int j = 1; i + j < number.length() && j <= 3; j++) {
            nextIndexes[i].add(i + j);
        }
    }
    Stack<Integer> currentRecord = new Stack<>();
    solutions = new ArrayList<>();
    dfs(nextIndexes, currentRecord, 0);
}

public static void splitNumbers(String number) {
    generateSolutions(number);
    for (List<Integer> solution: solutions) {
        int beginIndex = -1;
        String answer = "";
        for (int index: solution) {
            answer += number.substring(beginIndex + 1, index + 1) + " ";
            beginIndex = index;
        }
        System.out.println(answer);
    }
}

public static void main(String[] args) {
    splitNumbers("10234056708208");
}

"10234056708208“的结果如下：

1023 4056 708 208 

1023 4056 70 8208 

1023 405 6708 208 

1023 405 670 8208 

1023 40 5670 8208 

1023 40 56 708 208 

1023 40 56 70 8208 

102 3405 6708 208 

102 3405 670 8208 

102 340 5670 8208 

102 340 56 708 208 

102 340 56 70 8208 

10 2340 5670 8208 

10 2340 56 708 208 

10 2340 56 70 8208 

10 23 4056 708 208 

10 23 4056 70 8208 

10 23 405 6708 208 

10 23 405 670 8208 

10 23 40 5670 8208 

10 23 40 56 708 208 

10 23 40 56 70 8208

Answer 3

我想到的是，你可以用2或3除以数字的长度，这会给你有2或3个元素的部分的数目。然后得到其余的数字/部件除法。当最新除法的其余部分大于0时，向第1部分添加一个元素，然后继续。以下是一些代码：

int n = numbers.length();
int parts = n/3;
int leftover = n%parts;
int next = 0;
for (int i = 0; i < n - n/parts;) {
     i = next;
     if (leftover > 0) {
         leftover--;
         next+=n/parts + 1;
     } else {
         next+=n/parts;
     }
     System.out.print(numbers.substring(i, next) + ", ");
}

供您参考：

2005002193401

会给

2005,002,193,401