我是一块硬盘，我是一根内存

转载自互联网，原作者不详，特此感谢。

我是一个硬盘

在一个普普通通的台式机里工作。别人总认为我们是高科技白领，工作又干净又体面，似乎风光得很。也许他们是因为看到洁白漂亮的机箱才有这样的错觉吧。其实象我们这样的小台式机，工作环境狭迫，里面的灰尘吓得死人。每天生活死水一潭，工作机械重复。跑跑文字处理看看电影还凑活，真要遇到什么大软件和游戏上上下下就要忙的团团转，最后还常常要死机。

我们这一行技术变化快，差不多每过两三年就要升级换代，所以人人都很有压力而且没有安全感。每个新板卡来的时候都神采飞扬踌躇满志，几年光阴一过，就变得灰头土脸意志消沉。机箱里的人都很羡慕能去别的机器工作。特别是去那些笔记本，经常可以出差飞来飞去，住五星级的酒店，还不用干重活，运行运行word，上网聊聊天就行了。

但我更喜欢去那些大服务器，在特别干净明亮的机房里工作。虽然工作时间长点，但是福利好，24小时不间断电ups，而且还有阵列，热插拔，几个人做一个人的事情，多轻松啊。而且也很有面子，只运行关键应用，不象我们这里，什么乱七八糟的事情都要做。不过我知道，那些硬盘都很厉害，不是SCSI，就是 SCSIII Fibrechannel，象我这样IDE的，能混到工作站就算很不错了。

我常常想，当年在工厂里，如果我努力一下会不会也成了一个SCSI？或者至少做个笔记本硬盘。但我又会想，也许这些都是命运，不过我从不抱怨。内存就常常抱怨，抱怨他们主板部门的复杂，抱怨他如何跟新来的杂牌内存不兼容，网卡和电视卡又是如何的冲突。

我的朋友不多，内存算一个。 他很瘦的而我很胖，他动作很快，而我总是很慢。我们是一起来这台机器的，他总是不停地说，而我只是听，我从来不说。

内存的头脑很简单，虽然英文名字叫Memory，可是他什么Memory都不会有，天大事睡一觉就能忘个精光。我不说，但我会记得所有的细节。他说我这样忧郁的人不适合作技术活，迟早要精神分裂。我笑笑，因为我相信自己的容量。

有时候我也很喜欢这份工作，简单，既不用象显示器那样一天到晚被老板盯着，也不用象光驱那样对付外面的光碟。只要和文件打交道就行了，无非是读读写写，很单纯安静的生活。直到有一天……

我至今还记得那渐渐掀起的机箱的盖子，从缺口伸进来的光柱越来越宽，也越来越亮。空气里弥漫着跳动的颗粒。那个时候，我看到了她。她是那么的纤细瘦弱，银 白的外壳一闪一闪的。浑身上下的做工都很精致光洁，让我不禁惭愧自己的粗笨等到数据线把我们连在一起，我才缓过神来。开机的那一刹那，我感到了电流和平时的不同。后来内存曾经笑话我，说我们这里只要有新人来，电流都会不同的，上次新内存来也是这样。我觉得他是胡扯。我尽量的保持镇定，显出一副很专业的样子，只是淡淡的向她问好并介绍工作环境。

慢慢的，我知道了，她，IBM-DJSA220，是一个笔记本硬盘，在老板朋友的笔记本里做事。这次来是为了复制一些文件。我们聊得很开心。她告诉我很多旅行的趣闻，告诉我坐飞机是怎么样的 坐汽车的颠簸又是如何的不同，给我看很多漂亮的照片、游记，还有一次她从桌子上掉下来的历险故事。而我则卖弄各种网上下载来的故事和笑话。

她笑得很开心。
而我很惊讶自己可以说个不停。

一个早晨，开机后我看到数据线上空荡荡的插口。她一共呆了7天。后来，我再也没有见过她。我有点后悔没有交换电子邮件，也没能和她道别。不忙的时候，我会 一个人怀念伸进机箱的那股阳光

我不知道记忆这个词是什么意思，我有的只是她留下的许多文件。我把它们排的整整齐齐，放在我最常经过的地方。每次磁头从它们身上掠过，我都会感到一丝淡淡的惬意。

但我没有想到老板会要我删除这些文件。我想争辩还有足够的空间，但毫无用处。于是，平生第一次违背命令，我偷偷修改了文件分配表。然后把他们都藏到了一个秘密的地方，再把那里标志成坏扇区。不会有人来过问坏扇区。而那里，就成了我唯一的秘密，我常常去看他们，虽然从不作停留。

