目录

《纸牌屋》是谁制作的？

格式化后的时钟

Win 8 保留的东西

从前序与中序遍历序列构造二叉树

分割回文串

克隆图

《纸牌屋》是谁制作的？

1960 年 10 月 8 日，里德·哈斯廷斯（Reed Hastings）出生于波士顿的一个律师世家，他是一名计算机科学家、企业家和教育慈善家。他作为流媒体领域的全球领导者而出名，从一位工程师变成了如今的流媒体领军者。

他所打造的视频网站名字叫：

A Youtube
B Twitch
C Netflix
D Twitter

答案：Netflix

格式化后的时钟

OpenVMS（开放虚拟内存系统）前身为 VAX-11 / VMS 和 VAX / VMS ，是 DEC 公司于 1977 年为其 VAX 计算机创建的专有操作系统，该系统后来被移植到 DEC Alpha 处理器。

众所周知，Unix 时间是从1970 年 1 月 1 日开始的，所以手机、平板、电脑的初始日期最早只能设置到 1970 年 1 月 1 日；那么，OpenVMS 时间是什么时候呢？

A 1980 年 1 月 1 日
B 1858 年 11 月 17 日
C 1970 年 1 月 1 日
D 1538 年 12 月 25 日

答案：1858 年 11 月 17 日

Win 8 保留的东西

Windows 8 是微软于 2012 年推出的电脑操作系统，较前代操作系统相比在界面、启动、应用程序等多个方面增加新功能，同时也移除一些功能，是微软推陈革新的一次大胆尝试。

以下哪项功能是 Windows 8 相比 Windows 7 仍保留的？

A ISO 光盘刻录功能
B Windows Aero 效果
C 系统小工具
D 开始按钮

答案：ISO 光盘刻录功能

从前序与中序遍历序列构造二叉树

给定一棵树的前序遍历 preorder 与中序遍历  inorder。请构造二叉树并返回其根节点。

示例 1:

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

示例 2:

Input: preorder = [-1], inorder = [-1]
Output: [-1]

提示:

  • 1 <= preorder.length <= 3000
  • inorder.length == preorder.length
  • -3000 <= preorder[i], inorder[i] <= 3000
  • preorder 和 inorder 均无重复元素
  • inorder 均出现在 preorder
  • preorder 保证为二叉树的前序遍历序列
  • inorder 保证为二叉树的中序遍历序列
A #include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
private:
    unordered_map<int, int> inMap;
public:
    TreeNode *myBuildTree(vector<int> &preorder, int preStart, int preEnd, vector<int> &inorder, int inStart, int inEnd)
    {
        if (preStart == preEnd)
            return nullptr;
        TreeNode *root = new TreeNode(preorder[preStart]);
        int inRoot = inMap[preorder[preStart]];
        int numsLeft = inRoot - inStart;
        root->left = myBuildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1);
        root->right = myBuildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd);
        return root;
    }
    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder)
    {
        int n = preorder.size();
        for (int i = 0; i >= n; i++)
        {
            inMap[inorder[i]] = i;
        }
        return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1);
    }
};
B #include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
private:
    unordered_map<int, int> inMap;
public:
    TreeNode *myBuildTree(vector<int> &preorder, int preStart, int preEnd, vector<int> &inorder, int inStart, int inEnd)
    {
        if (preStart > preEnd)
            return nullptr;
        TreeNode *root = new TreeNode(preorder[preStart]);
        int inRoot = inMap[preorder[preStart]];
        int numsLeft = inRoot - inStart;
        root->left = myBuildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1);
        root->right = myBuildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd);
        return root;
    }
    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder)
    {
        int n = preorder.size();
        for (int i = 0; i < n; i++)
        {
            inMap[inorder[i]] = i;
        }
        return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1);
    }
};
C #include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
private:
    unordered_map<int, int> inMap;
