0101 蓝桥杯真题04

/*
* 马虎的算式
* 小明是个急性子，上小学的时候经常把老师写在黑板上的题目抄错了。
* 有一次，老师出的题目是：36 x 495 = ?
* 他却给抄成了：396 x 45 = ?
* 但结果却很戏剧性，他的答案竟然是对的！！
* 因为 36 * 495 = 396 * 45 = 17820
* 类似这样的巧合情况可能还有很多，比如：27 * 594 = 297 * 54
* 假设 a b c d e 代表1~9不同的5个数字（注意是各不相同的数字，且不含0）
* 能满足形如： ab * cde = adb * ce 这样的算式一共有多少种呢？
*
* 请你利用计算机的优势寻找所有的可能，并回答不同算式的种类数。
* 满足乘法交换律的算式计为不同的种类，所以答案肯定是个偶数。
*
*
*/
public class _011马虎的算式 {
   public static void main(String[] args) {
       int count = 0;
       for(int a = 1;a < 10;a++) {
           for(int b = 1;b < 10;b++) {
               if(a != b) {
                   for(int c = 1;c < 10;c++) {
                       if(c != a && c!= b) {
                           for(int d = 1;d < 10;d++) {
                               if(d != a && d != b && d != c) {
                                   for(int e = 1;e < 10;e++) {
                                       if(e != a && e != b && e != c && e != d) {
                                           if((a*10+b)*(c*100+d*10+e)==(a*100+d*10+b)*(c*10+e)) {
                                               count++;
                                           }
                                       }
                                   }
                               }
                           }
                       }
                   }
               }
           }
       }
       System.out.println(count);
   }
}

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;

/*
* 黄金连分数
* 黄金分割数0.61803… 是个无理数，这个常数十分重要，在许多工程问题中会出现。有时需要把这个数字求得很精确。
*
* 对于某些精密工程，常数的精度很重要。也许你听说过哈勃太空望远镜，它首次升空后就发现了一处人工加工错误，对那样一个庞然大物，
* 其实只是镜面加工时有比头发丝还细许多倍的一处错误而已，却使它成了“近视眼”!!
*
* 言归正传，我们如何求得黄金分割数的尽可能精确的值呢？有许多方法。
*
* 比较简单的一种是用连分数：
* 1
* 黄金数 = ---------------------
* 1
* 1 + -----------------
* 1
* 1 + -------------
* 1
* 1 + ---------
* 1 + ...
*
*
* 这个连分数计算的“层数”越多，它的值越接近黄金分割数。
*
* 请你利用这一特性，求出黄金分割数的足够精确值，要求四舍五入到小数点后100位。
*
* 小数点后3位的值为：0.618
* 小数点后4位的值为：0.6180
* 小数点后5位的值为：0.61803
* 小数点后7位的值为：0.6180340
* （注意尾部的0，不能忽略）
*
* 你的任务是：写出精确到小数点后100位精度的黄金分割值。
*
* 注意：尾数的四舍五入！尾数是0也要保留！
*
* 显然答案是一个小数，其小数点后有100位数字，请通过浏览器直接提交该数字。
*
* 思路
* 1/2，2/3，3/5，5/8...
* 规律：分子是前一项的分母，分母是前一项的分子分母相加
* 分子：1，2，3，5...
* 分母：2，3，5，8...
* ==>斐波那契
*
* 注意：要使n足够大，让小数点后101位是不变的（稳定）
*
* 在Java中提供了用于大数字运算的类，即 java.math.BigInteger 类和 java.math.BigDecimal 类。
* 这两个类用于高精度计算，其中BigInteger 类是针对整型大数字的处理类，而 BigDecimal 类是针对大小数的处理类。
*
* 相关方法
* 1.BigDecimal(BigInteger unscaledVal, int scale)
* 将BigInteger转换为BigDecimal，并进行舍入
* 2.RoundingMode.HALF_UP:四舍五入
* 3.toPlainString() ：返回不带指数字段的此 BigDecimal 的字符串表示形式
* 4.substring():返回字符串的子字符串
*/
public class _012黄金连分数 {
   public static void main(String[] args) {
       BigInteger a = BigInteger.ONE;//1
       BigInteger b = BigInteger.ONE;//1
       for(int i = 3;i < 500;i++) {//迭代
           BigInteger temp = b;
           b = a.add(b);
           a = temp;
       }
       BigDecimal divide = new BigDecimal(a,110).divide(new BigDecimal(b,110),RoundingMode.HALF_UP);
       System.out.println(divide.toPlainString().substring(0,103));//截取字符串[0,103)位，即小数点后101位，四舍五入
       //0.61803398874989484820458683436563811772030917980576286213544862270526046281890244970720720418939113748
       //答案为
       //0.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375
   }
}

