官方文档

在2005年更新的官方文档，点击这里.

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

pyLirc v0.0.5

Introduction

pyLirc is a module for Python that interacts with lirc to give 
Python programs the ability to receive commands from remote 
controls.

This isn't much of documentation, but at least it's a start and
there isn't much to document right now anyway.


Initialization

Before you can receive any commands from lirc, you'll need to 
initialize the module. After importing pyLirc, call the pylirc.init()
function:

   import pylirc

   integer = pylirc.init(string name[, string configuration [, integer blocking ]])

the returnvalue is the returnvalue of lircs client library
lirc_init(), ie a socket, or zero on failure.

The socket can be used with select.select() to wait for data if you don't
want to use blocking. This is especially useful in multithreaded programs
as blocking mode of pylirc will blick all threads, whereas select() will
only block the current and with optional timeout.

name: the name used for your program in the lirc configuration
file, must be supplied.

configuration:  a filename to a lirc configuration file in case you wish not to
use lircs default configuration file (usually ~/.lircrc).

blocking: a flag indicating wether you want blocking mode or not. See also 
blocking() and select.select() (latter in python docs)


Polling

If initialization was ok, you can poll lirc for commands. To read any commands
in queue call pylirc.nextcode():

   list = pylirc.nextcode([integer Exteneded])

The returnvalue is 'None', if no commands was on the queue, or a list
containing the commands read.

To get the commands one by one enumerate the list:

   for code in list:
      print code

If you supply the optional argument Extended as true, code will be a dictionary
otherwise it will be a string (old behaviour).

The dictionary currently contains:
"config": The config string from lirc config file - the same string you'd get in
          non-extended mode.
"repeat": The repeat count of the buttonpress.
      
Note, that there can still be more commands on queue after a call
to pylirc.nextcode(). You should call it in a loop until you get
'None' back.


Exiting

When you're done using pyLirc and before you exit your program you
should clean up:

   pylirc.exit()


Changing mode

When you initialize pyLirc, you can chose wether you want blocking or
non-blocking mode. Blocking mode means pylirc.nextcode() waits until
there is a command to be read until it returns.
To change mode after initialization, use blocking():

   success = pylirc.blocking(int)

中文翻译

自己尝试翻译一下，英语渣渣，有不正确的地方请指正。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

pyLirc v0.0.5

介绍

pyLirc是一个与LIRC交互给
Python程序从远程接收远程命令的能力
的Python模块。

这是没有太多的文档，毕竟它是一个新项目，
现在反正没有太多的文档。

初始化

在接受来自lirc的命令之前，你应该初始化本模块。在 import pylirc之后，使用 pylirc.inti()函数：
	import pylirc
	integer = pylirc.init(string name[, string configuration [, integer blocking ]])
返回值是客户端库中lirc_init()函数的返回值，是一个socket，如果返回值是0，则初始化失败。

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#!/usr/bin/env python
import pylirc

class Buttons:
    SELECT = 0
    RIGHT = 1
    DOWN = 2
    UP = 3
    LEFT = 4

    def __init__(self, app, conf):
        if not pylirc.init(app, conf, 1):
            raise Exception("Unable to init pylirc");
        pylirc.blocking(0)

    def readButton(self):
        btn = pylirc.nextcode()
        if btn:
            return btn[0]
        else:
            return None

由于众所周知的原因，国内的网络环境一直不是很好。最近我在Eclipse上安装Pydev也不可以了。所以，打算用本地安装的方法来解决。

可以在这里下载到最新的PyDev for Eclipse。
然后，将压缩包内的features和plugins文件夹拷贝到eclipse的安装目录下。重启eclipse，在Help->About Eclipse->Installation Details中看到PyDev的信息。

其实很简单，但刚开始一点都不会。

1
2
3
4
5
6
7

$sqlite test.db
SQLite version 2.8.17
Enter ".help" for instructions
sqlite> .database
seq  name             file                                                      
---  ---------  -------------------------
0    main        /home/pi/code/testDB.db

这样就创建成功了。

题目