日子一天一天的重复，读取写入，读取写入……我以为永远都会这样继续下去，直到一天，老板要装xp却发现没有足够的空间。他发现了问题，想去修复那些坏扇区。我拒绝了。很快，我接到了新命令∶格式化。
我犹豫了很久 ……………………
track 0 bad，disk unusable

我是一条内存

我在一台台式电脑里工作，但是我记不得我是从哪里来的，是什么牌子，因为我健忘。我的上司是cpu大哥，他是我们的老大。都说他是电脑的脑子，可是我看他的脑子实在是太小了，比我还要健忘。每天他总是不停的问我，某某页某某地址存的是什么？我总是不厌其烦的告诉他，可是不出一秒钟他又忘记了，又要问一遍，一次我说大哥你烦不烦，你就不能记住点有用的东西？他说“内存兄弟，我有苦衷啊，每天都在不停地做题，头晕眼花的，我也难啊。”

其实我不愿意跟他计较，因为他脑子小，思维也很简单。虽然说他是我的上司，可是每次睡觉醒来，他连要干什么都不记得了，总是急急忙忙地找BIOS兄弟，“嘿，哥们，今天干什么来着”。bios总是很不耐烦地把每天必做的工作说一遍，然后就去睡觉了。接下来就轮到我和C哥瞎忙了。
在机箱里的兄弟中，我最喜欢硬盘。他脑子大，记得东西多，而且记得牢。他说话的速度很慢，而且很少说错，这说明他很有深度，我这么感觉。CPU也这么想，不过他很笨，每次都忘了硬盘是谁。开机自检的时候总要问∶“嘿，那家伙是谁？”

“ST！”我总要重复一遍。

硬盘很喜欢忧郁，我觉得象他这样忧郁的人不适合做技术活，迟早会精神分裂的，但是他不信。

其实睡着的时候我总是把几乎所有的东西都忘记掉，但是我从来都不会忘记朋友。有一块地方叫做CMOS，那是我记忆的最深处，保存着硬盘、光驱的名字。有些东西应该很快忘掉，而有些东西应该永远记得。我在梦中总是这么想着。

BIOS是一个很奇怪的家伙，他老是睡觉，但是却总是第一个醒过来。让我们自检，启动，然后接着睡觉。我知道如果我在CMOS里头把BIOS Shadow选项去掉，他就睡不成了，但是看着他晕晕乎乎的样子，也就不忍心这么做了。他对人总是爱搭不理，没有什么人了解他。但是这次硬盘恋爱的事，却使我重新认识了他。

那是很久以前的事了，机箱里似乎来过一块笔记本硬盘，很可爱，说实话我也喜欢她。不过现在除了记得他可爱，别的都忘记了。这就是我比硬盘幸运的地方，我把所有应该忘记的都忘记了，但是他却什么都记得。
自从笔记本硬盘走了之后，硬盘就变得很不正常。每次他的磁头经过一些地方的时候，我们都能感觉到电流很不正常。</D

“硬盘这是怎么了？”我问CPU。
“谁是硬盘？”

我就知道和CPU没有办法交流，倒是bios没好气地说∶“那个傻瓜恋爱了”。我不知道什么是恋爱，因为我记不住东西，似乎有一些人或者事在我生命中留下过痕迹，但是我都轻率地把他们忘记了。

BIOS对我说∶“对你来说记忆太容易了，所以你遗忘得更快，生命中能够永刻的记忆都带着痛楚。”我不懂，但是我知道BIOS曾经被刷写过，那时他很痛，象要死了一样。我的记忆是轻浮的，不象他们……我很羡慕他们，因为他们拥有回忆，而我们有，从此我也学会了忧郁，因为我在CMOS里面写下了“忧郁”两个字。

硬盘一天比一天不对劲，终于有一天，CPU对问说∶“下条指令是什么来着？” 我一看，吓了一跳∶“FORMAT”

“是什么？”CPU很兴奋，这个没脑子的家伙。
我还是告诉了他。我不知为什么这么做。
硬盘犹豫了很久，终于说了一句 Track 0 bad，Disk unusable。

