快乐数
编写一个算法来判断一个数是不是“快乐数”。
一个“快乐数”定义为:对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和,然后重复这个过程直到这个数变为 1,也可能是无限循环但始终变不到 1。如果可以变为 1,那么这个数就是快乐数。
示例:
输入: 19 输出: true 解释: 12 + 92 = 82 82 + 22 = 68 62 + 82 = 100 12 + 02 + 02 = 1
class Solution {
public:
int getAns(int n){
string s=to_string(n);
int res=0;
for(int i=0;i<s.size();i++){
int t=s[i]-'0';
res+=t*t;
}
return res;
}
bool find(int n,vector<int>& happy){
for(int i=0;i<happy.size();i++){
if(n==happy[i]) return true;
}
return false;
}
bool isHappy(int n) {
vector<int> happy;
int num=getAns(n);
while(num!=1&&find(num,happy)==false){
happy.push_back(num);
num=getAns(num);
}
if(num==1) return true;
else return false;
}
};
两整数之和
不使用运算符 +
和 -
,计算两整数 a
、b
之和。
示例 1:
输入: a = 1, b = 2 输出: 3
示例 2:
输入: a = -2, b = 3 输出: 1
class Solution {
public:
int getSum(int a, int b) {
int res=a^b; //异或操作:相加不进位
int carry=((unsigned int)(a&b))<<1; //使用与操作看哪里需要进位,防止负号转化为无符号整数
if(carry!=0){
res=getSum(res,carry);
}
return res;
}
};
Fizz Buzz
写一个程序,输出从 1 到 n 数字的字符串表示。
1. 如果 n 是3的倍数,输出“Fizz”;
2. 如果 n 是5的倍数,输出“Buzz”;
3.如果 n 同时是3和5的倍数,输出 “FizzBuzz”。
示例:
n = 15, 返回: [ "1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz" ]
class Solution {
public:
vector<string> fizzBuzz(int n) {
vector<string> res(n);
for(int i=0;i<n;i++){
res[i]=to_string(i+1);
}
for(int mu=1;mu*3<=n;mu++){
res[mu*3-1]="Fizz";
}
for(int mu=1;mu*5<=n;mu++){
if(res[mu*5-1]=="Fizz")
res[mu*5-1]="FizzBuzz";
else
res[mu*5-1]="Buzz";
}
return res;
}
};
加油站
在一条环路上有 N 个加油站,其中第 i 个加油站有汽油 gas[i]
升。
你有一辆油箱容量无限的的汽车,从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i]
升。你从其中的一个加油站出发,开始时油箱为空。
如果你可以绕环路行驶一周,则返回出发时加油站的编号,否则返回 -1。
说明:
- 如果题目有解,该答案即为唯一答案。
- 输入数组均为非空数组,且长度相同。
- 输入数组中的元素均为非负数。
示例 1:
输入: gas = [1,2,3,4,5] cost = [3,4,5,1,2] 输出: 3 解释: 从 3 号加油站(索引为 3 处)出发,可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油 开往 4 号加油站,此时油箱有 4 - 1 + 5 = 8 升汽油 开往 0 号加油站,此时油箱有 8 - 2 + 1 = 7 升汽油 开往 1 号加油站,此时油箱有 7 - 3 + 2 = 6 升汽油 开往 2 号加油站,此时油箱有 6 - 4 + 3 = 5 升汽油 开往 3 号加油站,你需要消耗 5 升汽油,正好足够你返回到 3 号加油站。 因此,3 可为起始索引。
示例 2:
输入: gas = [2,3,4] cost = [3,4,3] 输出: -1 解释: 你不能从 0 号或 1 号加油站出发,因为没有足够的汽油可以让你行驶到下一个加油站。 我们从 2 号加油站出发,可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油 开往 0 号加油站,此时油箱有 4 - 3 + 2 = 3 升汽油 开往 1 号加油站,此时油箱有 3 - 3 + 3 = 3 升汽油 你无法返回 2 号加油站,因为返程需要消耗 4 升汽油,但是你的油箱只有 3 升汽油。 因此,无论怎样,你都不可能绕环路行驶一周。
class Solution {
public:
int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
int size=gas.size();
vector<int> cha(size);
int sum=0;
for(int i=0;i<size;i++){
cha[i]=gas[i]-cost[i];
sum+=cha[i];
}
if(sum<0) return -1;
for(int i=0;i<size;i++){
if(cha[i]<0) continue;
int cur=cha[i];
int j=(i+1)%size;
while(cur>=0&&j!=i){
cur+=cha[j];
j=(j+1)%size;
}
if(cur<0) continue;
else if(j==i)
return j;
}
return -1;
}
};
LRU缓存机制
运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作: 获取数据 get
和 写入数据 put
。
获取数据 get(key)
- 如果密钥 (key) 存在于缓存中,则获取密钥的值(总是正数),否则返回 -1。
写入数据 put(key, value)
- 如果密钥不存在,则写入其数据值。当缓存容量达到上限时,它应该在写入新数据之前删除最近最少使用的数据值,从而为新的数据值留出空间。
进阶:
你是否可以在 O(1) 时间复杂度内完成这两种操作?
示例:
LRUCache cache = new LRUCache( 2 /* 缓存容量 */ ); cache.put(1, 1); cache.put(2, 2); cache.get(1); // 返回 1 cache.put(3, 3); // 该操作会使得密钥 2 作废 cache.get(2); // 返回 -1 (未找到) cache.put(4, 4); // 该操作会使得密钥 1 作废 cache.get(1); // 返回 -1 (未找到) cache.get(3); // 返回 3 cache.get(4); // 返回 4
#include<iostream>
#include<vector>
#include<map>
using namespace std;
struct kv{
int key;
int value;
bool flag=true;
};
class LRUCache {
public:
int cap;
int size;
int begin;
vector<kv> que;
map<int,int> pos;
LRUCache(int capacity) {
cap=capacity;
size=0;
begin=0;
}
int get(int key) {
if(pos.find(key)!=pos.end()&&pos[key]!=-1){
kv temp;
temp.key=key;
temp.value=que[pos[key]].value;
que[pos[key]].flag=false;
que.push_back(temp);
pos[key]=que.size()-1;
return que[pos[key]].value;
}
else{
return -1;
}
}
void put(int key, int value) {
if(size<cap){
if(pos.find(key)!=pos.end()&&pos[key]!=-1){
kv temp;
temp.key=key;
temp.value=value;
que[pos[key]].flag=false;
que.push_back(temp);
pos[key]=que.size()-1;
}
else{
size++;
kv temp;
temp.key=key;
temp.value=value;
que.push_back(temp);
pos[key]=que.size()-1;
}
}
else{
if(pos.find(key)!=pos.end()&&pos[key]!=-1){
kv temp;
temp.key=key;
temp.value=value;
que[pos[key]].flag=false;
que.push_back(temp);
pos[key]=que.size()-1;
}
else{
while(que[begin].flag==false){
begin++;
}
que[begin].flag=false;
pos[que[begin].key]=-1;
begin++;
kv temp;
temp.key=key;
temp.value=value;
que.push_back(temp);
pos[key]=que.size()-1;
}
}
}
};
/**
* Your LRUCache object will be instantiated and called as such:
* LRUCache* obj = new LRUCache(capacity);
* int param_1 = obj->get(key);
* obj->put(key,value);
*/