编程语言笔记

阅读数:0次

c++

搜索

1
2
3
4
5
6
7
8
9
10
11
找第一个比target大的位置
auto row = upper_bound(matrix.begin(), matrix.end(), target, [](const int b, const vector<int>&a){
    return b < a[0];
});
if (row == matrix.begin()) {
    return false;
}
--row;

二分查找
binary_search(row->begin(), row->end(), target);

引用

1
2
函数用&传回多个参数 fun(int &a, TreeNode* & note){}
函数传二维数组 vector<vector<char>>& board

排序

1
2
3
4
按照大到小排序
bool cmp(string a, string b){
    return a > b;
}

STL

  • vector
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
sort(nums.begin(), nums.end());  排序 
vector<vector<int>> edge; edge.emplace_back(); 不需要新建
edge.push_back({1,2,3,4,}) 直接加vector
vector<int>对象
初始化
v = {};
v = {'a'};
push_back() emplace_back()
pop_back()
v.back()
二维数组
auto dp = vector<vector<int>>(n, vector<int>(m));
vector<vector<int>> dp = vector<vector<int>>(n, vector<int>(m));

v.at(i - 1) = v[i-1]
  • string 字符串
1
2
3
4
5
6
reverse(s.begin(), s.end()); 翻转
s.substr(i, n); 子串
s[i] = 'a' 可以赋值

s = to_string(val) 数字转字符串
i = stoi(s) 字符串转数字
  • pair
1
2
3
4
pair<int, int>
c = make_pair(a, b)
c.first
c.second
  • stack 栈
1
2
3
4
stack<int>st;
while(!st.empty()) st.pop();
st.top();
st.push();
  • queue
1
2
3
q.pop()
q.front()
q.push()
  • priority_queue 优先队列
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//自定义1
priority_queue<int, vector<int>, less<int> > a == priority_queue<int>a;
//自定义2
struct Status {
    int val;
    ListNode *ptr;
    bool operator < (const Status &rhs) const {
        return val > rhs.val;
    }
};
priority_queue <Status> q;
q.push({node->val, node})
//自定义3
struct tmp2 //重写仿函数
{
    bool operator() (Node a, Node b) 
    {
        return a.x < b.x; //大顶堆
    }
};
priority_queue<Node, vector<Node>, tmp2> f;

q.push(a) q.emplace(a)
q.empty()
auto f = q.top(); 
q.pop();
  • unordered_map
1
2
3
4
5
6
7
8
9
无序，查找问题，更加高效一些，o(1)时间
查询o1,插入on
unordered_map<int, list<pair<int,int>>::iterator>mp;
mp.find(key)!=mp.end()
mp[key]->second;
mp.erase(key); 删除
unordered_map<int, vector<string>> ans;
ans.count(a)

  • map
1
2
3
查询ologn,插入ologn
红黑树，有顺序要求的问题，用map会更高效一些
for(map<string, int>::iterator it=mp.begin(); it != mp.end(); it++) cout << (*it).first << " " << (*it).second << endl;
  • list 双向链表
1
2
3
4
5
6
7
8
9
10
11
12
list<pair<int, int>>l;
l.splice(l.begin(), l, mp[key]);
l.erase(mp[key]);
l.push_front(make_pair(key, value));
l.begin();
l.rbegin()->first
l.pop_back();

l.front() 值
l.begin() 迭代器
l.erase(l.begin());
l.push_back(a);
  • unordered_set
1
2
3
4
5
查询o1,插入on
unordered_set<string>mp;
mp.count(a)
vector转set
unordered_set(v.begin(), v.end());
  • set
1
2
3
4
查询ologn,插入ologn
set<int>s
s.insert()
s.count()

数据结构

  • 字典树
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
struct TrieNode {
    string word;
    unordered_map<char, TrieNode*>child;
    TrieNode(){
        this->word = "";
    }
};
void insertTrie(TrieNode * root, string word){
    TrieNode*node = root;
    for(int i = 0; i < word.size(); i++){
        if(!node->child.count(word[i])){
            node->child[word[i]] = new TrieNode();
        }
        node = node->child[word[i]];
    }
    node->word = word;
}
TrieNode*root = new TrieNode();
insertTrie(root, words[w]);
root->child.count(ch))
TrieNode*nxt = root->child[ch];
nxt->word.size()
nxt->child.empty()
root->child.erase(ch)

python

知识

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
python赋值只是引用, 函数从参数返回注意要把结果放在原来参数的存储位置

for i in range((n-1)/2, -1, -1): 从大到小计算
for i, num in enumerate(nums)
for num in nums:
    num = 不能赋值

遍历
for i in range(0, n-step, step*2)
for i in range(n-1, -1, -1):

float("-inf") 无穷

参数引用
字典和列表是传址