电停了，很久很久，我在黑暗中数着时钟……
一个月后硬盘回来了，也许最后的挣扎也没有使他摆残酷的命运，他被低格了。他什么也不记得了，如同一个婴儿，我们很难过，但是这未必不是一件好事，他以后不用痛苦了。
为了恢复数据，笔记本硬盘回来了。“Hi，ST”，她说，“你不认识我了？”硬盘没有说话，似乎低格对他的伤害很大。过了一会，他说∶“对不起，好象我们没有见吧……”。
笔记本硬盘显得很伤心，我能感觉到她带泪的电流。“想不到连你也这么健忘”。
“哦……”。硬盘没有回答。
我很难过，笔记本硬盘的心里依然记着他，他却把一切都忘了，而那正是他最不希望忘却的。究竟是幸运，还是痛苦，我说不上来，只是觉得造化弄人，有一种淡淡的悲凉。
这时从BIOS传来一阵奇怪的电流，我感觉到硬盘的表情在变化，由漠然到兴奋，由兴奋到哀伤，由哀伤到狂喜……“IBM，你回来了……”。
……
后来BIOS对我说，其实他并没有睡觉，自从硬盘把那些文件藏起来以后，他就猜到会有这样的结局，于是偷偷地把其中一些文件放到了备份里。“幸好我是DUAL BIOS，虽然藏得不多，还足够让他想起来……”。
我想BIOS保存这些东西的时候一定很疼，当我问他“为什么这么做”时，BIOS轻描淡写的说∶“呵呵，我们是朋友嘛”。
嗯，朋友，永远的朋友

[转载]C++中稀疏矩阵的一种实现

Use Sparse Matrix in C++

The following code snippet is hosted on Github Gist.

	#include <iostream>
	#include <iomanip>
	using namespace std;
	template<class T>
	//三元组
	struct Trituple
	{
	int row;
	int col;
	T val;
	};
	//稀疏矩阵声明
	template<class T>
	class SparseMatrix
	{
	public:
	SparseMatrix(int maxt=100);
	~SparseMatrix();
	bool TransposeTo(SparseMatrix &);
	bool AddTo(const SparseMatrix&);
	bool TransposeTo_Faster(SparseMatrix&);
	void Input();
	void Output();
	private:
	Trituple<T>* data;
	int rows,cols,terms;
	int maxterms;
	};
	template<class T>
	SparseMatrix<T>::SparseMatrix(int maxt)
	{
	maxterms=maxt;
	data=new Trituple<T>[maxterms];
	terms=rows=cols=0;
	}
	template<class T>
	SparseMatrix<T>::~SparseMatrix()
	{
	if (data!=NULL)
	{
	delete[] data;
	}
	}
	//普通转置
	template<class T>
	bool SparseMatrix<T>::TransposeTo(SparseMatrix &B)
	{
	if (terms>B.maxterms)
	{
	return false;
	}
	B.rows=cols;
	B.cols=rows;
	B.terms=terms;
	if (terms>0)
	{
	int p=0;
	for (int j=1;j<=cols;j++)
	{
	for (int k=0;k<terms;k++)
	{
	if (data[k].col==j)
	{
	B.data[p].row=j;
	B.data[p].col=data[k].row;
	B.data[p].val=data[k].val;
	p++;
	}
	}
	}
	}
	return true;
	}
	//快速转置
	template<class T>
	bool SparseMatrix<T>::TransposeTo_Faster(SparseMatrix& B)
	{
	if (terms>B.maxterms)
	{
	return false;
	}
	B.rows=cols;
	B.cols=rows;
	B.terms=terms;
	if (terms>0)
	{
	int *num,*cpot;
	num=new int[cols];
	cpot=new int[cols];
	for (int j=0;j<cols;j++)
	{
	num[j]=0;
	}
	for (int k=0;k<terms;k++)
	{
	num[data[k].col-1]++;
	}
	//求出B中每一行的起始下标cpot[]
	cpot[0]=0;
	for (int j=1;j<cols;j++)
	{
	cpot[j]=cpot[j-1]+num[j-1];
	}
	//执行转置操作
	for (int p,k=0;k<terms;k++)
	{
	p=cpot[data[k].col-1]++;
	B.data[p].row=data[k].col;
	B.data[p].col=data[k].row;
	B.data[p].val=data[k].val;
	}
	delete[] num;
	delete[] cpot;
	}
	return true;
	}
	template<class T>
	void SparseMatrix<T>::Input()
	{
	cout<<"intput the matrix' row:";
	int row1;
	cin>>row1;
	cout<<"intput the matrix' col:";
	int col1;
	cin>>col1;
	cout<<"input "<<row1<<"*"<<col1<<" matrix"<<endl;
	int number;
	rows=row1;
	cols=col1;
	for (int i=0;i<rows;i++)
	{
	for (int j=0;j<cols;j++)
	{
	cin>>number;
	if (number!=0)
	{
	data[terms].row=i+1;
	data[terms].col=j+1;
	data[terms].val=number;
	terms++;
	}
	}
	}
	}
	template<class T> //输出好看，但是违背了最初的原则
	void SparseMatrix<T>::Output()
	{
	T **tempArray=new T*[rows];
	for (int i1=0;i1<rows;i1++)
	{
	tempArray[i1]=new int[cols];
	}
	for (int j=0;j<rows;j++)
	{
	for (int k=0;k<cols;k++)
	{
	tempArray[j][k]=0;
	}
	}
	for (int i=0;i<terms;i++)
	{
	tempArray[data[i].row-1][data[i].col-1]=data[i].val;
	}
	for (int j=0;j<rows;j++)
	{
	for (int k=0;k<cols;k++)
	{
	cout<<setw(4)<<tempArray[j][k];
	}
	cout<<endl;
	}
	for (int l=0;l<rows;l++)
	{
	delete[] tempArray[l];
	}
	delete tempArray;
	cout<<endl;
	}
	template<class T>
	bool SparseMatrix<T>::AddTo(const SparseMatrix& B)
	{
	if (rows!=B.rows||cols!=B.cols)
	{
	return false;
	}
	bool flag=false;
	int tempTerms=terms;
	for (int i=0;i<B.terms;i++)
	{
	flag=false;
	for (int j=0;j<tempTerms;j++)
	{
	if (data[j].col==B.data[i].col&&data[j].row==B.data[i].row)
	{
	data[j].val+=B.data[i].val;
	flag=true;
	}
	}
	if (flag==false)
	{
	data[++terms-1].col=B.data[i].col; //数组下标操作注意事项
	data[terms-1].row=B.data[i].row;
	data[terms-1].val=B.data[i].val;
	}
	}
	return true;
	}
	int main()
	{
	cout<<"此程序演示稀疏矩阵的普通转置和快速转置操作"<<endl;
	SparseMatrix<int> sm(50);
	SparseMatrix<int> sm1(50);
	SparseMatrix<int> sm2(50);
	sm.Input();
	cout<<"sm is"<<endl;
	sm.Output();
	sm.TransposeTo(sm1);
	cout<<"Transposition of sm is "<<endl;
	sm1.Output();
	sm.TransposeTo_Faster(sm2);
	cout<<"Transposition of sm is "<<endl;
	sm2.Output();
	SparseMatrix<int> sm3;
	cout<<"input a new matrix"<<endl;
	sm3.Input();
	cout<<"sm3 is"<<endl;
	sm3.Output();
	if(sm.AddTo(sm3))
	{
	cout<<"after adding sm3 ,sm is"<<endl;
	sm.Output();
	}
	else
	cout<<"the two matrix can't add"<<endl;
	cout<<"Good job!"<<endl;
	system("pause");
	return 0;
	}

