博客园_World of Silence

[转载]使用CPU时间戳进行高精度计时

2012-05-15T01:25:00Z

使用CPU时间戳进行高精度计时 zhangyan_qd（原作）

关键字高精度计时 CPU C++

使用CPU时间戳进行高精度计时

对关注性能的程序开发人员而言，一个好的计时部件既是益友，也是良师。计时器既可以作为程序组件帮助程序员精确的控制程序进程，又是一件有力的调试武器，在有经验的程序员手里可以尽快的确定程序的性能瓶颈，或者对不同的算法作出有说服力的性能比较。
在Windows平台下，常用的计时器有两种，一种是timeGetTime多媒体计时器，它可以提供毫秒级的计时。但这个精度对很多应用场合而言还是太粗糙了。另一种是QueryPerformanceCount计数器，随系统的不同可以提供微秒级的计数。对于实时图形处理、多媒体数据流处理、或者实时系统构造的程序员，善用QueryPerformanceCount/QueryPerformanceFrequency是一项基本功。
本文要介绍的，是另一种直接利用Pentium CPU内部时间戳进行计时的高精度计时手段。以下讨论主要得益于《Windows图形编程》一书，第15页－17页，有兴趣的读者可以直接参考该书。关于RDTSC指令的详细讨论，可以参考Intel产品手册。本文仅仅作抛砖之用。

在Intel Pentium以上级别的CPU中，有一个称为“时间戳（Time Stamp）”的部件，它以64位无符号整型数的格式，记录了自CPU上电以来所经过的时钟周期数。由于目前的CPU主频都非常高，因此这个部件可以达到纳秒级的计时精度。这个精确性是上述两种方法所无法比拟的。
在Pentium以上的CPU中，提供了一条机器指令RDTSC（Read Time Stamp Counter）来读取这个时间戳的数字，并将其保存在EDX:EAX寄存器对中。由于EDX:EAX寄存器对恰好是Win32平台下C++语言保存函数返回值的寄存器，所以我们可以把这条指令看成是一个普通的函数调用。像这样：

inline unsigned __int64 GetCycleCount()
{
__asm RDTSC
}

但是不行，因为RDTSC不被C++的内嵌汇编器直接支持，所以我们要用_emit伪指令直接嵌入该指令的机器码形式0X0F、0X31，如下：

inline unsigned __int64 GetCycleCount()
{
__asm _emit 0x0F
__asm _emit 0x31
}

以后在需要计数器的场合，可以像使用普通的Win32 API一样，调用两次GetCycleCount函数，比较两个返回值的差，像这样：

unsigned long t;
t = (unsigned long)GetCycleCount();
//Do Something time-intensive ...
t -= (unsigned long)GetCycleCount();

《Windows图形编程》第15页编写了一个类，把这个计数器封装起来。有兴趣的读者可以去参考那个类的代码。作者为了更精确的定时，做了一点小小的改进，把执行RDTSC指令的时间，通过连续两次调用GetCycleCount函数计算出来并保存了起来，以后每次计时结束后，都从实际得到的计数中减掉这一小段时间，以得到更准确的计时数字。但我个人觉得这一点点改进意义不大。在我的机器上实测，这条指令大概花掉了几十到100多个周期，在Celeron 800MHz的机器上，这不过是十分之一微秒的时间。对大多数应用来说，这点时间完全可以忽略不计；而对那些确实要精确到纳秒数量级的应用来说，这个补偿也过于粗糙了。

这个方法的优点是：
1.高精度。可以直接达到纳秒级的计时精度（在1GHz的CPU上每个时钟周期就是一纳秒），这是其他计时方法所难以企及的。
2.成本低。timeGetTime 函数需要链接多媒体库winmm.lib，QueryPerformance* 函数根据MSDN的说明，需要硬件的支持（虽然我还没有见过不支持的机器）和KERNEL库的支持，所以二者都只能在Windows平台下使用（关于DOS平台下的高精度计时问题，可以参考《图形程序开发人员指南》，里面有关于控制定时器8253的详细说明）。但RDTSC指令是一条CPU指令，凡是i386平台下Pentium以上的机器均支持，甚至没有平台的限制（我相信i386版本UNIX和Linux下这个方法同样适用，但没有条件试验），而且函数调用的开销是最小的。
3.具有和CPU主频直接对应的速率关系。一个计数相当于1/(CPU主频Hz数)秒，这样只要知道了CPU的主频，可以直接计算出时间。这和QueryPerformanceCount不同，后者需要通过QueryPerformanceFrequency获取当前计数器每秒的计数次数才能换算成时间。

这个方法的缺点是：
1.现有的C/C++编译器多数不直接支持使用RDTSC指令，需要用直接嵌入机器码的方式编程，比较麻烦。
2.数据抖动比较厉害。其实对任何计量手段而言，精度和稳定性永远是一对矛盾。如果用低精度的timeGetTime来计时，基本上每次计时的结果都是相同的；而RDTSC指令每次结果都不一样，经常有几百甚至上千的差距。这是这种方法高精度本身固有的矛盾。

关于这个方法计时的最大长度，我们可以简单的用下列公式计算：

自CPU上电以来的秒数 = RDTSC读出的周期数 / CPU主频速率（Hz）

64位无符号整数所能表达的最大数字是1.8×10^19，在我的Celeron 800上可以计时大约700年（书中说可以在200MHz的Pentium上计时117年，这个数字不知道是怎么得出来的，与我的计算有出入）。无论如何，我们大可不必关心溢出的问题。

下面是几个小例子，简要比较了三种计时方法的用法与精度
//Timer1.cpp 使用了RDTSC指令的Timer类//KTimer类的定义可以参见《Windows图形编程》P15
//编译行：CL Timer1.cpp /link USER32.lib
#include <stdio.h>
#include "KTimer.h "
main()
{
unsigned t;
KTimer timer;
timer.Start();
Sleep(1000);
t = timer.Stop();
printf( "Lasting Time: %d\n ",t);
}

//Timer2.cpp 使用了timeGetTime函数
//需包含 <mmsys.h> ，但由于Windows头文件错综复杂的关系
//简单包含 <windows.h> 比较偷懒：）
//编译行：CL timer2.cpp /link winmm.lib
#include <windows.h>
#include <stdio.h>

main()
{
DWORD t1, t2;
t1 = timeGetTime();
Sleep(1000);
t2 = timeGetTime();
printf( "Begin Time: %u\n ", t1);
printf( "End Time: %u\n ", t2);
printf( "Lasting Time: %u\n ",(t2-t1));
}

//Timer3.cpp 使用了QueryPerformanceCounter函数
//编译行：CL timer3.cpp /link KERNEl32.lib
#include <windows.h>
#include <stdio.h>

