给你一个 32 位的有符号整数 x ，返回 x 中每位上的数字反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。
示例 1：
输入：x = 123
输出：321
示例 2：
输入：x = -123
输出：-321
示例 3：
输入：x = 120
输出：21
示例 4：
输入：x = 0
输出：0
class Solution {
public int reverse(int x) {
long temp = 0;
while(x != 0){
temp = temp * 10 + x % 10;
x /= 10;
}
if ((int)temp == temp){
return (int)temp;
}
else {
return 0;
}
}
}
给你一个数组 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] 。
示例 2：
输入：nums = [1,1,1,1,1]
输出：[1,2,3,4,5]
解释：动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。
示例 3：
输入：nums = [3,1,2,10,1]
输出：[3,4,6,16,17]
class Solution {
public int[] runningSum(int[] nums) {
int N = nums.length;
int[] result = new int[N];
result[0] = nums [0];
for (int i = 1; i < N; i++) {
result[i] = result[i - 1] + nums[i];
}
return result;
}
}
给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。
客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。
示例 1：
输入：accounts = [[1,2,3],[3,2,1]]
输出：6
解释：
第 1 位客户的资产总量 = 1 + 2 + 3 = 6
第 2 位客户的资产总量 = 3 + 2 + 1 = 6
两位客户都是最富有的，资产总量都是 6 ，所以返回 6 。
class Solution {
public int maximumWealth(int[][] accounts) {
int[] sum = new int[accounts.length];
for (int i = 0; i < accounts.length; i++){
for (int j = 0; j < accounts[i].length; j++){
sum[i] += accounts[i][j];
}
}
int max = sum[0];
for (int i = 1 ; i < sum.length; i++) {
if (sum[i] > max) {
max = sum[i];
}
}
return max;
}
}
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
示例 1：
输入: s = “abcdefg”, k = 2 输出: “cdefgab” 示例 2：
输入: s = “lrloseumgh”, k = 6 输出: “umghlrlose”
class Solution {
public String reverseLeftWords(String s, int n) {
return s.substring(n) + s.substring(0, n);
}
}
实现一种算法，删除单向链表中间的某个节点（即不是第一个或最后一个节点），假定你只能访问该节点。
示例：
输入：单向链表a->b->c->d->e->f中的节点c 结果：不返回任何数据，但该链表变为a->b->d->e->f
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public void deleteNode(ListNode node) {
node.val = node.next.val;
node.next = node.next.next;
}
}
给你一个数组 items ，其中 items[i] = [typei, colori, namei] ，描述第 i 件物品的类型、颜色以及名称。
另给你一条由两个字符串 ruleKey 和 ruleValue 表示的检索规则。
如果第 i 件物品能满足下述条件之一，则认为该物品与给定的检索规则 匹配 ：
ruleKey == "type" 且 ruleValue == typei 。ruleKey == "color" 且 ruleValue == colori 。ruleKey == "name" 且 ruleValue == namei 。统计并返回 匹配检索规则的物品数量 。
class Solution {
public int countMatches(List<List<String>> items, String ruleKey, String ruleValue) {
int result = 0;
switch (ruleKey) {
case "type":
for (int i = 0; i < items.size(); i++){
if (items.get(i).get(0).equals(ruleValue)) {
result += 1;
}
}
break;
case "color":
for (int i = 0; i < items.size(); i++){
if (items.get(i).get(1).equals(ruleValue)) {
result += 1;
}
}
break;
case "name":
for (int i = 0; i < items.size(); i++){
if (items.get(i).get(2).equals(ruleValue)) {
result += 1;
}
}
break;
}
return result;
}
}
给你一个整数数组 nums 。
如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i < j ，就可以认为这是一组 好数对 。
返回好数对的数目。
示例 1：
输入：nums = [1,2,3,1,1,3]
输出：4
解释：有 4 组好数对，分别是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始
示例 2：
输入：nums = [1,1,1,1]
输出：6
解释：数组中的每组数字都是好数对
示例 3：
输入：nums = [1,2,3]
输出：0
class Solution {
public int numIdenticalPairs(int[] nums) {
int result = 0;
int[] temp = new int[100];
for (int i : nums) {
temp[i - 1]++;
}
for (int i : temp){
if (i > 1){
int mul = 0;
for (int j = 1; j < i; j++){
mul += j;
}
result += mul;
}
}
return result;
}
}
给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
示例 1：
输入：x = 121
输出：true
示例 2：
输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3：
输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。
示例 4：
输入：x = -101
输出：false
class Solution {
public boolean isPalindrome(int x) {
if (x < 0) return false;
boolean result = true;
String str = Integer.toString(x);
char[] ch = str.toCharArray();
for (int i = 0; i <= ch.length / 2; i++) {
if (ch[i] != ch[ch.length - i - 1])
result = false;
}
return result;
}
}