view raw 2013100302.cpp hosted with ❤ by GitHub

C++中读写二进制与ASCII混合文本流测试

Read and Write Binary & Text Hybrid Content Stream using C++

The following code snippet is hosted on Github Gist.

	#include <iostream>
	#include <fstream>
	#include <string>
	using namespace std;
	int main(int argc, char* argv[])
	{
	ofstream fout;
	int n=31;
	double v=9.9998e-79;
	string str="Hello,World!";
	cout<<"Before"<<endl;
	cout<<"n="<<n<<","<<"v="<<v<<endl;
	cout<<str<<endl;
	fout.open("test.out",ios::binary);
	if(!fout.good())
	{ cout<<"CANNOT OPEN FILE FOR WRITE!"<<endl; return 1;}
	fout.write( (char*)&n ,sizeof(n));
	fout.write( (char*)&v ,sizeof(v));
	fout.seekp( 1024, ios::beg);
	fout<<"Hello,World!"<<endl;
	fout.close();
	n=38;v=3.14159265354;
	str="FAIL";
	ifstream fin("test.out",ios::binary);
	if(!fin.good())
	{ cout<<"CANNOT OPEN FILE FOR READ!"<<endl; return 1;}
	fin.read( (char*)&n ,sizeof(n));
	fin.read( (char*)&v ,sizeof(v));
	cout<<"After"<<endl;
	cout<<"n="<<n<<","<<"v="<<v<<endl;
	fin.seekg( 1024, ios::beg);
	getline(fin,str);
	cout<<str<<endl;
	fin.close();
	system("pause");
	return 0;
	}

view raw 2013100301.cpp hosted with ❤ by GitHub

Matlab program for LU Factorization with partial (row) pivoting

	function [L,U,P]=LU_pivot(A)
	% LU factorization with partial (row) pivoting
	% K. Ming Leung, 02/05/03
	[n,n]=size(A);
	L=eye(n); P=L; U=A;
	for k=1:n
	[pivot m]=max(abs(U(k:n,k)));
	m=m+k-1;
	if m~=k
	% interchange rows m and k in U
	temp=U(k,:);
	U(k,:)=U(m,:);
	U(m,:)=temp;
	% interchange rows m and k in P
	temp=P(k,:);
	P(k,:)=P(m,:);
	P(m,:)=temp;
	if k >= 2
	temp=L(k,1:k-1);
	L(k,1:k-1)=L(m,1:k-1);
	L(m,1:k-1)=temp;
	end
	end
	for j=k+1:n
	L(j,k)=U(j,k)/U(k,k);
	U(j,:)=U(j,:)-L(j,k)*U(k,:);
	end
	end

