通过替换隐藏的“#"数字符号生成所有可能的字符串组合 [英] Generate all possible string combinations by replacing the hidden “#” number sign

问题描述

我的任务是生成没有隐藏的# 数字符号的行的所有可能组合.输入是 XOXX#OO#XO，下面是输出应该是什么的例子:

XOXXOOOOXO哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦~哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦哦~XXXOOXXO

我只能以迭代方式解决这个解决方案，我不知道如何解决这个问题，并且我已经研究了这个代码一周了.

这是我的代码:

import java.lang.Math;公共课帮助{公共静态无效主(字符串 [] args){String str = new String("XOXX#OO#XO");取消隐藏(字符串)；}公共静态无效取消隐藏(字符串 str){//将字符串转换为字符char[] chArr = str.toCharArray();//寻找XO的所有组合char[] xo = new char[]{'X', 'O'};整数计数 = 0;字符烫= 0;字符串 s = "";//查找'#'出现在字符串中的次数for (int i = 0; i < str.length(); i++) {如果 (chArr[i] == '#')计数++；}int[] 组合 = 新的 int[count];int pMax = xo.length;而(组合 [0]  0; i--) {组合 [i - 1]++;//增加上一个索引组合[i] = 0;//设置当前索引为零}}}}

解决方案

您可以使用 streams迭代 生成所有可能的字符串组合，如下所示:

public static String[] unHide(String str) {//围绕数字符号"的子串数组String[] arr = str.split("#", -1);//一组可能的组合返回 IntStream//遍历数组索引.range(0, arr.length)//附加每个可能的子串//组合，除了最后一个//返回流.mapToObj(i -> i  Arrays.stream(arr1).flatMap(str1 -> Arrays.stream(arr2).map(str2 -> str1 + str2)).toArray(String[]::new)).orElse(null);}

//输出到markdown表公共静态无效主(字符串 [] args){String[] 测试 = {XOXX#OOXO"、XOXX#OO#XO"、#XOXX#OOXO#"、XO#XX#OO#XO"}；String header = String.join("</pre> | <pre>", tests);字符串矩阵 = Arrays.stream(tests).map(test -> unHide(test)).map(arr -> String.join("
", arr)).collect(Collectors.joining("</pre> | <pre>"));System.out.println("| 
" + header + "
 |");System.out.println("|---|---|---|---|");System.out.println("| 
" + 矩阵 + "
 |");}

<头>

XOXX#OOXO	XOXX#OO#XO	#XOXX#OOXO#	XO#XX#OO#XO
XOXXOOOXO XOXOXOOOXO	XOXXOOOOXO XOXXOOOXXO XOXXXOOOXO XOXXOOXXO	OXOXXOOOXOO OXOXXOOOXOX OXOXXXOOOXOO OXOXXXOOOXOX XXOXXOOOXOO XXOXXOOOXOO XXOXOXOOOXOO XXOXOXOOOXOX	XOOXXOOOOXO XOOXXOOOXXO XOOXXXOOOXO XOOXXXOOXXO XOXXXOOOOXXO XOXXXOOOXXO XOXXXXOOXXO XOXXXXOOXXO

My task is to generates all possible combinations of that rows without the hidden # number sign. The input is XOXX#OO#XO and here is the example of what the output should be:

XOXXOOOOXO 
XOXXOOOXXO 
XOXXXOOOXO 
XOXXXOOXXO

I am only allowed to solve this solution iteratively and I am not sure how to fix this and have been working on this code for a week now.

Here is my code:

import java.lang.Math;

public class help {
    public static void main(String[] args) {
        String str = new String("XOXX#OO#XO");
        UnHide(str);
    }

    public static void UnHide(String str) {
        //converting string to char 
        char[] chArr = str.toCharArray();
        //finding all combinations for XO 
        char[] xo = new char[]{'X', 'O'};

        int count = 0;
        char perm = 0;
        String s = "";

        //finding amount of times '#' appears in string
        for (int i = 0; i < str.length(); i++) {
            if (chArr[i] == '#')
                count++;
        }

        int[] combo = new int[count];
        int pMax = xo.length;

        while (combo[0] < pMax) {
            // print the current permutation
            for (int k = 0; k < count; k++) {
                //print each character
                //System.out.print(xo[combo[i]]);
                perm = xo[combo[k]];
                s = String.valueOf(perm);

                char[] xoArr = s.toCharArray();
                String strChar = new String(xoArr);
                //substituting '#' to XO combo
                for (int i = 0; i < chArr.length; i++) {
                    for (int j = 0; j < s.length(); j++) {
                        if (chArr[i] == '#') {
                            chArr[i] = xoArr[j];
                            strChar = String.copyValueOf(chArr);
                            i++;
                        }
                    }
                    i++;
                    if (i == chArr.length - 1) {
                        System.out.println(strChar);
                        i = 0;
                    }
                }
            }

            System.out.println(); //print end of line

            // increment combo
            combo[count - 1]++; // increment the last index
            //// if increment overflows
            for (int i = count - 1; combo[i] == pMax && i > 0; i--) {
                combo[i - 1]++;  // increment previous index
                combo[i] = 0;   // set current index to zero  
            }
        }
    }
}

解决方案

You can iteratively generate all possible combinations of strings using streams as follows:

public static String[] unHide(String str) {
    // an array of substrings around a 'number sign'
    String[] arr = str.split("#", -1);
    // an array of possible combinations
    return IntStream
            // iterate over array indices
            .range(0, arr.length)
            // append each substring with possible
            // combinations, except the last one
            // return Stream<String[]>
            .mapToObj(i -> i < arr.length - 1 ?
                    new String[]{arr[i] + "O", arr[i] + "X"} :
                    new String[]{arr[i]})
            // reduce stream of arrays to a single array
            // by sequentially multiplying array pairs
            .reduce((arr1, arr2) -> Arrays.stream(arr1)
                    .flatMap(str1 -> Arrays.stream(arr2)
                            .map(str2 -> str1 + str2))
                    .toArray(String[]::new))
            .orElse(null);
}

// output to the markdown table
public static void main(String[] args) {
    String[] tests = {"XOXX#OOXO", "XOXX#OO#XO", "#XOXX#OOXO#", "XO#XX#OO#XO"};
    String header = String.join("</pre> | <pre>", tests);
    String matrices = Arrays.stream(tests)
            .map(test -> unHide(test))
            .map(arr -> String.join("<br>", arr))
            .collect(Collectors.joining("</pre> | <pre>"));

    System.out.println("| <pre>" + header + "</pre> |");
    System.out.println("|---|---|---|---|");
    System.out.println("| <pre>" + matrices + "</pre> |");
}

XOXX#OOXO	XOXX#OO#XO	#XOXX#OOXO#	XO#XX#OO#XO
XOXXOOOXO XOXXXOOXO	XOXXOOOOXO XOXXOOOXXO XOXXXOOOXO XOXXXOOXXO	OXOXXOOOXOO OXOXXOOOXOX OXOXXXOOXOO OXOXXXOOXOX XXOXXOOOXOO XXOXXOOOXOX XXOXXXOOXOO XXOXXXOOXOX	XOOXXOOOOXO XOOXXOOOXXO XOOXXXOOOXO XOOXXXOOXXO XOXXXOOOOXO XOXXXOOOXXO XOXXXXOOOXO XOXXXXOOXXO

这篇关于通过替换隐藏的“#"数字符号生成所有可能的字符串组合的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！