1 Question: Find a 9-digit number. This number is composed of 1,2,3,4,5,6,7,8,9, and the numbers cannot be repeated, so that the first digit of this number can be divisible by 1. The first two The number of digits is divisible by 2, the first three digits are divisible by 3, and so on until the entire nine digits are divisible by 9.
2 Problem-solving ideas:
Idea 1: Violent solution, cycle from 1123456789 to 999999999, respectively calculate whether the first 2 digits can be divisible by 2, whether the first 3 digits can be divisible by 3... If it can continue, if not, exit and enter the next cycle ; I feel that this method is too inefficient.
Idea 2: Use 1 to 9 numbers to form an array {1, 2, 3, 4, 5, 6, 7, 8, 9}, take out elements from the array respectively, and form 1-digit and 2-digit numbers that meet the needs ...9 digits, and carry out circular matching, and finally get the required number; the author uses this method to solve it, and attaches the code.
Idea 3: According to some mathematical common sense, reasoning, such as divisibility by 2, divisibility by 3 and so on, reasoning, and finally calculate the result.
3 java code
import java.util.Arrays;
public class UniqueSolution {
static boolean pr=false;//true 打印测试日志
public static void main(String[] args){
int[] arrayInt={
1,2,3,4,5,6,7,8,9};
int resultNum=computerUniqueNumber(arrayInt);
if (Integer.valueOf(resultNum).equals(0)){
System.out.println("未找到题目所要求的数");
} else System.out.println("题目的答案是:" + resultNum);
}
static int computerUniqueNumber(int[] arrayInt){
int times=0;//用于记录循环次数
int[] newArray=arrayInt.clone();//用做数组中转
int sizeNewArray=newArray.length; //中转数组长度
int iLoop=sizeNewArray;//循环次数
int[] iArray=newArray.clone();//循环数组
int resultNum=0;//用于记录所求数字
for (int i=0;i<iLoop;i++){
times++;
if (pr) {
System.out.println("**********************************");
}
if (pr) {
System.out.println("i:" + i);
}
iArray=arrayInt.clone();
//前一位数
int[] arrayFront1 = new int[1];
arrayFront1[0]=iArray[i];
int intFront1 = arrayToInt(arrayFront1);
int modFront1=intFront1%1;
if (modFront1==0){
if (pr) {
System.out.println("intFront1:" + intFront1);
}
//清除第一个数字
iArray[i]=0;//用过的数字置为0，做标记;
newArray=arrayDeleteZero(iArray);//剔除0元素，生成新的数组
iArray=newArray;//赋新值，清除0，供下一级循环使用
sizeNewArray=newArray.length;//剔除非0元素后数组的长度
if (pr) {
System.out.println("newArray:" + Arrays.toString(newArray));
}
if (pr) {
System.out.println("sizeNewArray:" + sizeNewArray);
}
int jLoop=sizeNewArray;
int[] jArray=iArray.clone();
for (int j=0;j<jLoop;j++){
times++;
if (pr) {
System.out.println("j:" + j);
}
jArray=iArray.clone();
//前二位数
int[] arrayFront2=new int[2];
arrayFront2=arrayNext(arrayFront1,2,jArray[j]);
int intFront2=arrayToInt(arrayFront2);
int modFront2=intFront2%2;
if (modFront2==0){
if (pr) {
System.out.println("intFront2:" + intFront2);
}
//清除第二个数字
jArray[j]=0;
newArray=arrayDeleteZero(jArray);
jArray=newArray;
sizeNewArray=newArray.length;
if (pr) {
System.out.println("newArray:" + Arrays.toString(newArray));
}
if (pr) {
System.out.println("sizeNewArray:" + sizeNewArray);
}
int kLoop=sizeNewArray;
int[] kArray=newArray.clone();
for (int k=0;k<kLoop;k++) {
times++;
if (pr) {
System.out.println("k:" + k);
}
kArray=jArray.clone();
//前三位数
int[] arrayFront3 = new int[3];
arrayFront3=arrayNext(arrayFront2,3,kArray[k]);
int intFront3 = arrayToInt(arrayFront3);
int modFront3=intFront3%3;
if (modFront3==0){
if (pr) {
System.out.println("intFront3:" + intFront3);
}
//清除第三个数字
kArray[k]=0;
newArray=arrayDeleteZero(kArray);
kArray=newArray;
sizeNewArray=newArray.length;
if (pr) {
System.out.println("newArray:" + Arrays.toString(newArray));
}
if (pr) {
System.out.println("sizeNewArray:" + sizeNewArray);
}
int lLoop=sizeNewArray;
int[] lArray=newArray.clone();
for (int l=0;l<lLoop;l++) {
times++;
if (pr) {
System.out.println("l:" + l);
}
lArray=kArray.clone();
//前四位数
int[] arrayFront4 = new int[4];
arrayFront4=arrayNext(arrayFront3,4,lArray[l]);
int intFront4 = arrayToInt(arrayFront4);
int modFront4 = intFront4 % 4;
if (modFront4 == 0) {
if (pr) {
System.out.println("intFront4:" + intFront4);
}
//清除第四个数字
lArray[l]=0;
newArray=arrayDeleteZero(lArray);
lArray=newArray;
sizeNewArray=newArray.length;
if (pr) {
System.out.println("newArray:" + Arrays.toString(newArray));
}
if (pr) {
System.out.println("sizeNewArray:" + sizeNewArray);
}
int mLoop=sizeNewArray;
int[] mArray=newArray.clone();
for (int m=0;m<mLoop;m++) {
times++;
if (pr) {
System.out.println("m:" + m);
}
mArray=lArray.clone();
//前五位数
int[] arrayFront5 = new int[5];
arrayFront5=arrayNext(arrayFront4,5,mArray[m]);
int intFront5 = arrayToInt(arrayFront5);
int modFront5 = intFront5 % 5;
if (modFront5 == 0) {
if (pr) {
System.out.println("intFront5:" + intFront5);
}
//清除第五个数字
mArray[m] = 0;
newArray = arrayDeleteZero(mArray);
mArray=newArray;
sizeNewArray = newArray.length;
if (pr) {
System.out.println("newArray:" + Arrays.toString(newArray));
}
if (pr) {
System.out.println("sizeNewArray:" + sizeNewArray);
}
int nLoop=sizeNewArray;
int[] nArray=newArray.clone();
for (int n=0;n<nLoop;n++) {
times++;
if (pr) {
System.out.println("n:" + n);
}
nArray=mArray.clone();
前六位数
int[] arrayFront6 = new int[6];
arrayFront6=arrayNext(arrayFront5,6,nArray[n]);
int intFront6 = arrayToInt(arrayFront6);
int modFront6 = intFront6 % 6;
if (modFront6 == 0) {
if (pr) {
System.out.println("intFront6:" + intFront6);
}
//清除第六个数字
nArray[n] = 0;
newArray = arrayDeleteZero(nArray);
nArray=newArray;
sizeNewArray = newArray.length;
if (pr) {
System.out.println("newArray:" + Arrays.toString(newArray));
}
if (pr) {
System.out.println("sizeNewArray:" + sizeNewArray);
}
int oLoop=sizeNewArray;
int[] oArray=newArray.clone();
for (int o=0;o<oLoop;o++) {
times++;
if (pr) {
System.out.println("o:" + o);
}
oArray=nArray.clone();
//前七位数
int[] arrayFront7 = new int[7];
arrayFront7=arrayNext(arrayFront6,7,oArray[o]);
int intFront7 = arrayToInt(arrayFront7);
int modFront7 = intFront7 % 7;
if (modFront7 == 0) {
if (pr) {
System.out.println("intFront7:" + intFront7);
}
//清除第七个数字
oArray[o] = 0;
newArray = arrayDeleteZero(oArray);
oArray=newArray;
sizeNewArray = newArray.length;
if (pr) {
System.out.println("newArray:" + Arrays.toString(newArray));
}
if (pr) {
System.out.println("sizeNewArray:" + sizeNewArray);
}
int pLoop=sizeNewArray;
int[] pArray=newArray.clone();
for (int p=0;p<pLoop;p++) {
times++;
if (pr) {
System.out.println("p:" + p);
}
pArray=oArray.clone();
//前八位数
int[] arrayFront8 = new int[8];
arrayFront8=arrayNext(arrayFront7,8,pArray[p]);
int intFront8 = arrayToInt(arrayFront8);
int modFront8 = intFront8 % 8;
if (modFront8 == 0) {
if (pr) {
System.out.println("intFront8:" + intFront8);
}
//清除第八个数字
pArray[p] = 0;
newArray = arrayDeleteZero(pArray);
pArray=newArray;
sizeNewArray = newArray.length;
if (pr) {
System.out.println("newArray:" + Arrays.toString(newArray));
}
if (pr) {
System.out.println("sizeNewArray:" + sizeNewArray);
}
int qLoop=sizeNewArray;
int[] qArray=newArray.clone();
for (int q=0;q<qLoop;q++) {
times++;
if (pr) {
System.out.println("q:" + q);
}
qArray=pArray.clone();
//前九位数
int[] arrayFront9 = new int[9];
arrayFront9=arrayNext(arrayFront8,9,qArray[q]);
int intFront9 = arrayToInt(arrayFront9);
int modFront9 = intFront9 % 9;
if (modFront9 == 0) {
resultNum=intFront9;
if (pr) {
System.out.println("newArray:" + Arrays.toString(newArray));
}
if (pr) {
System.out.println("sizeNewArray:" + sizeNewArray);
}
}//if q modFront9
} //for q
}//if p modFront8
} //for p
}//if o modFront7
} //for o
}//if n modFront6
} //for n
}//if m modFront5
} //for m
}//if l modFront4
} // for l
} //if modFront3
}// for k
}//if modFront2
}//for j
}// if modFront1
}//for i
System.out.println("循环的次数:"+times);
return resultNum;
}
//数组转数字
static int arrayToInt(int[] arrayInt){
String strNum="";
for (int num : arrayInt) {
strNum=strNum+Integer.toString(num);
}
int intNum=Integer.parseInt(strNum);
return intNum;
}
//剔除非零元素，生成新的数组
static int[] arrayDeleteZero(int[] arrayInt){
int i=0;
int sizeArrayInt=arrayInt.length;
for (int num : arrayInt) {
if (num==0){
i++;
}
}
//计算新数组长度
int sizeArrayIntNew=sizeArrayInt-i;
int[] arrayIntNew=new int[sizeArrayIntNew];
int j=0;
for (int k=0;k<sizeArrayInt;k++){
if (arrayInt[k]==0){
j++;
} else {
arrayIntNew[k-j]=arrayInt[k];
}
}
return arrayIntNew;
}
//生成下一个数组
static int[] arrayNext(int[] arrayPrior,int sizeNextArray,int num){
int[] nextArray=new int[sizeNextArray];
for (int i=0;i<arrayPrior.length;i++){
nextArray[i]=arrayPrior[i];
}
nextArray[sizeNextArray-1]=num;
return nextArray;
}
}
4 running results
