一、图形显示

此题虽然简单，但是需啊哟注意的是，每个“*”后边有一个空格】

问题描述
　　编写一个程序，首先输入一个整数，例如5，然后在屏幕上显示如下的图形（5表示行数）：
　　* * * * *
　　* * * *
　　* * *
　　* *
　　*
  1.  import java.util.Scanner;
  2.  
  3.  public class Main {
  4.      public static void main(String[] args) {
  5.          Scanner mScanner = new Scanner(System.in);
  6.          int n = mScanner.nextInt();
  7.          for (int i = n; i > 0; i--) {
  8.              if (i != n) {
  9.                  System.out.println();
  10.              }
  11.              for (int j = 0; j < i; j++) {
  12.                  System.out.print("* ");
  13.              }
  14.          }
  15.      }
  16.  }

二、排序

【由小到大排序后逆序输出】
问题描述
　　编写一个程序，输入3个整数，然后程序将对这三个整数按照从大到小进行排列。
　　输入格式：输入只有一行，即三个整数，中间用空格隔开。
　　输出格式：输出只有一行，即排序后的结果。
　　输入输出样例
样例输入
　　9 2 30
样例输出
　　30 9 2

  1.  import java.util.Arrays;
  2.  import java.util.Scanner;
  3.  
  4.  public class Main{
  5.  
  6.      public static void main(String[] args) {
  7.          Scanner mScanner = new Scanner(System.in);
  8.          int[] array = new int[3];
  9.          for (int i = 0; i < array.length; i++) {
  10.              array[i] = mScanner.nextInt();
  11.          }
  12.          Arrays.sort(array);
  13.          for (int i = array.length - 1; i >= 0; i--) {
  14.              System.out.print(array[i] + " ");
  15.          }
  16.      }
  17.  
  18.  }

三、2的次幂表示

【这个是从网上找的一个答案，通过测试】
问题描述
　　任何一个正整数都可以用2进制表示，例如：137的2进制表示为10001001。
　　将这种2进制表示写成2的次幂的和的形式，令次幂高的排在前面，可得到如下表达式：137=2^7+2^3+2^0
　　现在约定幂次用括号来表示，即a^b表示为a（b）
　　此时，137可表示为：2（7）+2（3）+2（0）
　　进一步：7=2^2+2+2^0 （2^1用2表示）
　　3=2+2^0 
　　所以最后137可表示为：2（2（2）+2+2（0））+2（2+2（0））+2（0）
　　又如：1315=2^10+2^8+2^5+2+1
　　所以1315最后可表示为：
　　2（2（2+2（0））+2）+2（2（2+2（0）））+2（2（2）+2（0））+2+2（0）
输入格式
　　正整数（1<=n<=20000）
输出格式
　　符合约定的n的0，2表示（在表示中不能有空格）
样例输入
　　137
样例输出
　　2(2(2)+2+2(0))+2(2+2(0))+2(0)
样例输入
　　1315
样例输出
　　2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0)
提示
　　用递归实现会比较简单，可以一边递归一边输出
  1.  import java.util.Scanner;
  2.  
  3.  public class Main{
  4.      public void fun(double e) {
  5.          double d = e;
  6.          if (d == 1) {
  7.              System.out.print("2(0)");
  8.          } else {
  9.              if (d == 2) {
  10.                  System.out.print("2");
  11.              } else {
  12.                  int x = 1;
  13.                  int m = 0;
  14.                  while (m == 0) {
  15.                      if ((Math.pow(2, x + 1) > d) && (d >= Math.pow(2, x))) {
  16.                          m = 1;
  17.                          if (d == Math.pow(2, x)) {
  18.                              System.out.print("2");
  19.                              if (x == 1) {
  20.                              } else {
  21.                                  System.out.print("(");
  22.                                  fun(x);
  23.                                  System.out.print(")");
  24.                              }
  25.                          } else {
  26.                              System.out.print("2");
  27.                              if (x == 1) {
  28.                              } else {
  29.                                  System.out.print("(");
  30.                                  fun(x);
  31.                                  System.out.print(")");
  32.                              }
  33.                              System.out.print("+");
  34.                              fun(d - Math.pow(2, x));
  35.                          }
  36.                      } else {
  37.                          x++;
  38.                      }
  39.                  }
  40.              }
  41.          }
  42.      }
  43.  
  44.      public static void main(String[] args) {
  45.          Scanner mScanner = new Scanner(System.in);
  46.          double n = mScanner.nextInt();
  47.          Main cm = new Main();
  48.          cm.fun(n);
  49.      }
  50.  }

