Eazow

How did Vera discover she had this gift of second sight?

Several cases have been reported in Russia recently of people who can read and detect colours with their fingers, and even see through solid doors and walls. One case concerns an eleven-year-old schoolgirl, Vera Petrova, who has normal vision but who can also perceive things with different parts of her skin, and through solid walls. This ability was first noticed by her father. One day she came into his office and happened to put her hand on the door of a locked safe. Suddenly she asked her father why he kept so many old newspapers locked away there, and even described the way they were done up in bundles.

Vera’s curious talent was brought to the notice of a scientific research institute in the town of Ulyanovsk, near where she lives, and in April she was given a series of tests by a special commission of the Ministry of Health of the Russian Federal Republic. During these tests she was able to read a newspaper through an opaque screen and, stranger still, by moving her elbow over a child’s game of Lotto she was able to describe the figures and colours printed on it; and, in another instance, wearing stockings and slippers, to make out with her foot the outlines and colours of a picture hidden under a carpet. Other experiments showed that her knees and shoulders had a similar sensitivity. During all these tests Vera was blindfold; and, indeed, except when blindfold she lacked the ability to perceive things with her skin. It was also found that although she could perceive things with her fingers this ability ceased the moment her hands were wet.

📚 核心词汇

vision /ˈvɪʒən/ 视力；视觉；远见 n. She has perfect vision.
perceive /pərˈsiːv/ 感知；察觉；理解 v. I perceive a change in his attitude.
bundles /ˈbʌndəlz/ 捆；束；包裹 n. The newspapers were tied in bundles.
institute /ˈɪnstɪtuːt/ 研究所；学院；机构 n. He works at a research institute.
Ministry /ˈmɪnɪstri/ 部；部门；内阁部 n. Ministry of Health
opaque /oʊˈpeɪk/ 不透明的；难懂的 adj. The glass was completely opaque.
slippers /ˈslɪpərz/ 拖鞋 n. She wore comfortable slippers.
carpet /ˈkɑːrpɪt/ 地毯；毛毯 n. The carpet was soft and warm.
blindfold /ˈblaɪndfoʊld/ 蒙眼；蒙住眼睛 v./adj. She was blindfolded during the test.

🎯 重要短语

短语 中文含义 用法示例
second sight 第二视觉；超感官知觉 指超自然的感知能力
detect colours 辨别颜色 用非视觉方式识别颜色
see through 透视；看穿 see through solid walls
bring to notice 引起注意 Her talent was brought to notice
make out 辨认出；理解 make out the outlines
cease the moment 一…就停止 ceased the moment her hands were wet

📝 全文翻译

薇拉是如何发现自己拥有这种第二视觉天赋的？

最近在俄罗斯出现了几起关于人们能够用手指阅读和辨别颜色，甚至能透视坚固门墙的案例报告。其中一个案例涉及一名11岁的女学生薇拉·彼得洛娃，她拥有正常的视力，但同时也能用身体不同部位的皮肤感知事物，甚至能透过坚固的墙壁。这种能力最初是被她父亲发现的。有一天，她走进父亲的办公室，碰巧把手放在了一个上锁保险柜的门上。突然，她问父亲为什么要把这么多旧报纸锁在里面，甚至还描述了这些报纸是如何捆绑成束的。

薇拉这种奇特的天赋引起了她居住地附近乌里扬诺夫斯克市一家科学研究机构的注意。4月份，俄罗斯联邦共和国卫生部的一个特别委员会对她进行了一系列测试。在这些测试中，她能够透过不透明的屏幕阅读报纸；更奇怪的是，通过用肘部在儿童乐透游戏上移动，她能够描述印在上面的数字和颜色；在另一个实验中，她穿着袜子和拖鞋，用脚辨认出隐藏在地毯下面图片的轮廓和颜色。其他实验表明，她的膝盖和肩膀也有类似的敏感性。在所有这些测试中，薇拉都被蒙住了眼睛；实际上，除了蒙眼时，她缺乏用皮肤感知事物的能力。研究还发现，虽然她能用手指感知事物，但一旦手湿了，这种能力就会立即消失。

What was the main objective of early mountain climbers?

Modern alpinist try to climb mountains by a route which will give them good sport, and the more difficult it is , the more highly it is regarded. In the pioneering days, however, this was not the case at all. The early climbers were looking for the easiest way to the top, because the summit was the prize they sought, especially if it had never been attained before. It is true that during their explorations they often faced difficulties and dangers of the most perilous nature, equipped in a manner which would make a modern climber shudder at the thought, but they did not go out of their way to court such excitement. They had a single aim, a solitary goal — the top!