On every June 1st, the Children’s Day, there will be a game named “crashing balloon” on TV. The rule is very simple. On the ground there are 100 labeled balloons, with the numbers 1 to 100. After the referee shouts “Let’s go!” the two players, who each starts with a score of “1”, race to crash the balloons by their feet and, at the same time, multiply their scores by the numbers written on the balloons they crash. After a minute, the little audiences are allowed to take the remaining balloons away, and each contestant reports his\her score, the product of the numbers on the balloons he\she’s crashed. The unofficial winner is the player who announced the highest score.

Inevitably, though, disputes arise, and so the official winner is not determined until the disputes are resolved. The player who claims the lower score is entitled to challenge his\her opponent’s score. The player with the lower score is presumed to have told the truth, because if he\she were to lie about his\her score, he\she would surely come up with a bigger better lie. The challenge is upheld if the player with the higher score has a score that cannot be achieved with balloons not crashed by the challenging player. So, if the challenge is successful, the player claiming the lower score wins.

So, for example, if one player claims 343 points and the other claims 49, then clearly the first player is lying; the only way to score 343 is by crashing balloons labeled 7 and 49, and the only way to score 49 is by crashing a balloon labeled 49. Since each of two scores requires crashing the balloon labeled 49, the one claiming 343 points is presumed to be lying.

On the other hand, if one player claims 162 points and the other claims 81, it is possible for both to be telling the truth (e.g. one crashes balloons 2, 3 and 27, while the other crashes balloon 81), so the challenge would not be upheld.

By the way, if the challenger made a mistake on calculating his/her score, then the challenge would not be upheld. For example, if one player claims 10001 points and the other claims 10003, then clearly none of them are telling the truth. In this case, the challenge would not be upheld.

Unfortunately, anyone who is willing to referee a game of crashing balloon is likely to get over-excited in the hot atmosphere that he\she could not reasonably be expected to perform the intricate calculations that refereeing requires. Hence the need for you, sober programmer, to provide a software solution.

Input

Pairs of unequal, positive numbers, with each pair on a single line, that are claimed scores from a game of crashing balloon.
Output

Numbers, one to a line, that are the winning scores, assuming that the player with the lower score always challenges the outcome.
Sample Input

343 49
3599 610
62 36

Sample Output

49
610
62

代码

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

//http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1003

#include<cstdio>
#include<algorithm>
using namespace std;

bool f1, f2;

void dfs(int numa, int numb, int k)
{
	if(numb == 1)
    {
        f2 = true;
        if(numa == 1) f1 = true;
    }

	if(k == 1 || (f1 && f2)) return;
	if(numa % k == 0) dfs(numa / k, numb, k - 1);
	if(numb % k == 0) dfs(numa, numb / k, k - 1);
	dfs(numa, numb, k - 1);
}

int main()
{
	int a, b;
	while(scanf("%d%d",&a,&b) != EOF)
	{
		if(a < b) swap(a, b);
		f1 = f2 = false;
		dfs(a, b, 100);
		if(!f1 && f2) printf("%d\n",b);
		else printf("%d\n",a);
	}
	return 0;
}

记录原因

这是我正在DIY的一个基于树莓派智能家居的过程中，配置lirc的一个小问题的总结。
因为在网上搜索到的类似的博客给出的解决方式都不可行，所以打算记录下来，方便后来者。

事情的起因

安装lirc——一个开源的红外控制的库

1

sudo apt-get install lirc

配置到这一步时，网络上给出的下一步都是在

加载内核模块

1	sudo modprobe lirc_rpi gpio_in_pin=23gpio_out_pin=24

然而照着做以后，并不能成功。

解决方法

配置树莓派的lirc，需要在/boot/config.txt中添加，在这里找到的。

1

dtoverlay=lirc-rpi,gpio_in_pin=23,gpio_out_pin=24

然后重启就可以了。

加载lir_rpi内核模块

1

sudo modprobe lirc_rpi

测试

1

sudo mode2 -d /dev/lirc0

现在就会看到一大串space和pulse交替产生。