0098 蓝桥杯真题01

import java.util.Calendar;

/*
* 世纪末的星期
* 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。还有人称今后的某个世纪末的12月31日，如果是星期一则会…
* 有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!! 于是，“谣言制造商”又修改为星期日…
* 1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？
* 请回答该年份（只写这个4位整数，不要写12月31等多余信息）
*
* 思路
* 运用日期API中Calendar类
*
* 构造方法
* 1.protected Calendar() :由于修饰符是protected，所以无法直接创建该对象。需要通过别的途径生成该对象
*
* 成员方法
* 1.static Calendar getInstance(): 使用默认时区和区域设置获取日历。通过该方法生成Calendar对象。
*                             如Calendar cr=Calendar.getInstance()；
* 2.public void set(int year,int month,int date,int hourofday,int minute,int second)
*    设置日历的年、月、日、时、分、秒。
*
* 3.public int get(int field):返回给定日历字段的值。所谓字段就是年、月、日等等。
*
* 日历字段
* 1.YEAR   年
* 2.MINUTE 分
* 3.DAY_OF_WEEK_IN_MONTH 某月中第几周
* 4.MONTH 月
* 5.SECOND/MILLISECOND 秒/毫秒
* 6.WEEK_OF_MONTH 日历式的第几周
* 7.DATE 日
* 8.DAY_OF_MONTH   日
* 9.DAY_OF_YEAR   一年的第多少天
* 10.HOUR_OF_DAY   时
* 11.DAY_OF_WEEK   周几
* 12.WEEK_OF_YEAR   一年的第多少周
*/
public class _01世纪末的星期 {
   public static void main(String[] args) {
       Calendar calendar = Calendar.getInstance();
       for(int i = 1999;i < 10000;i += 100) {
           calendar.set(Calendar.YEAR, i);//1999年
           calendar.set(Calendar.MONTH, 11);//从0开始，11为12月
           calendar.set(Calendar.DAY_OF_MONTH, 31);//31日
           if (calendar.get(Calendar.DAY_OF_WEEK) == 1){//星期天为1，星期一为2....
               System.out.println(i);
               break;//2299
           }
       }
   }
}

/*
* 小明参加了学校的趣味运动会，其中的一个项目是：跳格子。
* 地上画着一些格子，每个格子里写一个字，如下所示：
* 从我做起振
* 我做起振兴
* 做起振兴中
* 起振兴中华
* 比赛时，先站在左上角的写着“从”字的格子里，可以横向或纵向跳到相邻的格子里，但不能跳到对角的格子或其它位置。一直要跳到“华”字结束。
* 要求跳过的路线刚好构成“从我做起振兴中华”这句话。
* 请你帮助小明算一算他一共有多少种可能的跳跃路线呢？
*
* 思路
* 枚举：递归和迭代
* 递归三要素
* 1.找重复，利用重复不断减小问题的规模；
* 2.找变化，变化的状态量就是递归的参数；
* 3.找出口，判断什么可以退出递归。
*
* 观察题目，其实在每个格子上时都只能向下走或者向右走，在当前格子上有两种走法，
* 而当到达边界处时，比如走到最下面一行格子或者最右边一列格子时，只能一路向右或向下走，这时从当前格子走到最后只能有一种走法。
*/
public class _02振兴中华 {
   public static void main(String[] args) {
       int ans = f(0, 0);
       System.out.println(ans);//35
   }

   private static int f(int x, int y) {//变化（坐标在变）
       if (x == 3||y == 4) {//出口（走到边界只有1种走法）
           return 1;
       }
       return f(x + 1, y) + f(x, y + 1);//重复（没有走到边界，有两种走法，相加）
   }
}

import java.math.BigInteger;

