/*猜算式
看下面的算式：
□□ x □□ = □□ x □□□
它表示：两个两位数相乘等于一个两位数乘以一个三位数。
如果没有限定条件，这样的例子很多。
但目前的限定是：这9个方块，表示1~9的9个数字，不包含0。
该算式中1至9的每个数字出现且只出现一次！
比如：
46 x 79 = 23 x 158
54 x 69 = 27 x 138
54 x 93 = 27 x 186
.....
请编程，输出所有可能的情况！
注意：
左边的两个乘数交换算同一方案，不要重复输出！
不同方案的输出顺序不重要
*/
import java.util.List;
import java.util.ArrayList;
public class 乘法运算 {
static List<String> lis = new ArrayList<String>(); // 结果1(有重复的结果)
static List<String> lis2 = new ArrayList<String>(); // 结果2(去重复后的结果)
static int kinds = 1;
// 是否重复
public static boolean isDup(String s1,String s2){
String a1 = s1.substring(0,2);
String a2 = s1.substring(2,4);
String b1 = s2.substring(0,2);
String b2 = s2.substring(2,4);
if(a1.equals(b2)&&a2.equals(b1)){
return true;
}else{
return false;
}
}
// 去除lis重复元素
public static void removeDuplicate(){
lis2.add(lis.get(0));
for(int i=1;i<lis.size();i++){
boolean flag=false; // 标记是否重复
for(int j=0;j<lis2.size();j++){
flag = isDup(lis.get(i),lis2.get(j)); // 判断是否重复
if(flag) break; // 如果元素重复,直接跳出这层循环,测试下个数据
}
if(!flag){
lis2.add(lis.get(i)); // 不重复,则添加
kinds++;
}
}
}
// 输出
public static void print(){
for(String s:lis2){
String a = s.substring(0,2);
String b = s.substring(2,4);
String c = s.substring(4,6);
String d = s.substring(6);
System.out.println(a+" x "+b+" = "+c+" x "+d);
}
}
// 检测结果,符合条件的输出
public static void check(int[] n){
StringBuffer sb = new StringBuffer();
for(int x:n){ // 数字数组转为字符串
sb.append(x);
}
int a = Integer.parseInt(sb.substring(0,2).toString());
int b = Integer.parseInt(sb.substring(2,4).toString());
int c = Integer.parseInt(sb.substring(4,6).toString());
int d = Integer.parseInt(sb.substring(6).toString());
if(a*b==c*d){
lis.add(sb.toString()); // 添加结果
}
}
// 全排列
public static void allSort(int[] n,int start,int end){
if(start>=end){
check(n); // 检测结果,符合条件的输出
return ;
}else{
for(int i=start;i<=end;i++){
int t = n[start]; // 交换元素
n[start] = n[i];
n[i] = t;
// 递归全排列
allSort(n,start+1,end);
t = n[start]; // 还原元素
n[start] = n[i];
n[i] = t;
}
}
}
public static void main(String[] args){
//fun(); //
int[] n = {1,2,3,4,5,6,7,8,9};
allSort(n,0,n.length-1);
removeDuplicate(); // 去除重复元素
print(); // 输出结果
System.out.println("kinds:"+kinds);
}
}
/*----------------------------------黄金分隔线---------------------------*/
import java.util.List;
import java.util.ArrayList;
public class 乘法运算 {
static List<String> lis = new ArrayList<String>(); // 结果1(有重复的结果)
static List<String> lis2 = new ArrayList<String>(); // 结果2(去重复后的结果)
static int kinds = 1;
// 是否重复
public static boolean isDup(String s1,String s2){
String a1 = s1.substring(0,2);
String a2 = s1.substring(2,4);
String b1 = s2.substring(0,2);
String b2 = s2.substring(2,4);
if(a1.equals(b2)&&a2.equals(b1)){
return true;
}else{
return false;
}
}
// 去除lis重复元素
public static void removeDuplicate(){
lis2.add(lis.get(0));
for(int i=1;i<lis.size();i++){
boolean flag=false; // 标记是否重复
for(int j=0;j<lis2.size();j++){
flag = isDup(lis.get(i),lis2.get(j)); // 判断是否重复
if(flag) break; // 如果元素重复,直接跳出这层循环,测试下个数据
}
if(!flag){
lis2.add(lis.get(i)); // 不重复,则添加
kinds++;
}
}
}
// 输出
public static void print(){
for(String s:lis2){
String a = s.substring(0,2);
String b = s.substring(2,4);
String c = s.substring(4,6);
String d = s.substring(6);
System.out.println(a+" x "+b+" = "+c+" x "+d);
}
}
// 检测结果,符合条件的输出
public static void check(List<Integer> lis1){
StringBuffer sb = new StringBuffer();
for(int x:lis1){ // 数字数组转为字符串
sb.append(x);
}
int a = Integer.parseInt(sb.substring(0,2).toString());
int b = Integer.parseInt(sb.substring(2,4).toString());
int c = Integer.parseInt(sb.substring(4,6).toString());
int d = Integer.parseInt(sb.substring(6).toString());
if(a*b==c*d){
lis.add(sb.toString()); // 添加结果
}
}
// 全排列
public static void allSort(List<Integer> lis1,int start,int end){
if (start == end) {
check(lis1);
return;
}
for (int i = 1; i <= 9; i++) {
if (!lis1.contains(i)) {
lis1.set(start, i);
} else {
continue;
}
allSort(lis1, start + 1, end);
lis1.set(start, 0);
}
}
public static void main(String[] args){
List<Integer> lis1 = new ArrayList<Integer>();
for (int i = 0; i < 9; i++) {
lis1.add(0); // 初始化为全0
}
allSort(lis1,0,lis1.size());
removeDuplicate(); // 去除重复元素
print(); // 输出结果
System.out.println("kinds:"+kinds);
}
}
/*----------------------------------黄金分隔线---------------------------*/
import java.util.List;
import java.util.ArrayList;
public class 乘法运算 {
static List<String> lis = new ArrayList<String>(); // 结果1(有重复的结果)
static List<String> lis2 = new ArrayList<String>(); // 结果2(去重复后的结果)
static int kinds = 1;
static int n[] = new int[9];
static boolean vis[] = new boolean[10];
// 是否重复
public static boolean isDup(String s1,String s2){
String a1 = s1.substring(0,2);
String a2 = s1.substring(2,4);
String b1 = s2.substring(0,2);
String b2 = s2.substring(2,4);
if(a1.equals(b2)&&a2.equals(b1)){
return true;
}else{
return false;
}
}
// 去除lis重复元素
public static void removeDuplicate(){
lis2.add(lis.get(0));
for(int i=1;i<lis.size();i++){
boolean flag=false; // 标记是否重复
for(int j=0;j<lis2.size();j++){
flag = isDup(lis.get(i),lis2.get(j)); // 判断是否重复
if(flag) break; // 如果元素重复,直接跳出这层循环,测试下个数据
}
if(!flag){
lis2.add(lis.get(i)); // 不重复,则添加
kinds++;
}
}
}
// 输出
public static void print(){
for(String s:lis2){
String a = s.substring(0,2);
String b = s.substring(2,4);
String c = s.substring(4,6);
String d = s.substring(6);
System.out.println(a+" x "+b+" = "+c+" x "+d);
}
}
// 检测结果,符合条件的输出
public static void check(int [] n){
StringBuffer sb = new StringBuffer();
for(int x:n){ // 数字数组转为字符串
sb.append(x);
}
int a = Integer.parseInt(sb.substring(0,2).toString());
int b = Integer.parseInt(sb.substring(2,4).toString());
int c = Integer.parseInt(sb.substring(4,6).toString());
int d = Integer.parseInt(sb.substring(6).toString());
if(a*b==c*d){
lis.add(sb.toString()); // 添加结果
}
}
// 全排列
public static void allSort(int start,int end){
if (start == end) {
check(n);
} else {
for (int i = 1; i < 10; i++) {
if (vis[i])
continue;
n[start] = i;
vis[i] = true;
allSort(start + 1, end);
vis[i] = false;
}
}
}
public static void main(String[] args){
allSort(0,9);
removeDuplicate(); // 去除重复元素
print(); // 输出结果
System.out.println("kinds:"+kinds);
}
}
/*----------------------------------黄金分隔线---------------------------*/
import java.util.List;
import java.util.ArrayList;
public class 乘法运算 {
static List<String> lis = new ArrayList<String>(); // 结果1(有重复的结果)
static List<String> lis2 = new ArrayList<String>(); // 结果2(去重复后的结果)
static int kinds = 1;
static boolean vis[] = new boolean[10];
// 是否重复
public static boolean isDup(String s1,String s2){
String a1 = s1.substring(0,2);
String a2 = s1.substring(2,4);
String b1 = s2.substring(0,2);
String b2 = s2.substring(2,4);
if(a1.equals(b2)&&a2.equals(b1)){
return true;
}else{
return false;
}
}
// 去除lis重复元素
public static void removeDuplicate(){
lis2.add(lis.get(0));
for(int i=1;i<lis.size();i++){
boolean flag=false; // 标记是否重复
for(int j=0;j<lis2.size();j++){
flag = isDup(lis.get(i),lis2.get(j)); // 判断是否重复
if(flag) break; // 如果元素重复,直接跳出这层循环,测试下个数据
}
if(!flag){
lis2.add(lis.get(i)); // 不重复,则添加
kinds++;
}
}
}
// 输出
public static void print(){
for(String s:lis2){
String a = s.substring(0,2);
String b = s.substring(2,4);
String c = s.substring(4,6);
String d = s.substring(6);
System.out.println(a+" x "+b+" = "+c+" x "+d);
}
}
// 检测结果,符合条件的输出
public static void check(List<Integer> lis1){
StringBuffer sb = new StringBuffer();
for(int x:lis1){ // 数字数组转为字符串
sb.append(x);
}
int a = Integer.parseInt(sb.substring(0,2).toString());
int b = Integer.parseInt(sb.substring(2,4).toString());
int c = Integer.parseInt(sb.substring(4,6).toString());
int d = Integer.parseInt(sb.substring(6).toString());
if(a*b==c*d){
lis.add(sb.toString()); // 添加结果
}
}
// 全排列
public static void allSort(List<Integer> lis1,int start,int end){
if(start==end){
check(lis1);
return ;
}
for(int i=1;i<10;i++){
if(!lis1.contains(i)){
lis1.set(start, i);
}else{
continue;
}
allSort(lis1,start+1,end);
lis1.set(start, 0);
}
}
public static void main(String[] args){
List<Integer> lis1 = new ArrayList<Integer>();
for(int i=0;i<9;i++){
lis1.add(0);
}
allSort(lis1,0,9);
removeDuplicate(); // 去除重复元素
print(); // 输出结果
System.out.println("kinds:"+kinds);
}
}
/*----------------------------------黄金分隔线---------------------------*/
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class 乘法运算 {
static List<int[]> lis = new ArrayList<int[]>();
static List<int[]> lis2 = new ArrayList<int[]>();
static int kinds;
// 输出所有组合
public static void print(){
for(int[] n:lis2){
int a = n[0]*10+n[1];
int b = n[2]*10+n[3];
int c = n[4]*10+n[5];
int d = n[6]*100+n[7]*10+n[8];
System.out.println(a+" x "+b+" = "+c+" x "+d);
}
}
// 是否重复
public static boolean isDup(int a[],int b[]){
int a1 = a[0]*10+a[1];
int a2 = a[2]*10+a[3];
int b1 = b[0]*10+b[1];
int b2 = b[2]*10+b[3];
if(a1 == b2&&a2==b1){
return true;
}else{
return false;
}
}
// 去除lis重复元素
public static void removeDuplicate(){
lis2.add(lis.get(0));
for(int i=1;i<lis.size();i++){
boolean flag=true; // 标记是否重复
for(int j=0;j<lis2.size();j++){
flag = isDup(lis.get(i),lis2.get(j)); // 判断是否重复
if(flag) break; // 如果元素重复,直接跳出这层循环,测试下个数据
}
if(!flag){
lis2.add(lis.get(i)); // 不重复,则添加
kinds = kinds +1;
}
}
}
// 检测,并添加符合的组合
public static void check(int[] n){
int a = n[0]*10+n[1];
int b = n[2]*10+n[3];
int c = n[4]*10+n[5];
int d = n[6]*100+n[7]*10+n[8];
if(a*b==c*d){
lis.add(Arrays.copyOf(n, n.length));
}
}
// 全排列
public static void f(int[] n,int start,int end){
if(start>=end){
check(n); // 检测,并添加符合的组合
return ;
}else{
for(int i=start;i<n.length;i++){
int temp = n[start];
n[start] = n[i];
n[i] = temp;
f(n,start+1,end);
temp = n[start];
n[start] = n[i];
n[i] = temp;
}
}
}
public static void main(String[] args){
int[] n = {1,2,3,4,5,6,7,8,9};
f(n,0,n.length-1);
removeDuplicate(); // 去除重复元素
print(); // 输出结果
System.out.println("kinds:"+kinds); // 输出个数
}
}
/*----------------------------------黄金分隔线---------------------------*/
//其实题目要求左边的两个乘数交换算同一方案，不要重复输出！
//即由对称性可知，求出所有组合，然后除以2即为所求答案
//所以程序可以省略去重函数public static void removeDuplicate()
//程序代码可化简为:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class 乘法运算 {
static List<int[]> lis = new ArrayList<int[]>();
static int kinds;
// 检测,并添加符合的组合
public static void check(int[] n){
int a = n[0]*10+n[1];
int b = n[2]*10+n[3];
int c = n[4]*10+n[5];
int d = n[6]*100+n[7]*10+n[8];
if(a*b==c*d){
lis.add(Arrays.copyOf(n, n.length));
kinds++;
}
}
// 全排列
public static void f(int[] n,int start,int end){
if(start>=end){
check(n); // 检测,并添加符合的组合
return ;
}else{
for(int i=start;i<n.length;i++){
int temp = n[start];
n[start] = n[i];
n[i] = temp;
f(n,start+1,end);
temp = n[start];
n[start] = n[i];
n[i] = temp;
}
}
}
public static void main(String[] args){
int[] n = {1,2,3,4,5,6,7,8,9};
f(n,0,n.length-1);
System.out.println("kinds:"+kinds/2); // 输出个数
}
}
浙公网安备 33010602011771号