int n = board.length;
char[][] grid = new char[n][n];
for (int i = 0; i < n; i++) {
grid[i] = board[i].toCharArray();
}
int empty = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == ’ ') empty++;
}
}
if (empty > 0) {
if (check(grid, ‘X’)) return “X”;
if (check(grid, ‘O’)) return “O”;
return “Pending”;
}
if (check(grid, ‘X’)) return “X”;
if (check(grid, ‘O’)) return “O”;
return “Draw”;
}
private boolean check(char[][] grid, char c) {
int n = grid.length;
// 检查行
for (int row = 0; row < n; row++) {
int col;
for (col = 0; col < n; col++) {
if (grid[row][col] != c) break;
}
if (col >= n) return true;
}
// 检查列
for (int col = 0; col < n; col++) {
int row;
for (row = 0; row < n; row++) {
if (grid[row][col] != c) break;
}
if (row >= n) return true;
}
// 主对角线
int i;
for (i = 0; i < n; i++) {
if (grid[i][i] != c) break;
}
if (i >= n) return true;
// 副对角线
i = 0;
for (; i < n; i++) {
if (grid[i][n - 1 - i] != c) break;
}
return i >= n;
}
}
Q16.5 阶乘尾数
设计一个算法,算出 n 阶乘有多少个尾随零。
示例 1:
输入: 3
输出: 0
解释: 3! = 6, 尾数中没有零。
示例 2:
输入: 5
输出: 1
解释: 5! = 120, 尾数中有 1 个零.
说明: 你算法的时间复杂度应为 O(log n) 。
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/factorial-zeros-lcci
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
class Solution {
public int trailingZeroes(int n) {
/*
0 是由 *10 得到的,而 10 是由 2 * 5 得到的
因此我们求 n! 过程中存在多少个 2 * 5
因为 2 的个数必定比 5 的个数多,因此我们只求 5 的个数
如果直接一个一个遍历,即
for(int i = 5; i <= n; i++){
int temp = i;
while(temp % 5 == 0){
count++;
temp /= 5;
}
}
那么 n 过大时,从 1 遍历到 n, 那么会超时,因此我们修改下规律
n! = 1 * 2 * 3 * 4 * (1 * 5) * … * (2 * 5) * … * (3 * 5) …
我们发现,
每隔 5 个数就会出现 一个 5,因此我们只需要通过 n / 5 来计算存在存在多少个 5 个数,那么就对应的存在多少个 5
但是,我们也会发现
每隔 25 个数会出现 一个 25, 而 25 存在 两个 5,我们上面只计算了 25 的一个 5,因此我们需要 n / 25 来计算存在多少个 25,加上它遗漏的 5
同时,
我们还会发现
每隔 125 个数会出现一个 125,而 125 存在 三个 5,我们上面只计算了 125 的两个 5,因此我们需要 n / 125 来计算存在多少个 125,加上它遗漏的 5
…
因此我们 count = n / 5 + n / 25 + n / 125 + …
最终分母可能过大溢出,上面的式子可以进行转换
count = n / 5 + n / 5 / 5 + n / 5 / 5 / 5 + …
因此,我们这样进行循环
n /= 5;
count += n;
这样,第一次加上的就是 每隔 5 个数的 5 的个数,第二次加上的就是 每隔 25 个数的 5 的个数 …
*/
int count = 0;
while(n >= 5){
n /= 5;
count += n;
}
return count;
}
}
Q16.6 最小差
给定两个整数数组a和b,计算具有最小差绝对值的一对数值(每个数组中取一个值),并返回该对数值的差
示例:
输入:{1, 3, 15, 11, 2}, {23, 127, 235, 19, 8}
输出: 3,即数值对(11, 8)
提示:
1 <= a.length, b.length <= 100000
-2147483648 <= a[i], b[i] <= 2147483647
正确结果在区间[-2147483648, 2147483647]内
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/smallest-difference-lcci
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
class Solution {
public int smallestDifference(int[] a, int[] b) {
/*
对两个数组进行排序
双指针
int diff = a[i] - b[j]
如果 diff < 0 ,表示 a[i] 小于 b[j] ,a 尽可能接近 b,那么 i++
如果 diff > 0 ,表示 a[i] 大于 b[j] ,b 尽可能接近 a,那么 j++
特殊情况:
a = {1,2,3,4,5}
b = {6,7,8,9,10}
如果 a 数组最大值比 b 数组最小值还小,那么 a 数组 i 会一直右移,直到到达边界 break
*/
int alen = a.length;
int blen = b.length;
Arrays.sort(a);
Arrays.sort(b);
int minVal = Integer.MAX_VALUE;
int i = 0;
int j = 0;
while(i < alen && j < blen){
//使用 long,防止 -2147483648 转正数后还是 -2147483648
long diff = a[i] - b[j];
minVal = (int)Math.min(Math.abs(diff), minVal);
if(diff < 0){
i++;
}else{
j++;
}
}
return minVal;
}
}
Q16.7 最大数值
编写一个方法,找出两个数字
a
和b
中最大的那一个。不得使用if-else或其他比较运算符。
示例:
输入: a = 1, b = 2
输出: 2
class Solution {
public int maximum(int a, int b) {
long dif = (long)a - (long)b;
int k = (int)(dif >>> 63);
return a*(k^1) + b*k;
}
}
Q16.8 整数的英语表示
给定一个整数,打印该整数的英文描述。
示例 1:
输入: 123
输出: “One Hundred Twenty Three”
示例 2:
输入: 12345
输出: “Twelve Thousand Three Hundred Forty Five”
示例 3:
输入: 1234567
输出: “One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven”
示例 4:
输入: 1234567891
输出: “One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety One”
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/english-int-lcci
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
/*
*@v7fgg
*执行用时 :17 ms, 在所有 Java 提交中击败了27.86%的用户
*内存消耗 :39.8 MB, 在所有 Java 提交中击败了100.00%的户
*2020年6月18日 22:24
*/
class Solution {
public String numberToWords(int num) {
//考虑特殊情况的0
if(num==0){return “Zero”;}
String ans="";
//原数字在后面还要用到,因此复制一份,这里只需要考虑绝对值
int m=Math.abs(num);
int yi=m%1000;//1000以内的值,也就是后三位
int qian=m/1000%1000;//多少千thousand
int baiwan=m/1000000%1000;//多少百万million
int shiyi=m/1000000000;//多少十亿billion
if(yi>0){
ans=in1000(yi);
}
if(qian>0){
ans=in1000(qian)+" Thousand "+ans;
}
if(baiwan>0){
ans=in1000(baiwan)+" Million "+ans;
}
if(shiyi>0){
ans=in1000(shiyi)+" Billion "+ans;
}
//考虑负数的情况
if(num<0){ans="Negative "+ans;}
return ans.trim();
}
public String in1000(int a){
//此函数是把一个1000以内的数字变成字符串
String shuzi1[]=new String[]{"",“One”,“Two”,“Three”,“Four”,“Five”,“Six”,“Seven”,“Eight”,“Nine”,“Ten”,“Eleven”,“Twelve”,“Thirteen”,“Fourteen”,“Fifteen”,“Sixteen”,“Seventeen”,“Eighteen”,“Nineteen”};
String shuzi2[]=new String[]{"",“Ten”,“Twenty”,“Thirty”,“Forty”,“Fifty”,“Sixty”,“Seventy”,“Eighty”,“Ninety”};
String r="";
if(a%100<20){
r=shuzi1[a%100];
a/=100;
}
else{
r=shuzi1[a%10];
a/=10;
if(a>0){
//要去掉空格,因为会出现比如:3000000 thirty thousand
r=(shuzi2[a%10]+" "+r).trim();
a/=10;
}
}
if(a>0){
//去空格是因为会出现比如:100000 one hundred thousand
r=(shuzi1[a]+" Hundred "+r).trim();
}
return r;
}
}
Q16.9 运算
请实现整数数字的乘法、减法和除法运算,运算结果均为整数数字,程序中只允许使用加法运算符和逻辑运算符,允许程序中出现正负常数,不允许使用位运算。
你的实现应该支持如下操作:
Operations() 构造函数
minus(a, b) 减法,返回a - b
multiply(a, b) 乘法,返回a * b
divide(a, b) 除法,返回a / b
示例:
Operations operations = new Operations();
operations.minus(1, 2); //返回-1
operations.multiply(3, 4); //返回12
operations.divide(5, -2); //返回-2
提示:
你可以假设函数输入一定是有效的,例如不会出现除法分母为0的情况
单个用例的函数调用次数不会超过1000次
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/operations-lcci
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
import java.math.BigInteger;
class Operations {
public Operations() {
}
public int minus(int a, int b) {
return BigInteger.valueOf(a).subtract(BigInteger.valueOf(b)).intValue();
}
public int multiply(int a, int b) {
return BigInteger.valueOf(a).multiply(BigInteger.valueOf(b)).intValue();
}
public int divide(int a, int b) {
return BigInteger.valueOf(a).divide(BigInteger.valueOf(b)).intValue();
}
}
Q16.10 生存人数
给定 N 个人的出生年份和死亡年份,第 i 个人的出生年份为 birth[i],死亡年份为 death[i],实现一个方法以计算生存人数最多的年份。
你可以假设所有人都出生于 1900 年至 2000 年(含 1900 和 2000 )之间。如果一个人在某一年的任意时期处于生存状态,那么他应该被纳入那一年的统计中。例如,生于 1908 年、死于 1909 年的人应当被列入 1908 年和 1909 年的计数。
如果有多个年份生存人数相同且均为最大值,输出其中最小的年份。
示例:
输入:
birth = {1900, 1901, 1950}
death = {1948, 1951, 2000}
输出: 1901
提示:
0 < birth.length == death.length <= 10000
birth[i] <= death[i]
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/living-people-lcci
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
class Solution {
public int maxAliveYear(int[] birth, int[] death) {
Q16.10 生存人数
给定 N 个人的出生年份和死亡年份,第 i 个人的出生年份为 birth[i],死亡年份为 death[i],实现一个方法以计算生存人数最多的年份。
你可以假设所有人都出生于 1900 年至 2000 年(含 1900 和 2000 )之间。如果一个人在某一年的任意时期处于生存状态,那么他应该被纳入那一年的统计中。例如,生于 1908 年、死于 1909 年的人应当被列入 1908 年和 1909 年的计数。
如果有多个年份生存人数相同且均为最大值,输出其中最小的年份。
示例:
输入:
birth = {1900, 1901, 1950}
death = {1948, 1951, 2000}
输出: 1901
提示:
0 < birth.length == death.length <= 10000
birth[i] <= death[i]
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/living-people-lcci
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
class Solution {
public int maxAliveYear(int[] birth, int[] death) {