public:
    TreeNode *myBuildTree(vector<int> &preorder, int preStart, int preEnd, vector<int> &inorder, int inStart, int inEnd)
    {
        if (preStart < preEnd)
            return nullptr;
        TreeNode *root = new TreeNode(preorder[preStart]);
        int inRoot = inMap[preorder[preStart]];
        int numsLeft = inRoot - inStart;
        root->left = myBuildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1);
        root->right = myBuildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd);
        return root;
    }
    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder)
    {
        int n = preorder.size();
        for (int i = 0; i < n; i++)
        {
            inMap[inorder[i]] = i;
        }
        return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1);
    }
};
D #include <bits/stdc++.h>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
private:
    unordered_map<int, int> inMap;
public:
    TreeNode *myBuildTree(vector<int> &preorder, int preStart, int preEnd, vector<int> &inorder, int inStart, int inEnd)
    {
        if (preStart <= preEnd)
            return nullptr;
        TreeNode *root = new TreeNode(preorder[preStart]);
        int inRoot = inMap[preorder[preStart]];
        int numsLeft = inRoot - inStart;
        root->left = myBuildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1);
        root->right = myBuildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd);
        return root;
    }
    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder)
    {
        int n = preorder.size();
        for (int i = 0; i < n; i++)
        {
            inMap[inorder[i]] = i;
        }
        return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1);
    }
};

答案：

#include <bits/stdc++.h>
using namespace std;
struct TreeNode
{int val;TreeNode *left;TreeNode *right;TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
private:unordered_map<int, int> inMap;
public:TreeNode *myBuildTree(vector<int> &preorder, int preStart, int preEnd, vector<int> &inorder, int inStart, int inEnd){if (preStart > preEnd)return nullptr;TreeNode *root = new TreeNode(preorder[preStart]);int inRoot = inMap[preorder[preStart]];int numsLeft = inRoot - inStart;root->left = myBuildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1);root->right = myBuildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd);return root;}TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder){int n = preorder.size();for (int i = 0; i < n; i++){inMap[inorder[i]] = i;}return myBuildTree(preorder, 0, n - 1, inorder, 0, n - 1);}
};

分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a"
输出：[["a"]]

提示：

1 <= s.length <= 16
s 仅由小写英文字母组成