四、前缀表达式

【此题貌似没有按照题中要求的设计相应的函数，但是也通过了测试】
问题描述
　　编写一个程序，以字符串方式输入一个前缀表达式，然后计算它的值。输入格式为：“运算符 对象1 对象2”，其中，运算符为“+”（加法）、“-”（减法）、“*”（乘法）或“/”（除法），运算对象为不超过10的整数，它们之间用一个空格隔开。要求：对于加、减、乘、除这四种运算，分别设计相应的函数来实现。
　　输入格式：输入只有一行，即一个前缀表达式字符串。
　　输出格式：输出相应的计算结果（如果是除法，直接采用c语言的“/”运算符，结果为整数）。
　　输入输出样例
样例输入
　　+ 5 2
样例输出
　　7
  1.  import java.util.Scanner;
  2.  
  3.  public class Main {
  4.  
  5.      public static void main(String[] args) {
  6.          Scanner mScanner = new Scanner(System.in);
  7.          String mm = mScanner.next();
  8.          int a = mScanner.nextInt();
  9.          int b = mScanner.nextInt();
  10.          if (mm.equals("+")) {
  11.              System.out.println(a+b);
  12.          }else if (mm.equals("-")) {
  13.              System.out.println(a-b);
  14.          }else if (mm.equals("*")) {
  15.              System.out.println(a*b);
  16.          }else if (mm.equals("/")) {
  17.              System.out.println(a/b);
  18.          }
  19.      }
  20.  }

五、Anagrams问题

【我的做法是先把输入的字符串使用 toLowerCase() 函数全部转化为小写字母，然后使用排序函数对字符数组进行排序，最后依次比较每个字符的大小即可！】
问题描述
　　Anagrams指的是具有如下特性的两个单词：在这两个单词当中，每一个英文字母（不区分大小写）所出现的次数都是相同的。例如，“Unclear”和“Nuclear”、“Rimon”和“MinOR”都是Anagrams。编写一个程序，输入两个单词，然后判断一下，这两个单词是否是Anagrams。每一个单词的长度不会超过80个字符，而且是大小写无关的。
　　输入格式：输入有两行，分别为两个单词。
　　输出格式：输出只有一个字母Y或N，分别表示Yes和No。
　　输入输出样例
样例输入
　　Unclear
　　Nuclear
样例输出
　　Y
  1.  import java.util.Arrays;
  2.  import java.util.Scanner;
  3.  
  4.  public class Main{
  5.  
  6.      public static void main(String[] args) {
  7.          Scanner mScanner = new Scanner(System.in);
  8.          String str1 = mScanner.next().toLowerCase();
  9.          String str2 = mScanner.next().toLowerCase();
  10.          if (str1.length() == str2.length()) {
  11.              char[] arr1 = fun(str1);
  12.              char[] arr2 = fun(str2);
  13.              boolean tag = true;
  14.              for (int i = 0; i < arr1.length; i++) {
  15.                  if (arr1[i] != arr2[i]) {
  16.                      tag = false;
  17.                  }
  18.              }
  19.              if (tag) {
  20.                  System.out.println("Y");
  21.              }else{
  22.                  System.out.println("N");
  23.              }
  24.          } else {
  25.              System.out.println("N");
  26.          }
  27.      }
  28.  
  29.      public static char[] fun(String str) {
  30.          char[] array = str.toCharArray();
  31.          Arrays.sort(array);
  32.          return array;
  33.      }
  34.  
  35.  }