交换位置
nums[i], nums[mx-1] = nums[mx-1], nums[i]

函数里修改list，函数外也会有影响

复制

1
2
3
4
5
6
7
8
9
import copy 
a = [[10], 20]
b = a[:] # 方法1  [[10, 11], 20, 21]
c = list(a) # 方法2 [[10, 11], 20]
d = a * 1 # 方法3 [[10, 11], 20]
e = copy.copy(a) # 方法4 [[10, 11], 20]
f = copy.deepcopy(a) # 方法5 [[10], 20] 【推荐】
a.append(21)
a[0].append(11)

数据结构

  • string
1
2
3
4
修改string, 要先转字符list，再合并
w = list(s)
w[i] = '*'
ns = "".join(w)
  • list
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
实现堆栈
a = []
a.append()
a.pop()
a[-1]

list.index(x)返回list第一个x位置
list.reverse() 翻转

构建数组
al = [0] * n
ar = [n-1] * n
生成值为0的二维数组
[[0] * m] * n 表示的是指向 [0]*m 这个列表的引用
[[0] * m for _ in range(n)] 这才正确
f = [[False] * (n + 1) for _ in range(m + 1)]

  • dict
1
2
a = {'b':1}
a.pop('b')
  • deque 双向队列
1
2
3
4
5
q = collections.deque([a])或者 q = collections.deque() q.append(a)    
while q:
id = q.popleft()
q.append(e)
len(q)
  • PriorityQueue 基于heapq的 python3才能用
1
2
3
4
5
6
7
8
from queue import PriorityQueue
q = PriorityQueue()
q.put((-buildings[idx][2], buildings[idx][1]))  按照逐个元素从小到大
q.put(Node(buildings[idx][1], buildings[idx][2]))  或者使用class
排序
while not q.empty():
    a = q.get() 会直接pop
    q.put(a)
  • heapq 最小堆 python2可以用
1
2
3
4
5
6
7
8
9
10
import heapq
q = []
heapq.heappush(q, (-buildings[idx][2], buildings[idx][1]))
while q:
    a = heapq.heappop(q)
    heapq.heappush(q, a)
heapify([1,2,3]) 列表转堆
heapreplace(q, new) 弹出最小元素，插入新元素
nsmallest(3, q) 前n个最小元素
nlargest(3, q)
  • class
1
2
3
4
5
6
7
8
class Node(object):
    def __init__(self, x, h):
        self.x = x
        self.h = h
        return
 
    def __lt__(self, other): 排序
        return self.h > other.h
  • 字典树
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class TrieNode(object):
    def __init__(self):
        self.child = {}
        self.word = ""
def insertTrie(root, word):
    node = root
    for i in range(len(word)):
        if word[i] not in node.child:
            node.child[word[i]] = TrieNode()
        node = node.child[word[i]]
    node.word = word
root = TrieNode()
insertTrie(root, word)
if ch not in root.child:
nxt =  root.child[ch]
len(nxt.word)
len(nxt.child.keys()) == 0:
root.child.pop(ch)

排序

1
2
3
4
5
6
7
8
9
10
11
12
def comp(a, b):
    an = a+b
    bn = b+a
    if an > bn: return -1
    elif an < bn: return 1
    else: return 0

ans.sort(key=functools.cmp_to_key(comp))
ans.sort(cmp = lambda x,y: cmp(y+x, x+y))
ans.sort(key=functools.cmp_to_key(lambda x,y: cmp(y+x, x+y)))

ans = sorted(ans) #需要赋值，只是sorted不改变存储位置

目录结构【需要重新梳理】

下次一层调用上一层

1
2
3
4
5
6
7
8
方法一
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)), "../.."))

方法二
export PYTHONPATH="$PYTHONPATH:$PWD" 好像没用 会话没了就没了
echo $PYTHONPATH

参见https://github.com/CalmCapK/toolkit/test_directory_structure

文件操作

大文件一行行读取

1
2
with open(path, "r", encoding="utf-8") as f:
    for line in tqdm(f):

多线程

参见https://github.com/CalmCapK/toolkit/python_example.py

随机抽取

参见https://github.com/CalmCapK/toolkit/python_example.py

二维数组根据下标索引赋值

1
2
3
4
5
6
res = res.softmax(dim=-1) 
val, ind = res.topk(k) //ind: batch_size x topk
output = np.zeros((batch_size, label_num) , dtype = float)) 
for i in range(batch_size):
    //gpu tensor -> cpu numpy
    output[i][ind[i].cpu().detach().numpy().astype(int)] = 1

函数生成变量赋值？

1
2
3
4
5
def fun():
    dic = {}
    return dic

data = fun()

opencv无法读取中文路径

https://www.zhihu.com/question/67157462

赏

谢谢你请我吃糖果

微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家