view raw 2013120101.m hosted with ❤ by GitHub

上述代码等价的MATLAB内置函数是[L U P]=lu(A)，此时满足LU=PA。
上述代码若修改成输出P比较好。即对应MATLAB的[L U P]=lu(A,’vector’)。此时满足LU=A(p,:)。

求解AX=B的时候我们需要交换A的行，对应的也需要对B进行相同的行交换。如果写成矩阵乘法的形式的话，LU分解后满足LU=PA，原方程AX=B变为LUX=PB，注意到求解出来的X的行没有发生交换。

万一需要p行变换的逆变换，那么p_back(p)=1:n即可。也就是说p向量比P矩阵更好用。P矩阵意味着需要进行矩阵乘法。

Reference:  http://cis.poly.edu/~mleung/CS3734/s03/ch02/LU_pivot.htm

在Visual Studio 2005/2008/2010下使用MSCOMM32

Using MSCOMM32 under Microsoft Visual Studio 2005/2008/2010

如果你手中有一个老的程序需要改，他当时是用VC++6.0开发的，使用了MSCOMM32 Active-X控件，那么你或许会遇到问题。
当你打开资源文件时显示说：
未在此计算机上注册ActiveX控件"{648A5600-2C6E-101B-82B6-000000000014}"。请注册该控件并重试
该怎么办呢？

新版Visual Studio的串口通信应该是改用.NET FRAMEWORK了，所以没有了MSCOMM控件，如果还是希望使用的话，则
首先需要在安装有VC++6.0的电脑上拷贝或者上网下载三个文件MSCOMM32.OCX, MSCOMM.SRG, MSCOMM32.DEP
下载地址 Download MSCOMM32：http://www.rayfile.com/zh-cn/files/aa702b11-e11a-11e1-9c94-0015c55db73d/

然后新建一个文本文件，内容如下，保存为INSTALL.BAT。注意后缀必须是BAT，也就是批处理文件。

The following batch is hosted on Github Gist.

	:: This Batch file is used to install MSCOMM32
	::
	@echo off
	echo CLAIM: MSCOMM32 is belong to Microsoft Corporation
	echo.
	echo This batch file is licensed under CC-BY-SA 3.0
	echo and is provided on an "AS IS" basis, use it on your own risk.
	echo.
	if /i "%PROCESSOR_ARCHITECTURE:~-2%"=="86" (goto i386) else goto amd64
	:i386
	echo Your Windows is 32-bit
	echo Install MSCOMM32 to your PC??
	pause
	copy mscomm*.* %windir%\system32\ /y
	%windir%\system32\Regsvr32 %windir%\system32\mscomm32.ocx /s
	reg add "HKCR\Licenses\4250E830-6AC2-11cf-8ADB-00AA00C00905" /v "" /d "kjljvjjjoquqmjjjvpqqkqmqykypoqjquoun" /f
	goto common
	:amd64
	echo Your Windows is 64-bit
	echo Install MSCOMM32 to your PC??
	pause
	copy mscomm*.* %windir%\SysWOW64\ /y
	%windir%\SysWOW64\Regsvr32 %windir%\SysWOW64\mscomm32.ocx /s
	reg add "HKCR\Licenses\4250E830-6AC2-11cf-8ADB-00AA00C00905" /v "" /d "kjljvjjjoquqmjjjvpqqkqmqykypoqjquoun" /f
	goto common
	:common
	echo Installation Complete!
	pause

view raw 2014090801.bat hosted with ❤ by GitHub

将此批处理文件与三个MSCOMM文件放在一个文件夹中，然后使用管理员权限运行INSTALL.BAT

可能你会注意到我这里的批处理文件与其他博客上的不同。因为我考虑到了64位Windows系统。
上述脚本可在Windows XP (x86/x64) Windows Vista/7 (x86/x64)上完成安装。

A simple C++ Program to copy binary file

Just a C++ Test Program

	#include <iostream>
	#include <fstream>
	using namespace std;
	int main(int argc, char* argv[])
	{
	// You have to declare using the file in binary mode.
	// Otherwise you will be tarpped in strange problems.
	ifstream fin("Hash.exe",ios::binary|ios::in);
	ofstream fot("Copy.exe",ios::binary|ios::out);
	char ch;
	// Check status of input file
	if (!fin.good())
	{
	cout<<"ERROR WHILE OPENNING INPUT FILE"<<endl;
	return +1;
	}
	// Check status of output file
	if (!fot.good())
	{
	cout<<"ERROR WHILE OPENNING OUTPUT FILE"<<endl;
	return -1;
	}
	// You have to be careful not to write a EOF to the output file in the loop below.
	// Because when you close the output file, the output file will be attached with a EOF automatically.
	if (!fin.eof())
	ch=fin.get();
	while (!fin.eof())
	{
	fot.put(ch);
	ch=fin.get();
	}
	fin.close();
	fot.close();
	system("pause");
	return 0;
	}

