十道简单算法题
前言
最近在回顾之前使用C写过的数据结构和算法的东西，发现本身的算法和数据结构是真的薄弱，如今用Java改写一下，重温一下。java
只能说慢慢积累吧～下面的题目难度都是简单的，算法的大佬可直接忽略这篇文章了～入门或者算法薄弱的同窗可参考一下～程序员
不少与排序相关的小算法(合并数组、获取数字每位值的和)，我都没有写下来了，由于只要会了归并排序(合并数组)，会了桶排序(获取数字每位的值)，这些都不成问题了。若是还不太熟悉八大基础排序的同窗可看:【八大基础排序总结】算法
因为篇幅问题，每篇写十道吧～数组
若是有错的地方，或者有更好的实现，更恰当的理解方式但愿你们不吝在评论区留言哦～你们多多交流微信
十道简单算法题
题目的总览
-
1-n阶乘之和 - 获取二维数组每列最小的值
- 求"1！+4！(2的平方)+9！(3的平方)+...+n的值
- 数组对角线元素之和
- 打印杨辉三角形
- 猴子吃桃子问题
- 计算单词的个数
- 判断字母是否彻底同样
- 判断一个数是否是2的某次方
- 判断一个数字是否是ugly number
1、1-n阶乘之和
1-n阶乘之和怎么算？
- 1的阶乘是
1 - 2的阶乘是
1*2 - 3的阶乘是
1*2*3 - 4的阶乘是
1*2*3*4 - .........
如今咱们要求这些阶乘的和。思路：数据结构
- 3阶乘的和其实上就是2阶乘的和+3的阶乘
- 4阶乘的和其实上就是3阶乘的和+4的阶乘
- .......
/**
* 1-n的阶乘之和
*/
public static void Factorial(int n) {
//总和
double sum = 0;
//阶乘值，初始化为1
double factorial = 1;
for (int i = 1; i <= n; i++) {
factorial = factorial * i;
sum = (int) (sum + factorial);
}
System.out.println("公众号：Java3y" + " " + sum);
}
2、获取二维数组每列最小的值
获取二维数组每列最小的值
思路：遍历列，再遍历列中行数据结构和算法
咱们通常操做数组都是从行开始，再到列的。此次要求的是每列的最小值，所以须要在内部for循环遍历的是行spa
/**
* 求出二维数组每列的最小值
*/
public static void minArray() {
//二维数组
int[][] arrays = {
{23, 106, 8, 234},
{25, 9, 73, 19},
{56, 25, 67, 137}
};
//获取列数
int maxColLength = arrays[0].length;
//使用一个数组来装载每列最小的值
int[] minArray = new int[maxColLength];
//控制列数
for (int i = 0; i < maxColLength; i++) {
//假设每列的第一个元素是最小的
int min = arrays[0][i];
//控制行数
for (int j = 1; j < arrays.length; j++) {
//找到最小值
if (arrays[j][i] < min) {
min = arrays[j][i];
}
}
//赋值给装载每列最小的值的数组
minArray[i] = min;
}
System.out.println("公众号：Java3y" + " " + minArray);
}
3、求"1！+4！(2的平方)+9！(3的平方)+...+n的值
求"1！+4！(2的平方)+9！(3的平方)的值
思路：先求平方，后求阶乘，最后相加便可～3d
/**
* 求"1！+4！(2的平方)+9！(3的平方)+...+n的值
*/
public static void calculate() {
double sum = 0;
for (int i = 1; i <= 3; i++) {
//获得平方数
int square = i * i;
//阶乘值，从1开始
double factorial = 1;
//求阶乘
for (int j = 1; j <= square; j++) {
factorial = factorial * j;
}
sum = sum + factorial;
}
System.out.println("公众号：Java3y" + " " + sum);
}
4、数组对角线元素之和
数组对角线元素之和
思路：code
- 只要行和列相等，便是对角线的元素
/**
* 数组对角线之和
*/
public static void arraySum() {
int[][] arrays = {
{23, 106, 8, 234},
{25, 9, 73, 19},
{56, 25, 67, 137},
{33, 22, 11, 44},
};
//和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
if (i == j) {
sum = sum + arrays[i][j];
}
}
}
System.out.println("公众号：Java3y" + sum);
}
5、打印杨辉三角形
杨辉三角形
杨辉三角形长的是这个样子：
ps：图片来源网上，侵删～
规律：
-
每行的第一个和最后一个都是1
- 进一步推算：第1列所有为1，第一行全都是1，当列数等于行数为1
- 当前值等于头上的值加头上的左边的值
- 第一行一列，第二行两列，第三行三列.......
代码实现：
/**
* 打印杨辉三角形
*/
public static void PascalTriangle() {
//打印十行的杨辉三角形
int[][] arrays = new int[10][];
//行数
for (int i = 0; i < arrays.length; i++) {
//初始化第二层的大小
arrays[i] = new int[i + 1];
//列数
for (int j = 0; j <= i; j++) {
//是第一列，第一行，行数等于列数，那么统统为1
if (i == 0 || j == 0 || j == i) {
arrays[i][j] = 1;
} else {
//当前值等于头上的值+头上左边的值
arrays[i][j] = arrays[i - 1][j] + arrays[i - 1][j - 1];
}
}
}
System.out.println("公众号：Java3y" + "-------------------------------");
for (int[] array : arrays) {
for (int value : array) {
System.out.print(value + "\t");
}
System.out.println();
}
System.out.println("公众号：Java3y" + "-------------------------------");
}
结果：
6、猴子吃桃子问题
猴子摘下了n个桃子，当天吃掉一半多一个，次日也是吃掉剩下桃子的一半多一个，到了第十天，桃子只剩下了1个。问：猴子第一天摘了多少个桃子
思路：
- 假设当天有n个桃子，它是前一天桃子的一半少1个，
f(n - 1) = f(n)/2 - 1, - 咱们就能够推出当天桃子的个数：根据递推公式：
f(n) = 2 * f(n - 1) + 2
用递归和循环均可解决：
递归方式：
/**
* 猴子吃桃问题
* @param x 天数
*/
public static int monkeyQue(int x) {
if (x <= 0) {
return 0;
} else if (x == 1) {
return 1;
} else {
return 2 * monkeyQue(x - 1) + 2;
}
}
循环方式：
int x = 1;
for (int i = 1; i <= 9; i++) {
x = (x + 1) * 2;
}
结果：
7、计算单词的个数
输入一段字符，计算出里面单词的个数，单词之间用空格隔开 ,一个空格隔开，就表明着一个单词了
思路：
- 把字符遍历一遍，累计由空格串转换为非空格串的次数，次数就是单词的个数
- 定义一个标志性变量flag，0表示的是空格状态，1表示的是非空格状态
/**
* 输入一段字符，计算出里面单词的个数
*
* @param str 一段文字
*/
public static int countWord(String str) {
// 0 表示空格状态，1 表示非空格状态
int flag = 0;
// 单词次数
int num = 0;
for (int i = 0; i < str.length(); i++) {
if (String.valueOf(str.charAt(i)).equals(" ") ) {
flag = 0;
} else if (flag == 0) {
num++;
flag = 1;
}
}
return num ;
}
结果：
8、判断字母是否彻底同样
给定两个字符串s和t，判断这两个字符串中的字母是否是彻底同样（顺序能够不同）
思路：
- 遍历这两个字符串，用每一个字符减去
'a'，将其分别存入到数组中去，随后看这两个数组是否相等便可
要点：
-
'c'-'a'=2便可计算出存储的位置，若是有多个，则+1便可，后面咱们来比较数组大小
代码实现：
/**
* 给定两个字符串s和t，判断这两个字符串中的字母是否是彻底同样（顺序能够不同）
*/
public static void isAnagram() {
//分别存储字符串的字符
int[] array1 = new int[26];
int[] array2 = new int[26];
String s1 = "pleasefollowthewechatpublicnumber";
String s2 = "pleowcnumberthewechatpubliasefoll";
for (int i = 0; i < s1.length(); i++) {
char value = s1.charAt(i);
// 算出要存储的位置
int index = value - 'a';
array1[index]++;
}
for (int i = 0; i < s2.length(); i++) {
char value = s2.charAt(i);
// 算出要存储的位置
int index = value - 'a';
array2[index]++;
}
for (int i = 0; i < 26; i++) {
if (array1[i] != array2[i]) {
System.out.println("不相同");
return;
}
}
System.out.println("相同");
}
结果：
9、判断一个数是否是2的某次方
判断一个数是否是2的某次方
思路：
- 除2取余数，直至余数不为0【针对2的倍数这种状况】，看是否是等于1就能够判断是否是2的某次方了
/**
* 判断是不是2的某次方
*/
public static void isPowerOfTwo() {
int num = 3;
if (num == 0) {
System.out.println("不是");
}
while (num % 2 == 0) {
num = num / 2;
}
if (num == 1) {
System.out.println("是");
} else {
System.out.println("不是");
}
}
结果：
这题还有另外一种解决方式，就是位运算：
- 2的n次方都有一个特色，二进制都是1000000
- 若是 2的n次方的二进制-1和2的n次方二进制作按位与运算，那么得出的结果确定是0
if(num <= 0){
System.out.println("不是");
}
else if(num == 1){
System.out.println("是");
}
else{
if( (num & (num-1) ) == 0){
System.out.println("是");
}
else{
System.out.println("不是");
}
}
10、判断一个数字是否是ugly number
判断一个数字是否是ugly number（分解出来的质因数只有二、三、5这3个数字）
思路：
-
若是是由2,3,5组成的，那么这个数不断除以2,3,5，最后得出的是1，这个数就是纯粹用2,3,5组成的
- 跟以前判断该数是否2的某次方是同样的思路～
代码：
/**
* 判断一个数字是否是ugly number（分解出来的质因数只有二、三、5这3个数字）
* @param num
*/
public static void isUgly(int num) {
if (num <= 0) {
System.out.println("不是");
} else {
while (num % 2 == 0) {
num = num / 2;
}
while (num % 3 == 0) {
num = num / 3;
}
while (num % 5 == 0) {
num = num / 5;
}
if (num == 1) {
System.out.println("是");
} else {
System.out.println("是");
}
}
}
结果：
总结
没错，你没看错，简单的小算法也要总结！
其实我以为这些比较简单的算法是有"套路"可言的，你若是知道它的套路，你就很容易想得出来，若是你不知道它的套路，那么极可能就不会作了(没思路)。
积累了必定的"套路"之后，咱们就能够根据经验来推断，揣摩算法题怎么作了。
举个很简单的例子：
- 乘法是在加法的基础之上的，那乘法咱们是怎么学的？背(积累)出来的，
9*9乘法表谁没背过？好比看到2+2+2+2+2，会了乘法(套路)之后，谁还会慢慢加上去。看见了5个2，就直接得出2*5了
-
1-n阶乘之和- 求n的阶乘就用
1*2*3*4*...n，实际上就是一个循环的过程，求和就套个sum变量便可！
- 求n的阶乘就用
-
获取二维数组每列最小的值
- 外层循环控制列数，内层循环控制行数，这就是遍历每列的方法～
-
求"1！+4！(2的平方)+9！(3的平方)+...+n的值
- 先求平方，再求阶乘，最后套个sum变量
-
数组对角线元素之和
- 行和列的位置相等，便是对角线上的元素
-
打印杨辉三角形
- 找出杨辉三角形的规律：第一行、第一列和列值等于行值时上的元素都是1，其他的都是头上的值加头上的左边的值
-
猴子吃桃子问题
- 根据条件，咱们能够推算出前一天桃子，进而推出当天桃子(规律)。猴子都是在相等的条件(剩下桃子的一半多一个)，所以就应该想到循环或者递归
-
计算单词的个数
- 利用每一个单词间会有个空格的规律，用变量来记住这个状态(字母与空格)的转换，便可计算出单词的个数！
-
判断字母是否彻底同样
- 将每一个字母都分别装载到数组里面去，
'c-a'就是字母c在数组的位置了(也就是2)。因为字母出现的次数不惟一，所以咱们比较的是数组的值(若是出现了两次，那么值为2，若是出现了3次，那么值为3)。只要用于装载两个数组的值都吻合，那么字母就是同样！
- 将每一个字母都分别装载到数组里面去，
-
判断一个数是否是2的某次方
- 最佳方案：2的某次方在二进制都有个特色：10000(n个0)--->ps:程序员的整数～..........那么比这个数少一位的二进制确定是01111，它俩作
&运算，那么确定为0。用这个特性就很是好判断该数是不是2的某次方了 - 次方案：2的某次方的数不断缩小(只要
number % 2 == 0就能够缩小，每次number / 2)，最后的商必然是1。
- 最佳方案：2的某次方在二进制都有个特色：10000(n个0)--->ps:程序员的整数～..........那么比这个数少一位的二进制确定是01111，它俩作
-
判断一个数字是否是ugly number
- 分解出来的质因数只有二、三、5这3个数字，这题其实就是判断该数是否为2的某次方的升级版。将这个数不断缩小(只要
number%2||%3||%5==0,每次number / 2 | / 3 /5)，最后的商必然是1。
- 分解出来的质因数只有二、三、5这3个数字，这题其实就是判断该数是否为2的某次方的升级版。将这个数不断缩小(只要
若是文章有错的地方欢迎指正，你们互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同窗，能够 关注微信公众号:Java3y
相关文章
- 1. 十道简单算法题
- 2. 三道简单算法题
- 3. 15道简单算法题
- 4. java实现9道简单算法题
- 5. （立下flag）每日10道前端面试题-08 十道算法简单算法
- 6. LeetCode 简单算法题
- 7. 简单递归算法题
- 8. [2]十道算法题【Java实现】
- 9. unittest单元测试(简单算法题)
- 10. 这道算法题太太太太太简单啦
- 更多相关文章...
- • Markdown 标题 - Markdown 教程
- • jQuery Mobile 主题 - jQuery Mobile 教程
- • 为了进字节跳动，我精选了29道Java经典算法题，带详细讲解
- • 算法总结-广度优先算法
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 十道简单算法题
- 2. 三道简单算法题
- 3. 15道简单算法题
- 4. java实现9道简单算法题
- 5. （立下flag）每日10道前端面试题-08 十道算法简单算法
- 6. LeetCode 简单算法题
- 7. 简单递归算法题
- 8. [2]十道算法题【Java实现】
- 9. unittest单元测试(简单算法题)
- 10. 这道算法题太太太太太简单啦