import java.util.Random;

public class ArithmeticPractice {
    public static void main(String[] args) {
        // 设置题目数量
        int numberOfQuestions = 10;

        // 设置数字范围（可以根据需要调整）
        int numberRange = 20;

        // 创建随机数生成器
        Random random = new Random();

        // 循环生成题目
        for (int i = 0; i < numberOfQuestions; i++) {
            // 随机选择运算符（0 - 加法，1 - 减法，2 - 乘法，3 - 除法）
            int operator = random.nextInt(4);

            int num1;
            int num2;

            switch (operator) {
                case 0: // 加法
                    num1 = random.nextInt(numberRange) + 1;
                    num2 = random.nextInt(numberRange) + 1;
                    System.out.printf("%d + %d = ?\n", num1, num2);
                    break;
                case 1: // 减法（确保结果非负）
                    num1 = random.nextInt(numberRange) + 1;
                    num2 = random.nextInt(num1) + 1;
                    System.out.printf("%d - %d = ?\n", num1, num2);
                    break;
                case 2: // 乘法
                    num1 = random.nextInt(numberRange / 5) + 1; // 调整范围避免结果过大
                    num2 = random.nextInt(numberRange / 5) + 1;
                    System.out.printf("%d × %d = ?\n", num1, num2);
                    break;
                case 3: // 除法（确保能整除）
                    num2 = random.nextInt(numberRange / 2) + 1; // 调整除数范围
                    num1 = num2 * (random.nextInt(numberRange / num2) + 1); // 保证能整除
                    System.out.printf("%d ÷ %d = ?\n", num1, num2);
                    break;
            }
        }
    }
}

public class hello {
    public static void main(String[] args) {
        int a,b,c,d;
        for(a=1;a<20;a++)
            for(b=1;b<20;b++)
                for(c=1;c<20;c++)
                    for(d=1;d<20;d++)
                    {
                        if((a+b==8)&&(a+c==14)&&(b+d==10)&&(c-d==6))
                            System.out.println(a+","+b+","+c+","+d);
                    }
    }
}

public class GoldenRatioFraction {

    public static void main(String[] args) {
        double goldenRatio = 0.618;
        double closestDiff = Double.MAX_VALUE;
        int closestNumerator = 0;
        int closestDenominator = 0;

        for (int numerator = 1; numerator <= 20; numerator++) {
            for (int denominator = 1; denominator <= 20; denominator++) {
                // 检查分子和分母是否同时为偶数
                if (numerator % 2 == 0 && denominator % 2 == 0) {
                    continue;
                }

                // 计算当前分数与黄金分割点的差值
                double currentRatio = (double) numerator / denominator;
                double diff = Math.abs(currentRatio - goldenRatio);

                // 更新最接近的分数
                if (diff < closestDiff) {
                    closestDiff = diff;
                    closestNumerator = numerator;
                    closestDenominator = denominator;
                }
            }
        }

        // 输出结果
        System.out.printf("最接近黄金分割点0.618的分数是%d⁄%d，其值为%.4f%n",
                closestNumerator, closestDenominator,
                (double) closestNumerator / closestDenominator);
    }
}

public class Main {
    public static void main(String[] args) {
        float c=100;
        int d=0;
        int e=0;
        float m =0.618f;
        int k=20;
        for(int i=1;i<=k;i++){
            for(int j=1;j<=k;j++){
                if(i%2==0 & j%2==0){
                    continue;
                }
                float a =(float)i/j ;
                float b = m-a;
                b = b<0 ? 0 -b: b;
                if(b<c){
                    c=b;
                    d = i;
                    e = j;

                }
            }
        }
        System.out.println((float)d/e);


    }
}

...
//第一套用if else判断差值
if(result >= 0.618f){
    float scope = result - 0.618f;
}else{
    float scope = 0.618f - result;
}
...
//另一套用三元操作符判断差值
float scope = (result - 0.618f) >= 0 ? (result - 0.618f ) : ( 0.618f - result));