/*
* 梅森素数如果一个数字的所有真因子之和等于自身，则称它为“完全数”或“完美数”
* 例如：6 = 1 + 2 + 3
* 28 = 1 + 2 + 4 + 7 + 14
* 早在公元前300多年，欧几里得就给出了判定完全数的定理：
* 若 2^n - 1 是素数，则 2^(n-1) * (2^n - 1) 是完全数。
* 其中 ^ 表示“乘方”运算，乘方的优先级比四则运算高，例如：2^3 = 8， 2 * 2^3 = 16, 2^3-1 = 7
* 但人们很快发现，当n很大时，判定一个大数是否为素数到今天也依然是个难题。
* 因为法国数学家梅森的猜想，我们习惯上把形如：2^n - 1 的素数称为：梅森素数。
* 截止2013年2月，一共只找到了48个梅森素数。新近找到的梅森素数太大，以至于难于用一般的编程思路窥其全貌，所以我们把任务的难度降低一点：
* 1963年，美国伊利诺伊大学为了纪念他们找到的第23个梅森素数 n=11213，在每个寄出的信封上都印上了“2^11213-1 是素数”的字样。
* 2^11213 - 1 这个数字已经很大(有3000多位)，请你编程求出这个素数的十进制表示的最后100位。
*
* 思路
* 运用API中的BigInteger类
* 在Java中提供了用于大数字运算的类，即 java.math.BigInteger 类和 java.math.BigDecimal 类。
* 这两个类用于高精度计算，其中BigInteger 类是针对整型大数字的处理类，而 BigDecimal 类是针对大小数的处理类。
*
* 1.java.math.BigInteger.valueOf(long value)方法
* 返回一个BigInteger，其值等于作为参数传递的long的值。
* 该方法是静态方法，因此不需要使用此方法创建BigInteger类的对象。
* 我们可以通过BigInteger.valueOf(long value)代码调用此函数。
*
* 2.基本运算
* 返回值为BigInteger类型
* add()       加
* subtract()   减
* multiply()   乘
* divide()       除
* mod()       取模
* remainder()   求余
* pow()       平方
* abs()       绝对值
* negate()       相反数
*
* 3.比较大小
* compareTo()返回一个int型数据：1 大于； 0 等于； -1 小于
* max()，min()：分别返回大的（小的）那个BigInteger数据
*
* 4.常量
* ZERO，ONE，TEN 返回值为BigInteger类型
*
* 5.字符串方法
* public String substring(int beginIndex)
* public String substring(int beginIndex, int endIndex)
* beginIndex -- 起始索引（包括）, 索引从 0 开始。
* endIndex -- 结束索引（不包括）。
*/
public class _03梅森素数 {
   public static void main(String[] args) {
       BigInteger x = BigInteger.valueOf(2).pow(11213).subtract(BigInteger.ONE);//2^11213-1
       String s = x.toString();//转为字符串
       int length = s.length();//长度
       String ans = s.substring(length - 100);//最后100位
       System.out.println("最后" + ans.length() + "位是" + ans);//输出
       //8586718527586602439602335283513944980064327030278104224144971883680541689784796267391476087696392191
   }
}

/*
* 小李的店里专卖其它店中下架的样品电视机，可称为：样品电视专卖店
* 其标价都是4位数字（即千元不等）。
* 小李为了标价清晰、方便，使用了预制的类似数码管的标价签，只要用颜色笔涂数字就可以了
* 这种价牌有个特点，对一些数字，倒过来看也是合理的数字。如：1 2 5 6 8 9 0都可以。
* 这样一来，如果牌子挂倒了，有可能完全变成了另一个价格，比如：1958 倒着挂就是：8561，差了几千元啊!!
* 当然，多数情况不能倒读，比如，1110 就不能倒过来，因为0不能作为开始数字。
* 有一天，悲剧终于发生了。某个店员不小心把店里的某两个价格牌给挂倒了。并且这两个价格牌的电视机都卖出去了!
* 庆幸的是价格出入不大，其中一个价牌赔了2百多，另一个价牌却赚了8百多，综合起来，反而多赚了558元。
* 请根据这些信息计算：赔钱的那个价牌正确的价格应该是多少？
*
* 思路
* 1.枚举四位数，简单筛选
* 2.将其颠倒，和原价做差
* 3.将赔2百多的放入一个集合，将赚8百多的放入一个集合
* 4.遍历两个集合，检查是否相加为558
*
* 相关方法
* 1.contains() 方法用于判断字符串中是否包含指定的字符或字符串
* 2.continue 语句是跳过循环体中剩余的语句而强制执行下一次循环，其作用为结束本次循环
* 3.parseInt() 方法用于将字符串参数作为有符号的十进制整数进行解析
* 4.charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1
*/

import java.util.ArrayList;

