力扣1344 时钟指针的夹角
1344. 时钟指针的夹角
给你两个数 hour 和 minutes 。请你返回在时钟上，由给定时间的时针和分针组成的较小角的角度（60 单位制）。
示例 1：
输入：hour = 12, minutes = 30 输出：165 示例 2：
输入：hour = 3, minutes = 30
输出；75
示例 3：
输入：hour = 3, minutes = 15
输出：7.5
示例 4：
输入：hour = 4, minutes = 50
输出：155
示例 5：
输入：hour = 12, minutes = 0
输出：0
提示：
1 <= hour <= 12
0 <= minutes <= 59
与标准答案误差在 10^-5 以内的结果都被视为正确结果。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/angle-between-hands-of-a-clock
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution {public:double angleClock(int hour, int minutes) {double min_angle_ratio = minutes/60.0;double min_angle = min_angle_ratio * 360;double hour_angle = hour * 30 + min_angle_ratio * 30;double cross = abs(hour_angle - min_angle);return cross < 360 - cross ? cross : 360 - cross;}};
力扣50 Pow（x，n）
50. Pow(x, n)
实现 pow(x, n) ，即计算 x 的 n 次幂函数。
示例 1:
输入: 2.00000, 10
输出: 1024.00000
示例 2:
输入: 2.10000, 3
输出: 9.26100
示例 3:
输入: 2.00000, -2
输出: 0.25000
解释: 2-2 = 1/22 = 1/4 = 0.25
说明:
-100.0 < x < 100.0
n 是 32 位有符号整数，其数值范围是 [−231, 231 − 1] 。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/powx-n
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
class Solution {public:double myPow(double x, int n) {if(x == 0)return 0;if(n == 0)return 1;if(n == 1)return x;if(n == -1)return 1/x;long long ret = 0;long long pownum = 2;long long absn = abs(n);while(pownum <= absn){ret++;pownum = pownum * 2;}long long remain = absn - (pownum / 2);if(n < 0)remain = -remain;double remainres = myPow(x, remain);while(ret--){x = x * x;}if(n < 0)return (1/x) * remainres;elsereturn x * remainres;}};
折木棍
题目描述
在你的面前从左到右摆放着n根长短不一的木棍，你每次可以折断一根木棍，并将折断后得到的两根木棍一左一右放在原来的位置（即若原木棍有左邻居，则两根新木棍必须放在左邻居的右边，若原木棍有右邻居，新木棍必须放在右邻居的左边，所有木棍保持左右排列）。折断后的两根木棍的长度必须为整数，且它们之和等于折断前的木棍长度。你希望最终从左到右的木棍长度单调不减，那么你需要折断多少次呢？
思路：
- 从后往前单调递减。
- 如果当前的木棍比右边的木棍长，将木棍分割成为如果小于等于右边木棍长度的木棍。
- 尽量保持平均大小，将略小的入栈。
int breakNum(vector<int>& nums) {
int ans = 0;
for (int i = nums.size() - 2; i >= 0; i--) {
if (nums[i + 1] >= nums[i]) continue;
int t = (nums[i] - 1) / nums[i + 1];
ans += t;
nums[i] /= (t + 1);
}
return ans;
}
作者：Ikaruga
链接：https://leetcode-cn.com/circle/discuss/eXOcnD/view/SecVmv/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
力扣 7 整数反转
7. 整数反转
给你一个 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
提示：
-231 <= x <= 231 - 1
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
对于这道题，需要记住的是，对于数字的处理，利用求余可以得到每一位的数字，从而利用得到的数字进行进一步的处理，同时还需要注意的是，要注意到边界，比方对于32bit的有符号整数，其边界为-32768 ～ 32767
class Solution {
public:
int reverse(int x) {
int rev = 0;
while(x != 0)
{
int pop = x % 10;
x /= 10;
if(rev > INT_MAX/10 || (rev == INT_MAX/10 && pop > 7)) return 0;
if(rev < INT_MIN/10 || (rev == INT_MIN/10 && pop < -8)) return 0;
rev = rev * 10 + pop;
}
return rev;
}
};
三数之和
15. 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
示例 2：
输入：nums = []
输出：[]
示例 3：
输入：nums = [0]
输出：[]
提示：
0 <= nums.length <= 3000
-105 <= nums[i] <= 105
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
这道题属于两数之和的变种，只要固定一个数，便可以转换成为两数之和，这道题的细节之处在于，首先不要忘记先对数组进行排序，其次，在选择固定数的时候，切记不要采用重复数。因为题目中要求每个数组都需要是唯一的。
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
sort(nums.begin(), nums.end());
vector<vector<int>>ret;
int size = nums.size();
if(size <= 2)
return ret;
for(int first = 0; first < size; first++)
{
if(first > 0 && nums[first] == nums[first-1])
continue;
int target = -nums[first];
int second = first + 1;
int third = size - 1;
while(second < third)
{
if(nums[second] + nums[third] == target)
{
ret.push_back({nums[first], nums[second], nums[third]});
while(++second < size)
{
if(nums[second] != nums[second -1 ])
break;
}
while(--third > 0)
{
if(nums[third] != nums[third + 1])
break;
}
}
else if(nums[second] + nums[third] < target)
second++;
else
third--;
}
}
return ret;
}
};
力扣1260 二维网格的迁移
1260. 二维网格迁移
给你一个 m 行 n 列的二维网格 grid 和一个整数 k。你需要将 grid 迁移 k 次。
每次「迁移」操作将会引发下述活动：
位于 grid[i][j] 的元素将会移动到 grid[i][j + 1]。 位于 grid[i][n - 1] 的元素将会移动到 grid[i + 1][0]。 位于 grid[m - 1][n - 1] 的元素将会移动到 grid[0][0]。 请你返回 k 次迁移操作后最终得到的 二维网格。
示例 1：
输入：grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1 输出：[[9,1,2],[3,4,5],[6,7,8]] 示例 2：
输入：grid = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4 输出：[[12,0,21,13],[3,8,1,9],[19,7,2,5],[4,6,11,10]] 示例 3：
输入：grid = [[1,2,3],[4,5,6],[7,8,9]], k = 9 输出：[[1,2,3],[4,5,6],[7,8,9]]
提示：
m == grid.length n == grid[i].length 1 <= m <= 50 1 <= n <= 50 -1000 <= grid[i][j] <= 1000 0 <= k <= 100
来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/shift-2d-grid 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
分析题目后得到如下的计算公式
finalcol = （curcol + k）% n;
finalrow = (currow + (curcol + k)/n) % m
class Solution {
public:
vector<vector<int>> shiftGrid(vector<vector<int>>& grid, int k) {
if(k == 0)
return grid;
int m = grid.size();
int n = grid[0].size();
vector<vector<int>>ret(m, vector<int>(n, 0));
for(int i = 0; i < m; i++)
{
for(int j = 0; j < n; j++)
{
int col = (j + k) % n;
int row = (i + (j + k) / n) % m;
ret[row][col] = grid[i][j];
}
}
return ret;
}
};
若有收获，就点个赞吧
0 人点赞