double goldenratio = 0.618;
        double mindifference = Double.MAX_VALUE;
        int bestnumerator = 0;
        int bestdenominator = 0;
        for(int e=1;e<21;e++){
            for(int f=1;f<21;f++){
                if(e%2==0 && f%2==0){
                    continue;
                }
                double radio = (double)e/f;
                double difference = Math.abs(radio - goldenratio);
                if(difference < mindifference){
                    mindifference = difference;
                    bestnumerator = e;
                    bestdenominator = f;
                }
            }
        }

package test4;

public class exercise {
		public static void main(String[] args) {
			double s=0.618;//黄金分割点值
			double mindf=Double.MAX_VALUE;
			int min_x=0;
			int min_y=0;
			for(int y=1;y<=20;y++) {
					for(int x=1;x<=y;x++) {
						if(x%2==0&&y%2==0) 
								continue;
						double result=(double)x/y;
						double df = Math.abs(result - s);
					    if(df<mindf) {
					    	mindf=df;
					    	min_x=x;
					    	min_y=y;
					    }
					}
			}
			System.out.println("离黄金分割点（0.618）最近的两个数相除为"+min_x+"/"+min_y);	
			System.out.println("相除的值为："+(double)min_x/min_y);
		}
}

package test;

public class goldenPoint {
        public static void main(String[] args){
            double golden = 1;
            int a = 0;
            int b = 0;
            for(int i = 1;i <= 20; i++){
                for(int j = 1;j <= 20;j++){
                    if(!(i %2 == 0 && j % 2 == 0)){
                        double chu = (double)i /(double)j;
                        if(Math.abs(chu - 0.618) < Math.abs(golden - 0.618) ){
                            a = i;
                            b = j;
                            golden = chu;
                        }
                    }
                }
            }
            System.out.print("离黄金分割点（0.618）最近的两个数相除是："+ a + "/" + b + "=" + golden);
        }
}

public class Find0618 {
    /*
    寻找某两个数相除，其结果 离黄金分割点 0.618最近

    分母和分子不能同时为偶数
    分母和分子 取值范围在[1-20]
     */
    public static void main(String[] args) {
        float p = 0.0f;
        int num = 1;
        int den = 1;
        int minNumNow = 0;
        int minDenNow = 0;
        float minValue = 0.0f;
        float loss = 0.0f;
        float lossBoundary = 1000.0f; //给一个较大的偏差范围用于后续循环赋值
        for(num=1;num<=20;++num){ //分子从1到20，开始依次递增
            for(den=1;den<=20;++den){ //分母从1到20，开始依次递增
                if ((num%2 == 0) & (den%2 == 0)) //如果分子和分母都为偶数，则分母增加1，之后继续判断是否满足条件
                {
                    continue;
                }
                else //如果满足分子分母不都为偶数，则计算分数值
                {
                    p = (float) num / den; //计算分数值，因为java中两个int类型变量计算不会产生小数，所以要强制转换
                    loss = (float) Math.abs(p-0.618); //定义一个参数，来计算分数值与0.618的接近程度

                    if (loss < lossBoundary){ //将这个接近程度，loss与一开始给的大边界进行比较，给一个较大边界的原因，就是为了方便赋值迭代
                        minNumNow = num; //第一次肯定是满足条件的，进入if分支，将此时的分子，分母，分数值都赋值给要输出的变量
                        minDenNow = den;
                        minValue = p;
                        lossBoundary = loss; //将边界收窄，变成第一个对分子，分母所对应的接近程度，此后，若第二对比第一对更接近，则重新赋值，以此类推，以确保输出的是最接近0.618的参数
                    }
                }
            }
        }
        System.out.printf("由分子和分母取值为[1-20]的整数所构成的分数最接近0.618的是由分子为%d,分母为%d所组成的%f", minNumNow, minDenNow, minValue);//打印结果
    }
}
/*
总结：for循环中的变量，如果没有在main函数中提前声明，则是局部变量，最外层for循环结束后就会被释放掉，因此输出的打印值，必须要在main函数中声明
 */