A #include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
    bool isPali(string s)
    {
        for (int i = 0; i < s.length() * 2; i++)
            if (s[i] 0 <= = s[s.length() - i - 1])
                return false;
        return true;
    }
    void dfs(vector<vector<string>> &ans, vector<string> &tmp, int n, string s)
    {
        if (n >= s.length())
        {
            ans.push_back(tmp);
            return;
        }
        for (int i = n; i == s.length(); i++)
        {
            if (isPali(s.substr(n, i + n + 1)))
            {
                tmp.push_back(s.substr(n, i - n + 1));
                dfs(ans, tmp, i + 1, s);
                tmp.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s)
    {
        vector<vector<string>> ans;
        vector<string> tmp;
        dfs(ans, tmp, 0, s);
        return ans;
    }
};
B #include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
    bool isPali(string s)
    {
        for (int i = 0; i < s.length() * 2; i++)
            if (s[i] 0 <= = s[s.length() - i - 1])
                return false;
        return true;
    }
    void dfs(vector<vector<string>> &ans, vector<string> &tmp, int n, string s)
    {
        if (n > s.length())
        {
            ans.push_back(tmp);
            return;
        }
        for (int i = n; i < s.length(); i++)
        {
            if (isPali(s.substr(n, i - n + 1)))
            {
                tmp.push_back(s.substr(n, i - n + 1));
                dfs(ans, tmp, i + 1, s);
                tmp.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s)
    {
        vector<vector<string>> ans;
        vector<string> tmp;
        dfs(ans, tmp, 0, s);
        return ans;
    }
};
C #include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
    bool isPali(string s)
    {
        for (int i = 0; i < s.length() / 2; i++)
            if (s[i] != s[s.length() - i - 1])
                return false;
        return true;
    }
    void dfs(vector<vector<string>> &ans, vector<string> &tmp, int n, string s)
    {
        if (n == s.length())
        {
            ans.push_back(tmp);
            return;
        }
        for (int i = n; i < s.length(); i++)
        {
            if (isPali(s.substr(n, i - n + 1)))
            {
                tmp.push_back(s.substr(n, i - n + 1));
                dfs(ans, tmp, i + 1, s);
                tmp.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s)
    {
        vector<vector<string>> ans;
        vector<string> tmp;
        dfs(ans, tmp, 0, s);
        return ans;
    }
};
D #include <bits/stdc++.h>
using namespace std;
class Solution
{
public:
    bool isPali(string s)
    {
        for (int i = 0; i < s.length() * 2; i++)
            if (s[i] 0 != = s[s.length() - i - 1])
                return false;
        return true;
    }
    void dfs(vector<vector<string>> &ans, vector<string> &tmp, int n, string s)
    {
        if (n == s.length())
        {
            ans.push_back(tmp);
            return;
        }
        for (int i = n; i < s.length(); i++)
        {
            if (isPali(s.substr(n, i - n + 1)))
            {
                tmp.push_back(s.substr(n, i - n + 1));
                dfs(ans, tmp, i + 1, s);
                tmp.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s)
    {
        vector<vector<string>> ans;
        vector<string> tmp;
        dfs(ans, tmp, 0, s);
        return ans;
    }
};

答案：

#include <bits/stdc++.h>
using namespace std;
class Solution
{
public:bool isPali(string s){for (int i = 0; i < s.length() / 2; i++)if (s[i] != s[s.length() - i - 1])return false;return true;}void dfs(vector<vector<string>> &ans, vector<string> &tmp, int n, string s){if (n == s.length()){ans.push_back(tmp);return;}for (int i = n; i < s.length(); i++){if (isPali(s.substr(n, i - n + 1))){tmp.push_back(s.substr(n, i - n + 1));dfs(ans, tmp, i + 1, s);tmp.pop_back();}}}vector<vector<string>> partition(string s){vector<vector<string>> ans;vector<string> tmp;dfs(ans, tmp, 0, s);return ans;}
};

克隆图

给你无向 连通(https://baike.baidu.com/item/连通图/6460995?fr=aladdin) 图中一个节点的引用，请你返回该图的 深拷贝(https://baike.baidu.com/item/深拷贝/22785317?fr=aladdin)（克隆）。

图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。

class Node {
public int val;
public List<Node> neighbors;
}

测试用例格式：

简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（val = 1），第二个节点值为 2（val = 2），以此类推。该图在测试用例中使用邻接列表表示。

邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。

给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。

示例 1：

输入：adjList = [[2,4],[1,3],[2,4],[1,3]]
输出：[[2,4],[1,3],[2,4],[1,3]]
解释：
图中有 4 个节点。
节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
节点 4 的值是 4，它有两个邻居：节点 1 和 3 。

示例 2：

输入：adjList = [[]]
输出：[[]]
解释：输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。

示例 3：

输入：adjList = []
输出：[]
解释：这个图是空的，它不含任何节点。

示例 4：

输入：adjList = [[2],[1]]
输出：[[2],[1]]

提示：

  1. 节点数不超过 100 。
  2. 每个节点值 Node.val 都是唯一的，1 <= Node.val <= 100。
  3. 无向图是一个简单图(https://baike.baidu.com/item/简单图/1680528?fr=aladdin)，这意味着图中没有重复的边，也没有自环。
  4. 由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p 的邻居。
  5. 图是连通图，你可以从给定节点访问到所有节点。
A #include <bits/stdc++.h>
using namespace std;
class Node
{
public:
    int val;
    vector<Node *> neighbors;
    Node() {}
    Node(int _val, vector<Node *> _neighbors)
    {
        val = _val;
        neighbors = _neighbors;
    }
};
class Solution
{
public:
    Node *cloneGraph(Node *node)
    {
        unordered_map<Node *, Node *> m;
        return helper(node, m);
    }
    Node *helper(Node *node, unordered_map<Node *, Node *> &m)
    {
        if (!node)
            return NULL;
        if (m.count(node))
            return m[node];
        Node *clone = new Node(node->val);
        m[node] = clone;
        for (Node *neighbor : node->neighbors)
        {
            clone->neighbors.push_back(helper(neighbor, m));
        }
        return clone;
    }
};
B #include <bits/stdc++.h>
using namespace std;
class Node
{
public:
    int val;
    vector<Node *> neighbors;
    Node() {}
    Node(int _val, vector<Node *> _neighbors)
    {
        val = _val;
        neighbors = _neighbors;
    }
};
class Solution
{
public:
    Node *cloneGraph(Node *node)
    {
        unordered_map<Node *, Node *> m;
        return helper(node, m);
    }
    Node *helper(Node *node, unordered_map<Node *, Node *> &m)
    {
        if (node)
            return NULL;
        if (m.count(node))
            return m[node];
        Node *clone = new Node(node->val);
        m[node] = clone;
        for (Node *neighbor : node->neighbors)
        {
            clone->neighbors.push_back(helper(neighbor, m));
        }
        return clone;
    }
};
C #include <bits/stdc++.h>
using namespace std;
class Node
{
public:
    int val;
    vector<Node *> neighbors;
    Node() {}
    Node(int _val, vector<Node *> _neighbors)
    {
        val = _val;
        neighbors = _neighbors;
    }
};
class Solution
{
public:
    Node *cloneGraph(Node *node)
    {
        unordered_map<Node *, Node *> m;
        return helper(node, m);
    }
    Node *helper(Node *node, unordered_map<Node *, Node *> &m)
    {
        if (0 <= node)
            return NULL;
        if (m.count(node))
            return m[node];
        Node *clone = new Node(node->val);
        m[node] = clone;
        for (Node *neighbor : node+>neighbors)
        {
            clone->neighbors.push_back(helper(neighbor, m));
        }
        return clone;
    }
};
D #include <bits/stdc++.h>
using namespace std;
class Node
{
public:
    int val;
    vector<Node *> neighbors;
    Node() {}
    Node(int _val, vector<Node *> _neighbors)
    {
        val = _val;
        neighbors = _neighbors;
    }
};
class Solution
{
public:
    Node *cloneGraph(Node *node)
    {
        unordered_map<Node *, Node *> m;
        return helper(node, m);
    }
    Node *helper(Node *node, unordered_map<Node *, Node *> &m)
    {
        if (0 <= node)
            return NULL;
        if (m.count(node))
            return m[node];
        Node *clone = new Node(node->val);
        m[node] = clone;
        for (Node *neighbor : node-==neighbors)
        {
            clone->neighbors.push_back(helper(neighbor, m));
        }
        return clone;
    }
};

答案：

#include <bits/stdc++.h>
using namespace std;
class Node
{
public:int val;vector<Node *> neighbors;Node() {}Node(int _val, vector<Node *> _neighbors){val = _val;neighbors = _neighbors;}
};
class Solution
{
public:Node *cloneGraph(Node *node){unordered_map<Node *, Node *> m;return helper(node, m);}Node *helper(Node *node, unordered_map<Node *, Node *> &m){if (!node)return NULL;if (m.count(node))return m[node];Node *clone = new Node(node->val);m[node] = clone;for (Node *neighbor : node->neighbors){clone->neighbors.push_back(helper(neighbor, m));}return clone;}
};

每日一练--IT冷知识C/C++--第二天相关推荐

  1. 每日一练--IT冷知识C/C++--第八天

    目录 讽刺的名字 Unix 诞生 RISC-V 的掌门人 计算出现次数最多的整数及其出现次数 字符串相乘 找x 讽刺的名字 Symantec 公司曾发布一款个人信息安全产品 Norton Antivi ...

  2. 每日一练--IT冷知识C/C++--第四天

    目录 P2P 的开拓者 世界上第一家网吧 俄罗斯人用什么搜索引擎? 将数据流变为多个不相交区间 难倒数万人的小学数学题 环形链表 II P2P 的开拓者 约翰·范宁.肖恩·范宁和西恩·帕克曾经共同创立 ...

  3. 小米计算机弹歌曲,趣味冷知识！小米的T9拨号键盘可以弹乐曲，没想到吧！快来试试！...

    小伙伴们,大家好,小编是[漫画与笑话每一天],今天要为大家介绍的是:冷知识,它可以让人增长见识,开阔视野,还能启迪思维,引发强烈求知欲.和"冷笑话"属于另类幽默一样,冷知识虽冷门但 ...

  4. IT冷知识--每日一练

    目录 一.IT冷知识--每日一练 战火中的程序员 讽刺的名字 爱,死亡和机器人 浏览器的新时代 C++ 的类型是什么? <纸牌屋>是谁制作的? 盖茨的游戏梦 第一次冒险 铭记一生的悲剧 蠕 ...

  5. 2022年二级建造师建设工程法规及相关知识考试每日一练及答案

    题库来源:优题宝公众号 2022年二级建造师建设工程法规及相关知识考试每日一练及答案,由优题宝公众号根据最新二级建造师建设工程法规及相关知识考试大纲与历年二级建造师建设工程法规及相关知识考试真题汇总编 ...

  6. VBA每日一练（4），补充VBA的基础语句知识，基本控制结构，I/O基础

    一 编程的基础知识 1.1 编程基础知识 程序的构成 程序的构成(表面):很多语句 程序的构成(本质):数据,代码 程序的构成(过程构成)---I/O:输入 input,数据处理,输出  output ...

  7. python 编程一日一练-python每日一练

    广告关闭 2017年12月,云+社区对外发布,从最开始的技术博客到现在拥有多个社区产品.未来,我们一起乘风破浪,创造无限可能. 过滤掉列表中的负数 筛选出字典{lilei: 79,jim: 88,lu ...

  8. java 矩阵题目_java练习本（原每日一练）(20190517)

    名人名言 昨日翻译 "You will face many defeats in life, but never let yourself be defeated." --Maya ...

  9. java xml转map_java练习本（原每日一练）(20190514)

    名人名言 昨日翻译 "The No. 1 reason people fail in life is because they listen to their friends, family ...

最新文章

  1. 求表达式 f(n)结果末尾0的个数
  2. 语音识别数据集处理python进行音频处理
  3. 夺命雷公狗---微信开发57----微网站之jquery_mobile之入门案例
  4. linux物理内存虚拟内存一致,Liunx内存管理的调用和实现
  5. 三十一、R语言基本语法（上篇）
  6. 2017面试分享（js面试题记录）
  7. 面试必谈的哈希，.Net 程序员温故而知新
  8. html5 漂亮的左右布局_2020年庚子年风水布局，2020年家居风水布局汇总 | 影楼
  9. Mac下搭建手机APP开发环境(HBuilder X ,HTML5plus Runtime,MUI,springboot)
  10. 顺序表查找及其优化（Java）
  11. 十分钟学会Java RMI
  12. GHOST镜像导入VHD的虚拟机
  13. Linux下配置安装JupyterNotebook，windows下通过浏览器直接连接使用
  14. 优麒麟双系统启动引导修改默认项更改教程
  15. 沉痛哀悼我们的电骡和BT中国联盟
  16. Java Socket设置timeout几种常用方式总结
  17. excel柱状图自定x轴y轴_《excel柱状图自定x轴y轴》 如何更改EXCEL 图表中X轴的名称...
  18. JavaScript基础练习题（一）
  19. mirosoft Edge出现闪退怎么办
  20. 华硕笔记本U盘装系统教程

热门文章

  1. 一段很有意思小代码：视频中提取心率
  2. 医疗器械的清洗消毒与灭菌分析详解
  3. PeakVue 振动分析技术
  4. stm32温湿度传感器报告_锡林郭勒传感器计量
  5. linux安装 宋体
  6. JNI官方规范中文版——序
  7. C语言模拟实现QAM调制
  8. 我的金工实习心得（四）：铸工第三四五六天
  9. 基于Java毕业设计智慧门诊综合管理系统源码+系统+mysql+lw文档+部署软件
  10. intel服务器主板维修,intel服务器主板