六、出现次数最多的整数

【此题没有太大难度，但是如果考虑的不全面的话想得100分也有点难度，问题是他给出的测试的数据中给出的测试数值小于或者等于1，大于20……这就是一个坑。。。】
问题描述
　　编写一个程序，读入一组整数，这组整数是按照从小到大的顺序排列的，它们的个数N也是由用户输入的，最多不会超过20。然后程序将对这个数组进行统计，把出现次数最多的那个数组元素值打印出来。如果有两个元素值出现的次数相同，即并列第一，那么只打印比较小的那个值。
　　输入格式：第一行是一个整数N，N   £  20；接下来有N行，每一行表示一个整数，并且按照从小到大的顺序排列。
　　输出格式：输出只有一行，即出现次数最多的那个元素值。
　　输入输出样例
样例输入
　　5
　　100
　　150
　　150
　　200
　　250
样例输出
　　150
  1.  import java.util.Scanner;
  2.  
  3.  public class Main{
  4.  
  5.      public static void main(String[] args) {
  6.          Scanner mScanner = new Scanner(System.in);
  7.          int m = mScanner.nextInt();
  8.          if (m < 1 || m > 20) {
  9.              return;
  10.          }
  11.          int[] array = new int[m];
  12.          for (int i = 0; i < m; i++) {
  13.              array[i] = mScanner.nextInt();
  14.          }
  15.  
  16.          int max = 0;
  17.          int tag = 0;
  18.          int num = 0;
  19.          for (int i = 1; i < array.length; i++) {
  20.              if (array[i - 1] == array[i]) {
  21.                  tag++;
  22.              } else {
  23.                  tag = 0;
  24.              }
  25.              if (tag > max) {
  26.                  num = array[i];
  27.                  max = tag;
  28.              }
  29.          }
  30.          if (num==0) {
  31.              num = array[0];
  32.          }
  33.          System.out.println(num);
  34.      }
  35.  
  36.  }

七、字串统计

问题描述
　　给定一个长度为n的字符串S，还有一个数字L，统计长度大于等于L的出现次数最多的子串（不同的出现可以相交），如果有多个，输出最长的，如果仍然有多个，输出第一次出现最早的。
输入格式
　　第一行一个数字L。
　　第二行是字符串S。
　　L大于0，且不超过S的长度。
输出格式
　　一行，题目要求的字符串。

　　输入样例1：
　　4
　　bbaabbaaaaa

　　输出样例1：
　　bbaa

　　输入样例2：
　　2
　　bbaabbaaaaa

　　输出样例2：
　　aa

数据规模和约定
　　n<=60
　　S中所有字符都是小写英文字母。

　　提示
　　枚举所有可能的子串，统计出现次数，找出符合条件的那个

 
 

八、矩阵乘法

【此题考查矩阵的乘法，如果不会矩阵的乘法的话，可以好好看看这个题，还有二维数组的运算问题】
问题描述
　　输入两个矩阵，分别是m*s，s*n大小。输出两个矩阵相乘的结果。
输入格式
　　第一行，空格隔开的三个正整数m,s,n（均不超过200）。
　　接下来m行，每行s个空格隔开的整数，表示矩阵A（i，j）。
　　接下来s行，每行n个空格隔开的整数，表示矩阵B（i，j）。
输出格式
　　m行，每行n个空格隔开的整数，输出相乘後的矩阵C（i，j）的值。
样例输入
　　2 3 2
　　1 0 -1
　　1 1 -3
　　0 3
　　1 2
　　3 1
样例输出
　　-3 2
　　-8 2