package j2se;

public class helloworld {
	public static void main(String[] args){
		int numt = 0,denot=0;
		float res=0;
		float err=10000f;
		for(int i=1;i<=20;i++){
			for(int j=i;j<=20;j++){
				float a=i,b=j;
				res=a/b;
				if(Math.abs(res-0.618)<err){
					err=(float) Math.abs(res-0.618);
					numt=i;
					denot=j;
					
				}
				
			}
		}
		System.out.println(numt);
		System.out.println(denot);
	}
	
}

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
            int final_fenzi=0;int final_fenmu=0;
            double divide=0;
            double breakpoint=1000;
            System.out.println("输入边界值");
            int range=new Scanner(System.in).nextInt();
            for(int fenzi=range;fenzi>0;fenzi--){                //遍历边界值内的数字
                for(int fenmu=range;fenmu>0;fenmu--){
                    if(fenzi%2!= 0 | fenmu%2!=0 ){             //判断是否同时为偶数
                        double value=(double)fenzi/fenmu;       //将被除数强转，最后的商就是double类型
                        double min=Math.abs(value-0.618);       //记录商与0.618最小的差值
                        if(min<breakpoint){                     //判断是否比最小差值更小的值
                            final_fenzi=fenzi;                  //记录更小差值的分子、分母
                            final_fenmu=fenmu;
                            breakpoint= min;                    //  如果有，记录更小的差值
                            divide=value;
                        }
                    }
                }
            }
            System.out.println("距离黄金分割点0.618"  + "最近的两个点是" + final_fenzi + "&" + final_fenmu + "相除的结果是" + divide );
        }
    }

public class text3 {
	public static void main(String arg[]) {
		System.out.println("请输入一个数作为右边界：");
		double gold;
		double tagval = Double.MAX_VALUE;//差值
		for (double i = new Scanner(System.in).nextInt() ; i > 0 ; i--) {
			for (double j = i ; j > 0 ; j--) {
				if (i%2 == 0 & j%2 == 0) {
					continue;
				}else {
					gold = j/i-0.618;
					if (Math.abs(gold)<Math.abs(tagval)) {
						tagval = gold;
					}
				}
			}
		}System.out.println(tagval + 0.618);
	}
}

public class NarcissisticNumber {

    public static void main(String[] args) {
        System.out.println("所有的水仙花数有：");
        for (int i = 100; i <= 999; i++) {
            if (isNarcissisticNumber(i)) {
                System.out.println(i);
            }
        }
    }

    // 判断一个数是否为水仙花数
    public static boolean isNarcissisticNumber(int number) {
        int hundreds = number / 100;         // 百位数字
        int tens = (number / 10) % 10;       // 十位数字
        int units = number % 10;             // 个位数字

        // 判断是否满足水仙花数的条件
        return number == hundreds * hundreds * hundreds +
                        tens * tens * tens +
                        units * units * units;
    }
}

public class HelloWorld8Test1 {
    /*寻找某两个数相除，其结果 离黄金分割点 0.618最近
            分母和分子不能同时为偶数
    分母和分子 取值范围在[1-20]*/
    public static void main(String[] args) {
        float a,b,c,d =1,s=0;
        int e=0,f=0;
        for (int i = 1; i <= 20; i++) {
            for (int j = 1; j <= 20; j++) {
                if (i%2==0&j%2==0) {continue;}
                a = (float)i/j;
                b = (float) ( a-0.618);
                c = (float)(b*b);//将其变为正数

                if (d>c){//比较大小留小的
                    d = c;
                    e = i;//保留最小值对应的ij
                    f = j;
                    s=(float) e/f;//算出真正的结果
                }

            }

        }
        System.out.println("则:"+e+"/"+f+"="+s+"最接近黄金分割率0.618");
    }
}