从头开始之LeetCode
20201124
1.两数之和
给定一个整数数组 nums 和一个目标值 target
class Solution { public int[] twoSum(int[] nums, int target) { int nnn[] = new int[2]; for(int i=0;i<nums.length;i++){ for(int j=1;j<nums.length;j++){ if(i!=j){ if(nums[i]+nums[j]==target){ nnn[0]=i; nnn[1]=j; } } } } return nnn; } }
1662. 检查两个字符串数组是否相等
给你两个字符串数组 word1 和 word2 。如果两个数组表示的字符串相同，返回true；否则，返回 false 。
数组表示的字符串 是由数组中的所有元素 按顺序 连接形成的字符串。
class Solution { public boolean arrayStringsAreEqual(String[] word1, String[] word2) { String a1=""; String a2=""; for(int i=0;i<word1.length;i++) a1+=word1[i]; for(int j=0;j<word2.length;j++) a2+=word2[j]; if(a1.equals(a2)) return true; else return false; } }
1480. 一维数组的动态和
给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。
请返回 nums 的动态和。
示例 1：
输入：nums = [1,2,3,4] 输出：[1,3,6,10] 解释：动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。
1 class Solution { 2 public int[] runningSum(int[] nums) { 3 for(int i=1;i<nums.length;i++){ 4 nums[i]+=nums[i-1]; 5 } 6 return nums; 7 } 8 }
要利用好循环啊学习人
剑指 Offer 58 - II. 左旋转字符串
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。
比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
class Solution { public String reverseLeftWords(String s, int n) { return s.substring(n)+s.substring(0,n); } }
1470. 重新排列数组
给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,...,xn,y1,y2,...,yn] 的格式排列。
请你将数组按 [x1,y1,x2,y2,...,xn,yn] 格式重新排列，返回重排后的数组。
class Solution { public int[] shuffle(int[] nums, int n) { int [] ret = new int[2*n]; for(int i=0;i<n;i++){ ret[i*2]=nums[i]; ret[i*2+1]= nums[n+i]; } return ret; } }
哎呦喂，没想到说新建一个数组，局限在原有给的参数上，又憨了
20201125
1512. 好数对的数目
给你一个整数数组 nums 。
如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i < j ，就可以认为这是一组 好数对 。
返回好数对的数目。
class Solution { public int numIdenticalPairs(int[] nums) { int sum=0; for(int i=0;i<nums.length;i++){ for(int j=1;j<nums.length;j++){ if(nums[i]==nums[j]&&i<j) sum++; } } return sum; } }
这个很简单
1431. 拥有最多糖果的孩子
给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。
对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有 最多 的糖果数目。
class Solution { public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) { int len = candies.length; int []after = new int[len]; int max=0; for(int i=0;i<len;i++){ if(candies[i]>=max) max=candies[i]; after[i]=candies[i]+extraCandies; } ArrayList<Boolean> list = new ArrayList<Boolean>(); for(int j=0;j<len;j++){ if(after[j]>=max) list.add(true); else list.add(false); } return list; } }
也是不难
771. 宝石与石头
给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。
class Solution { public int numJewelsInStones(String J, String S) { int sum=0; for(int i=0;i<S.length();i++){ for(int j=0;j<J.length();j++){ if((S.charAt(i))==(J.charAt(j))) sum++; } } return sum; } }
不难
LCP 01. 猜数字
小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？
输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。
class Solution { public int game(int[] guess, int[] answer) { int sum=0; for(int i=0;i<guess.length;i++){ if(guess[i]==answer[i]) sum++; } return sum; } }
简单到令人懵逼
1486. 数组异或操作
给你两个整数，n 和 start 。
数组 nums 定义为：nums[i] = start + 2*i（下标从 0 开始）且 n == nums.length 。
请返回 nums 中所有元素按位异或（XOR）后得到的结果。
class Solution { public int xorOperation(int n, int start) { int sum=0; int nums[]= new int[n]; for(int i=0;i<n;i++){ nums[i]=start+2*i; sum^=nums[i]; } return sum; } }
简单
20201126
1603. 设计停车系统
请你给一个停车场设计一个停车系统。停车场总共有三种不同大小的车位：大，中和小，每种尺寸分别有固定数目的车位。
请你实现 ParkingSystem 类：
ParkingSystem(int big, int medium, int small)初始化ParkingSystem类，三个参数分别对应每种停车位的数目。bool addCar(int carType)检查是否有carType对应的停车位。carType有三种类型：大，中，小，分别用数字1，2和3表示。一辆车只能停在
carType对应尺寸的停车位中。如果没有空车位，请返回false，否则将该车停入车位并返回true。
class ParkingSystem { private int big; private int medium; private int small; public ParkingSystem(int big, int medium, int small) { this.big=big; this.medium=medium; this.small=small; } public boolean addCar(int carType) { if(carType==1&&big>=1){ big--; return true; } else if(carType==2&&medium>=1){ medium--; return true; } else if(carType==3&&small>=1){ small--; return true; } else return false; } } /** * Your ParkingSystem object will be instantiated and called as such: * ParkingSystem obj = new ParkingSystem(big, medium, small); * boolean param_1 = obj.addCar(carType); */
简单
1108. IP 地址无效化
给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。
所谓无效化 IP 地址，其实就是用 "[.]" 代替了每个 "."。
class Solution { public String defangIPaddr(String address) { String add=address.replace(".","[.]"); return add; } }
直接一个replace就结束了
LCP 06. 拿硬币
桌上有 n 堆力扣币，每堆的数量保存在数组 coins 中。我们每次可以选择任意一堆，拿走其中的一枚或者两枚，求拿完所有力扣币的最少次数。
class Solution { public int minCount(int[] coins) { int sum=0; for(int i=0;i<coins.length;i++){ if(coins[i]%2==0) sum+=coins[i]/2; else sum+=coins[i]/2+1; } return sum; } }
不难
1281. 整数的各位积和之差
给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。
class Solution { public int subtractProductAndSum(int n) { int ji =1; int he =0; char[] chars = String.valueOf(n).toCharArray(); for(int i=0;i<chars.length;i++){ int j=Integer.parseInt(String.valueOf(chars[i])); ji=ji*j; he+=j; } return (ji-he); } }
不够熟悉各种数据类型的转换
将int转为char[]：char[] chars = String.valueOf(n).toCharArray();
1389. 按既定顺序创建目标数组
给你两个整数数组 nums 和 index。你需要按照以下规则创建目标数组：
- 目标数组
target最初为空。 - 按从左到右的顺序依次读取
nums[i]和index[i]，在target数组中的下标index[i]处插入值nums[i]。 - 重复上一步，直到在
nums和index中都没有要读取的元素。
请你返回目标数组。
题目保证数字插入位置总是存在。
class Solution { public int[] createTargetArray(int[] nums, int[] index) { List<Integer> list = new ArrayList<Integer>(); for (int i = 0; i < nums.length; ++i) { list.add(index[i], nums[i]); } int[] ret = new int[nums.length]; for (int i = 0; i < nums.length; ++i) { ret[i] = list.get(i); } return ret; } } 作者：LeetCode-Solution
这道题自己没搞出来，没想到用list，看了官方的题解。
list的add可以自动向后移如果插入i已有，很方便。
1313. 解压缩编码列表
给你一个以行程长度编码压缩的整数列表 nums 。
考虑每对相邻的两个元素 [freq, val] = [nums[2*i], nums[2*i+1]] （其中 i >= 0 ），每一对都表示解压后子列表中有 freq 个值为 val 的元素，你需要从左到右连接所有子列表以生成解压后的列表。
请你返回解压后的列表。
class Solution { public int[] decompressRLElist(int[] nums) { List<Integer> list=new ArrayList<Integer>(); for(int i=0;i<nums.length;i++){ if(i%2!=0){ for(int j=0;j<nums[i-1];j++) list.add(nums[i]); } } int [] nsz=new int[list.size()]; for(int i=0;i<list.size();i++){ nsz[i]=list.get(i); } return nsz; } }
要注意的是list它是size（）。而数组是length
1365. 有多少小于当前数字的数字
给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。
换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。
以数组形式返回答案。
class Solution { public int[] smallerNumbersThanCurrent(int[] nums) { int []sum=new int[nums.length]; for(int i=0;i<nums.length;i++){ for(int j=0;j<nums.length;j++){ if(j!= i&&nums[j] < nums[i]) sum[i]++; } } return sum; } }
不难
20201127
1342. 将数字变成 0 的操作次数
给你一个非负整数 num ，请你返回将它变成 0 所需要的步数。 如果当前数字是偶数，你需要把它除以 2 ；否则，减去 1 。
class Solution { public int numberOfSteps (int num) { int sum=0; while(num!=0){ sum++; if(num%2==0) num=num/2; else num=num-1; } return sum; } }
1295. 统计位数为偶数的数字
给你一个整数数组 nums，请你返回其中位数为 偶数 的数字的个数。
class Solution { public int findNumbers(int[] nums) { int sum=0; for(int i=0;i<nums.length;i++){ char[] chars = String.valueOf(nums[i]).toCharArray(); if(chars.length%2==0) sum++; } return sum; } }
char[] chars = String.valueOf(nums[i]).toCharArray();
1450. 在既定时间做作业的学生人数
给你两个整数数组 startTime（开始时间）和 endTime（结束时间），并指定一个整数 queryTime 作为查询时间。
已知，第 i 名学生在 startTime[i] 时开始写作业并于 endTime[i] 时完成作业。
请返回在查询时间 queryTime 时正在做作业的学生人数。形式上，返回能够使 queryTime 处于区间 [startTime[i], endTime[i]]（含）的学生人数。
class Solution { public int busyStudent(int[] startTime, int[] endTime, int queryTime) { int sum=0; for(int i=0;i<startTime.length;i++){ if(startTime[i]<=queryTime&&endTime[i]>=queryTime) sum++; } return sum; } }
LCP 17. 速算机器人
小扣在秋日市集发现了一款速算机器人。店家对机器人说出两个数字（记作 x 和 y），请小扣说出计算指令：
"A"运算：使x = 2 * x + y；"B"运算：使y = 2 * y + x。
在本次游戏中，店家说出的数字为 x = 1 和 y = 0，小扣说出的计算指令记作仅由大写字母 A、B 组成的字符串 s，字符串中字符的顺序表示计算顺序，请返回最终 x 与 y 的和为多少。
class Solution { public int calculate(String s) { int x=1,y=0; for(int i=0;i<s.length();i++){ if('A'==s.charAt(i)) x = 2 * x + y; else y = 2 * y + x; } return x+y; } }
182. 查找重复的电子邮箱
编写一个 SQL 查询，查找 Person 表中所有重复的电子邮箱。
# Write your MySQL query statement below SELECT DISTINCT a.Email FROM Person a,Person b WHERE a.id != b.id AND a.Email=b.Email
不能忘记distinct
595. 大的国家
如果一个国家的面积超过 300 万平方公里，或者人口超过 2500 万，那么这个国家就是大国家。
编写一个 SQL 查询，输出表中所有大国家的名称、人口和面积。
# Write your MySQL query statement below SELECT name,population,area FROM World WHERE population>25000000 OR area>=3000000
20201128
1534. 统计好三元组
给你一个整数数组 arr ，以及 a、b 、c 三个整数。请你统计其中好三元组的数量。
如果三元组 (arr[i], arr[j], arr[k]) 满足下列全部条件，则认为它是一个 好三元组 。
0 <= i < j < k < arr.length|arr[i] - arr[j]| <= a|arr[j] - arr[k]| <= b|arr[i] - arr[k]| <= c
其中 |x| 表示 x 的绝对值。
返回 好三元组的数量 。
class Solution { public int countGoodTriplets(int[] arr, int a, int b, int c) { int sum=0; for(int i=0;i<arr.length;i++){ for(int j=i+1;j<arr.length;j++){ for(int k=j+1;k<arr.length;k++){ int s1=0,s2=0,s3=0; if(arr[i]>=arr[j]) s1=arr[i]-arr[j]; else s1=arr[j]-arr[i]; if(arr[k]>=arr[j]) s2=arr[k]-arr[j]; else s2=arr[j]-arr[k]; if(arr[i]>=arr[k]) s3=arr[i]-arr[k]; else s3=arr[k]-arr[i]; if(s1<=a&&s2<=b&&s3<=c) sum++; } } } return sum; } }
剑指 Offer 17. 打印从1到最大的n位数
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
示例 1:
输入: n = 1 输出: [1,2,3,4,5,6,7,8,9]
说明：
- 用返回一个整数列表来代替打印
- n 为正整数
class Solution { public int[] printNumbers(int n) { int ss = (int)Math.pow(10,n)-1; int a[]=new int [ss]; for(int i=0;i<ss;i++) a[i]=i+1; return a; } }
注意一下Math.pow返回不是int就行，强制转换。
657. 机器人能否返回原点
在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。
移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。
class Solution { public boolean judgeCircle(String moves) { int a=0,b=0,c=0,d=0; for(int i=0;i<moves.length();i++){ if(moves.charAt(i)=='R') a++; if(moves.charAt(i)=='L') b++; if(moves.charAt(i)=='D') c++; if(moves.charAt(i)=='U') d++; } if(a==b&&c==d) return true; else return false; } }
1299. 将每个元素替换为右侧最大元素
给你一个数组 arr ，请你将每个元素用它右边最大的元素替换，如果是最后一个元素，用 -1 替换。
完成所有替换操作后，请你返回这个数组。
class Solution { public int[] replaceElements(int[] arr) { int brr[]=new int[arr.length]; for(int i=0;i<arr.length;i++){ int max=0; for(int j=i+1;j<arr.length;j++){ if(arr[j]>max) max=arr[j]; } brr[i]=max; } brr[arr.length-1]=-1; return brr; } }
1464. 数组中两元素的最大乘积
给你一个整数数组 nums，请你选择数组的两个不同下标 i 和 j，使 (nums[i]-1)*(nums[j]-1) 取得最大值。
请你计算并返回该式的最大值。
class Solution { public int maxProduct(int[] nums) { int max=0; for(int i=0;i<nums.length;i++){ for(int j=i+1;j<nums.length;j++){ if((nums[i]-1)*(nums[j]-1)>max) max=(nums[i]-1)*(nums[j]-1); } } return max; } }
20201129
1304. 和为零的N个唯一整数
给你一个整数 n，请你返回 任意 一个由 n 个 各不相同 的整数组成的数组，并且这 n 个数相加和为 0 。
class Solution { public int[] sumZero(int n) { int x[]=new int[n]; int sum=0; for(int i=0;i<n-1;i++){ x[i]=i+1; sum+=x[i]; } x[n-1]=0-sum; return x; } }
char[] chars = String.valueOf(nums[i]).toCharArray();
剑指 Offer 05. 替换空格
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
class Solution { public String replaceSpace(String s) { String ss=s.replace(" ","%20"); return ss; } }
620. 有趣的电影
某城市开了一家新的电影院，吸引了很多人过来看电影。该电影院特别注意用户体验，专门有个 LED显示板做电影推荐，上面公布着影评和相关电影描述。
作为该电影院的信息部主管，您需要编写一个 SQL查询，找出所有影片描述为非 boring (不无聊) 的并且 id 为奇数 的影片，结果请按等级 rating 排列。
# Write your MySQL query statement below SELECT * FROM cinema WHERE id%2=1 AND description!='boring' ORDER BY rating DESC
344. 反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符
class Solution { public void reverseString(char[] s) { for(int i=0;i<s.length/2;i++){ char a =s[i]; s[i]=s[s.length-1-i]; s[s.length-1-i] =a; } } }
905. 按奇偶排序数组
给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。
你可以返回满足此条件的任何数组作为答案。
class Solution { public int[] sortArrayByParity(int[] A) { List<Integer> ou =new ArrayList<>(); List<Integer> ji =new ArrayList<>(); for(int i=0;i<A.length;i++){ if(A[i]%2==0) ou.add(A[i]); else ji.add(A[i]); } int []ss = new int[ou.size()+ji.size()]; for(int i=0;i<ou.size();i++){ ss[i]=ou.get(i); } for(int i=0;i<ji.size();i++){ ss[i+ou.size()]=ji.get(i); } return ss; } }
这道题循环太多，过于耗时了，必定有更好的方法。
20201130
627. 变更性别
给定一个 salary 表，如下所示，有 m = 男性 和 f = 女性 的值。交换所有的 f 和 m 值（例如，将所有 f 值更改为 m，反之亦然）。要求只使用一个更新（Update）语句，并且没有中间的临时表。
注意，您必只能写一个 Update 语句，请不要编写任何 Select 语句。
方法一：update salary set sex=if(sex = "m","f","m") 方法二：UPDATE salary SET sex = CASE sex WHEN "m" THEN "f" ELSE "m" END;
学到了
原来sql语句也包括if-else和case when
1672. 最富有客户的资产总量
给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。
客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。
class Solution { public int maximumWealth(int[][] accounts) { int max=0; for(int i=0;i<accounts.length;i++){ int sum=0; for(int j=0;j<accounts[i].length;j++){ sum+=accounts[i][j]; if(max<sum) max=sum; } } return max; } }
今天学习了二维数组，arr.length是二维数组的行数，也是一维数组的个数。arr[i].length是每一个一维数组里包含数的多少，是列数。
709. 转换成小写字母
实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。
class Solution { public String toLowerCase(String str) { char []cc =String.valueOf(str).toCharArray(); for(int i =0;i<cc.length;i++){ if(cc[i]<='Z'&&cc[i]>='A') cc[i]+=32; } return String.valueOf(cc); } }
ASCII码：
a-z：97-122 A-Z：65-90 0-9：48-57
1351. 统计有序矩阵中的负数
给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。
请你统计并返回 grid 中 负数 的数目。
class Solution { public int countNegatives(int[][] grid) { int sum=0; for(int i=0;i<grid.length;i++){ for(int j=0;j<grid[i].length;j++){ if(grid[i][j]<0) sum++; } } return sum; } }
就是每一行列的数目是arr[i].length
1252. 奇数值单元格的数目
给你一个 n 行 m 列的矩阵，最开始的时候，每个单元格中的值都是 0。
另有一个索引数组 indices，indices[i] = [ri, ci] 中的 ri 和 ci 分别表示指定的行和列（从 0 开始编号）。
你需要将每对 [ri, ci] 指定的行和列上的所有单元格的值加 1。
请你在执行完所有 indices 指定的增量操作后，返回矩阵中 「奇数值单元格」 的数目。
class Solution { public int oddCells(int n, int m, int[][] indices) { int[][] chushi =new int[n][m]; int x=0,y=0,sum=0; for(int i=0;i<indices.length;i++){ x = indices[i][0]; for (int j = 0; j < m; j++){ chushi[x][j] = chushi[x][j] + 1; } y = indices[i][1]; for (int k = 0; k < n; k++){ chushi[k][y] = chushi[k][y] + 1; } } for(int i=0;i<n;i++){ for(int j=0;j<m;j++){ if(chushi[i][j]%2!=0) sum++; } } return sum; } }
这道题好难啊。不太明白一整列一整行怎么直接增加。看了题解。
定义了x和y是为了在改变列时不改变行这种？应该是。
20201201
面试题 02.03. 删除中间节点
实现一种算法，删除单向链表中间的某个节点（即不是第一个或最后一个节点），假定你只能访问该节点。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: void deleteNode(ListNode* node) { ListNode *p = node->next; node->val=node->next->val; node->next=p->next; delete p; } };
1290. 二进制链表转整数
给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。
请你返回该链表所表示数字的 十进制值 。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: int getDecimalValue(ListNode* head) { int sum=0,zong=0,zhi=0; ListNode *p=head; ListNode*q=head; while(p!=NULL){ p=p->next; zong++; } while(q!=NULL){ sum+=(int)pow(2,zong-zhi-1)*q->val; q=q->next; zhi++; } return sum; } };
官方：学习一下二进制转十位制的新的算法
class Solution { public: int getDecimalValue(ListNode* head) { ListNode* cur = head; int ans = 0; while (cur != nullptr) { ans = ans * 2 + cur->val; cur = cur->next; } return ans; } };
题解还有String拿到所有位，然后Integer.valueOf(str,2);把二进制的str转换为int
1528. 重新排列字符串
给你一个字符串 s 和一个 长度相同 的整数数组 indices 。
请你重新排列字符串 s ，其中第 i 个字符需要移动到 indices[i] 指示的位置。
返回重新排列后的字符串。
class Solution { public String restoreString(String s, int[] indices) { String nn=""; for(int i=0;i<indices.length;i++){ for(int j=0;j<indices.length;j++){ if(indices[j]==i) nn+=s.charAt(j); } } return nn; } }
很慢但是自己想透了
官方：所以还是没想透
class Solution { public String restoreString(String s, int[] indices) { int length = s.length(); char[] result = new char[length]; for (int i = 0; i < length; i++) { result[indices[i]] = s.charAt(i); } return new String(result); } }
237. 删除链表中的节点
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: void deleteNode(ListNode* node) { node->val=node->next->val; node->next=node->next->next; } };
这题真的有点毛病
1266. 访问所有点的最小时间
平面上有 n 个点，点的位置用整数坐标表示 points[i] = [xi, yi]。请你计算访问所有这些点需要的最小时间（以秒为单位）。
你可以按照下面的规则在平面上移动：
- 每一秒沿水平或者竖直方向移动一个单位长度，或者跨过对角线（可以看作在一秒内向水平和竖直方向各移动一个单位长度）。
- 必须按照数组中出现的顺序来访问这些点。
class Solution { public int minTimeToVisitAllPoints(int[][] points) { int sum=0; for(int x=points.length-1;x>0;x--){ int a = 0; if(Math.abs(points[x][0]-points[x-1][0])>Math.abs(points[x][1]-points[x-1][1])) a = Math.abs(points[x][0]-points[x-1][0]); else a = Math.abs(points[x][1]-points[x-1][1]); sum+=a; System.out.println(sum); } return sum; } }
不难
20201202
今天有点不在状态，唉。
88. 合并两个有序数组
给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
说明：
- 初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
- 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
class Solution { public void merge(int[] nums1, int m, int[] nums2, int n) { for(int i=1;i<=n;i++) nums1[m+i-1]=nums2[i-1]; for(int i=0;i<nums1.length;i++) { for(int j=i+1;j<nums1.length;j++) if(nums1[j]<nums1[i]) { int temp = nums1[i]; nums1[i]=nums1[j]; nums1[j]=temp; } } } }
942. 增减字符串匹配
给定只含 "I"（增大）或 "D"（减小）的字符串 S ，令 N = S.length。
返回 [0, 1, ..., N] 的任意排列 A 使得对于所有 i = 0, ..., N-1，都有：
- 如果
S[i] == "I"，那么A[i] < A[i+1] - 如果
S[i] == "D"，那么A[i] > A[i+1]
class Solution { public int[] diStringMatch(String S) { int []ss = new int [S.length()+1]; int a=0,b=S.length(); for(int i=0;i<S.length();i++){ if(S.charAt(i) == 'I') ss[i]=a++; else ss[i]=b--; } ss[S.length()]=a; return ss; } }
开始连题目都读不懂，绝了
1460. 通过翻转子数组使两个数组相等
给你两个长度相同的整数数组 target 和 arr 。
每一步中，你可以选择 arr 的任意 非空子数组 并将它翻转。你可以执行此过程任意次。
如果你能让 arr 变得与 target 相同，返回 True；否则，返回 False 。
class Solution { public boolean canBeEqual(int[] target, int[] arr) { Arrays.sort(target); Arrays.sort(arr); int n=0; for(int i=0;i<target.length;i++){ if(target[i]==arr[i]) n++; } if(n==target.length) return true; else return false; } }
题目老吓人了，其实就是两个数组排序后是不是想等，唉。
学到的数组排序是Arrays.sort(arr);
1051. 高度检查器
学校在拍年度纪念照时，一般要求学生按照 非递减 的高度顺序排列。
请你返回能让所有学生以 非递减 高度排列的最小必要移动人数。
注意，当一组学生被选中时，他们之间可以以任何可能的方式重新排序，而未被选中的学生应该保持不动。
class Solution { public int heightChecker(int[] heights) { int mm[] = new int [heights.length]; for(int i=0;i<heights.length;i++){ mm[i]=heights[i]; } Arrays.sort(heights); int n=0; for(int i=0;i<heights.length;i++){ if(mm[i]!=heights[i]) n++; } return n; } }
就看原来和现在变了多少
1502. 判断能否形成等差数列
给你一个数字数组 arr 。
如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 等差数列 。
如果可以重新排列数组形成等差数列，请返回 true ；否则，返回 false 。
class Solution { public boolean canMakeArithmeticProgression(int[] arr) { Arrays.sort(arr); int n=arr[1]-arr[0],m=0; for(int i=0;i<arr.length-1;i++){ if((arr[i+1]-arr[i])==n) m++; } if(m==arr.length-1) return true; else return false; } }
面试题 01.01. 判定字符是否唯一
实现一个算法，确定一个字符串 s 的所有字符是否全都不同。
class Solution { public boolean isUnique(String astr) { for(int i=0;i<astr.length();i++){ for(int j=i+1;j<astr.length();j++){ if(astr.charAt(i)==astr.charAt(j)) return false; } } return true; } }
20201203
977. 有序数组的平方
给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
class Solution { public int[] sortedSquares(int[] nums) { for(int i=0;i<nums.length;i++){ nums[i] = (int)Math.pow(nums[i],2); } Arrays.sort(nums); return nums; } }
剑指 Offer 06. 从尾到头打印链表
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: vector<int> reversePrint(ListNode* head) { vector<int> ans; while(head!=NULL){ ans.push_back(head->val); head=head->next; } reverse(ans.begin(),ans.end()); return ans; } };
1323. 6 和 9 组成的最大数字
给你一个仅由数字 6 和 9 组成的正整数 num。
你最多只能翻转一位数字，将 6 变成 9，或者把 9 变成 6 。
请返回你可以得到的最大数字。
class Solution { public int maximum69Number (int num) { char[] chars = String.valueOf(num).toCharArray(); for(int i=0;i<chars.length;i++){ if(chars[i]-'0'==6){ chars[i]='9'; break; } } String ss =""; int n=0; for(int i=0;i<chars.length;i++){ ss+=chars[i]; } n=Integer.parseInt(ss);; return n; } }
int a = Integer.parseInt(str);
804. 唯一摩尔斯密码词
国际摩尔斯密码定义一种标准编码方式，将每个字母对应于一个由一系列点和短线组成的字符串， 比如: "a" 对应 ".-", "b" 对应 "-...", "c" 对应 "-.-.", 等等。
为了方便，所有26个英文字母对应摩尔斯密码表如下：[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
给定一个单词列表，每个单词可以写成每个字母对应摩尔斯密码的组合。例如，"cab" 可以写成 "-.-..--..."，(即 "-.-." + ".-" + "-..." 字符串的结合)。我们将这样一个连接过程称作单词翻译。
返回我们可以获得所有词不同单词翻译的数量。
class Solution { public int uniqueMorseRepresentations(String[] words) { String fuhao[] = new String []{".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."}; HashSet<String> list = new HashSet<>(); for(int i=0;i<words.length;i++){ String temp=""; for(int j=0;j<words[i].length();j++){ temp+=fuhao[words[i].charAt(j)-'a']; } list.add(temp); } return list.size(); } }
832. 翻转图像
给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。
水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。
反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。
class Solution { public int[][] flipAndInvertImage(int[][] A) { int [][] B =new int [A.length][A[0].length]; for(int i=0;i<A.length;i++){ for(int j=0;j<A[i].length;j++){ B[i][j]=A[i][A[i].length-1-j]; if(B[i][j]==0) B[i][j]=1; else B[i][j]=0; } } return B; } }
20201204
1619. 删除某些元素后的数组均值
给你一个整数数组 arr ，请你删除最小 5% 的数字和最大 5% 的数字后，剩余数字的平均值。
与 标准答案 误差在 10-5 的结果都被视为正确结果。
class Solution { public double trimMean(int[] arr) { Arrays.sort(arr); int l=arr.length; int left=l/20; int right=l-left; double remain=l-left-left; double sum=0; for(int i=left;i<right;i++){ sum+=arr[i]; } return sum/remain; } }
1200. 最小绝对差
给你个整数数组 arr，其中每个元素都 不相同。
请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。
class Solution { public List<List<Integer>> minimumAbsDifference(int[] arr) { Arrays.sort(arr); int sum=30; List<List<Integer>> aa =new ArrayList<List<Integer>>(); for(int i=0;i<arr.length-1;i++){ if(arr[i+1]-arr[i]<=sum){ sum=arr[i+1]-arr[i]; } } for(int i=0;i<arr.length-1;i++){ if(arr[i+1]-arr[i]==sum){ aa.add(Arrays.asList(arr[i], arr[i + 1])); } } return aa; } }
Arrays.asList该方法是将数组转化成List集合的方法。
List<String> list = Arrays.asList("a","b","c");
191. 位1的个数
编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为汉明重量）。
提示：
- 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
- 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数
-3。
public class Solution { // you need to treat n as an unsigned value public int hammingWeight(int n) { String ss =Integer.toBinaryString(n); System.out.println(ss); int sum=0; for(int i=0;i<ss.length();i++){ if(ss.charAt(i)=='1') sum++; } return sum; } }
500. 键盘行
给定一个单词列表，只返回可以使用在键盘同一行的字母打印出来的单词。键盘如下图所示。
class Solution { public String[] findWords(String[] words) { String str1 = "qwertyuiopQWERTYUIOP"; String str2 = "asdfghjklASDFGHJKL"; String str3 = "zxcvbnmZXCVBNM"; ArrayList<String> tmp=new ArrayList<>(); for(int i=0;i<words.length;i++){ char[] chs=words[i].toCharArray(); int str1Count=0,str2Count=0,str3Count=0; for(int j=0;j<chs.length;j++){ if(str1.contains(chs[j]+"")){ str1Count++; } if(str2.contains(chs[j]+"")){ str2Count++; } if(str3.contains(chs[j]+"")){ str3Count++; } } if((str1Count==0&&str2Count==0)|| (str1Count==0&&str3Count==0)|| (str2Count==0&&str3Count==0)){ tmp.add(new String(chs)); } } return tmp.toArray(new String[tmp.size()]); } }
class Solution { public String[] findWords(String[] words) { String str1 = "qwertyuiopQWERTYUIOP"; String str2 = "asdfghjklASDFGHJKL"; String str3 = "zxcvbnmZXCVBNM"; String[] res=new String[words.length]; ArrayList<String> tmp=new ArrayList<>(); for(int i=0;i<words.length;i++){ char[] chs=words[i].toCharArray(); int str1Count=0,str2Count=0,str3Count=0; for(int j=0;j<chs.length;j++){ if(str1.contains(chs[j]+"")){ str1Count++; } if(str2.contains(chs[j]+"")){ str2Count++; } if(str3.contains(chs[j]+"")){ str3Count++; } } if((str1Count==0&&str2Count==0)|| (str1Count==0&&str3Count==0)|| (str2Count==0&&str3Count==0)){ tmp.add(new String(chs)); } } return tmp.toArray(new String[tmp.size()]); ArrayList<String> tmp=new ArrayList<>();
1217. 玩筹码
数轴上放置了一些筹码，每个筹码的位置存在数组 chips 当中。
你可以对 任何筹码 执行下面两种操作之一（不限操作次数，0 次也可以）：
- 将第
i个筹码向左或者右移动 2 个单位，代价为 0。 - 将第
i个筹码向左或者右移动 1 个单位，代价为 1。
最开始的时候，同一位置上也可能放着两个或者更多的筹码。
返回将所有筹码移动到同一位置（任意位置）上所需要的最小代价
class Solution { public int minCostToMoveChips(int[] position) { int odd = 0, even = 0; for (int i = 0; i < position.length; i++) { if (position[i] % 2 == 0) { even++; } else if (position[i] % 2 != 0) { odd++; } } if(even>odd) return odd; else return even; } }
移动2个位置不需要代价，那么奇数位置移到奇数位置不用代价，偶数位置移到偶数位置不用代价，那就只需要统计奇数位置和偶数位置的个数，找到小的
20201206
258. 各位相加
给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。
class Solution { public int addDigits(int num) { return (num - 1) % 9 + 1; } }
任意num为9的倍数时，其位数最终和必为0，求余
面试题 08.03. 魔术索引
魔术索引。 在数组A[0...n-1]中，有所谓的魔术索引，满足条件A[i] = i。给定一个有序整数数组，编写一种方法找出魔术索引，若有的话，在数组A中找出一个魔术索引，如果没有，则返回-1。
若有多个魔术索引，返回索引值最小的一个。
class Solution { public int findMagicIndex(int[] nums) { int chu=-5; for(int i=0;i<nums.length;i++){ if(i==nums[i]){ chu=i; break; } } if(chu==-5) return -1; else return chu; } }
不难
1491. 去掉最低工资和最高工资后的工资平均值
给你一个整数数组 salary ，数组里每个数都是 唯一 的，其中 salary[i] 是第 i 个员工的工资。
请你返回去掉最低工资和最高工资以后，剩下员工工资的平均值。
class Solution { public double average(int[] salary) { Arrays.sort(salary); double num=0; for(int i=1;i<salary.length-1;i++){ num+=salary[i]; } return num/(salary.length-2); } }
avg需要数据类型是double，不能忘记这个
183. 从不订购的客户
某网站包含两个表，Customers 表和 Orders 表。编写一个 SQL 查询，找出所有从不订购任何东西的客户。
# Write your MySQL query statement below SELECT Name as Customers FROM Customers WHERE Customers.Id <>ALL (SELECT CustomerId FROM Orders)
<>ALL不等于子查询结果中的任何一个值
1550. 存在连续三个奇数的数组
给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
class Solution { public boolean threeConsecutiveOdds(int[] arr) { for(int i=1;i<arr.length-1;i++){ if(arr[i-1]%2!=0&&arr[i]%2!=0&&arr[i+1]%2!=0) return true; } return false; } }
确定好数组范围
20201207
867. 转置矩阵
给定一个矩阵 A， 返回 A 的转置矩阵。
矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。
class Solution { public int[][] transpose(int[][] A) { int B[][]=new int[A[0].length][A.length]; for(int i=0;i<A.length;i++){ for(int j=0;j<A[i].length;j++){ B[j][i]=A[i][j]; } } return B; } }
我憨憨了，B的定义反过来就是了，我报错了半天
766. 托普利茨矩阵
如果矩阵上每一条由左上到右下的对角线上的元素都相同，那么这个矩阵是托普利茨矩阵 。
给定一个 M x N 的矩阵，当且仅当它是托普利茨矩阵时返回 True。
class Solution { public boolean isToeplitzMatrix(int[][] matrix) { for(int i=1;i<matrix.length;i++){ for(int j=1;j<matrix[i].length;j++){ if(matrix[i-1][j-1]!=matrix[i][j]){ return false; } } } return true; } }
我傻了，不应该去数等于，应该直接返回不等于的。没想通刚开始
961. 重复 N 次的元素
在大小为 2N 的数组 A 中有 N+1 个不同的元素，其中有一个元素重复了 N 次。
返回重复了 N 次的那个元素。
class Solution { public int repeatedNTimes(int[] A) { Arrays.sort(A); for(int i=1;i<A.length;i++){ if(A[i-1]==A[i]) return A[i]; } return 0; } }
慢是慢，但是简单
剑指 Offer 57. 和为s的两个数字
输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。
class Solution { public int[] twoSum(int[] nums, int target) { int ans[]=new int[2]; int i=0,j=nums.length-1; while(i<j){ int s=nums[i]+nums[j]; if(s<target){ i++; }else if(s>target){ j--; }else{ ans[0]=nums[i]; ans[1]=nums[j]; break; } } return ans; } }
好家伙，用for直接超时了。看了眼题解评论，这一招太妙了。
860. 柠檬水找零
在柠檬水摊上，每一杯柠檬水的售价为 5 美元。
顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。
每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。
注意，一开始你手头没有任何零钱。
如果你能给每位顾客正确找零，返回 true ，否则返回 false 。
class Solution { public boolean lemonadeChange(int[] bills) { int wu=0,shi=0; for(int i=0;i<bills.length;i++){ if(bills[i]==5) wu++; if(bills[i]==10){ shi++; if(wu==0) return false; else wu--; } if(bills[i]==20){ if(wu>=3&&shi==0) wu-=3; else if(wu>=1&&shi>=1){ wu--; shi--; } else return false; } } return true; } }
搞清楚了可太牛了，yeah
20201208
1678. 设计 Goal 解析器
请你设计一个可以解释字符串 command 的 Goal 解析器 。command 由 "G"、"()" 和/或 "(al)" 按某种顺序组成。Goal 解析器会将 "G" 解释为字符串 "G"、"()" 解释为字符串 "o" ，"(al)" 解释为字符串 "al" 。然后，按原顺序将经解释得到的字符串连接成一个字符串。
给你字符串 command ，返回Goal解析器 对command 的解释结果。
class Solution { public String interpret(String command) { if (command == null) { return ""; } int index = 0; String sb = ""; while (index < command.length()) { if (command.charAt(index) == 'G') { sb+="G"; index++; } else if (command.charAt(index) == '(' && command.charAt(index + 1) == ')') { sb+="o"; index = index + 2; } else if (command.charAt(index) == '(' && command.charAt(index + 1) == 'a') { sb+="al"; index = index + 4; } } return sb; } }
509. 斐波那契数
斐波那契数，通常用 F(n) 表示，形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
F(0) = 0, F(1) = 1 F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
给定 N，计算 F(N)。
class Solution { public int fib(int n) { int sum=0; if(n==0) sum=0; if(n==1) sum=1; if(n>1){ sum+=fib(n-1)+fib(n-2); } return sum; } }
883. 三维形体投影面积
在 N * N 的网格中，我们放置了一些与 x，y，z 三轴对齐的 1 * 1 * 1 立方体。
每个值 v = grid[i][j] 表示 v 个正方体叠放在单元格 (i, j) 上。
现在，我们查看这些立方体在 xy、yz 和 zx 平面上的投影。
投影就像影子，将三维形体映射到一个二维平面上。
在这里，从顶部、前面和侧面看立方体时，我们会看到“影子”。
返回所有三个投影的总面积。
class Solution { public int projectionArea(int[][] grid) { int sum=0; int row = 0; //记录每一行最大值(xz平面) int []col = new int[grid[0].length]; //记录每一列最大值(yz平面) for(int i = 0; i < grid.length; i++){ row = 0; for(int j = 0; j < grid[i].length; j++){ if(grid[i][j] > 0){ sum++; } row = Math.max(row, grid[i][j]); col[j] = Math.max(col[j], grid[i][j]); } sum += row; } for(int i : col){ sum += i; } return sum; } }
正视图：每一行最大值之和；
侧视图：每一列最大值之和；
俯视图：柱子个数；
884. 两句话中的不常见单词
给定两个句子 A 和 B 。 （句子是一串由空格分隔的单词。每个单词仅由小写字母组成。）
如果一个单词在其中一个句子中只出现一次，在另一个句子中却没有出现，那么这个单词就是不常见的。
返回所有不常用单词的列表。
您可以按任何顺序返回列表。
class Solution { public String[] uncommonFromSentences(String A, String B) { String []aStr =A.split(" "); String []bStr =B.split(" "); List<String> list = new ArrayList<>(); Map<String, Integer> map = new HashMap<>(); for (String a : aStr) map.put(a, map.getOrDefault(a, 0)+1); for (String b : bStr) if (map.getOrDefault(b, 0) <= 0) map.put(b, map.getOrDefault(b, 0)-1); else if (map.getOrDefault(b, 0) == 1) map.put(b, map.getOrDefault(b, 0)+1); for (Map.Entry<String, Integer> e : map.entrySet()) if (Math.abs(e.getValue()) == 1) list.add(e.getKey()); return list.toArray(new String[list.size()]); } }
Map.getOrDefault()方法,当Map集合中有这个key时，就使用这个key值，如果没有就使用默认值defaultValue
389. 找不同
给定两个字符串 s 和 t，它们只包含小写字母。
字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。
请找出在 t 中被添加的字母。
class Solution { public char findTheDifference(String s, String t) { int tSum = 0, sSum = 0; for(int i = 0; i < t.length(); i++){ tSum += (int)t.charAt(i); } for(int i = 0; i < s.length(); i++){ sSum += (int)s.charAt(i); } return (char)(tSum-sSum); } }
我想的就是双重循环比对，大佬就直接ASCII码，太绝了ASCII码。
20201209
1572. 矩阵对角线元素的和
给你一个正方形矩阵 mat，请你返回矩阵对角线元素的和。
请你返回在矩阵主对角线上的元素和副对角线上且不在主对角线上元素的和。
class Solution { public int diagonalSum(int[][] mat) { int sum=0; for(int i=0;i<mat.length;i++){ for(int j=0;j<mat[i].length;j++){ if(i==j){ sum+=mat[i][j]; } else if(i+j==mat.length-1){ sum+=mat[i][j]; } } } return sum; } }
1370. 上升下降字符串
给你一个字符串s ，请你根据下面的算法重新构造字符串：- 从
s中选出 最小 的字符，将它 接在 结果字符串的后面。 - 从
s剩余字符中选出 最小 的字符，且该字符比上一个添加的字符大，将它 接在 结果字符串后面。 - 重复步骤 2 ，直到你没法从
s中选择字符。 - 从
s中选出 最大 的字符，将它 接在 结果字符串的后面。 - 从
s剩余字符中选出 最大 的字符，且该字符比上一个添加的字符小，将它 接在 结果字符串后面。 - 重复步骤 5 ，直到你没法从
s中选择字符。 - 重复步骤 1 到 6 ，直到
s中所有字符都已经被选过。
s 中字符重新排序后的 结果字符串 。
class Solution { public String sortString(String s) { int[] num = new int[26]; for (int i = 0; i < s.length(); i++) { num[s.charAt(i) - 'a']++; } StringBuffer ret = new StringBuffer(); while (ret.length() < s.length()) { for (int i = 0; i < 26; i++) { if (num[i] > 0) { ret.append((char) (i + 'a')); num[i]--; } } for (int i = 25; i >= 0; i--) { if (num[i] > 0) { ret.append((char) (i + 'a')); num[i]--; } } } return ret.toString(); } }
建立数组并且通过nums[i]的个数来实现，这个想法其实是很绝的
String对象是不可变对象,每次操作String都会建立新的对象来保存新的值。
StringBuffer对象实例化后,只对这一个对象操作。
1221. 分割平衡字符串
在一个「平衡字符串」中，'L' 和 'R' 字符的数量是相同的。
给出一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。
返回可以通过分割得到的平衡字符串的最大数量。
class Solution { public int balancedStringSplit(String s) { int balance=0,count=0; for (int i = 0; i < s.length(); i++) { if (s.charAt(i)=='L') { count++; } if (s.charAt(i)=='R') { count--; } if (count==0) { balance++; } } return balance; } }
卡题目bug
剑指 Offer 22. 链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode getKthFromEnd(ListNode head, int k) { ListNode fast = head; while(fast!=null) { fast = fast.next; if(k==0) { head = head.next; }else { k--; } } return head; } }
1436. 旅行终点站
给你一份旅游线路图，该线路图中的旅行线路用数组 paths 表示，其中 paths[i] = [cityAi, cityBi] 表示该线路将会从 cityAi 直接前往 cityBi 。请你找出这次旅行的终点站，即没有任何可以通往其他城市的线路的城市。
题目数据保证线路图会形成一条不存在循环的线路，因此只会有一个旅行终点站。
class Solution { public String destCity(List<List<String>> paths) { Map<String, Integer> map = new HashMap<>(); for(List<String> list : paths){ map.put(list.get(0),1); } for(List<String> list : paths){ if(map.get(list.get(1))==null) return list.get(1); } return null; } }
map计数。
遍历List<List<String>> paths是for(List<String> list : paths)
20201210
461. 汉明距离
两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。
给出两个整数 x 和 y，计算它们之间的汉明距离。
注意：0 ≤ x, y < 231.
class Solution { public int hammingDistance(int x, int y) { int count=0; if(x==y) return 0; while(x!=0||y!=0){ if(x%2!=y%2) count++; x=x/2; y=y/2; } return count; } }
1021. 删除最外层的括号
有效括号字符串为空 ("")、"(" + A + ")" 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。例如，""，"()"，"(())()" 和 "(()(()))" 都是有效的括号字符串。
如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。
给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + ... + P_k，其中 P_i 是有效括号字符串原语。
对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。
class Solution { public String removeOuterParentheses(String S) { StringBuilder res = new StringBuilder(); int left = 0, right = 0; for (char c: S.toCharArray()) { if (c == '(') left++; if (left > 1) res.append(c); if (c == ')') left--; } return res.toString(); } }
852. 山脉数组的峰顶索引
我们把符合下列属性的数组 A 称作山脉：
A.length >= 3- 存在
0 < i < A.length - 1使得A[0] < A[1] < ... A[i-1] < A[i] > A[i+1] > ... > A[A.length - 1]
给定一个确定为山脉的数组，返回任何满足 A[0] < A[1] < ... A[i-1] < A[i] > A[i+1] > ... > A[A.length - 1] 的 i 的值。
class Solution { public int peakIndexInMountainArray(int[] arr) { int xia=0; for(int i=0;i<arr.length;i++){ if(arr[i]>arr[xia]){ xia=i; } } return xia; } }
最大值索引，题目难读
859. 亲密字符串
给定两个由小写字母构成的字符串 A 和 B ，只要我们可以通过交换 A 中的两个字母得到与 B 相等的结果，就返回 true ；否则返回 false 。
交换字母的定义是取两个下标 i 和 j （下标从 0 开始），只要 i!=j 就交换 A[i] 和 A[j] 处的字符。例如，在 "abcd" 中交换下标 0 和下标 2 的元素可以生成 "cbad" 。
class Solution { public boolean buddyStrings(String A, String B) { if(A.length()!=B.length()) return false; else if(A.equals(B)){ for (int i = 0; i < A.length(); i++) if (A.indexOf(A.charAt(i)) != i) return true; } char strA1 = 0, strA2 = 0, strB1 = 0, strB2 = 0; int count=0; for(int i=0;i<A.length();i++){ if(A.charAt(i)!=B.charAt(i)){ count++; if (count == 1) { strA1 = A.charAt(i); strB1 = B.charAt(i); } if (count == 2) { strA2 = A.charAt(i); strB2 = B.charAt(i); } } if (count > 2) return false; } return count == 2 && strA1 == strB2 && strA2 == strB1; } }
想到了count就好写很多了。
876. 链表的中间结点
给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode middleNode(ListNode head) { ListNode slow = head, fast = head; while(fast != null && fast.next != null){ slow = slow.next; fast = fast.next.next; } return slow; } }
链表的快慢指针，fast每次走2，slow每次走1.在fast到结尾的时候，slow刚好在中间，这道题可真厉害。
slow = slow.next;fast = fast.next.next;
浙公网安备 33010602011771号