It is hard for us to realize nowadays how difficult it was for the pioneers. Except for one or two places such as Zermatt and Chamonix, which had rapidly become popular, Alpine villages tended to be impoverished settlements cut off from civilization by the high mountains. Such inns as there were generally dirty and flea-ridden; the food simply local cheese accompanied by bread often twelve months old, all washed down with coarse wine. Often a valley boasted no inn at all, and climbers found shelter wherever they could sometimes with the local priest(who was usually as poor as his parishioners), sometimes with shepherds or cheese-makes. Invariably the background was the same: dirt and poverty, and very uncomfortable. For men accustomed to eating seven-course dinners and sleeping between fine linen sheets at home, the change to the Alps must have been very hard indeed.

How much of each year do spiders spend killing insects?

Why, you may wonder, should spiders be our friends? Because they destroy so many insects, and insects include some of the greatest enemies of the human race. Insects would make it impossible for us to live in the world; they would devour all our crops and kill our flocks and herds, if it were not for the protection we get from insect-eating animals. We owe a lot to the birds and beasts who eat insects but all of them put together kill only a fraction of the number destroyed by spiders. Moreover, unlike some of the other insect eaters, spiders never do the least harm to us or our belongings.

Spiders are not insects, as many people think, not even nearly related to them. One can tell the difference almost at a glance, for a spider always has eight legs and an insect never more than six.

How many spiders are engaged in this work on our behalf? One authority on spiders made a census of the spiders in a grass field in the south of England, and he estimated that there were more than 2,250,000 in one acre; that is something like 6,000,000 spiders of different kinds of a football pitch. Spiders are busy for at least half the year in killing insects. It is impossible to make more than the wildest guess at how many they kill, but they are hungry creatures, not content with only three meals a day. It has been estimated that the weight of all the insects destroyed by spiders in Britain in one year would be greater than the total weight of all the human beings in the country.

Why are legends handed down by storytellers useful?

We can read of things that happened 5,000 years ago in the Near East, where people first learned to write. But there are some parts of the world where even now people cannot write. The only way that they can preserve their history is to recount it as sagas - legends handed down from one generation of storyteller to another. These legends are useful because the can tell us something about migrations of people who lived long ago, but none could write down what they did. Anthropologist wondered where the remote ancestors of the Polynesian peoples now living in the Pacific Islands came from. The sagas of these people explain that some of them came from Indonesia about 2,000 years ago.

But the first people who were like ourselves lived so long ago that even their sagas, if they had any, are forgotten. So archaeologists have neither history nor legends to help them find out where the first “modern men” came from.

Fortunately, however, ancient men made tools of stone, especially flint, because this is easier to shape than other kinds. They may also have used wood and skins, but these have rotted away. Stone does not decay, and so the tools of lone ago have remained when even the bones of the men who made them have disappeared without trace.

📖 文章主题

探讨人类如何通过文字记录、口头传说和考古发现来了解古代人类的历史。

🎯 核心问题回答

Why are legends handed down by storytellers useful?

答案：传说之所以有用，是因为它们能告诉我们关于古代人类迁徙的信息，尤其是那些生活在很久以前、没有文字记录能力的人群。

原文依据：

“These legends are useful because they can tell us something about migrations of people who lived long ago, but none could write down what they did.”

📝 段落解析

第一段：三种了解历史的方式

核心内容

1. 文字记录（5,000年前开始）

   • 近东地区最早学会书写
   • 可以读到5000年前发生的事情

2. 口头传说（无文字地区）

   • 通过讲故事的方式代代相传
   • 称为 sagas（传奇故事）

3. 传说的价值

   • 帮助了解古代人类的迁徙
   • 例如：波利尼西亚人的祖先来自印度尼西亚（约2000年前）

重点句型

1
2
3
4
5

The only way that they can preserve their history is to recount it as sagas.
他们保存历史的唯一方式就是把它当作传说讲述出来。

结构：The only way (that)... is to do sth.
唯一的方法是...

第二段：最早人类的困境

核心内容

• 最早的”现代人”生活得太久远
• 即使有传说也已被遗忘
• 考古学家既没有历史记录，也没有传说可以依靠

关键表达

1
2
3
4

But the first people who were like ourselves lived so long ago that...
但是最早像我们这样的人生活得如此久远，以至于...

结构：so... that...（如此...以至于...）

第三段：考古学的希望——石器

核心内容