main()
{
LARGE_INTEGER t1, t2, tc;
QueryPerformanceFrequency(&tc);
printf( "Frequency: %u\n ", tc.QuadPart);
QueryPerformanceCounter(&t1);
Sleep(1000);
QueryPerformanceCounter(&t2);
printf( "Begin Time: %u\n ", t1.QuadPart);
printf( "End Time: %u\n ", t2.QuadPart);
printf( "Lasting Time: %u\n ",( t2.QuadPart- t1.QuadPart));
}

////////////////////////////////////////////////
//以上三个示例程序都是测试1秒钟休眠所耗费的时间
file://测试环境：Celeron 800MHz / 256M SDRAM
// Windows 2000 Professional SP2
// Microsoft Visual C++ 6.0 SP5
////////////////////////////////////////////////
以下是Timer1的运行结果，使用的是高精度的RDTSC指令
Lasting Time: 804586872

以下是Timer2的运行结果，使用的是最粗糙的timeGetTime API
Begin Time: 20254254
End Time: 20255255
Lasting Time: 1001

以下是Timer3的运行结果，使用的是QueryPerformanceCount API
Frequency: 3579545
Begin Time: 3804729124
End Time: 3808298836
Lasting Time: 3569712

古人说，触类旁通。从一本介绍图形编程的书上得到一个如此有用的实时处理知识，我感到非常高兴。有美不敢自专，希望大家和我一样喜欢这个轻便有效的计时器。

参考资料：
[YUAN 2002]Feng Yuan 著，英宇工作室译，Windows图形编程，机械工业出版社，2002.4.，P15-17

本文链接

[转载]CreateWaitableTimer和SetWaitableTimer函数

2012-05-15T00:58:00Z

使用定时器的API函数CreateWaitableTimer和SetWaitableTimer来实现了，这对API函数创建的时钟是比较精确的，可以达到100倍的10亿分之一秒,即100纳秒。

函数CreateWaitableTimer和SetWaitableTimer声明如下：

WINBASEAPI
__out
HANDLE
WINAPI
CreateWaitableTimerA(
    __in_opt LPSECURITY_ATTRIBUTES lpTimerAttributes,
    __in     BOOL bManualReset,
    __in_opt LPCSTR lpTimerName
    );
WINBASEAPI
__out
HANDLE
WINAPI
CreateWaitableTimerW(
    __in_opt LPSECURITY_ATTRIBUTES lpTimerAttributes,
    __in     BOOL bManualReset,
    __in_opt LPCWSTR lpTimerName
    );
#ifdef UNICODE
#define CreateWaitableTimer CreateWaitableTimerW
#else
#define CreateWaitableTimer CreateWaitableTimerA
#endif // !UNICODE

WINBASEAPI
BOOL
WINAPI
SetWaitableTimer(
    __in     HANDLE hTimer,
    __in     const LARGE_INTEGER *lpDueTime,
    __in     LONG lPeriod,
    __in_opt PTIMERAPCROUTINE pfnCompletionRoutine,
    __in_opt LPVOID lpArgToCompletionRoutine,
    __in     BOOL fResume
    );

lpTimerAttributes是设置定时器的属性。
bManualReset是是否手动复位。
lpTimerName是定时器的名称。
hTimer是定时器的句柄。
lpDueTime是设置定时器时间间隔，当设置为正值是绝对时间；当设置为负数是相对时间。
lPeriod是周期。
pfnCompletionRoutine是设置回调函数。
lpArgToCompletionRoutine是传送给回调函数的参数。
fResume是设置系统是否自动恢复。

调用函数的例子如下：
#001 //创建定时器
#002  //蔡军生 2007/11/06 QQ:9073204 深圳
#003  int CreateTestTimer(void)
#004  {
#005         HANDLE hTimer = NULL;
#006         LARGE_INTEGER liDueTime;
#007
#008         //设置相对时间为10秒。
#009         liDueTime.QuadPart = -100000000;
#010
#011      ;   //创建定时器。
#012        hTimer = CreateWaitableTimer(NULL, TRUE, _T("TestWaitableTimer"));
#013         if (!hTimer)
#014         {
#015               return 1;
#016         }
#017
#018         OutputDebugString(_T("10秒定时器/r/n"));
#019
#020         // 设置10秒钟。
#021        if (!SetWaitableTimer(hTimer, &liDueTime, 0, NULL, NULL, 0))
#022         {
#023               //
#024               CloseHandle(hTimer);
#025               return 2;
#026         }
#027
#028         //等定时器有信号。
#029         if (WaitForSingleObject(hTimer, INFINITE) != WAIT_OBJECT_0)
#030         {
#031               OutputDebugString(_T("10秒定时器出错了/r/n"));
#032               //
#033               CloseHandle(hTimer);
#034               return 3;
#035         }
#036         else
#037         {
#038               //10秒钟到达。
#039               OutputDebugString(_T("10秒定时器到了/r/n"));
#040         }
#041
#042         //
#043         CloseHandle(hTimer);
#044         return 0;
#045  }

本文链接

[转载]VC实现CPU速度自测

2012-05-13T15:08:00Z

简单说下原理：
在两个固定的时刻测出当前CPU的时钟计数，用这个计数除以间隔的时间就得到相应的频率值了。
需要说明的是为了获得当前CPU的内侧时钟值，要采用内嵌汇编的方式得到，这就要将当前的测试进程的优先级设定的较高，故采用了实时进程优先级：REALTIME_PRIORITY_CLASS,该优先级别高，并且有这种权限的进程中的所有线程要比其他进程中的所有线程的级别都高。

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
85
86
87
88
89
90
91
92
93
94
95
96
97

用VC实现CPU速度自测