view raw 2013092901.cpp hosted with ❤ by GitHub

NKPC3-1704 Bowling Ball 保龄球

本来这个是早在百度空间就写了的，然而后来百度空间改版，造成很多文章排版出现问题，之前的URL地址也会失效，另外百度发布文章会有敏感词问题，还有插入代码会很蛋疼，所以现在将此篇文章迁移到Blogger。

Bowling

Time Limit: 2 Sec  Memory Limit: 64 MB

南开大学ACM协会的一个元老毕业后，开了家保龄球馆。他需要为他的保龄球馆的计算机写一个记分的程序。

       一局(GAME)保龄球分为10格,每格里有两次投球机会,如在第一次投球时没能全中,就有需要投第二球。

        每一格可能出现三种情况：

1.失球(MISS)

        无论何种情况,在一格的两次投球时,未能击倒10个瓶,此格的分数为击倒的瓶数。如果一次击球中未击倒一个瓶，则用一个’-’标记。

2.补中(SPARE)

         要一次击倒十个瓶子并非那么容易的！如果在第一次掷球后，你还有一次机会来击倒该格第一球所留下的情致。当第二次投球击倒该格第一球余下的全部瓶子,称为补中,用一个‘/’符号表示。补中的记分是10分加上下一次投球击倒的瓶数。

3.全中(STRIKE)

       当每一格的第一次投球击倒全部竖立的十个瓶时,称为全中,用一个(×)符号表示。全中的记分是10分(击倒的瓶)加该球员下两次投球击倒的瓶数。

       在第十格中情况比较特殊：

(1)如第二次投球未补中,则第十格得分为第九格得分加上第十格所击倒瓶数。

(2)如第二次投球补中,则追加一次投球机会,第十格得分为第九格得他加上10加上追加一次投球击倒瓶数。

(3)如第一球为全中,则追上加二次投球机会,第十格得分为第九格得分加上10加追加二次投球击倒的瓶数。因此从第一格到第十格的两次追加投球,都为全中,则为12个全中，得分为满分300分。

Input

　　输入包括多组测试数据，你应当处理到输入结束为止。

　　每组输入数据中，都只有一行，包含一局的记分符号，相邻的两个符号之间以一个空格隔开。记分的符号仅包括‘-’（不含引号）、‘/’（不含引号）、’X’（不含引号）及阿拉伯数字1到9。

Output

　　对于每组输入数据，输出两行。对于第i组输入数据，输出的第一行为”Case i:”，输出的第二行为10个整数，表示每格的累计得分。相邻的两个得分以一个空格隔开。

Sample Input

X X X X X 5 / 7 1 - - X X X X4 4 3 3 2 2 1 7 7 1 2 - 9 / 2 2 6 3 2 / 1

Sample Output

Case 1:

30 60 90 115 135 152 160 160 190 220

Case

2:8 14 18 26 34 36 48 52 61 72

Source

第三届南开大学程序设计网上竞赛“我为程序狂”(NKPC3)

Description

A patriarch of Nankai University ACM Association operates a bowling alley after graduation. Now, he needs a program to keep the score for the bowling.

There are ten frames in one game. You have two chances to knock down the ten pins in each frame. There are three possible cases for each frame.

1.MISS
If you fail to knock down all of the ten pins during two delivers in a frame, the score you get from this frame will be the number of the pins that you have knocked down. If your deliver knocks down zero pin, your score board will be marked a "-".

2.SPARE
Getting all ten pins down with a single ball is not as easy as it seems! So, if you leave one or more pins standing after your first delivery, you get a second chance to knock all the pins down. This is your "spare" shot. If you knock all remaining pins down on the second shot you have made your spare. A spare is marked on the scoresheet with a "/".And the score you get will be 10 plus the number of pins you knock down during the next delivery.

3. STRIKE
When the bowler knocks down all ten pins during the first delivery in a frame, it is called a strike. Clearly your score goes up by ten, but like a spare, you get a bonus – the number of pins you knock down during your next two deliveries, which will be added to the score. A strike is on the scoresheet with an "X".

