content stringlengths 263 5.24M | pred_label stringclasses 1
value | pred_score_pos float64 0.6 1 |
|---|---|---|
# 题目
编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则：
* 数字 1-9 在每一行只能出现一次。
* 数字 1-9 在每一列只能出现一次。
* 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 '.' 表示。
示例：
输入：board = [["5","3",".",".","7",".",... | __label__POS | 0.962159 |
# 题目
给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。
返回复制链表的头节点。
用一个由 n 个... | __label__POS | 1.000009 |
# 题目
编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。
示例 1：
输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出：true
示例 2：
以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为 [2,1,5,6,2,3]。
![image](https://user-images.githubusercontent.com/59190045/125074097-6a4a6c80-e0ef... | __label__POS | 1.00001 |
# 题目
给定两个整数，分别表示分数的分子 numerator 和分母 denominator，以 字符串形式返回小数 。
如果小数部分为循环小数，则将循环的部分括在括号内。
如果存在多个答案，只需返回 任意一个 。
对于所有给定的输入，保证 答案字符串的长度小于 104 。
示例 1：
输入：numerator = 1, denominator = 2
输出："0.5"
示例 2：
输入：numerator = 2, denominator = 1
输出："2"
示例 3：
输入：numerator = 2, denominator = 3
输出："0.(6)"
示例 ... | __label__POS | 0.999571 |
# 题目
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。
示例 1：
输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]
示例 2：
 和 (6,9) 之间都存在最大差值 3。
示例 2:
输入: [10]
输出: 0
解释: 数组元素个数小于 2，因此返回 0。
说明:
* 你可以假设数组中所有元素都是非负整数，且数值在 32 位有符号整数范围内。
* 请尝试在线性时间复杂度和空间复杂度的条件下解决此问题。
# 参考答案
```c++
class Solution {
... | __label__POS | 1.000007 |
# 题目
给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]
示例 2：
|12;
public static final int PPC_BC_LE = (1<<5)|4;
public static final int PPC_BC_EQ = (2<<5)|12;
public static final int PPC_B... | __label__POS | 1.000009 |
// For Capstone Engine. AUTO-GENERATED FILE, DO NOT EDIT
package capstone;
public class Mips_const {
public static final int MIPS_OP_INVALID = 0;
public static final int MIPS_OP_REG = 1;
public static final int MIPS_OP_IMM = 2;
public static final int MIPS_OP_MEM = 3;
public static final int MIPS_REG_INVALID = ... | __label__POS | 1.000009 |
# 题目
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例 1：
```
输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
```
示例 2：
```
输入：digits = ""
输出：[]
```
... | __label__POS | 0.999955 |
# 题目
实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：
* BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
* boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。
* int next()将指针向右移动，然后返回指针处的数字。
注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小... | __label__POS | 0.999382 |
# 题目
```
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
```
# 参考答案
```c++
class Solution {
public:
int len... | __label__POS | 1.00001 |
# 题目
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
假设你总是可以到达数组的最后一个位置。
示例 1:
输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
示例 2:
输入: [2,3,0,1,4]
输出: 2
提示:
* 1 <= nums.length <= 1000
* 0 <= nums[i] <= 10<sup... | __label__POS | 1.00001 |
# 题目
给定一个单词数组和一个长度 maxWidth，重新排版单词，使其成为每行恰好有 maxWidth 个字符，且左右两端对齐的文本。
你应该使用“贪心算法”来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格 ' ' 填充，使得每行恰好有 maxWidth 个字符。
要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配，则左侧放置的空格数要多于右侧的空格数。
文本的最后一行应为左对齐，且单词之间不插入额外的空格。
说明:
单词是指由非空格字符组成的字符序列。<br>
每个单词的长度大于 0，小于等于 maxWidth。<br>
输入单词数组 words 至少包含一个单词。<br>
... | __label__POS | 0.998058 |
; input_dword_1
(declare-fun b () (_ BitVec 32))
(let ((?x1167 (concat ((_ extract 31 30) b) (bvnot ((_ extract 29 27) b)) ((_ extract 26 24) b) (bvnot ((_ extract 23 22) b)) ((_ extract 21 17) b) (bvnot ((_ extract 16 9) b)) ((_ extract 8 8) b) (bvnot ((_ extract 7 7) b)) ((_ extract 6 6) b) (bvnot ((_ extract 5 3) b)... | __label__POS | 0.691175 |
# 题目
给定三个字符串 s1、s2、s3，请你帮忙验证 s3 是否是由 s1 和 s2 交错 组成的。
两个字符串 s 和 t 交错 的定义与过程如下，其中每个字符串都会被分割成若干 非空 子字符串：
* s = s1 + s2 + ... + sn
* t = t1 + t2 + ... + tm
* |n - m| <= 1
* 交错 是 s1 + t1 + s2 + t2 + s3 + t3 + ... 或者 t1 + s1 + t2 + s2 + t3 + s3 + ...
提示：a + b 意味着字符串 a 和 b 连接。
示例 1：
 (_ BitVec 32))
(let ((?x1746 (concat ((_ extract 27 2) (bvadd (_ bv422262738 32) d)) (bvnot (bvadd (_ bv2 2) ((_ extract 1 0) d))) ((_ extract 31 28) (bvadd (_ bv422262738 32) d)))))
(let ((?x1779 (bvadd (_ bv6 32) ?x1746)))
(let ((?x1879 (concat (bvnot ((_ extract 15 15) ?x1779)) ((_ ... | __label__POS | 0.704967 |
/*
* sorted by 4,/^$/|sort -bd +1
*/
int fqid(int fd, Qid *qid);
int BNList(Biobuf *b, NList *nl, char *sep);
int BSList(Biobuf *b, SList *sl, char *sep);
int BimapMimeParams(Biobuf *b, MimeHdr *mh);
int Bimapaddr(Biobuf *b, MAddr *a);
int Bimapdate(Biobuf *b, Tm *tm);
int Bimapstr(Biobuf *b, char *s);
int Brfc822dat... | __label__POS | 0.942644 |
# 题目
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
示例 1：
输入：head = [4,2,1,3]
输出：[1,2,3,4]
示例 2：
 的算法解决此问题吗？
示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]
示例 3：
输入：nums = [], target = 0
输出：[-1,-1]
提示... | __label__POS | 1.00001 |
# 题目
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
示例 1：
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2：
输入：nums = [0,1]
输出：[[0,1],[1,0]]
示例 3：
输入：nums = [1]
输出：[[1]]
提示：
* 1 <= nums.length <= 6
* -10 <= nums[i] <= 10
* nums 中的所有整数 互不相同
# 参考答案
```c++
clas... | __label__POS | 1.00001 |
; input_dword_4
(declare-fun e () (_ BitVec 32))
(let ((?x2001 (concat ((_ extract 7 3) (bvadd (_ bv4 32) e)) (bvnot ((_ extract 2 2) (bvadd (_ bv4 32) e))) ((_ extract 1 0) e) ((_ extract 31 8) (bvadd (_ bv4 32) e)))))
(let ((?x2045 (bvadd (_ bv3921822786 32) (bvnot (bvadd (_ bv4294967292 32) ?x2001)))))
(let ((?x2281... | __label__POS | 0.797805 |
; generate_magic_from_pc_son
(declare-fun n_break () (_ BitVec 32))
(declare-fun pc_son () (_ BitVec 32))
(let ((?x14 (bvadd n_break (bvmul (_ bv4294967295 32) ((_ extract 63 32) (bvmul (_ bv1148159575 64) (concat (_ bv0 32) n_break)))))))
(let ((?x21 ((_ extract 63 32) (bvmul (_ bv1148159575 64) (concat (_ bv0 32) n_b... | __label__POS | 0.841724 |
; input_dword_0
(declare-fun a () (_ BitVec 32))
(let ((?x966 ((_ extract 31 30) (bvadd (_ bv1169698645 32) (bvnot a)))))
(let ((?x991 ((_ extract 4 4) (bvadd (_ bv21 5) (concat (bvadd (_ bv5 3) (bvnot ((_ extract 2 0) a))) ?x966)))))
(let ((?x999 (bvnot ?x991)))
(let ((?x952 ((_ extract 15 5) (bvadd (_ bv35861 16) (co... | __label__POS | 0.676531 |
// Capstone Java binding
// By Nguyen Anh Quynh & Dang Hoang Vu, 2013
package capstone;
import com.sun.jna.Structure;
import com.sun.jna.Union;
import java.util.List;
import java.util.Arrays;
import static capstone.Arm64_const.*;
public class Arm64 {
public static class MemType extends Structure {
public i... | __label__POS | 0.909633 |
// For Capstone Engine. AUTO-GENERATED FILE, DO NOT EDIT
package capstone;
public class Sysz_const {
public static final int SYSZ_CC_INVALID = 0;
public static final int SYSZ_CC_O = 1;
public static final int SYSZ_CC_H = 2;
public static final int SYSZ_CC_NLE = 3;
public static final int SYSZ_CC_L = 4;
public s... | __label__POS | 1.000009 |
// For Capstone Engine. AUTO-GENERATED FILE, DO NOT EDIT
package capstone;
public class TMS320C64x_const {
public static final int TMS320C64X_OP_INVALID = 0;
public static final int TMS320C64X_OP_REG = 1;
public static final int TMS320C64X_OP_IMM = 2;
public static final int TMS320C64X_OP_MEM = 3;
public static ... | __label__POS | 1.000009 |
// Capstone Java binding
// By Nguyen Anh Quynh & Dang Hoang Vu, 2013
package capstone;
import com.sun.jna.Structure;
import com.sun.jna.Union;
import java.util.List;
import java.util.Arrays;
import static capstone.Xcore_const.*;
public class Xcore {
public static class MemType extends Structure {
public b... | __label__POS | 0.991061 |
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <auth.h>
#include "imap4d.h"
static int copyData(int ffd, int tfd, MbLock *ml);
static MbLock mLock =
{
.fd = -1
};
static char curDir[MboxNameLen];
void
resetCurDir(void)
{
curDir[0] = '\0';
}
int
myChdir(char *dir)
{
if(strcmp(dir, curDir) == 0)
retu... | __label__POS | 0.908011 |
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <auth.h>
#include <libsec.h>
#include "imap4d.h"
static int saveMsg(char *dst, char *digest, int flags, char *head, int nhead, Biobuf *b, long n);
static int saveb(int fd, DigestState *dstate, char *buf, int nr, int nw);
static long appSpool(Biobuf *bout, Biob... | __label__POS | 0.866377 |
# 题目
编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为汉明重量）。
提示：
* 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
* 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。
示例 1：
输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 000000000... | __label__POS | 1.00001 |
# 题目
已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：
* 若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
* 若旋转 7 次，则可以得到 [0,1,4,4,5,6,7]
注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
给你一个可能存在 重复 元素值的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
... | __label__POS | 1.000009 |
# 题目
给定一个已按照 升序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。
函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
示例 1：
输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index... | __label__POS | 1.00001 |
# 题目
给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]
示例 2：
 (_ BitVec 32))
(declare-fun magic () (_ BitVec 32))
(let ((?x578 (bvadd (_ bv32 32) (bvnot n_loop))))
(let ((?x637 (bvmul (_ bv4294967295 32) n_loop)))
(let ((?x422 (concat (bvnot ((_ extract 8 7) magic)) ((_ extract 6 5) magic) (bvnot ((_ extract 4 4) magic)) ((_ extract 3 ... | __label__POS | 0.934789 |
; input_dword_5
(declare-fun f () (_ BitVec 32))
(let ((?x2610 (concat (bvnot ((_ extract 19 19) (bvadd (_ bv216130 20) ((_ extract 19 0) f)))) ((_ extract 18 18) (bvadd (_ bv216130 20) ((_ extract 19 0) f))) (bvnot ((_ extract 17 10) (bvadd (_ bv216130 20) ((_ extract 19 0) f)))) ((_ extract 9 9) (bvadd (_ bv216130 20... | __label__POS | 0.647247 |
; input_dword_2
(declare-fun c () (_ BitVec 32))
(let ((?x1558 (concat ((_ extract 31 30) (bvadd (_ bv1210289743 32) (bvnot c))) (bvnot ((_ extract 29 27) (bvadd (_ bv1210289743 32) (bvnot c)))) ((_ extract 26 24) (bvadd (_ bv1210289743 32) (bvnot c))) (bvnot ((_ extract 23 22) (bvadd (_ bv1210289743 32) (bvnot c)))) (... | __label__POS | 0.870657 |
# 题目
给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同 二叉搜索树 。可以按 任意顺序 返回答案。
示例 1：
输入：n = 3
输出：[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]
示例 2：
输入：n = 1
输出：[[1]]... | __label__POS | 1.000007 |
# 题目
给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例:
给定的有序链表： [-10, -3, 0, 5, 9],
一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：
0
/ \
-3 9
/ /
-10 5
# 参考答案
```c++
class Solution {
public:
int getLength(ListNode*... | __label__POS | 1.00001 |
# 题目
给定一个二叉树
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
示例：
... | __label__POS | 1.000008 |
# 题目
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (... | __label__POS | 1.00001 |
# 题目
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：2
示例 2：
输入：root = [2,null,3,null,4,null,5,null,6]
输出：5
提示：
树中节点数的范围在 [0... | __label__POS | 1.00001 |
# 题目
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
示例 1：
输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
示例 2：
输入：nums = [1,2,3,1]
输出：4
... | __label__POS | 1.00001 |
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <auth.h>
#include "imap4d.h"
#define SUBSCRIBED "imap.subscribed"
static int matches(char *ref, char *pat, char *name);
static int mayMatch(char *pat, char *name, int star);
static int checkMatch(char *cmd, char *ref, char *pat, char *mbox, long mtime, int is... | __label__POS | 0.800635 |
# 题目
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。
说明：不允许修改给定的链表。
示例 1：
输入：head = [3,2,0,-4], pos =... | __label__POS | 1.000009 |
#include "debug.c"
#define BP (PDWORD)0x00461005
int main()
{
PROCESS_INFORMATION iProcess = {0};
STARTUPINFOA iStartup = {0};
unsigned int ret = 0;
PCHAR procDump = NULL;
DWORD tailleBin = 0;
HANDLE hFile = 0;
DWORD nbByte = 0, imgBase = 0;
iStartup.cb = sizeof(STARTUPINFOA);
pr... | __label__POS | 0.733574 |
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <auth.h>
#include "imap4d.h"
/*
* reverse string [s:e) in place
*/
void
strrev(char *s, char *e)
{
int c;
while(--e > s){
c = *s;
*s++ = *e;
*e = c;
}
}
int
isdotdot(char *s)
{
return s[0] == '.' && s[1] == '.' && (s[2] == '/' || s[2] == '\0');
}... | __label__POS | 0.989109 |
#include <u.h>
#include <libc.h>
#include <auth.h>
#include <bio.h>
#include "imap4d.h"
void
debuglog(char *fmt, ...)
{
va_list arg;
static int logfd;
if(debug == 0)
return;
if(logfd == 0)
logfd = open("/sys/log/imap4d", OWRITE);
if(logfd > 0){
va_start(arg, fmt);
fprint(logfd, "%s: ", username);
vfpri... | __label__POS | 0.604651 |
# 题目
一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：
'A' -> 1
'B' -> 2
...
'Z' -> 26
要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，"11106" 可以映射为：
* "AAJF" ，将消息分组为 (1 1 10 6)
* "KJF" ，将消息分组为 (11 10 6)
注意，消息不能分组为 (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。
给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。
题目数据保证答案肯定... | __label__POS | 0.999991 |
# 题目
有效数字（按顺序）可以分成以下几个部分：
1.一个 小数 或者 整数<br>
2.（可选）一个 'e' 或 'E' ，后面跟着一个 整数
小数（按顺序）可以分成以下几个部分：<br>
1.（可选）一个符号字符（'+' 或 '-'）<br>
2.下述格式之一：<br>
* 至少一位数字，后面跟着一个点 '.'
* 至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字
* 一个点 '.' ，后面跟着至少一位数字
整数（按顺序）可以分成以下几个部分：<br>
1.（可选）一个符号字符（'+' 或 '-'）<br>
2.至少一位数字<br>
部分有效数字列举如下：
* ["2", "0089", "-0.1",... | __label__POS | 0.988782 |
# 题目
将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。
比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下：
```
P A H N
A P L S I I G
Y I R
```
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。
请你实现这个将字符串进行指定行数变换的函数：
```
string convert(string s, int numRows);
```
示例 1：
```
输入：s = "PAYPALISHIRING", numRows = 3
输出："PAHNAP... | __label__POS | 1.000009 |
# 题目
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文。
返回符合要求的 最少分割次数 。
示例 1：
输入：s = "aab"
输出：1
解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。
示例 2：
输入：s = "a"
输出：0
示例 3：
输入：s = "ab"
输出：1
提示：
* 1 <= s.length <= 2000
* s 仅由小写英文字母组成
# 参考答案
```c++
class Solution {
public:
int minCut(string s) {
... | __label__POS | 1.00001 |
# 题目
给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 1：
```
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
```
示例 2：
```
输入：lists = []
输出：[]
```
示例 3：
```
输入：lists = [[]]
输出：[]
```
提示：
* k == lists.length
* 0 <= k <= ... | __label__POS | 1.000009 |
# 题目
给你两个版本号 version1 和 version2 ，请你比较它们。
版本号由一个或多个修订号组成，各修订号由一个 '.' 连接。每个修订号由 多位数字 组成，可能包含 前导零 。每个版本号至少包含一个字符。修订号从左到右编号，下标从 0 开始，最左边的修订号下标为 0 ，下一个修订号下标为 1 ，以此类推。例如，2.5.33 和 0.1 都是有效的版本号。
比较版本号时，请按从左到右的顺序依次比较它们的修订号。比较修订号时，只需比较 忽略任何前导零后的整数值 。也就是说，修订号 1 和修订号 001 相等 。如果版本号没有指定某个下标处的修订号，则该修订号视为 0 。例如，版本 1.0 小于版本 1.1 ，因为... | __label__POS | 0.999992 |
# 题目
给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。
示例 1：
输入：board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
输出：[["X","X","X","X... | __label__POS | 0.999906 |
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <auth.h>
#include "imap4d.h"
/*
* modified utf-7, as per imap4 spec
* like utf-7, but substitues , for / in base 64,
* does not allow escaped ascii characters.
*
* /lib/rfc/rfc2152 is utf-7
* /lib/rfc/rfc1642 is obsolete utf-7
*
* test sequences from r... | __label__POS | 0.895959 |
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <auth.h>
#include "imap4d.h"
/*
* iterated over all of the items in the message set.
* errors are accumulated, but processing continues.
* if uids, then ignore non-existent messages.
* otherwise, that's an error
*/
int
forMsgs(Box *box, MsgSet *ms, ulong ... | __label__POS | 0.916475 |
# 题目
给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
示例 1：
输入：nums = [100,4,200,1,3,2]
输出：4
解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
示例 2：
输入：nums = [0,3,7,2,5,8,4,6,0,1]
输出：9
提示：
* 0 <= nums.length <= 10<sup>4</sup>
* -10<sup>9</sup> <= nums[i] <= 10<sup>9</sup>
# 参考答案
```c++
class Solution {
p... | __label__POS | 1.00001 |
# 题目
给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。
示例 1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
示例 2：
输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
提示：
* n... | __label__POS | 1.00001 |
#include <u.h>
#include <libc.h>
#include <auth.h>
#include <libsec.h>
#include <bio.h>
#include "imap4d.h"
/*
* hack to allow smtp forwarding.
* hide the peer IP address under a rock in the ratifier FS.
*/
void
enableForwarding(void)
{
char buf[64], peer[64], *p;
static ulong last;
ulong now;
int fd;
if(remo... | __label__POS | 0.662016 |
# 题目
给定一个二叉树的根节点 root ，返回它的 中序 遍历。
示例 1：
输入：root = [1,null,2,3]
输出：[1,3,2]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [1]
输出：[1]
示例 4：
输入：root = [1,2]
输出：[2,1]
示例 5：
输入：root = [1,null,2]
输出：[1,2]
提示：
* 树中节点数目在范围 [0, 100] 内
* -100 <= Node.val <= 100
# 参考答案
```c++
class Sol... | __label__POS | 1.00001 |
# 题目
根据 逆波兰表示法，求表达式的值。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
说明：
整数除法只保留整数部分。<br>
给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1：
输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
示例 2：
输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 +... | __label__POS | 0.999284 |
# 题目
给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：
* 插入一个字符
* 删除一个字符
* 替换一个字符
示例 1：
输入：word1 = "horse", word2 = "ros"
输出：3
解释：
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')
示例 2：
输入：word1 = "intention", word2 = "execution"
输... | __label__POS | 0.999982 |
# 题目
给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。
示例 1:
输入：s = "egg", t = "add"
输出：true
示例 2：
输入：s = "foo", t = "bar"
输出：false
示例 3：
输入：s = "paper", t = "title"
输出：true
提示：
可以假设 s 和 t 长度相同。
#... | __label__POS | 1.000009 |
# 题目
给定一个单链表 L：L<sub>0</sub>→L<sub>1</sub>→…→L<sub>n</sub>-1→L<sub>n</sub> ，
将其重新排列后变为： L<sub>0</sub>→L<sub>n</sub>→L<sub>1</sub>→L<sub>n</sub>-1→L<sub>2</sub>→L<sub>n</sub>-2→…
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1:
给定链表 1->2->3->4, 重新排列为 1->4->2->3.
示例 2:
给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3.
# 参考答案
``... | __label__POS | 1.00001 |
# 题目
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
注意：解集不能包含重复的组合。
示例 1:
输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
示例 2:
输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
... | __label__POS | 1.000008 |
# 题目
已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。
给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 num... | __label__POS | 1.00001 |
# 题目
峰值元素是指其值大于左右相邻值的元素。
给你一个输入数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞ 。
示例 1：
输入：nums = [1,2,3,1]
输出：2
解释：3 是峰值元素，你的函数应该返回其索引 2。
示例 2：
输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5
解释：你的函数可以返回索引 1，其峰值元素为 2；
或者返回索引 5， 其峰值元素为 6。
提示：
* 1 <= nums... | __label__POS | 1.00001 |
#!/usr/bin/env sage
# coding=utf-8
import pickle
r = Zmod(2)
equations = []
result = []
def bitvector_from_bytes(bs):
tmp = Integer(bs.encode('hex'), 16).bits()
tmp += [0] * (len(bs)*8-len(tmp))
tmp.reverse()
return vector(r, tmp)
def parse_ctext(ctext):
# transposition
c = bitvector_from_by... | __label__POS | 0.849988 |
# 题目
按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s<sub>1</sub> -> s<sub>2</sub> -> ... -> s<sub>k</sub> 这样的单词序列，并满足：
每对相邻的单词之间仅有单个字母不同。<br>
转换过程中的每个单词 s<sub>i</sub>（1 <= i <= k）必须是字典 wordList 中的单词。注意，beginWord 不必是字典 wordList 中的单词。<br>
s<sub>k</sub> == endWord<br>
给你两个单词 beginWord 和 end... | __label__POS | 0.996467 |
# 题目
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。
示例 1：
输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]
示例 2：
输入：head = [5], left = ... | __label__POS | 1.00001 |
# 题目
给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：true
示例 2：
![image](https://user-images.githubusercontent.com/59190045/... | __label__POS | 1.00001 |
# 题目
给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
'.' 匹配任意单个字符<br>
'*' 匹配零个或多个前面的那一个元素<br>
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。
示例 1：
```
输入：s = "aa" p = "a"
输出：false
解释："a" 无法匹配 "aa" 整个字符串。
```
示例 2:
```
输入：s = "aa" p = "a*"
输出：true
解释：因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
```
示例 3：
... | __label__POS | 0.999974 |
# 题目
根据一棵树的中序遍历与后序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。
例如，给出
中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树：
3
/ \
9 20
/ \
15 7
# 参考答案
```c++
class Solution {
public:
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
if (postorder.s... | __label__POS | 1.00001 |
# 题目
已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：<br>
若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]<br>
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]<br>
注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。<br>
给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组... | __label__POS | 1.000009 |
# 题目
给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。
示例 1:
输入: num1 = "2", num2 = "3"
输出: "6"
示例 2:
输入: num1 = "123", num2 = "456"
输出: "56088"
说明：
* num1 和 num2 的长度小于110。
* num1 和 num2 只包含数字 0-9。
* num1 和 num2 均不以零开头，除非是数字 0 本身。
* 不能使用任何标准库的大数类型（比如 BigInteger）或直接将输入转换为整数来处理。
# 参考答... | __label__POS | 1.00001 |
# 题目
给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。
示例 1：
输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
示例 2：
输入：nums = [3,2,1,0,4]
输出：false
解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
提示：
* 1 <= nums.length <= 3... | __label__POS | 1.00001 |
# 题目
罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
```
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
```
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字... | __label__POS | 1.000008 |
#include "common.h"
#include <auth.h>
#include <fcall.h>
#include <libsec.h>
#include <ctype.h>
#include "dat.h"
enum
{
OPERM = 0x3, // mask of all permission types in open mode
};
typedef struct Fid Fid;
struct Fid
{
Qid qid;
short busy;
short open;
int fid;
Fid *next;
Mailbox *mb;
Message *m;
Message *mt... | __label__POS | 0.656299 |
# 题目
对链表进行插入排序。
插入排序的动画演示如上。从第一个元素开始，该链表可以被认为已经部分排序（用黑色表示）。
每次迭代时，从输入数据中移除一个元素（用红色表示），并原地将其插入到已排好序的链表中。
插入排序算法：
* 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。
* 每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。
... | __label__POS | 1.00001 |
#include <u.h>
#include <libc.h>
#include <bio.h>
#include "hash.h"
/***
* String hash tables.
*/
Stringtab *tfree;
Stringtab*
taballoc(void)
{
static Stringtab *t;
static uint nt;
if(tfree){
Stringtab *tt = tfree;
tfree = tt->link;
return tt;
}
if(nt == 0){
t = malloc(64000*sizeof(Stringtab));
if... | __label__POS | 0.91733 |
# 题目
给定一个链表，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
如果链表中存在环，则返回 true 。 否则，返回 false 。
示例 1：
### 1、goto 语句(不建议使用)
**作用：** 可以无条件的跳转语句
**语法：** `goto 标记;`
**解释：** 如果标记的名称存在，执行到goto语句时，会跳转到标记的位置
```cpp
int main() {
cout << 1 << endl;
cout << 2 << endl;
goto F... | __label__POS | 0.996144 |
# 题目
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
示例 1：
输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2：
输入：nums = [0]
输出：[[],[0]]
提示：
* 1 <= nums.length <= 10
* -10 <= nums[i] <= 10
# 参考答案
```c++
class Solution {
public:
vector<int> t;
vec... | __label__POS | 1.00001 |
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <regexp.h>
#include "/sys/src/libregexp/regcomp.h"
#include "dfa.h"
#define DUMP
void
dump(Dreprog *pp)
{
int i, j;
Dreinst *l;
print("start %ld %ld %ld %ld\n",
pp->start[0]-pp->inst,
pp->start[1]-pp->inst,
pp->start[2]-pp->inst,
pp->start[3]-pp->... | __label__POS | 0.750548 |
#include <u.h>
#include <libc.h>
#include <db.h>
#include "msgdb.h"
struct Msgdb
{
DB *db;
int reset;
};
Msgdb*
mdopen(char *file, int create)
{
Msgdb *mdb;
DB *db;
HASHINFO h;
if((mdb = mallocz(sizeof(Msgdb), 1)) == nil)
return nil;
memset(&h, 0, sizeof h);
h.cachesize = 2*1024*1024;
if((db = dbopen(file... | __label__POS | 0.840656 |
# 题目
你一个整数 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
```
提示：... | __label__POS | 1.000007 |
# 题目
路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。
路径和 是路径中各节点值的总和。
给你一个二叉树的根节点 root ，返回其 最大路径和 。
示例 1：
输入：root = [1,2,3]
输出：6
解释：最优路径是 2 -> 1 -> 3 ，路... | __label__POS | 0.999983 |
# 题目
给你一个整数数组 nums 和两个整数 k 和 t 。请你判断是否存在 两个不同下标 i 和 j，使得 abs(nums[i] - nums[j]) <= t ，同时又满足 abs(i - j) <= k 。
如果存在则返回 true，不存在返回 false。
示例 1：
输入：nums = [1,2,3,1], k = 3, t = 0
输出：true
示例 2：
输入：nums = [1,0,1,1], k = 1, t = 2
输出：true
示例 3：
输入：nums = [1,5,9,1,5,9], k = 2, t = 3
输出：false
提示：... | __label__POS | 1.000005 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.