#include <windows.h>
#include <iostream>
using namespace std;
//测试速度的子程序
float MeasureSpeed(void);
int main(void)
{
cout << "您的CPU的运行速度是: " << MeasureSpeed() << "MHz" << endl;
system("pause");
return 0;
}
float MeasureSpeed()
{
unsigned long int ticks; //先是存放计时次数，后存放固定时间间隔值
unsigned long int stock0, stock1; //存放两固定时刻的CPU内置时钟值，值的含意为计数
unsigned long int cycles; //存放内置时钟值之差，好固定时段的计数值
unsigned long int freq[5] = {0,0,0,0,0}; //存放频率，为了提高精度，采用了相邻的测的5个频率的平均值
unsigned long int nums = 0; //循环次数
unsigned long int total = 0; //存放频率之和
LARGE_INTEGER t0,t1;
LARGE_INTEGER countfreq;
//返回高精度的计数频率，即每秒多少次;
if (!QueryPerformanceFrequency( &countfreq ) )
{
return 0.0f;
}
//返回特定进程的优先级;
DWORD priority_class = GetPriorityClass(GetCurrentProcess());
//返回特定线程的优先级;
int thread_priority = GetThreadPriority(GetCurrentThread());
//将当前进程设成实时进程;
SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
//设定线程优先级;
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
do
{
nums++;
freq[4] = freq[3];
freq[3] = freq[2];
freq[2] = freq[1];
freq[1] = freq[0];
//返回高精度计数的值;
QueryPerformanceCounter(&t0);
t1.LowPart = t0.LowPart;
t1.HighPart = t0.HighPart;
//这句中的50和后面相同语句中的1000是一个经验值，起的作用是控制时间间隔，可以
//调节这两个值来实现最佳时间间隔。
while ( (unsigned long int)t1.LowPart - (unsigned long int)t0.LowPart<10)
{
QueryPerformanceCounter(&t1);
}
_asm
{
rdtsc //启动读取CPU的内置时钟，其返回值是个64位的整数，高32到EDX，低32到EAX里
mov stock0, EAX //高位部份在短暂时间内是不会有变化的，故无需读出对比
}
t0.LowPart = t1.LowPart; // 重置初始时刻
t0.HighPart = t1.HighPart;
while ((unsigned long int)t1.LowPart-(unsigned long int)t0.LowPart<1000 )
{
QueryPerformanceCounter(&t1);
}
_asm
{
rdtsc
mov stock1, EAX
}
cycles = stock1 - stock0;
ticks = (unsigned long int) t1.LowPart - (unsigned long int) t0.LowPart;
ticks = ticks * 1000000;
ticks = ticks / countfreq.LowPart;
if ( ticks % countfreq.LowPart > countfreq.LowPart/2 )
{
ticks++; // 使数据收敛
}
freq[0] = cycles / ticks; // 求出频率，单位：MHz
if ( cycles%ticks > ticks/2 )
{
freq[0]++; // 使数据收敛
}
total = (freq[0] + freq[1] + freq[2] + freq[3] + freq[4]);
} while ((nums < 5 ) || (nums < 100) && ( (abs(5 * freq[0] - total) < 5)
|| (abs(5 * freq[1]-total) < 5) || (abs(5 * freq[2] - total) < 5)
|| (abs(5 * freq[3]-total) < 5) || (abs(5 * freq[4] - total) < 5)
));
//条件循环，以确保循环不少于5次，在大于5次后确保达到一定的精度后退出
if ( total/5 != ( total + 1 )/5 )
{
total ++; // 使数据收敛
}
// 恢复进程及线程的优先级别;
SetPriorityClass(GetCurrentProcess(), priority_class);
SetThreadPriority(GetCurrentThread(), thread_priority);
return float(total) / 5.0f;
}

上面的程序，可以做一定修改，循环中的控制语句也可以作适当的调整，来提高测试精度。调试环境VC6.0/XP

转载地址：http://blog.liuyixi.com/2009/07/02/vcshixiancpusuduzice/

本文链接

自动刷新查询火车票脚本

2012-01-19T11:56:00Z

本脚本来自网络，博主已验证，确实可以用。

关键是想买票得勤劳，建议6点爬起来，开浏览器登录，等到放票时间第一时间买

考虑到网络不通和不停手刷的双重折磨，写个脚本稍微减轻下这种痛苦

脚本目的：

1、session保持在线，不会下线，这样6点系统开登陆，刷到出票；

2、有新票提醒；

3、可以最小化浏览器干其他事情；

1、用Chrome（下载地址在这里：http://dl.pconline.com.cn/download/51614.html）浏览器,

2、到https://dynamic.12306.cn/otsweb/登录

3、点击车票预订

4、填好出发地、目的地、出发日期、出发时间，然后右键单击出发车次这个文本框->选择-审查元素

5、然后在控制台上，input的节点，选择add attribute（插入属性），插入以下脚本：

添加注入脚本内容：

onclick="mark=1;$(this).after('by UING,刷票并保持在线脚本1.0');kkk=function(){if(mark==0)return;mark++;$('#gridbox .row20px tr').find('td').each(function(){if($(this).index()==10) {if($(this).text()!='无' && $(this).text()!='--' && $(this).text().indexOf('次')==-1){alert('有硬卧票了！'); mark=0;}else{$(this).html('检测'+mark+'次')}}});$('#submitQuery').click(); setTimeout(kkk,2000)};kkk();"

6、回到页面，点下刚才编辑的文本框，触发JS事件，开始执行注入脚本。

注

1、$(this).index()==10 两次出现的10是第十列硬卧，按页面顺序软卧、软座的话改成9、11，以此类推

2、有票后弹窗并停止执行

3、懂jq的可以自行修改，这里仅抛砖引玉

4、放票时间参考12306首页，（http://www.12306.cn/mormhweb/zxdt/tlxw_tdbtz19.html）全天整点前后有少量票放出

-------用这段代码，有卧铺票时候直接点击购买，不弹窗提示

onclick="mark=1;$(this).after('by UING,刷票并保持在线脚本1.0');kkk=function(){if(mark==0)return;mark++;$('#gridbox .row20px tr').find('td').each(function(){if($(this).index()==10) {if($(this).text()!='无' && $(this).text()!='--' && $(this).text().indexOf('次')==-1) {mark=0;$(this).parent().find('.yuding_u_over').click();}else{$(this).html(' 检测'+mark+'次 ')}}});$('#submitQuery').click();setTimeout(kkk,2000)};kkk();"

===========================================================

下面是另一种方式。

技术宅范的
https://github.com/zzdhidden/12306
需使用谷歌浏览器。
安装该插件。
https://github.com/zzdhidden/12306/raw/master/12306BookingAssistant.user.js
登陆 https://dynamic.12306.cn/otsweb/

本文链接

北欧国旗的十字架

2011-12-10T03:12:00Z

北欧国旗的十字架

一一五七年，瑞典与芬兰发生战争，丹麦、冰岛、挪威也席卷进去。当时埃里克王向神祷告，结果奇迹发生了，蓝天上光彩奕奕闪烁着十字架光芒（实际是自然天象），十字架对基督教来说象征着仁爱。于是他们认为这是上帝的指示。于是北欧五国化干戈为玉帛，不仅宣誓结盟，而且五国都把国旗添上了个十字架。这就是北欧五国十字国旗的由来。

详细讲解

首先，北欧五国是指芬兰、瑞典、挪威、丹麦和冰岛。
第二，北欧五国都带国旗都有十字架的原因及过其含义。

北欧五国国旗选用基督教十字架为主要图案。在北欧历史上，最早使用基督教十字架为国旗图案的是丹麦，此后其他北欧国家均采用此法。

