public static void doAnagram(int newSize)
{
if(newSize == 1) //if innermost,go no further
{
displayWord();//打印出目前字母数组的单词
return;
}
for (int j=0; j<newSize; j++) //for each position
{
doAnagram(newSize - 1); //anagram remaining
rotate(newSize); //rotate word
}
}
import java.io.*;
class AnagramApp1
{
static int size;
static int count;
static char[] arrChar = new char[100];
public static void main(String[] args) throws IOException
{
System.out.print("Enter a word:");
String input = getString();
size = input.length();
count = 0;
for (int j=0; j<size; j++)
{
arrChar[j] = input.charAt(j);
}
doAnagram(size);
}
public static void doAnagram(int newSize)
{
if(newSize == 1) //if innermost,go no further
{
displayWord(newSize); //最后一层，输出的是全部字符的可能组合
return;
}
for (int j=0; j<newSize; j++) //for each position
{
doAnagram(newSize - 1); //anagram remaining
displayWord(newSize); //我加的显示语句，用于显示所有长度小于原单词长度的单词
rotate(newSize); //rotate word
}
}
public static void rotate(int newSize)
{
int j;
int position = size - newSize;
char temp = arrChar[position]; //save first letter
for (j=position+1; j<size; j++) //shift others left
{
arrChar[j-1] = arrChar[j];
}
arrChar[j-1] = temp; //put first on right
}
public static void displayWord(int newSize) //经过改造的显示方法，要接收一个参数以判断当前的递归层数
{
if(count < 99)
System.out.print(" ");
if(count < 9)
System.out.print(" ");
if(size-newSize+1 <= 2) //加入的判断，2就表示长度小于等于2的单词打印出来
{
System.out.print(++count + " ");
for(int j=0;j < size-newSize+1; j++)
{
System.out.print(arrChar[j]);
}
}
System.out.print(" ");
System.out.flush();
if(count%6 == 0)
System.out.println("");
}
public static String getString() throws IOException
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}
} //end class AnagramApp
import java.io.*;
class Test
{
static int size;
static int count;
static char[] arrChar = new char[100];
public static void main(String[] args) throws IOException
{
System.out.print("Enter a word:");
String input = getString();
size = input.length();
count = 0;
for (int j=0; j<size; j++)
{
arrChar[j] = input.charAt(j);
}
doAnagram(size);
}
public static void doAnagram(int newSize)
{
if(newSize == 1) //if innermost,go no further
{
displayWord(newSize); //最后一层，输出的是全部字符的可能组合
return;
}
for (int j=0; j<newSize; j++) //for each position
{
doAnagram(newSize - 1); //anagram remaining
displayWord(newSize); //我加的显示语句，用于显示所有长度小于原单词长度的单词
rotate(newSize); //rotate word
}
}
public static void rotate(int newSize)
{
int j;
int position = size - newSize;
char temp = arrChar[position]; //save first letter
for (j=position+1; j<size; j++) //shift others left
{
arrChar[j-1] = arrChar[j];
}
arrChar[j-1] = temp; //put first on right
}
public static void displayWord(int newSize) //经过改造的显示方法，要接收一个参数以判断当前的递归层数
{
if(count < 99)
System.out.print(" ");
if(count < 9)
System.out.print(" ");
if(size-newSize+1 <= 2) //加入的判断，2就表示长度小于等于2的单词打印出来
{
System.out.print(++count + " ");
for(int j=0;j < size-newSize+1; j++)
{
System.out.print(arrChar[j]);
}
}
System.out.print(" ");
System.out.flush();
if(count%6 == 0)
System.out.println("");
}
public static String getString() throws IOException
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}
}
public class Zhaoyong209
{
public static void main(String[] args)
{
for(int len=1;len<=MAXLEN;len++) //按文件名长度显示符合标准且不重复的所有文件名。
{
for(int disnum=0;disnum<str.length;disnum++)//第一个字符的循环。
{
s="";//清空文件名。
dis(len,disnum);//显示所有以这第一个字符开头的所有文件名。
}
}
System.out.println(total);//显示所有文件名总数。
}
private static void dis(int len,int disnum)//根据传入的参数显示文件名。其中，LEN为文件名长度，DISNUM为应显示的字符在STR[]中的位置。
{
if(canmodify&&s.length()>1)//如果文件名可以修改，则进行修改。
{
s=s.substring(0,s.length()-len);//将S存储的文件名的最后LEN个字符去掉，以便接受循环显示下一文件名。
}
canmodify=false;//设置为文件名不可修改。
s=s+str[disnum];//接受新的后续字符，构成符合要求的新文件名。
if(len==1)//如果文件名长度为1，执行下列操作。
{
System.out.println(s);//显示文件名。
canmodify=true;//已成功进行了一次最内层循环，设置文件名可以修改。
total++;//所有文件名总数+1。
}
if(len>1)//如果文件名长度>1，执行下列操作。
{
int temp;//设置一个临时参数，只能用于内循环，当跳出内循环时失效。
for(int i=0;i<str.length;i++)//当STR[]中的值未被完全循环完毕时，执行下列操作。
{
temp=len-1;//设置临时参数为LEN-1；
dis(temp,i);//调用自身。
}
}
}
private static int MAXLEN = 4; //设置文件名的最大长度。
private static String str[]= new String[]{"a","b","c","d"};//设置组成文件名的合法字符。
private static int total = 0; //设置成功排列的文件名总数。
private static boolean canmodify = false;//DIS（）函数所使用的一个用于控制字符串修改的变量。
private static String s;//用于保存文件名的字符串。
}
package niko7;
import java.math.BigInteger;
/**
* 转载、引用必须保留此信息。
* @author niko7,qq=9141741, (顾法华，杭州)
*
*/
public class MyTest
{
/**
* 计算组合总量。
*
* 总共有m个不同的字符，允许最多n个字符组成一字符串，计算总共有多少总组合。
* @param charCount 字符的数量
* @param maxLen 字符串的最大长度（最多允许的个数，1-maxLen都是符合要求的）
* @return 可能的组合的总数
*/
public static BigInteger getTotal(int charCount,int maxLen)
{
if(1==charCount)
{
return BigInteger.valueOf(maxLen);
}
BigInteger m = BigInteger.valueOf(charCount);
BigInteger total = m.pow(maxLen+1);
total = total.subtract(BigInteger.ONE);
total = total.divide(m.subtract(BigInteger.ONE));
return total.subtract(BigInteger.ONE);
}
/**
* 数字到字符串的转换方法。
*
* 进制转换的修改版本，去掉了“零”的概念，允许高位为“0”，拼出各种字符组合。
* 从外部输入 stringbuffer 和 radix ，是为了加快速度。
* @param stringBuffer 转换后的结果放入这里。
* @param num 需要转换的数字
* @param radix 进制。注意和chars匹配！
* @param chars 转换进制时使用的字符。注意和radix匹配！
*/
public static void number2String(StringBuffer stringBuffer,BigInteger num,BigInteger radix,char[] chars)
{
BigInteger cIndex = num.remainder(radix);
stringBuffer.insert(0, chars[cIndex.intValue()]);
if (num.compareTo(radix) >= 0)
{
num = num.subtract(cIndex);
num = num.divide(radix);
num = num.subtract(BigInteger.ONE);
number2String(stringBuffer,num, radix, chars);
}
}
}
package niko7;
import java.math.BigInteger;
import junit.framework.TestCase;
/**
* 转载、引用必须保留此信息。
* @author niko7,qq=9141741, (顾法华，杭州)
* email:niko7@163.com
*
*/
public class MyTestTest extends TestCase
{
protected void setUp() throws Exception
{
super.setUp();
}
protected void tearDown() throws Exception
{
super.tearDown();
}
public void testGetTotal()
{
//就一个字符，最大12，那么就是12中可能
assertEquals(BigInteger.valueOf(12),MyTest.getTotal(1,12));
//两个字符，最大3，那么就有14
assertEquals(BigInteger.valueOf(14),MyTest.getTotal(2,3));
//3个字符，最大3，那么就有39种
assertEquals(BigInteger.valueOf(39),MyTest.getTotal(3,3));
}
public void testNumber2String()
{
char[] chars = "012".toCharArray();
BigInteger charArrayLen = BigInteger.valueOf(chars.length);
StringBuffer sb = new StringBuffer();
BigInteger i = BigInteger.valueOf(38);
String expected = "222";
MyTest.number2String(sb,i,charArrayLen, chars);
System.out.println(sb);
assertEquals(expected, sb.toString());
sb = new StringBuffer();
i = BigInteger.valueOf(20);
expected = "022";
MyTest.number2String(sb,i,charArrayLen, chars);
System.out.println(sb);
assertEquals(expected, sb.toString());
}
public void testDemo()
{
char[] chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".toCharArray();
//char[] chars = "0123456".toCharArray();
int charCount = chars.length;
int maxLen = 12;
BigInteger charArrayLen = BigInteger.valueOf(charCount);
BigInteger t = MyTest.getTotal(charCount,maxLen);
System.out.println("共有可能的组合数量："+t);
for(BigInteger i = BigInteger.ZERO; i.compareTo(t)<0; i=i.add(BigInteger.ONE))
{
if(i.compareTo(BigInteger.valueOf(30000))>0)
{
System.out.println("运算量很大的，提前撤了！");
break;
}
StringBuffer sb = new StringBuffer();
MyTest.number2String(sb,i,charArrayLen, chars);
System.out.println(i+"\t"+sb);
}
}
}
public class listFileNames {
public static String letters = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
public static int length = 12;
public static void main(String args[])
{
for(int i=0;i<length;i++)
{
System.out.println("Length: " + (i+1));
list(letters, "", i+1);
}
System.out.println("The end!");
}
public static void list(String letters, String fileName, int length)
{
if(fileName.equals("") || !java.lang.Character.isDigit(fileName.charAt(0)))
{
String newLetters = "";
String newFileName = "";
if(fileName.length() < length)
{
for(int i=0;i<letters.length();i++)
{
if(i == 0)
{
newLetters = letters.substring(1, letters.length());
}
else
{
newLetters = letters.substring(0, i) + letters.substring(i+1, letters.length());
}
newFileName = fileName + letters.charAt(i);
list(newLetters, newFileName, length);
}
}
else
{
System.out.println(" " + fileName);
}
}
}
}
package niko7;
/**
* 用改过的数字进制转换枚举字符组合。这是简化的版本。
*
* 注意：随着被转换的数字越来越大，所花的时间会越来越多。
*
* 转载、引用必须保留此段信息。
* @author niko7,(顾法华，杭州)
* email:niko7@163.com
*
*/
public class SimpleDemo
{
public static void main(String[] args)
{
//允许组成的字符串的最大长度
int maxLen = 12;
//组成字符串的字符
char[] chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".toCharArray();
//char[] chars = "012".toCharArray();
//这就是对应的目标进制
int radix = chars.length;
//下面开始枚举各种组合
String s = "";
long i = 0;
do
{
System.out.println(i +"\t"+ number2String(i++, radix, chars));
} while (s.length() <= maxLen && i<3000);//这个任务很耗时，所以算了几个就提前结束
}
/**
* 为这个任务修正过的进制转换方法，转换出来的结果不能当成真正的数字使用
* @param num 待转换的数字
* @param radix 进制。注意与 chars 保持匹配！
* @param chars 表现数字用的字符。注意与 radix 保持匹配！
* @return
*/
public static String number2String(long num, int radix, char[] chars)
{
int cIndex = (int) (num % radix);
String s = String.valueOf(chars[cIndex]);
if (num >= radix)
{
s = number2String(((num - cIndex) / radix) - 1, radix, chars) + s;
}
return s;
}
}
public class test
{
public static void main(String[] args)
{
//允许组成的字符串的最大长度
int maxLen = 3;
//组成字符串的字符
char[] chars = "abcd1234".toCharArray();
//char[] chars = "012".toCharArray();
//0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
//这就是对应的目标进制
int radix = chars.length;
//下面开始枚举各种组合
String s = "";
long i = 0;
do
{
System.out.println((i+1) +"\t"+ number2String(i++, radix, chars));
}
while(i<count(radix,maxLen) && i<3000);//计算所有符合要求的排列,当排列多于3000个时只算前3000个
}
/**
* 为这个任务修正过的进制转换方法，转换出来的结果不能当成真正的数字使用
* @param num 待转换的数字
* @param radix 进制。注意与 chars 保持匹配！
* @param chars 表现数字用的字符。注意与 radix 保持匹配！
* @return
*/
public static String number2String(long num, int radix, char[] chars)
{
int cIndex = (int) (num % radix);
String s = String.valueOf(chars[cIndex]);
if (num >= radix)
{
s = number2String(((num - cIndex) / radix) - 1, radix, chars) + s;
}
return s;
}
/**
* 接收传入的标准字符chars长度和要求的文件名最大长度maxLen,返回总的组合数目.
* @param m 标准字符chars长度
* @param n 文件名最大长度maxLen
* @return
*/
public static long count(int m,int n)
{
long result=0;
for(int i=1;i<=n;i++)
result+=Math.pow(m,i);
return result;
}
}
//下面开始枚举各种组合
boolean complete = false;
long i = 0;
do
{
String s = number2String(i, radix, chars);
complete = s.length()>maxLen;
if(complete)
{
//完成任务了
break;
}
System.out.println(i++ +"\t"+ s);
}while(i<4000);//这个任务很耗时，象征性的算几个就够了
System.out.println(complete?"任务完成了！":"...\n因为运算量大，没有算完，提前结束了！");