1. 古人制作石器

   • 主要用燧石（flint），因为容易塑形
   • 也可能用木头和兽皮，但已腐烂

2. 石头的优势

   • 不会腐烂（decay）
   • 即使制作者的骨头都消失了，石器仍然保留

重点对比

📚 重点词汇详解

1. recount /rɪˈkaʊnt/

• 词性：动词
• 含义：详细叙述，讲述
• 例句：

  1 2	She recounted her adventures in Africa. 她详细讲述了在非洲的冒险经历。

2. saga /ˈsɑːɡə/

• 词性：名词
• 含义：传奇故事；长篇冒险故事
• 例句：

  1 2	The saga of their journey across the desert fascinated everyone. 他们穿越沙漠的传奇故事让所有人着迷。

3. anthropologist /ˌænθrəˈpɒlədʒɪst/

• 词性：名词
• 含义：人类学家
• 词根：anthropo-（人类）+ -logist（学家）
• 相关词：
  • anthropology（人类学）
  • archaeology（考古学）

4. Polynesian /ˌpɒlɪˈniːʒən/

• 词性：形容词/名词
• 含义：波利尼西亚的/波利尼西亚人
• 地理：太平洋岛屿地区

5. flint /flɪnt/

• 词性：名词
• 含义：燧石（一种坚硬的石头）
• 用途：古代制作工具和生火

6. rot /rɒt/

• 词性：动词
• 含义：腐烂，腐朽
• 短语：rot away（完全腐烂）
• 例句：

  1 2	The wood had rotted away over the years. 木头经年累月已经腐烂了。

7. decay /dɪˈkeɪ/

• 词性：动词/名词
• 含义：腐烂；衰败
• 区别：
  • rot：强调有机物质的腐烂
  • decay：更广泛，可指任何形式的衰败

8. trace /treɪs/

• 词性：名词/动词
• 含义：痕迹；追踪
• 短语：without trace（无影无踪）
• 例句：

  1 2	The plane vanished without trace. 飞机消失得无影无踪。

🔑 重点语法结构

1. 定语从句

1
2
3
4
5

We can read of things that happened 5,000 years ago.
我们可以读到5000年前发生的事情。

The only way that they can preserve their history is...
他们保存历史的唯一方式是...

2. 被动语态

1
2
3
4

legends handed down from one generation to another
代代相传的传说

（完整形式：legends that are handed down...）

3. so…that…结构

1
2

lived so long ago that even their sagas are forgotten
生活得如此久远，以至于即使他们的传说也被遗忘了

4. neither…nor…结构

1
2

archaeologists have neither history nor legends to help them
考古学家既没有历史也没有传说来帮助他们

💡 文章逻辑结构

1
2
3
4
5
6
7
8
9
10
11
12
13

了解古代人类历史的三种方式：

1. 文字记录 ✓
   └─ 5000年前开始
   └─ 有限制：只在某些地区

2. 口头传说 ✓
   └─ 无文字地区的方式
   └─ 有限制：最早的人类连传说都没留下

3. 考古发现 ✓✓✓
   └─ 石器工具
   └─ 最可靠：石头不会腐烂

🎓 学习要点

理解层面

1. 人类历史研究的三个来源
2. 为什么石器对考古学如此重要
3. 不同材料的保存性差异

语言层面

1. 定语从句的使用
2. 因果关系的表达（because, so…that）
3. 对比结构（but, however）

词汇层面

1. 历史考古相关词汇
2. 材料特性描述词汇
3. 时间表达方式

✍️ 写作可借鉴的表达

1. 引出话题：

   1 2	We can read of things that happened... 我们可以读到...发生的事情

2. 转折对比：

   1 2	But there are some parts of the world where... 但是世界上有些地方...

3. 强调唯一性：

   1 2	The only way that... is to... ...的唯一方式是...

4. 表达幸运：

   1 2	Fortunately, however,... 然而，幸运的是...

这篇文章展示了说明文的典型结构：提出问题→分析问题→给出答案，语言简洁清晰，逻辑严密，非常适合学习英语写作！

Problem

Given a collection of integers that might contain duplicates, nums, return all possible subsets.
Note: The solution set must not contain duplicate subsets.
For example,
If nums = [1,2,2], a solution is:

1
2
3
4
5
6
7
8

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

方法

设定返回的列表的列表为result。先对数组排序，如果nums[i]!=nums[i-1]，那么就遍历result，复制每个列表为tempList，加入nums[i]，然后将该列表加入result中；如果nums[i]==nums[i-1]，那么记录下加入nums[i-1]前返回列表的大小resultIndex，resultSize为加入nums[i-1]后的大小，对result中从resultIndex至resultSize的列表加入nums[i]，然后将新生成的列表加入result