芬兰 Finland

蓝色表示湖泊和天空，白色代表雪，十字代表芬兰是北欧各国的一员，在官方正式场合中，则使用十字中心有只狮子的国旗。

瑞典 Sweden

一一五七年瑞典和芬兰发生单争时，艾利克王在向神祷告时，看到蓝天上散发金光的十字架，据说是瑞典国旗的由来，事实上是由古代佛尔昆王朝中的金色十字架，以蓝底为本而设计的。

挪威 Norway

挪威与丹麦结盟时以红底白十字为国旗，联邦瓦解后，于是加上蓝色十字，蓝、白、红代表自由、平等、博爱。

丹麦 Denmark

丹麦的国旗是世界上最古老的国旗，十三世纪初，华德马尔二世和爱斯托尼亚人苦战时，奇迹突然降到他身上当时他张挂此旗作战大获全，于是丹麦一直使用这面旗。另一种说法，此旗是教宗送给十字军的旗帜，十字架代表教宗的支持。

冰岛 Iceland

基于历史及民族共通性，冰岛的国旗是采用北欧各国共通的十字形，蓝色自古以是冰岛民族的色彩，在传统服饰上经常使用的蓝色。

本文链接

lu面

2011-09-26T05:12:00Z

2006/8/10 13:48:37
到上海好几年了，却始终无法感受沪菜的精妙，这大概与我缺乏“吃”觉神经有关，总感觉吃难以在我的大脑皮层留下深刻的印象，有时吃到一个东西很好吃，可常常不久便忘了，不记得那样好吃的叫什么名，也记不清在哪里吃的，有点苦恼。但是，有些东西即使很久没吃过了，却是总忘不了，比如从小常吃却吃不腻的——Lu面。

从记得Lu面是什么味道开始，我始终只知读音，不知这Lu是哪个字，我奶奶不知道，我妈也不知道，以致我在说到这个字的时候，大脑里只好用“六面”、“陆面”、“鲁面”这些来代替。后来到了大学，跟一些同学说起Lu面时，他们都没吃过，也不曾听过，这面流传范围不广，不应该啊。不过名字不知如何写，读音也是方言，介绍起来确也困难。有人说是“卤面”，但明显做法跟“卤”是不同的；另有河南同学说是“焖面”，因为做法类似，后来兄弟们叫嚣着让他去河南餐馆请客，我点了焖面，不一样，跟Lu面还是有很大差距。再以后，在外面始终是无法吃到卤面，家里自从奶奶去世以后，也吃的更少了，而Lu面的Lu究竟哪个字，已成为萦绕心头二十多年的历史性难题。

今天这个难题终于得到了解答。偶然翻起的一张旧报纸，角上有篇文章《赵家私房菜》，说的是赵树理家的私房菜。赵树理在北京居住时，有一次请老舍先生在家里吃饭，赵树理特别向老舍介绍正在吃着的那碗面。赵树理说，那叫“垆面”。老赵还专门下了考证的功夫，说“垆”是当年卓文君与司马相如相恋“当垆卖酒”的那个“垆”字。老赵说时蛮正经，不像是逗笑。老赵特别说，这可比焖面更好吃。文章里还介绍了“赵家垆面”的做法，与我印象中也是一致。

“做垆面讲究的是好豆角（我家那边叫四季豆）。大约一斤半豆角配一斤面最合适。豆角洗净后不要切，而要一截一截地掐断，长一寸左右。掐断的比刀切的“入味”。然后用油炒，加盐、酱油、大料等。菜炒好，加水微煮。在煮时，把面放到上面，去焖。也有人先盛出一点菜汤，等蒸到三五分钟后再浇上一点。待面熟，铲起下面的豆角与面拌匀，那真可说是香气扑鼻。最重要的，事关好吃不好吃的大事有两点：一是，一定要手擀面，决不许用机压面或是挂面。加压面作出来，面与豆角互不粘连，像是拌上去的，此为大忌。而是擀面越硬越好。不能偷巧惜力，要和硬面，用力擀薄，力求切细。”
。。。。。。。。。。。。。。。。。。。。。。。。。。。。
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
流两排口水记之。
==========
本是06年写在msn space的 space废了现在转过来保存一下
本文链接

【转载】粤语翻译工具

2011-09-09T06:27:00Z

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.border.TitledBorder;