提示
　　矩阵C应该是m行n列，其中C(i,j)等于矩阵A第i行行向量与矩阵B第j列列向量的内积。
　　例如样例中C(1,1)=(1,0,-1)*(0,1,3) = 1 * 0 +0*1+(-1)*3=-3

  1.  import java.util.Scanner;
  2.  
  3.  public class Main {
  4.  
  5.      public static void main(String[] args) {
  6.          Scanner mScanner = new Scanner(System.in);
  7.          int m = mScanner.nextInt();
  8.          int s = mScanner.nextInt();
  9.          int n = mScanner.nextInt();
  10.          int[][] a = new int[m][s];
  11.          int[][] b = new int[s][n];
  12.          int[][] c = new int[m][n];
  13.          for (int i = 0; i < m; i++) {
  14.              for (int j = 0; j < s; j++) {
  15.                  a[i][j] = mScanner.nextInt();
  16.              }
  17.          }
  18.          for (int i = 0; i < s; i++) {
  19.              for (int j = 0; j < n; j++) {
  20.                  b[i][j] = mScanner.nextInt();
  21.              }
  22.          }
  23.  
  24.          getMatrix(a, b);
  25.  
  26.      }
  27.  
  28.      public static void getMatrix(int[][] a, int[][] b) {
  29.          int[][] c = new int[a.length][b[0].length];
  30.          for (int i = 0; i < a.length; i++) {
  31.              for (int j = 0; j < b[0].length; j++) {
  32.                  int sum = 0;
  33.                  for (int k = 0; k < b.length; k++) {
  34.                      sum += a[i][k] * b[k][j];
  35.                  }
  36.                  c[i][j] = sum;
  37.              }
  38.          }
  39.  
  40.          for (int i = 0; i < a.length; i++) {
  41.              for (int j = 0; j < b[0].length; j++) {
  42.                  System.out.print(c[i][j] + "\t");
  43.              }
  44.              System.out.println();
  45.          }
  46.  
  47.      }
  48.  
  49.  }

九、大小写转换

【大小写转换函数，字符串到字符数组的转化函数】
问题描述
　　编写一个程序，输入一个字符串（长度不超过20），然后把这个字符串内的每一个字符进行大小写变换，即将大写字母变成小写，小写字母变成大写，然后把这个新的字符串输出。
　　输入格式：输入一个字符串，而且这个字符串当中只包含英文字母，不包含其他类型的字符，也没有空格。
　　输出格式：输出经过转换后的字符串。
　　输入输出样例
样例输入
　　AeDb
样例输出
　　aEdB
  1.  import java.util.Scanner;
  2.  public class Main {
  3.  
  4.      public static void main(String[] args) {
  5.          Scanner mScanner = new Scanner(System.in);
  6.          String str = mScanner.next();
  7.          char[] arr = str.toCharArray();
  8.          for (int i = 0; i < arr.length; i++) {
  9.              if (Character.isLowerCase(arr[i])) {
  10.                  str = String.valueOf(arr[i]).toUpperCase();
  11.              } else {
  12.                  str = String.valueOf(arr[i]).toLowerCase();
  13.              }
  14.              System.out.print(str);
  15.          }
  16.      }
  17.  
  18.  }

十、动态数组使用

【此题可以考虑使用arrayList动态链表！】
　从键盘读入n个整数，使用动态数组存储所读入的整数，并计算它们的和与平均值分别输出。要求尽可能使用函数实现程序代码。平均值为小数的只保留其整数部分。
样例输入
　　5
　　3 4 0 0 2
样例输出
　　9 1
样例输入
　　7
　　3 2 7 5 2 9 1
样例输出
　　29 4
  1.  import java.util.ArrayList;
  2.  import java.util.Scanner;
  3.  
  4.  public class Main {
  5.  
  6.      public static void main(String[] args) {
  7.          Scanner mScanner = new Scanner(System.in);
  8.          int length = mScanner.nextInt();
  9.  
  10.          int sum = 0;
  11.          int average = 0;
  12.          for (int i = 0; i < length; i++) {
  13.              sum = sum + mScanner.nextInt();
  14.          }
  15.          System.out.println(sum + " " + sum / length);
  16.  
  17.      }
  18.  
  19.  }