代码

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

class Solution(object):
    def subsetsWithDup(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        result = [[]]
        nums.sort()
        i = 0
        resultSize = 0
        while i < len(nums):
            num = nums[i]
            resultIndex = 0
            if i>0 and nums[i]==nums[i-1]:
                resultIndex = resultSize;
            resultSize = len(result)
            while resultIndex < resultSize:
                tempList = result[resultIndex][:]
                tempList.append(num)
                result.append(tempList)
                resultIndex += 1
            i += 1
        return result

assert Solution().subsetsWithDup([1,2,2]) == [[],[1],[2],[1,2],[2,2],[1,2,2]]

Given a range [m, n] where 0 <= m <= n <= 2147483647, return the bitwise AND of all numbers in this range, inclusive.

For example, given the range [5, 7], you should return 4.

方法

直接对所有数按位与，会超时，因此只能采用别的方法。
对于[1,3], 对应二进制位01,010,011，按位与为0；对于[5,7]，对应二进制为0101,0110,0111，按位与为0100。
对于[m,n]，如果m!=n，那么m和n最右一位按位与必然为0；同时将m,n都右移一位，用bits记录移位数，如果m!=n，继续将m,n右移一位。最后m==n时，将m<<bits位即可，此时m可以为0或为其他值。如果m为0，n也为0,那么m和n的位数并不相同，因此结果为0；如果m不为0，那么m和n前几位必然相同，用m<<bits就可以得到最后结果。

C代码

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
27
28
29

#include <assert.h>

int rangeBitwiseAnd(int m, int n) {
    int bits = 0;
    while(m != n) {
        m >>= 1;
        n >>= 1;
        bits++;
    }
    return m<<bits;
}

/**
int rangeBitwiseAnd(int m, int n) {
    int bitwiseAnd = m;
    while(m <= n) {
        bitwiseAnd &= m;
        m++;
    }
    return bitwiseAnd;
}
*/

int main() {
    assert(rangeBitwiseAnd(5,7) == 4);
    assert(rangeBitwiseAnd(1,3) == 0);

    return 0;
}

Given an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2.

Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

C代码

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

#include <assert.h>
#include <stdlib.h>

/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int left = 0, right = numsSize-1;
    int* returnNums = NULL;
    int sum = 0;
    while(left < right) {
        sum = nums[left]+nums[right];
        if(sum == target) {
            returnNums = (int *)malloc(sizeof(int)*2);
            returnNums[0] = left+1;
            returnNums[1] = right+1;
            *returnSize = 2;
            break;
        }
        else if(sum > target)
            right--;
        else
            left++;
    }
    return returnNums;
}

/**
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int i = 0, j = i+1;
    int* returnNums = NULL;
    for(i=0, j=i+1; i < numsSize-1;) {
        if(nums[i] + nums[j] == target) {
            returnNums = (int *)malloc(sizeof(int) * 2);
            returnNums[0] = i+1;
            returnNums[1] = j+1;
            *returnSize = 2;
            return returnNums;
        }
        else if(nums[i] + nums[j] < target) {
            j++;
            if(j == numsSize) {
                i++;
                j = i+1;
            }
        }
        else {
            i++;
            j = i+1;
        }
    }
    return returnNums;
}
*/

int main() {
    int nums[3] = {2,3,4};
    int returnSize = 0;
    int* returnNums = twoSum(nums, 3, 6, &returnSize);
    assert(returnNums[0] == 1);
    assert(returnNums[1] == 3);

    return 0;
}

Problem

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.
The same repeated number may be chosen from C unlimited number of times.

Note:

• All numbers (including target) will be positive integers.

• The solution set must not contain duplicate combinations.
  For example, given candidate set [2, 3, 6, 7] and target 7,
  A solution set is:

  1 2 3 4

  [ [7], [2, 2, 3] ]

难度

Medium

思路

利用栈，如果要入栈的数加上已入栈的数的和小于target, 则入栈；如果等于target，则复制该栈，加入返回结果，然后从栈取出一个数，取其下一个数准备入栈；如果大于target, 则从栈取出一个数，取其下一个数准备入栈。注意一些边界条件的判断

Python代码

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