/**
* 粤语转换工具
* @author tiger
* @date 2011-04-13
*
* 选中上面框中的词语，可同步在下框中显示出翻译出的词语。
*/
public class Yueyu {

private static List<String> putongs = new ArrayList<String>();
private static List<String> yues = new ArrayList<String>();

static{

add("了", "左");
add("不", "唔");
add("是", "系");

add("说", "话");
add("想念", "挂住");
add("不是", "唔系");
add("说话", "讲野");

String yueyu_putonghua = "我(我) 你(你) 佢(他) 我哋(我们) 你哋(你们) 佢哋(他们) 人哋(人家) " +
"呢度(这里) 嗰度(那里) 边度(哪里) 呢(这) 嗰(那) 咁样(这样、那样)点解(为什么) 第日(改天) " +
"第次(下次)乜嘢(什么) 乜(什么) 几多(多少) 边(哪) 咁好(这么好)阿爸(爸爸) 阿妈(妈妈) 阿哥(哥哥) " +
"阿嫂(嫂嫂) 阿爷(爷爷) 阿嫲(奶奶) 阿公(外公) 阿婆(外婆、老婆婆) 阿叔(叔叔) 老豆(爸爸)! 老妈子(妈妈) " +
"家姐(姐姐)大佬(哥哥) 细佬(弟弟) 心抱(媳妇) 舅父(舅舅) 孙(孙子) 仔仔(儿子) 女女(女儿) 契爷(干爹) 契仔(干儿子) 寡佬(单身汉) " +
"仔(儿子) 女(女儿) 后底乸(继母) 太子爷(少东家) 契弟(王八蛋) 老坑(老头) 老嘢(老东西，老家伙) 老姑婆(老处女) 基老(男同性恋者) 老细(老板) " +
"老千(骗子) 后生仔(年轻小伙子) 后生女(年轻姑娘) 靓仔(漂亮的小伙子) 靓女(漂亮的姑娘) 细路(小孩) 细蚊仔(小孩) " +
"臊虾(婴儿) 马仔(打手) 事头婆(老板娘)返工(上班) 收工(下班) 揾食(谋生) 人工(工钱) 出粮(发工资) 搞掂(搞妥当) 搞弯(弄糟糕) " +
"就手(顺利) 捱夜(熬夜) 空姐(飞机女服务员) 钟点工(计时工) 揾工(找工作) 做嘢(干活) 捞边行(搞什么行业) 一脚踢(一人承担) 轮更(轮班) " +
"看更(看门) 起屋(盖房子) 抓车(驾驶汽车)熟手(老练) 车衫(缝衣服) 夹手夹脚(一起动手) 执头执尾(收拾零碎的东西) 搏命(拼命) 癐(累) " +
"差池(差错) 撞板(碰钉子) 松人(溜走) 走人(溜走) 炒鱿鱼(解雇) 开OT(加班) 秘捞(兼职) 手信(小礼物) 人客(客人) 生埗(陌生、生疏) " +
"老友记(老朋友) 仇口(仇人) 托大脚(拍马屁) 危(求) 畀面(给面子) 制(肯) 得闲(有空) 冇几何(不常) 冇相干(没关系) 唔觉意(不留心) " +
"唔话得(没说的) 倾(谈) 倾偈(聊天) 早晨(早上好) 早唞(晚安) 揾人(找人) 拍拖(谈恋爱) 挂住(想念) 隔篱(隔壁) 掟煲(恋人分手) " +
"好夹(很合得来) 探(拜访) 讲笑(开玩笑) 羞家(丢脸) 起身(起床) 着(穿) 除(脱) 浪口(漱口) 飞发(理发) 电发(烫发) " +
"洗面(洗脸) 屙屎(大便) 屙尿(小便)闩门(关门) 熄灯(关灯) 水喉(水龙头) 瞓觉(睡觉) 食(吃) 食晏(吃午餐) 食烟(抽烟) " +
"滚水(开水) 煲(煮) 焗(焖) 饮胜(干杯) 颈渴(口渴) 餸(下饭的菜) 腍(软) 霄夜(夜宵) 饮(渴) 台(桌子) 梳化(沙发) 雪柜(冰箱) " +
"傢俬(家具) 皮箧(皮箱) 夹万(保险箱) 刀仔(小刀) 花樽(花瓶) 香枧(香皂) 镬(锅) 咪(麦克风) 插苏(插座) 火水(煤油) 遮(伞) 地拖(拖把) " +
"电心(电池) 洋烛(蜡烛) 花洒(莲蓬头) 壳(勺子) 番枧(肥皂) 扫把(扫帚) 匙羹(小勺子) 褛(外套) 大褛(大衣) 衫(衣服) " +
"T恤(针织或棉质上衣) 裤(裤子) 鞋(鞋子) 底衫(内衣) 底裤(内裤) 高争鞋(高跟鞋) 领太(领带) 荷包(钱包) 唇膏(口红)" +
"头壳(脑袋) 头皮(头屑) 面珠墩(脸蛋儿) 酒凹(酒窝) 下爬(下巴) 眼(眼睛) 眼眉(眉毛) 眼核(眼珠) 耳仔(耳朵) 耳屎(耳垢) 大牙(槽牙) " +
"鼻哥(鼻子) 鼻哥窿(鼻孔)身子(身体) 心口(胸口) 膊头(肩膀) 毛管(毛孔)罗柚(屁股) 手板(手掌) 手瓜(胳膊) 脚(脚、腿) 背脊(脊背) " +
"尾龙骨(尾骨) 肚腩(小肚子) 睇医生(看病) 驳骨(接骨头) 联针(缝针) " +
"埋口(合口) 执药(抓药) 燥火(上火) 好翻(好了) 唔精神(不舒服) 冻亲(着凉) 头赤(头痛) 打冷震(发抖) 打噎(打嗝) 呕血(吐血) 浊亲(被水呛着)";

String yueyu_putonghua_2 =
"岳高头(仰起头)拧头(摇头) 目及 geb6(盯)眯méi1埋眼(闭眼)瞌heb3(闭)啜(嘬，吻)噍(嚼) 唞气(呼吸) 渺嘴(撇嘴) 擘大口(张大口)" +
"喐手(动手)笃(戳) 笠(套) 弗fit1(鞭打)抰yêng2(抖)揞(蒙，捂)搣mit1(掰)摱man1(攀，扳)掹meng1(拔)豆(碰，摸)掟déng3(扔)抠(掺杂)" +
"抠乱(搞混了) 抄cao3(搜，翻)挤(放)搦(拿) 捽(揉) 掴(用掌打) 省(擦) 吉(扎，刺)批(削)濑(洒) 枳zed1入去(塞进去)走(跑)走夹唔唞(拼命走) " +
"标(冲)坎头埋墙(把头撞在墙上，形容人自讨苦吃)企(站) 嗌(叫，喊)嗌交(吵架) 撩(逗)单单打打(说风凉话，含沙射影，讽刺攻击)诈假ga1意yi1(假装)诈娇(撒娇)" +
"扭拧(扭捏) 睇衰(看不起，看扁) 索气(吸气)揩油、索油(占便宜)攞嚟衰(自讨苦吃) 储储埋埋(攒起来)打交(打架) 打横(横着)打掂(竖着) 打底(垫底)打赤脚(赤着脚)" +
" 打大赤肋(赤着上身)折堕(做孽，遭遇悲惨)惊géng1(害怕)发姣(卖弄风骚)锡(疼爱)孭(背) 得人惊(令人害怕) 得个吉(一场空) 厄水(骗钱) 邓(替) " +
"抵(值得) " +
"翻嚟(回来) 打个冷(转一回) 骑呢(古怪) 揾笨(占人便宜) 典地(撒赖) 碌(滚动) 睇水(把风) 大洗(花钱过度)";

String yueyu_putonghua_3 = "钟意(喜欢) 爱锡(疼爱)快活(快乐)得戚(得意洋洋) 嬲nao1(生气)发嬲(生气)笑骑骑(笑哈哈) 笑口噬噬(张开嘴笑)" +
"笑口吟吟(笑容满面)莲子蓉面口(比喻笑容满面)偷笑(暗笑)熠熟狗头(形容人张开嘴笑，像煮熟的狗头一样)火起(发火)火滚(恼火) 一把火(一肚子火)" +
"嬲爆爆(气冲冲)眼崛崛(瞪大眼睛，表示不满或生气) 崛(瞪)吹胀(1气坏，2无可奈何)肉赤(心疼)忧心(担心) 心淡(心灰意冷) 唔忿气(不服气)闭翳(发愁) " +
"喊(哭)喊苦喊忽(哭哭啼啼)苦瓜咁嘅面(像苦瓜那样拉长着脸，比喻愁眉苦脸)谷气(憋气)欢喜(喜欢) 乞人憎(令人讨厌)心思思(老惦念着)心挂挂(牵肠挂肚)" +
" 心水(心意) 愿(愿意)情愿(宁愿)心多多(三心两意)心喐喐(指动了心想做某事，但还没有行动)特登(故意) 爱(要)激气(心里有气) 专登(特意)失魂(慌张，精神恍惚)" +
"失魂鱼(形容人惊慌失措如受惊的鱼)心息(死心) 想话(打算)谂住(打算，预计) 心罨(心里悲伤难受)" +
"心甘(甘心) 乍乍帝(装模作样) 拾下拾下(傻乎乎) 戆居(呆，傻，笨) 凼(哄) 蕉积(嚣张，气焰高涨) 个心嗱住(心里酸溜溜) ";

String yueyu_putonghua_4 = "乜(什么) 嘅(的) 嬲(生气)咁(如此) 哋(们) 睇(看) 啲(那些) 冇(没有) 惗(想) 嘎(啊) 咩(什么) 冧(陶醉) 波(球) 雪条(冰棒)" +
"啱啱(刚刚，刚好) 啱先(刚才) 正话(刚才) 凑啱(恰好) 不溜(一向) 先至(才) 就嚟(就要) 经已(已经) 卒之(终于) 终归(终究) " +
"终须(终究) 仲(还) 鬼咁(那么) 十分之(十分) 极之(极) 相当之(相当) 非常之(非常) 稍为(稍微) 净(光，只有) 净喺(只是，光是) " +
"差唔多(差不多) 连气(一连) 亦(也) 又试(又) 但凡(凡是) 逢喺(凡是) 咪mei2(别) 咪住(! 先别) 唔使(不用) 唔好(不好) 唔通(难道) 实(一定)" +
" 奉旨(肯定) 查实(其实) 是必(必定) 梗(肯定) 一于(就，表示下定决心去做某事) 千祈(千万) 专登(专门，故意) 特登(特地) 好在(幸亏) 直头(直接) " +
"直情(简直，根本) 同埋(和，同) 一喺(要么) 事关(因为) 固然之(固然) 固之然(固然) " +
"之不过(不过) 即管(尽管) 唔单只(不但) 不特止(不仅仅) 定(还是) 抑或(或者) 于是乎(于是) 然之后(然后) " +
"同(和) 为咗(为了) 啫(罢了) 之嘛(罢了) 啩(吧) " ;

add(yueyu_putonghua);
add(yueyu_putonghua_2);
add(yueyu_putonghua_3);
add(yueyu_putonghua_4);

}

/**
* 添加字库
* @param putonghua
* @param yueyu
*/
private static void add(String putonghua, String yueyu) {
putongs.add(putonghua);
yues.add(yueyu);
}

/**
* 添加字库
* @param str
*/
private static void add(String str) {
String temp;
String putonghua = "", yueyu = "";
boolean isPutong = false;
for (int i = 0; i < str.length(); i++) {
temp = str.substring(i, i + 1);
if(temp.equals(" "))
{
continue;
}
if(temp.equals("("))
{
isPutong = true;
}
else if(temp.equals(")"))
{
isPutong = false;
putongs.add(putonghua);
yues.add(yueyu);

System.out.println(putonghua + " , " + yueyu);

putonghua = "";
yueyu = "";
}
else{
if(isPutong)
{
putonghua += temp;
}else{
yueyu += temp;
}
}
}
}

/**
* 根据粤语词得到对应普通话
* @param yueyu
* @return
*/
private static String getPutonghua(String yueyu)
{
String result = yueyu;
for (int i = 0; i < yues.size(); i++) {
if(yues.get(i).equals(yueyu))
{
result = putongs.get(i);
}
}
return result;
}

/**
* 根据普通话词语得到对应粤语
* @param putonghua
* @return
*/
private static String getYueyu(String putonghua)
{
String result = putonghua;
for (int i = 0; i < putongs.size(); i++) {
if(putongs.get(i).equals(putonghua))
{
result = yues.get(i);
}
}
return result;
}

/**
* 普通话翻译为粤语
*
* 先判断两个字，尽量翻译之。如果翻译没有变化，再判断一个字。
*
* @param str
*/
private static String translate(String str) {
StringBuffer result = new StringBuffer();
String temp , yueyu;
int j;
int length = str.length();
for (int i = 0; i < length; i++) {
temp = str.substring(i, Math.min(i + 2, length));
yueyu = getYueyu(temp);
j = 1;
if(yueyu.equals(temp))
{
temp = str.substring(i, i + 1);
yueyu = getYueyu(temp);
j = 0;
}
i += j;
result.append(yueyu);
}
return result.toString();
}

/**
* 粤语翻译为普通话
*
* 先判断两个字，尽量翻译之。如果翻译没有变化，再判断一个字。
*
* @param str
*/
private static String translate2(String str) {
StringBuffer result = new StringBuffer();
String temp , putong;
int j;
int length = str.length();
for (int i = 0; i < length; i++) {
temp = str.substring(i, Math.min(i + 2, length));
putong = getPutonghua(temp);
j = 1;
if(putong.equals(temp))
{
temp = str.substring(i, i + 1);
putong = getPutonghua(temp);
j = 0;
}
i += j;
result.append(putong);
}
return result.toString();
}

class transToPutong implements ActionListener{
JTextArea area1, area2;
public transToPutong(JTextArea area1, JTextArea area2) {
this.area1 = area1;
this.area2 = area2;
}
@Override
public void actionPerformed(ActionEvent e) {
String text = area1.getText();
area2.setText(translate2(text));

isTranslateYueyu = false;
}
}

class transToYueyu implements ActionListener{
JTextArea area1, area2;
public transToYueyu(JTextArea area1, JTextArea area2) {
this.area1 = area1;
this.area2 = area2;
}
@Override
public void actionPerformed(ActionEvent e) {
String text = area1.getText();
area2.setText(translate(text));

isTranslateYueyu = true;
}
}

boolean isTranslateYueyu ;

class areaAction1 extends MouseAdapter{
JTextArea area1, area2;
public areaAction1(JTextArea area1, JTextArea area2) {
this.area1 = area1;
this.area2 = area2;
}
@Override
public void mouseReleased(MouseEvent e) {
super.mouseReleased(e);
String text = area1.getSelectedText();
String text2 = area2.getText();
if(text == null || text.trim().equals("") || text2 == null || text2.trim().equals(""))
{
return;
}
String transText = "";
if(isTranslateYueyu)
{
transText = getYueyu(text);
}else{
transText = getPutonghua(text);
}

int index = text2.indexOf(transText);
if(index != -1)
{
area2.requestFocus();
area2.setSelectionColor(Color.black);
area2.setSelectedTextColor(Color.GREEN);
area2.setSelectionStart(index);
area2.setSelectionEnd(index + transText.length());
area2.repaint();
}
}
}

/**
* @param args
*/
public static void main(String[] args) {

Yueyu y = new Yueyu();

JFrame frame = new JFrame("粤语翻译");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JPanel panel = new JPanel();
panel.setLayout(new BorderLayout());

JPanel textPanel = new JPanel();
textPanel.setLayout(new GridLayout(2, 1));

JTextArea area1 = new JTextArea(6, 36);
area1.setFont(new Font("Serif",Font.PLAIN,20));
area1.setBorder(new TitledBorder("输入要翻译的文字:"));
textPanel.add(area1);

JTextArea area2 = new JTextArea(6, 36);
area2.setFont(new Font("Serif",Font.PLAIN,20));
area2.setBorder(new TitledBorder("翻译后的文字："));
textPanel.add(area2);

panel.add(textPanel, BorderLayout.CENTER);

area1.addMouseListener(y.new areaAction1(area1, area2));

JPanel ctrlPanel = new JPanel();
ctrlPanel.setLayout(new GridLayout(2, 1, 0, 6));
JButton btn1 = new JButton("转为粤语");
ctrlPanel.add(btn1);

JButton btn2 = new JButton("转为普通话");
ctrlPanel.add(btn2);
panel.add(ctrlPanel, BorderLayout.EAST);

btn1.addActionListener(y. new transToYueyu(area1, area2));
btn2.addActionListener(y. new transToPutong(area1, area2));

frame.getContentPane().add(panel);
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);

}

}