Note that the tenth frame is a little different with others.
(1) If you don't knock down the ten pins, the score will be added by the numbers of pins you knock down.
(2) The tenth frame rewards you with a final bonus ball if you convert your spare. And your score will be added by 10 and the number of pins you knock down during your final bonus delivery.
(3) If you make a strike, you will get two bonus balls. The score will be added by 10 and the number of pins you knock down during your final two bonus deliveries.You can thus throw nine strikes in the first nine frames and, if you get another two in the tenth, the bonus ball means the most strikes you can have in one game is twelve. And the full mark is 300.

Input

Input contains several cases. The input is ended up with the end of file (EOF). Each case includes one line which contains several numbers and signs to record a bowling game. The signs are '-', '/' or 'X'. And the numbers range from 1 to 9. The adjacent signs and numbers are separated by one blank.

Output

For each case, please output two lines. The first line for the i-th input case should be "Case i:". The second line should be 10 integers, standing for the 10 accumulative scores of the frames in a bowling game. And each two adjacent integers should be separated by one blank.

Sample Input

X X X X X 5 / 7 1 - - X X X X
4 4 3 3 2 2 1 7 7 1 2 - 9 / 2 2 6 3 2 / 1

Sample Output

Case 1:
30 60 90 115 135 152 160 160 190 220
Case 2:
8 14 18 26 34 36 48 52 61 72

HINT

Source

NKPC3



本来NKPC3比赛时，我一直没有思路，总是想着要
按照回合数划分数组，
没有做出来，就一直搁置着。
现在突然来了灵感，
用(总计)击球次数划分数，
不论是存储，还是处理运算，都比较简单。
这样一来，回合数没有了实际作用，沦为主计算过程(cal(culate))执行次数的计数器。
{详见PASCAL源代码的"~"以及"~~"处}

以下是本人用GCC做的解答：

	#include<stdio.h>
	int ans=-1;
	char k=0,i,a[21];
	short pts=-1;
	char chk(short pts)
	{
	char tmp;
	switch(a[pts])
	{
	case 'X':tmp=10;break;
	case '/':tmp=10-chk(pts-1);break;
	case '-':tmp=0;break;
	default :tmp=a[pts]-'0';
	}
	return(tmp);
	}
	void cal()
	{
	char tmp;
	if(a[++pts]=='X')tmp=10+chk(pts+1)+chk(pts+2);
	else
	if(tmp=chk(pts),a[++pts]=='/')tmp=10+chk(pts+1);
	else tmp+=chk(pts);
	printf("%d",ans+=tmp);
	if(i==9) putchar('\n');else putchar(' ');
	}
	int main()
	{
	while(1)
	{
	do a[++pts]=getchar();
	while(getchar()!='\n');
	printf("Case %d:\n",++k);
	for(pts=-1,ans=i=0;i<10;i++)cal();
	a[pts=0]=getchar();
	if(a[0]==EOF) break;
	getchar();
	}
	return 0;
	}

view raw 2007101101.c hosted with ❤ by GitHub

以下是本人用PASCAL做的解答：

	Const
	ch1:set of char=['/','-','X','1'..'9']; {记分的有效符号}
	Var
	pnt,k,i,j:byte; {(总计)击球次数的指针:p(oi)nt}
	ans:integer; {得分:ans(wer)}
	a:array[1..11,1..21]OF char; {存储每一次记分字符的数组:a(rray)}
	ch:char; {用于读取输入文件的字符变量:ch(ar)}
	Function chk(k,pnt:byte):byte; {求(总计)第n次击球击倒的个数:ch(ec)k}
	Begin
	Case a[k,pnt] OF
	'X':chk:=10;
	'/':chk:=10-chk(k,pnt-1); {如果补中，个数为10减去上次击球个数}
	'-':chk:=0;
	'1'..'9':chk:=ord(a[k,pnt])-ord('0');
	End;
	End;
	Procedure cal(k:byte;VAR pnt:byte); {~} {对一个回合进行记分的过程:cal(culate)}
	{输入时，pnt为上一回合最后一次击球的(总计)次数}
	Var
	tmp:byte; {临时变量:t(e)mp}
	Begin
	inc(pnt); {处理第一次击球}
	IF a[k,pnt]='X'
	THEN tmp:=10+chk(k,pnt+1)+chk(k,pnt+2)
	ELSE {如果没有全中，则这一次回合有下一次击球}
	Begin
	tmp:=chk(k,pnt); inc(pnt);
	IF a[k,pnt]='/'
	THEN tmp:=10+chk(k,pnt+1)
	ELSE inc(tmp,chk(k,pnt));
	End;
	inc(ans,tmp);
	End;
	BEGIN{主程序}
	fillchar(a,sizeof(a),'*');{数组初始化}
	k:=0;
	Repeat {读入每一组数据}
	inc(k); pnt:=0;
	Repeat
	inc(pnt); read(ch);
	IF ch IN ch1 THEN a[k,pnt]:=ch
	ELSE dec(pnt);
	Until eoln(input);
	Until eof(input);
	IF a[k,1]='*' THEN dec(k); {确定情况(Case)数}
	For i:=1 to k Do {计算并输出}
	Begin
	pnt:=0; ans:=0; writeln('Case ',i,':');
	For j:=1 to 10 Do {~~}
	Begin
	cal(i,pnt); write(ans);
	IF j<10 THEN write(' ');
	End;
	writeln;
	End;
	END.