十一、删除数组零元素

【此题如果使用数组的话可能比较麻烦，但是使用 ArrayList 的话就能达到事半功倍的效果】
　　从键盘读入n个整数放入数组中，编写函数CompactIntegers，删除数组中所有值为0的元素，其后元素向数组首端移动。注意，CompactIntegers函数需要接受数组及其元素个数作为参数，函数返回值应为删除操作执行后数组的新元素个数。输出删除后数组中元素的个数并依次输出数组元素。　　样例输入: （输入格式说明：5为输入数据的个数，3 4 0 0 2 是以空格隔开的5个整数）
　　5
　　3 4 0 0 2
　　样例输出:（输出格式说明：3为非零数据的个数，3 4 2 是以空格隔开的3个非零整数）
　　3
　　3 4 2
样例输入
　　7
　　0 0 7 0 0 9 0
样例输出
　　2
　　7 9
样例输入
　　3
　　0 0 0
样例输出
　　0
  1.  import java.util.ArrayList;
  2.  import java.util.List;
  3.  import java.util.Scanner;
  4.  
  5.  public class Main {
  6.  
  7.      public static void main(String[] args) {
  8.  
  9.          Scanner mScanner = new Scanner(System.in);
  10.          int count = mScanner.nextInt();
  11.  
  12.          List<Integer> list = new ArrayList<Integer>();
  13.  
  14.          // int[] arr = new int[count];
  15.          for (int i = 0; i < count; i++) {
  16.              // arr[i] = mScanner.nextInt();
  17.              list.add(mScanner.nextInt());
  18.          }
  19.          int length = CompactIntegers(list, count);
  20.          System.out.println(length);
  21.  
  22.          for (int i = 0; i < list.size(); i++) {
  23.              System.out.print(list.get(i) + " ");
  24.          }
  25.  
  26.      }
  27.  
  28.      public static int CompactIntegers(List<Integer> list, int count) {
  29.          int ss = count;
  30.          for (int i = 0; i < list.size(); i++) {
  31.              if (list.get(i) == 0) {
  32.                  list.remove(i);
  33.                  ss--;
  34.                  i--;
  35.              }
  36.          }
  37.          return ss;
  38.      }
  39.  }