转载地址：http://www.cnblogs.com/chaohi/archive/2011/05/31/2064099.html

编辑器加载中...

本文链接

异形魔方的解法

2011-08-20T15:17:00Z

异形魔方的算法。by @沉默de世界

这个是暴力破解，打乱试了几次，一种用了7步还原，一种用了6步还原，估计大部分状态10步以内可以还原，超过10步计算就很费时了。

说明如图：（1）编号如图所示，上层12345678 下层11,12,13,14,15,16,17,18 。（2）R1动作为线前侧（图中5,6,7,8,14,15,16,17位置）旋转180度，R2为线前侧（7,6,5,4,18,17,16,15位置）旋转，R3为线右侧（3,4,5,6,12,13,14,15位置）旋转，R4为线右侧（5,4,3,2,16,15,14,13）旋转。（3）R5、R6、R7、R8分别对应上层顺时针旋转90度后执行R1、R2、R3、R4。（4）R9、R10、R11、R12分别对应上层顺时针旋转180度后执行R1、R2、R3、R4。（5）R13、R14、R15、R16分别对应上层顺时针旋转270度后执行R1、R2、R3、R4。（6）打乱状态starta，startb分别为上下两层、从左上角开始、按顺时针顺序的块编号,改程序中初始值即可。在以上转动过程中编号11的块位置是始终保持不变的。 //written by @沉默de世界#include "stdafx.h"
#include "stdio.h"

