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);
}
}