class Solution(object):
    def combinationSum(self, candidates, target):
        """
        :type candidates: List[int]
        :type tatget: int
        :rtype List[List[int]]
        """
        nums = []
        indexes = []
        returnLists = []
        sum = 0
        i = 0
        candidates.sort()
        while True:
            while i >= len(candidates):
                if len(nums) == 0:
                    return returnLists
                sum -= nums.pop()
                i = indexes.pop()+1
            if sum + candidates[i] < target:
                nums.append(candidates[i])
                indexes.append(i)
                sum += candidates[i]
            elif sum + candidates[i] > target:
                if len(nums) > 0:
                    sum -= nums.pop()
                    i = indexes.pop()+1
                else:
                    return returnLists
            elif sum + candidates[i] == target:
                newNums = nums[:]
                newNums.append(candidates[i])
                returnLists.append(newNums)
                if len(nums) > 0:
                    sum -= nums.pop()
                    i = indexes.pop()+1
                else:
                    i += 1


assert Solution().combinationSum([2,3,4], 7)==[[2,2,3], [3,4]]
assert Solution().combinationSum([2,3,6,7], 7)==[[2,2,3], [7]]
assert Solution().combinationSum([2], 1) == []

Given an integer array with all positive numbers and no duplicates, find the number of possible combinations that add up to a positive integer target.

Example:

1
2
3
4
5
6
7
8
9
10
11
12

nums = [1, 2, 3]
target = 4
The possible combination ways are:
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)
Note that different sequences are counted as different combinations.
Therefore the output is 7.

思路

假设给定的nums为num1, num2...numn，用results[i]表示组成i的组合个数，如果i>=numj, 那么

1

results[i] = results[i-num1]+results[i-num2]+...results[i-numj]

从0开始计算至target，就能获得target的组合个数

C代码

里面递归的方法会超时，因此被注释掉

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
27
28
29
30
31
32
33
34
35
36
37
38

#include <assert.h>
#include <stdlib.h>

/**
int combinationSum4(int* nums, int numsSize, int target) {
    if(target == 0)
        return 1;
    int i = 0;
    int result = 0;
    for(i = 0; i < numsSize; i++) {
        if(target >= nums[i])
            result += combinationSum4(nums, numsSize, target-nums[i]);
    }
    return result;
}
*/

int combinationSum4(int* nums, int numsSize, int target) {
    int* results = (int *)malloc(sizeof(int) * (target+1));
    int i = 0;
    int j = 0;
    results [0] = 1;
    for(i = 1; i <= target; i++)
        results[i] = 0;
    for(i = 0; i <= target; i++) {
        for(j = 0; j < numsSize; j++) {
            if(i >= nums[j])
                results[i] += results[i-nums[j]];
        }
    }
    return results[target];
}
int main() {
    int nums[3] = {1,2,3};
    assert(combinationSum4(nums, 3, 4) == 7);

    return 0;
}

Given a binary tree, return the preorder traversal of its nodes’ values.

For example:
Given binary tree {1,#,2,3},

1
2
3
4
5

1 
 \
  2
 / 
3

return [1,2,3].

Note: Recursive solution is trivial, could you do it iteratively?

方法

前序遍历二叉树，不用递归的方法，就需要借助栈了。
首先将root入栈，然后取出，先将右子节点压入栈，再讲左子节点压入栈。然后取出栈的节点，压入该节点的右、左子节点，循环直到栈为空即可。

c代码

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#include <assert.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    if(root == NULL)
        return NULL;

    int *vals = (int *)malloc(sizeof(int) * 1000);
    int valsTop = 0;
    struct TreeNode* node = root;
    struct TreeNode** nodes = (struct TreeNode **)malloc(sizeof(struct TreeNode *) * 1000);
    int nodesTop = 0;
    nodes[nodesTop++] = root;

    while(nodesTop > 0) {
        node = nodes[--nodesTop];
        vals[valsTop++] = node->val;

        if(node->right)
            nodes[nodesTop++] = node->right;
        if(node->left)
            nodes[nodesTop++] = node->left;
    }
    *returnSize = valsTop;
    return vals;
}

int main() {
    struct TreeNode* root = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    root->val = 1;
    struct TreeNode* node1_2 = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    node1_2->val = 2;
    root->left = NULL;
    root->right = node1_2;
    struct TreeNode* node2_3 = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    node2_3->val = 3;
    node1_2->left = node2_3;
    node1_2->right = NULL;
    node2_3->left = NULL;
    node2_3->right = NULL;

    int returnSize = 0;
    int* vals = preorderTraversal(root, &returnSize);
    assert(returnSize == 3);
    assert(vals[0] == 1);
    assert(vals[1] == 2);
    assert(vals[2] == 3);

    return 0;
}