#define DEEP_MAX 20
//70*6 * 70*6 *4 * 6*6*4
typedef struct_CUBE_STATUS{
int a[8];
int b[8];
}CUBE_STATUS;

CUBE_STATUS cb0,cb1,cb;
int succflag=0;
int act[DEEP_MAX]={0};
int deep_i=-1;
int deep_max=-1;
int deep_reuslt=0;

void cpy(CUBE_STATUS *p1, CUBE_STATUS *p0);
void pntcb(CUBE_STATUS *p);
void Rot(CUBE_STATUS *p);
void Rn(CUBE_STATUS *p,int n);
int IsSame(CUBE_STATUS *p1,CUBE_STATUS *p2);

int main(int argc, char* argv[])
{

//int starta[8]={3,4,5,6,17,16,15,14};
//int startb[8]={11,12,13,2,1,8,7,18};

//int starta[8]={1,2,3,4,5,16,7,8};
//int startb[8]={11,12,13,14,17,6,15,18};

int starta[8]={5,14,3,16, 15,6,7,8};
int startb[8]={11,12,13,2, 1,4,17,18};

int i=0;

for (i=0;i<8;i++)
{
cb0.a[i]=i+1;//目标状态
cb0.b[i]=i+11;
cb1.a[i]=starta[i];//初始状态
cb1.b[i]=startb[i];

cb.a[i]=starta[i];
cb.b[i]=startb[i];
}

printf("start...\n");

if(IsSame(&cb,&cb0))
succflag=1;
else
{
for (deep_i=0,deep_max=1;deep_max<=DEEP_MAX;deep_max++)
{
printf("\nMAXDEEP: %d \n",deep_max);
Rot(&cb);
if(succflag==1)break;
}
}

if(succflag==1)
{
printf("\nSucceed! It need %d steppes. \n",deep_reuslt);

printf("start:");
pntcb(&cb1);

for (i=0;i<deep_reuslt;i++)
{
Rn(&cb1,act[i]);

printf("R%-2d-> ",act[i]);
pntcb(&cb1);
}
}
else
printf("failed!\n");

return 0;
}

void Rot(CUBE_STATUS *p)
{
int i;

if(deep_i>=deep_max) return;

for (i=1;i<=16;i++)
{
CUBE_STATUS tmp;

if( deep_i>0 )
{
if ( ( i==1 && (act[deep_i-1]==1 || act[deep_i-1]==5 || act[deep_i-1]==9 || act[deep_i-1]==13) )
|| ( i==2 && (act[deep_i-1]==2 || act[deep_i-1]==6 || act[deep_i-1]==10 || act[deep_i-1]==14) )
|| ( i==3 && (act[deep_i-1]==3 || act[deep_i-1]==7 || act[deep_i-1]==11 || act[deep_i-1]==15) )
|| ( i==4 && (act[deep_i-1]==4 || act[deep_i-1]==8 || act[deep_i-1]==12 || act[deep_i-1]==16) )
)
continue;
}

cpy(&tmp,p);
Rn(&tmp,i);
act[deep_i]=i;

if(IsSame(&tmp,&cb0))
{
succflag=1;
deep_reuslt=deep_i+1;
return;
}
else
{
deep_i++;
Rot(&tmp);
deep_i--;
if(succflag==1)
{
return;
}
}
}

}

