帮帮忙写个算法

Question

 for (int i = 1024; i < 2048; i++) {
         String binStr = Integer.toBinaryString(i);
         System.out.println(binStr);

}
这样就可以了把

Answer 1

class Test {
static char[] digits=new char[]{'X','D'};
public static void main(String[] args) {
for (int i=0; i<1024; i++) {
System.out.println(toUnsignedString(i));
}
}
private static String toUnsignedString(int i) {
char[] buf=new char[10];
int charPos=10;
for (int j=0; j<10; j++) {
buf[--charPos]=digits[i&1];
i>>>=1;
}
return new String(buf);
}
}

Answer 2

从Integer类的toUnsignedString方法改的

Answer 3

这是个简单的组合，可以看成是10个格子，然后向这个10个格子里插5个D，剩下的格子不用管，肯定都是X，组合公式打不出来，简化后 10!/(5!*(10-5)!)  组合化简公式： n!/(r!*(n-r)!)

Answer 4

还有说明的就是 字符串 s="DXDXDXDXDX" 已经确定了组合出的字符串必须是包含了5个D和5个X，所以不会出现LZ说的 DDDDDDDDDD XXXXXXXXXX DDXXXXXXXX等等。

Answer 5

还有说明的就是 字符串 s="DXDXDXDXDX" 已经确定了组合出的字符串必须是包含了5个D和5个X，所以不会出现LZ说的 DDDDDDDDDD XXXXXXXXXX DDXXXXXXXX等等。事实上出现了这些情况二楼都说的很清楚了，我已经实现出来了

Answer 6

  List<String>strList=new ArrayList<String>();  
  StringBuilder sb=new StringBuilder();
  String str;
  char[]chs={'D','X'};
  Random r=new Random();
  
  while(true)
  {
  for(int j=0;j<10;j++)
  {
 sb.append(chs[r.nextInt(2)]); 
  }
  str=sb.toString();
  sb.delete(0, sb.length());
  if(strList.contains(str))
  continue;
  else strList.add(str);
  if(strList.size()==1024)//能计算出所有可能情况的个数
  break; 
  }
  for(int i=0;i<strList.size();i++)
  System.out.println(strList.get(i));
 System.out.println("总共："+strList.size());
//新手，自己写了一个，能够按照要求输出显示所有可能组合，求点评！！

Answer 7

之前有写过全排列的算法
加上了去重注意:根据我的理解，字符'D','X'每个只会出现5次，而不是10次。结果有A(10,5)=10!/5!=252种
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.LinkedList;public class Test001 { public static void main(String[] args) {
final String STR = "DXDXDXDXDX";
Collection<String> collection = getAllPermutation(STR, STR.length(), true);
for (String string : collection) {
System.out.println(string);
}
System.out.println("count:" + collection.size());
}

/**
 * 返回该字符串字符的排列组合
 * 
 * @param source
 *            字符串
 * @param count
 *            取出排列字符的个数
 * @param isUnique
 *            是否需要去重,需要去重设置true
 * @return 该字符串所有字符的排列组合，无法获取返回null
 */
public static Collection<String> getAllPermutation(String source,
int count, boolean isUnique) {
if (source == null || source.equals("")) {
return null;
}
Collection<String> collection = isUnique ? new LinkedHashSet<String>()
: new LinkedList<String>();
getAllPermutation(source.toCharArray(), count, 0, collection);
return collection;
} /**
 * 返回字符数组的排列组合
 */
static void getAllPermutation(char[] arr, int count, int index,
Collection<String> collection) {
if (index == count) {
collection.add(String.valueOf(Arrays.copyOfRange(arr,
index - count, index)));
return;
}
for (int i = index; i < arr.length; i++) {
swap(arr, i, index);
getAllPermutation(arr, count, index + 1, collection);
swap(arr, i, index);
}
} /**
 * 返回字符数组的组合
 */
static void getCombination(char[] arr, int count, int begin, int index,
char[] tempArr, Collection<String> collection) {
if (index == count) {
collection.add(String.valueOf(tempArr));
return;
}
for (int i = begin; i < arr.length; i++) {
tempArr[index] = arr[i];
getCombination(arr, count, i + 1, index + 1, tempArr, collection);
}
} static void swap(char array[], int i, int j) {
char tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}

Answer 8

1024种的递归解法
public class Test001 { static int _count = 0;

public static void main(String[] args) {
final char[] ARR = new char[] { 'D', 'X' };
output(ARR, 10, "");
System.out.println("count:" + _count);
} static void output(char[] arr, int n, String str) {
if (n == 0) {
System.out.println(str);
++_count;
return;
}
for (char c : arr) {
output(arr, n - 1, str + c);
}
}
}

Answer 9

再补充下:比如是1（二进制是0000000001假设把D看做1）那么String str="XXXXXXXXXD"
//以此类推 是2（二进制0000000010）的情况
String str ="XXXXXXXXDX"
//推理完成代码如下
String str="";
for (int i = 0; i < Integer.MAX_VALUE; i++) {
str = Integer.valueOf(i).toBinaryString(i);
if (str.length() != 10) {
                            //这里用了一个apache的包commons-lang-2.5.jar 包含StringUtils
str = StringUtils.leftPad(str, 10, "0");
}
str = str.replaceAll("0", "X");
str = str.replaceAll("1", "D");
System.out.println(str);
}
同理

Answer 10

i小于改成1024就行写成MAXVALUE了 不好意思

Answer 11

还有说明的就是 字符串 s="DXDXDXDXDX" 已经确定了组合出的字符串必须是包含了5个D和5个X，所以不会出现LZ说的 DDDDDDDDDD XXXXXXXXXX DDXXXXXXXX等等。事实上出现了这些情况二楼都说的很清楚了，我已经实现出来了嗯  一共是252种

Answer 12

还有说明的就是 字符串 s="DXDXDXDXDX" 已经确定了组合出的字符串必须是包含了5个D和5个X，所以不会出现LZ说的 DDDDDDDDDD XXXXXXXXXX DDXXXXXXXX等等。事实上出现了这些情况二楼都说的很清楚了，我已经实现出来了嗯  一共是252种
为什么不会出现0000000001这种情况？ 

Answer 13

C(1, n) + ... + C(n, n)；全组合啊

Answer 14

是我出的题有问题
s 指定了一个值了其实是想就两个String 转成 10个字段长度的String的可能性。

Answer 15

还有说明的就是 字符串 s="DXDXDXDXDX" 已经确定了组合出的字符串必须是包含了5个D和5个X，所以不会出现LZ说的 DDDDDDDDDD XXXXXXXXXX DDXXXXXXXX等等。事实上出现了这些情况二楼都说的很清楚了，我已经实现出来了嗯  一共是252种
为什么不会出现0000000001这种情况？ 还有说明的就是 字符串 s="DXDXDXDXDX" 已经确定了组合出的字符串必须是包含了5个D和5个X，所以不会出现LZ说的 DDDDDDDDDD XXXXXXXXXX DDXXXXXXXX等等。事实上出现了这些情况二楼都说的很清楚了，我已经实现出来了嗯  一共是252种
为什么不会出现0000000001这种情况？ 不是你写的 字符串 String s="DXDXDXDXDX"  那不就是说这个字符串包含了5个D和5个X 
怎么会出现 000000001这种情况  按题意 必然是5个0和5个1