注：本文系原创，首发于博客园，转载请注明出处。[http://www.cnblogs.com/zhjsll/p/4412250.html]

 

蓝桥杯算法训练<一>的更多相关文章

  1. Java实现 蓝桥杯 算法训练 猴子吃包子（暴力）

    试题 算法训练 猴子吃包子 问题描述 从前,有一只吃包子很厉害的猴子,它可以吃无数个包子,但是,它吃不同的包子速度也不同:肉包每秒钟吃x个:韭菜包每秒钟吃y个:没有馅的包子每秒钟吃z个:现在有x1个肉 ...

  2. Java实现蓝桥杯 算法训练 大等于n的最小完全平方数

    试题 算法训练 大等于n的最小完全平方数 资源限制 时间限制:1.0s 内存限制:256.0MB 问题描述 输出大等于n的最小的完全平方数. 若一个数能表示成某个自然数的平方的形式,则称这个数为完全平 ...

  3. 蓝桥杯算法训练 java算法 表达式求值

    问题描述 输入一个只包含加减乖除和括号的合法表达式,求表达式的值.其中除表示整除. 输入格式 输入一行,包含一个表达式. 输出格式 输出这个表达式的值. 样例输入 1-2+3*(4-5) 样例输出 - ...

  4. java实现 蓝桥杯 算法训练 Password Suspects

    问题描述 在年轻的时候,我们故事中的英雄--国王 Copa--他的私人数据并不是完全安全地隐蔽.对他来说是,这不可接受的.因此,他发明了一种密码,好记又难以破解.后来,他才知道这种密码是一个长度为奇数 ...

  5. 蓝桥杯 算法训练 Torry的困惑(基本型)（水题，筛法求素数）

    算法训练 Torry的困惑(基本型) 时间限制:1.0s   内存限制:512.0MB      问题描述 Torry从小喜爱数学.一天,老师告诉他,像2.3.5.7……这样的数叫做质数.Torry突 ...

  6. 蓝桥杯 算法训练 区间k大数查询（水题）

    算法训练 区间k大数查询 时间限制:1.0s   内存限制:256.0MB 问题描述 给定一个序列,每次询问序列中第l个数到第r个数中第K大的数是哪个. 输入格式 第一行包含一个数n,表示序列长度. ...

  7. 蓝桥杯--算法训练 区间k大数查询

                                                                                 算法训练 区间k大数查询   时间限制:1.0 ...

  8. 蓝桥杯 算法训练 ALGO-116 最大的算式

    算法训练 最大的算式   时间限制:1.0s   内存限制:256.0MB 问题描述 题目很简单,给出N个数字,不改变它们的相对位置,在中间加入K个乘号和N-K-1个加号,(括号随便加)使最终结果尽量 ...

  9. 蓝桥杯算法训练 区间k大数查询

    算法训练 区间k大数查询   问题描述 给定一个序列,每次询问序列中第l个数到第r个数中第K大的数是哪个. 输入格式 第一行包含一个数n,表示序列长度. 第二行包含n个正整数,表示给定的序列. 第三个 ...

  10. 蓝桥杯 算法训练 ALGO-15 旅行家的预算

    算法训练 旅行家的预算   时间限制:1.0s   内存限制:256.0MB 问题描述 一个旅行家想驾驶汽车以最少的费用从一个城市到另一个城市(假设出发时油箱是空的).给定两个城市之间的距离D1.汽车 ...

随机推荐

  1. #include <queue>

    双端队列deque比向量vector更有优势 双端队列(deque) 连续存储的指向不同元素的指针所组成的数组<deque> 队列(queue) 先进先出的值的排列 <queue&g ...

  2. hdu 5506 GT and set（dfs爆搜）

    Problem Description You are given N sets.The i−th set has Ai numbers.You should divide the sets into ...

  3. Android面试题目及其答案

    转自:http://blog.csdn.net/wwj_748/article/details/8868640 Android面试题目及其答案 1.Android dvm的进程和Linux的进程, 应 ...

  4. open函数

    open函数用来打开文件 其语法为:open(name[, mode[, buffering]]) open函数使用一个文件名作为唯一的强制参数,然后返回一个文件对象.模式(mode)和缓冲(buff ...

  5. 【MFC学习笔记-作业8-蝴蝶飞~】【什么鬼作业】

    作业要求: 用定时器控制蝴蝶在窗口废物,如图所示... 这是什么鬼作业啊...蝴蝶还要我这个手残手画啊233333333          (ノಠ .ಠ)ノ彡┻━┻ 不过多亏之前几个鬼作业的福 收获颇 ...

  6. 响应式布局之BootStrap

    本文在于巩固基础 学习bootStrap官网http://getbootstrap.com/ 响应式布局是Ethan Marcotte在2010年5月份提出的一个概念,简而言之,就是一个网站能够兼容多 ...

  7. Time Out 访问数据库超时处理 .NET

    using System.Reflection; using System.Data.SqlClient; TransactionSelectTableAdapter adapter = new Tr ...

  8. java调用Command命令

    ----------- import java.io.BufferedReader; import java.io.InputStreamReader; /** * 此类用来执行Command命令 * ...

  9. C#VS面向对象基础（二）

    这里我们接着上一篇博客,继续学习用C#实现面向对象中的概念.这里学习下边几个,当然我们还是通过动物比赛的例子. 多态:表示不同的对象可以执行相同的动作,但是通过它们自己的实现代码来执行.这里需要将父类 ...

  10. [Linked List]Linked List Cycle,Linked List Cycle II

    一.Linked List Cycle Total Accepted: 85115 Total Submissions: 232388 Difficulty: Medium Given a linke ...