int IsSame(CUBE_STATUS *p1,CUBE_STATUS *p2)
{
if(
(p1->b[0]==p2->b[0] && p1->b[1]==p2->b[1] &&
p1->b[2]==p2->b[2] && p1->b[3]==p2->b[3] &&
p1->b[4]==p2->b[4] && p1->b[5]==p2->b[5] &&
p1->b[6]==p2->b[6] && p1->b[7]==p2->b[7] )
&&(
(p1->a[0]==p2->a[0] && p1->a[1]==p2->a[1] &&
p1->a[2]==p2->a[2] && p1->a[3]==p2->a[3] &&
p1->a[4]==p2->a[4] && p1->a[5]==p2->a[5] &&
p1->a[6]==p2->a[6] && p1->a[7]==p2->a[7]) ||

(p1->a[0]==p2->a[2] && p1->a[1]==p2->a[3] &&
p1->a[2]==p2->a[4] && p1->a[3]==p2->a[5] &&
p1->a[4]==p2->a[6] && p1->a[5]==p2->a[7] &&
p1->a[6]==p2->a[0] && p1->a[7]==p2->a[1]) ||

(p1->a[0]==p2->a[4] && p1->a[1]==p2->a[5] &&
p1->a[2]==p2->a[6] && p1->a[3]==p2->a[7] &&
p1->a[4]==p2->a[0] && p1->a[5]==p2->a[1] &&
p1->a[6]==p2->a[2] && p1->a[7]==p2->a[3]) ||

(p1->a[0]==p2->a[6] && p1->a[1]==p2->a[7] &&
p1->a[2]==p2->a[0] && p1->a[3]==p2->a[1] &&
p1->a[4]==p2->a[2] && p1->a[5]==p2->a[3] &&
p1->a[6]==p2->a[4] && p1->a[7]==p2->a[5])
)
)
return 1;
else
return 0;
}

void R90(CUBE_STATUS *p)
{
int t0=0,t1=0;

t0=p->a[0];
t1=p->a[1];

p->a[0]=p->a[6];
p->a[1]=p->a[7];

p->a[6]=p->a[4];
p->a[7]=p->a[5];

p->a[4]=p->a[2];
p->a[5]=p->a[3];

p->a[2]=t0;
p->a[3]=t1;

}

void R180(CUBE_STATUS *p)
{
int t0=0,t1=0,t2=0,t3=0;

t0=p->a[0];
t1=p->a[1];
t2=p->a[2];
t3=p->a[3];

p->a[0]=p->a[4];
p->a[1]=p->a[5];
p->a[2]=p->a[6];
p->a[3]=p->a[7];

p->a[4]=t0;
p->a[5]=t1;
p->a[6]=t2;
p->a[7]=t3;

}

void R270(CUBE_STATUS *p)
{
int t0=0,t1=0;

t0=p->a[0];
t1=p->a[1];

p->a[0]=p->a[2];
p->a[1]=p->a[3];

p->a[2]=p->a[4];
p->a[3]=p->a[5];

p->a[4]=p->a[6];
p->a[5]=p->a[7];

p->a[6]=t0;
p->a[7]=t1;

}

void R1(CUBE_STATUS *p)
{
int ta7,ta6,ta5,ta4;

ta7=p->a[7];
ta6=p->a[6];
ta5=p->a[5];
ta4=p->a[4];

p->a[7]=p->b[3];
p->a[6]=p->b[4];
p->a[5]=p->b[5];
p->a[4]=p->b[6];

p->b[3]=ta7;
p->b[4]=ta6;
p->b[5]=ta5;
p->b[6]=ta4;
}

void R2(CUBE_STATUS *p)
{
int ta6,ta5,ta4,ta3;

ta6=p->a[6];
ta5=p->a[5];
ta4=p->a[4];
ta3=p->a[3];

p->a[6]=p->b[4];
p->a[5]=p->b[5];
p->a[4]=p->b[6];
p->a[3]=p->b[7];

p->b[4]=ta6;
p->b[5]=ta5;
p->b[6]=ta4;
p->b[7]=ta3;
}

void R3(CUBE_STATUS *p)
{
int ta2,ta5,ta4,ta3;

ta5=p->a[5];
ta4=p->a[4];
ta3=p->a[3];
ta2=p->a[2];

p->a[5]=p->b[1];
p->a[4]=p->b[2];
p->a[3]=p->b[3];
p->a[2]=p->b[4];

p->b[1]=ta5;
p->b[2]=ta4;
p->b[3]=ta3;
p->b[4]=ta2;
}

void R4(CUBE_STATUS *p)
{
int ta2,ta1,ta4,ta3;

ta1=p->a[1];
ta4=p->a[4];
ta3=p->a[3];
ta2=p->a[2];

p->a[4]=p->b[2];
p->a[3]=p->b[3];
p->a[2]=p->b[4];
p->a[1]=p->b[5];

p->b[2]=ta4;
p->b[3]=ta3;
p->b[4]=ta2;
p->b[5]=ta1;
}

void Rn(CUBE_STATUS *p,int n)
{
switch(n)
{
//case 0: R0(p);break;

case 1: R1(p);break;
case 2: R2(p);break;
case 3: R3(p);break;
case 4: R4(p);break;

case 5: R90(p);R1(p);break;
case 6: R90(p);R2(p);break;
case 7: R90(p);R3(p);break;
case 8: R90(p);R4(p);break;

case 9: R180(p);R1(p);break;
case 10: R180(p);R2(p);break;
case 11: R180(p);R3(p);break;
case 12: R180(p);R4(p);break;

case 13: R270(p);R1(p);break;
case 14: R270(p);R2(p);break;
case 15: R270(p);R3(p);break;
case 16: R270(p);R4(p);break;

default: ;
}
}

void cpy(CUBE_STATUS *p1, CUBE_STATUS *p0)
{
for (int i=0;i<8;i++)
{
p1->a[i]=p0->a[i];
p1->b[i]=p0->b[i];
}
}

void pntcb(CUBE_STATUS *p)
{
for (int j=0;j<8;j++)
{
printf("%d, ",p->a[j]);
}
printf(" ");
for (j=0;j<8;j++)
{
printf("%d, ",p->b[j]);
}
printf("\n");
}

本文链接

[转载]聪明地使用Google的7个技巧

2008-08-01T01:32:00Z

转载自：http://www.yeeyan.com/ 翻译: 余小果 10/18/2007 原文引用双语对照及眉批我在下面编辑了一份包含7个使用Google的技巧的清单,我相信每个人都会想要知道这些.我认为这些技巧合在一起已经代表了使用Google搜索的所有技巧和方法的最高成就.虽然除此之外还有很多小技巧,但这7个一直是我的最爱,好好享受吧.

转载：“凤求凰”的解释，有才

2008-04-19T09:12:00Z

三个字也是成语。“凤求凰”说的是汉代司马相如和卓文君的故事，来说说这个成语和其它相关的几个成语。司马相如这个人物，跟笔者我、读者你很多这些混BBS的文学青年们相比最大的区别就是：没什么区别。都是没什么实际的本事，口袋里没多少钱，还好写个贴子，喜欢个流行音乐，研究个穿衣吃饭泡MM，搞得挺有思想挺特别的样子其实没大出息，古代就有这种人。司马相如是成都人，本来叫司马犬子，就是...