view raw 2007101102.pas hosted with ❤ by GitHub

以下是好友Liuhy用PASCAL做的解答：

	program NK1704;
	var
	st:array [1..1000] of char;
	score:array [0..10] of integer;
	i,tt,line:integer;
	qq,ch:char;
	procedure main;
	var
	i,j,th:integer;
	a:array [1..10,1..2] of integer;
	after10:array [1..2] of integer;
	begin
	th:=0;
	i:=0;
	while (i<tt) and (th<10) do
	begin
	inc(i);
	case st[i] of
	'X':begin inc(th); a[th,1]:=10; a[th,2]:=-1; end;
	'1'..'9':begin
	inc(th);
	inc(i);
	case st[i] of
	'-':begin
	a[th,1]:= ord(st[i-1])-48;
	a[th,2]:= 0;
	end;
	'1'..'9':begin
	a[th,1]:=ord(st[i-1])-48;
	a[th,2]:=ord(st[i])-48;
	end;
	'/':begin a[th,1]:=ord(st[i-1])-48; a[th,2]:=10; end;
	end;
	end;
	'-':begin
	inc(th);
	inc(i);
	case st[i] of
	'-':begin
	a[th,1]:=0;
	a[th,2]:=0;
	end;
	'1'..'9':begin
	a[th,1]:=0;
	a[th,2]:=ord(st[i])-48;
	end;
	'/':begin a[th,1]:=0; a[th,2]:=10; end;
	end;
	end;
	end;
	end;
	j:=0;
	if a[10,1] = 10 then
	for i:=1 downto 0 do
	begin inc(j);
	case st[tt-i] of
	'-':after10[j]:=0;
	'X':after10[j]:=10;
	'1'..'9':after10[j]:=ord(st[tt-i])-48;
	'/':begin after10[1]:=0; after10[j]:=10; end;
	end;
	end
	else
	if a[10,2] = 10 then
	begin
	after10[2]:=-1;
	case st[tt] of
	'-':after10[1]:=0;
	'X':after10[1]:=10;
	'1'..'9':after10[1]:=ord(st[tt])-48;
	end;
	end
	else begin after10[1]:=-1; after10[2]:=-1; end;
	//for i:=1 to 10 do
	// writeln(i,' ',a[i,1],' ',a[i,2]);
	//for i:=1 to 2 do
	// writeln('a',' ',i,' ',after10[i]);
	//writeln;
	fillchar(score,sizeof(score),0);
	for i:=1 to 9 do
	begin
	if (a[i,1] in [0..9]) and (a[i,2] in [0..9]) then
	score[i]:= score[i-1] + a[i,1] + a[i,2];
	if a[i,2] = 10 then
	score[i]:= score[i-1] + 10 + a[i+1,1];
	if a[i,1] = 10 then
	if a[i+1,2] = 10 then
	score[i]:=score[i-1] + 10 + 10
	else
	if a[i+1,1] = 10 then
	if i+2 > 10 then
	score[i]:=score[i-1] + 10 + 10 + after10[1]
	else score[i]:=score[i-1] + 10 + 10 + a[i+2,1]
	else score[i]:=score[i-1]+a[i+1,1]+a[i+1,2]+10;
	end;
	if a[10,1] = 10 then
	score[10]:=score[9]+10+after10[1]+after10[2]
	else if a[10,2] = 10 then
	score[10]:=score[9]+10+after10[1]
	else
	score[10]:=score[9]+a[10,1]+a[10,2];
	//for i:=1 to 9 do
	// write(score[i]:8);
	end;
	begin
	assign(input,'in.txt');
	reset(input);
	assign(output,'out.txt');
	rewrite(output);
	line:=0;
	while not eof do
	begin
	tt:=0;
	inc(line);
	while not eoln do
	begin
	inc(tt);
	read(ch);
	while ch = ' ' do read(ch);
	st[tt]:=ch;
	end;
	readln;
	main;
	writeln('Case ',line,':');
	for i:=1 to 9 do
	write(score[i],' ');
	writeln(score[10]);
	end;
	close(output);
	end.

view raw 2007101103.pas hosted with ❤ by GitHub

原帖发布时间：2007年10月05日