/*
* 有理数就是可以表示为两个整数的比值的数字。一般情况下，我们用近似的小数表示。但有些时候，不允许出现误差，必须用两个整数来表示一个有理数。
* 这时，我们可以建立一个“有理数类”，下面的代码初步实现了这个目标。为了简明，它只提供了加法和乘法运算。
   class Rational
   {
private long ra;
private long rb;

private long gcd(long a, long b){
if(b==0) return a;
return gcd(b,a%b);
}
public Rational(long a, long b){
ra = a;
rb = b;
long k = gcd(ra,rb);
if(k>1){ //需要约分
ra /= k;
rb /= k;
}
}
// 加法
public Rational add(Rational x){
return ________________________________________; //填空位置
}
// 乘法
public Rational mul(Rational x){
return new Rational(ra*x.ra, rb*x.rb);
}
public String toString(){
if(rb==1) return "" + ra;
return ra + "/" + rb;
}
}

* 使用该类的示例：
Rational a = new Rational(1,3);
Rational b = new Rational(1,6);
Rational c = a.add(b);
System.out.println(a + "+" + b + "=" + c);

* 思路
* 加法：通分
* 分母 = 当前分母*传入分母
* 分子 = 当前分子*传入分母
*/
public class _013有理数类 {
   //测试
   public static void main(String[] args) {
       Rational a = new Rational(1,3);
   Rational b = new Rational(1,6);
   Rational c = a.add(b);
   System.out.println(a + "+" + b + "=" + c);//1/2
   }
   static class Rational
   {
private long ra;
private long rb;

private long gcd(long a, long b){
if(b==0) return a;
return gcd(b,a%b);
}
public Rational(long a, long b){
ra = a;
rb = b;
long k = gcd(ra,rb);
if(k>1){ //需要约分
ra /= k;
rb /= k;
}
}
// 加法
public Rational add(Rational x){
return new Rational(ra*x.rb + x.ra*rb,rb*x.rb);
}
// 乘法
public Rational mul(Rational x){
return new Rational(ra*x.ra, rb*x.rb);
}
public String toString(){
if(rb==1) return "" + ra;
return ra + "/" + rb;
}
}
}

import java.util.Scanner;

/*
* 题目描述
* 幸运数是波兰数学家乌拉姆命名的。它采用与生成素数类似的“筛法”生成。首先从1开始写出自然数1,2,3,4,5,6,....
* 1 就是第一个幸运数。
* 我们从2这个数开始。把所有序号能被2整除的项删除，变为： 1 _ 3 _ 5 _ 7 _ 9 ....
* 把它们缩紧，重新记序，为： 1 3 5 7 9 .... 。
* 这时，3为第2个幸运数，然后把所有能被3整除的序号位置的数删去。注意，是序号位置，不是那个数本身能否被3整除!! 删除的应该是5，11, 17, ...
* 此时7为第3个幸运数，然后再删去序号位置能被7整除的(19,39,...)
* 最后剩下的序列类似：
* 1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79, ...
*
* 输入
* 输入两个正整数m n, 用空格分开 (m < n < 1000*1000)
* 输出
* 程序输出位于m和n之间的幸运数的个数（不包含m和n）。

   样例输入
   30 69

   样例输出
   8

*/
public class _014幸运数 {
   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       int m = sc.nextInt();
       int n = sc.nextInt();
       int[] a = new int[n];
       //筛选：把能被2整除的项删除
       for(int i = 0;i < n;i++) {
           a[i] = 2 * i + 1;
       }

       int l = 1;//幸运数的下标，即a[l]为幸运数
       while(true) {
           int p = l+1;//数字向前挪动的位置
           for(int i = l+1;i < n;i++) {
               if((i+1) % a[l] == 0) {
                   //跳过
               }else {
                   a[p] = a[i];
                   p++;
               }
           }

//           for(int i = 0;i < n;i++) {
//               System.out.print(a[i] + " ");
//           }
//           System.out.println();
           l++;

           if(a[l] >= n) {
               break;
           }
       }

       int count = 0;//计数
       for(int i = 0;i < n;i++) {
           if(a[i] >= n) {
               break;
           }
           if(a[i] > m) {
               count++;
           }
       }
       System.out.println(count);
   }

}

import java.util.Scanner;

/*
* 问题描述
* 小明这些天一直在思考这样一个奇怪而有趣的问题：
* 在1~N的某个全排列中有多少个连号区间呢？这里所说的连号区间的定义是：
* 如果区间[L, R] 里的所有元素（即此排列的第L个到第R个元素）递增排序后能得到一个长度为R-L+1的“连续”数列，则称这个区间连号区间。
* 当N很小的时候，小明可以很快地算出答案，但是当N变大的时候，问题就不是那么简单了，现在小明需要你的帮助。
*
* 输入格式
* 第一行是一个正整数N (1 <= N <= 50000), 表示全排列的规模。
* 第二行是N个不同的数字Pi(1 <= Pi <= N)，表示这N个数字的某一全排列。
*
* 输出格式
* 输出一个整数，表示不同连号区间的数目。

   样例输入1
   4
   3 2 4 1
   样例输出1
   7
   样例输入2
   5
   3 4 2 5 1
   样例输出2
   9

* 思路
* 1.区间[L, R]，递增排序后能得到一个长度为R-L+1
*/
public class _015连号区间数 {
   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       int n = sc.nextInt();
       int[] arr = new int[n+1];

       for(int i = 1;i <=n;i++) {
           arr[i] = sc.nextInt();
       }

       int count = 0;
       for(int i = 1;i <= n;i++) {
           int max = arr[i];
           int min = arr[i];
           for(int j = i;j <= n;j++) {
               if(arr[j] > max) {
                   max = arr[j];
               }
               if(arr[j] < min) {
                   min = arr[j];
               }
               if(i==j) {
                   count++;
               }else {
                   if(max - min == j-i) {
                       count++;
                   }
               }
           }
       }
       System.out.println(count);
   }
}