public class _04颠倒的价牌 {
   public static void main(String[] args) {
       //创建集合，保存原价与差价
       ArrayList<Price> a1 = new ArrayList<>();
       ArrayList<Price> a2 = new ArrayList<>();

       //1.枚举四位数，简单筛选
       for(int i = 1000;i < 10000;i++) {
           String s = i + "";//转为字符串
           3,4,7不能颠倒，直接结束本次循环
           if (s.contains("3") || s.contains("4") || s.contains("7")) {
               continue;
           }
           //2.将其颠倒，和原价做差
           String res = reverse(s);//颠倒原价
           int i1 = Integer.parseInt(res);//转为int
           int minus = i1 - i;//颠倒价-原价
           //3.将赔2百多的放入一个集合，将赚8百多的放入一个集合
           if (minus < -200 && minus > -300) {//赔了2百多
               a1.add(new Price(i, minus));
           }
           if (minus < 900 && minus > 800) {//赚了8百多
               a2.add(new Price(i, minus));
           }
       }

       //遍历两个集合，检查是否相加为558
       for (Price price1 : a1) {
           for (Price price2 : a2) {
               if (price1.minus + price2.minus == 558) {//多赚558元
                   System.out.println("原价=" + price1.p + " 颠倒价-原价=" + price1.minus);
                   System.out.println("原价=" + price2.p + " 颠倒价-原价=" + price2.minus);
                   //答案为9088
               }
           }
       }
   }

   //编写reverse方法，实现颠倒原价
   private static String reverse(String s) {
       //创建一个大小为s.length的字符数组
       char[] chars = new char[s.length()];
       //遍历，j作为索引，将颠倒的价格保存在字符数组中
       for(int i = s.length() - 1,j = 0;i >= 0;i--,j++) {
           char c = s.charAt(i);
           //6颠倒成9，9颠倒成6，其他数字颠倒不变
           if (c == '6') {
               chars[j] = '9';
           }else if (c == '9') {
               chars[j] = '6';
           }else {
               chars[j] = c;
           }
       }
       //返回
       return new String(chars);
   }

   private static class Price{
       int p;//原价
       int minus;//颠倒价-原价
       //构造器
       public Price(int p, int minus) {
           this.p = p;
           this.minus = minus;
       }
   }
}

/*
* 三部排序
* 一般的排序有许多经典算法，如快速排序、希尔排序等。
* 但实际应用时，经常会或多或少有一些特殊的要求。我们没必要套用那些经典算法，可以根据实际情况建立更好的解法。
* 比如，对一个整型数组中的数字进行分类排序：
* 使得负数都靠左端，正数都靠右端，0在中部。注意问题的特点是：负数区域和正数区域内并不要求有序。可以利用这个特点通过1次线性扫描就结束战斗!!
* 以下的程序实现了该目标。
static void sort(int[] x)
{
   int p = 0;
   int left = 0;
   int right = x.length-1;

   while(p<=right){
   if(x[p]<0){
   int t = x[left];
   x[left] = x[p];
   x[p] = t;
   left++;
   p++;
   }
   else if(x[p]>0){
   int t = x[right];
   x[right] = x[p];
   x[p] = t;
   right--;
   }
   else{
   --------------------//填空
   }
   }
}
* 如果给定数组：
* 25,18,-2,0,16,-5,33,21,0,19,-16,25,-3,0
* 则排序后为：
* -3,-2,-16,-5,0,0,0,21,19,33,25,16,18,25
*/
public class _05三部排序 {
   static void sort(int[] x)
   {
       int p = 0;
       int left = 0;
       int right = x.length-1;

       while(p<=right){
       if(x[p]<0){//元素小于0，将元素和left位置元素交换，left,p后移
       int t = x[left];
       x[left] = x[p];
       x[p] = t;
       left++;
       p++;
       }
       else if(x[p]>0){//元素大于0，将元素和right位置元素交换，right前移
       int t = x[right];
       x[right] = x[p];
       x[p] = t;
       right--;
       }else{//元素等于0,不交换，直接让p后移
           p++;
       }
       }
   }
   //验证
   public static void main(String[] args) {
       int[] arr = {25,18,-2,0,16,-5,33,21,0,19,-16,25,-3,0};
       sort(arr);
       for (int i : arr) {
           System.out.print(i + " ");//-3 -2 -16 -5 0 0 0 21 19 33 25 16 18 25
       }
   }
}