周恒（zhouheng1212 ）的窝！(粗体字文章别删)

yaomingcctv

就这样简单。。。。。
FT。。。

zhouheng1212

原帖由 yaomingcctv 于 2006-8-15 15:17 发表
为什么泥。。
看你近来写的文章很平和呀。。
看的我很有种如沐春风的感觉。。

那些文章都是摘的，我写的感觉不算太好，不敢贴来。

yaomingcctv

原帖由 zhouheng1212 于 2006-8-15 11:25 发表

那些文章都是摘的，我写的感觉不算太好，不敢贴来。

您的缺点就是谦虚。。

yaomingcctv

先下了//。。。饭饭去。。

zhouheng1212

水沫夏天  


  夏天的风带着一丝恬燥，更带着一丝压抑。空旷的田野上，一片被夕阳印染的火红。这使这原本炎热的夏天添加了更深刻的一笔。可我偏偏爱上了这个残酷的季节。她没有春天的温暖，也没有秋天的思念，更没有冬天的浪漫。但她有我难忘的回忆。

  年少的夏天，满脸是天真的笑容。大家手拉这手，天南地北地狂侃。我们就像在森林里乱窜的小鹿。偶尔闯闯小祸，做做坏事，然后没心没肺的大笑。那段时光真地很完美—没有担忧，没有牵挂，没有烦恼。天黑了，大家一起数星星。看见流星时，还会许下天方夜谭的愿望。然后互相奚落对方一番，最后狂笑而过。

  可是童年的风筝飞远了—光着脚丫在河边玩耍的日子找不到了。也许是夏天太热了，她像泡沫一样溶进水里了。而我们的最纯真的回忆也随着她一起埋没了。

  长大后的一切都变了。有些人在为了学习而拼命努力着—有失败的，有成功的；有些人放弃学习踏上社会的方舟—有花天酒地的，有风花雪月的；有些人看透尘世，在绝望中，在无奈中离开…青春的脚步真地如此残酷吗？好多次大家见面时，都只是莞尔一笑—没有比这更多的言语。也许无奈时，大家早已习惯沉默。

  夏天的气息又开始弥漫在空气中，那么的熟悉，却又是那么的陌生。但这一切都不重要了。因为没有人回去注意，也不会有人去关心了—大家都累了，也都习惯了。童年的回忆像泡沫一样慢慢在彼此的心里消失。没有会去在意些什么，更没有人会去挽留些什么—这对于大家而言已没有任何意义了。因为她只是个水沫的夏天。

zhouheng1212

柳絮儿  


  像一场雪，像一场蓄谋已久而纷纷扬扬的雪，就这样漫天飞舞，四处飘落了。在某个有风的日子，像雪花一样洁白的柳絮儿开始了它生命中重要一次旅程。就像那些肩上扛着镰刀，挽着裤关，腰间系着草绳的麦客子，也随着柳絮儿一路南下，开始了赶场的日子。

  在乡村，柳絮儿是跟麦客子有着一定联系的。树毛毛淌，麦客子赶麦场。一群一群从山里走出来的麦客子，他们双肩披着洁白的花絮，在一个有风的清晨集体出发了。几棵生长在路边的柳树，把长长的枝条倒垂下来，还没有展开的叶片静静地蜷缩着，枝条柔亮而富有韧性，轻轻地摆动几下，整个树就婆婆而生动起来。远远看去，那柳条上像生长着一个个小棉花包，有的棉花包炸开了，露出了洁白的花絮。在枝条上轻轻地缠绕着，如果有一阵风，这些展开的花絮就一路飘飞了。

  柳树底下坐着几个挑水歇凉的人，一担水挑上沟畔，腿困不困都要在这树身下小坐片刻。扁担搭在肩上，清凉的水闪着纹波。一个人坐下歇了，另一个人也会将水桶放下，摸着汗珠来到树下。一个说，看，树毛毛开始淌了。另一个说，今年赶场的还没有起身。一个说，快了，镰刀都准备好了。……说话的是两个女人。她们正商量着为赶场的男人回去准备行头。出了门，要备足干粮，最主要的要背上女人连夜烙好的馍馍。如今出门简单多了，几乎没有人再背着“炒面袋袋”了。

  一夜之间，村庄就被一层白色的花絮笼罩了。柳絮儿轻舞着，在柳树环绕的村庄。山梁、沟畔、村庄、院落都被浅浅地遮掩起来，连空气都泛着白色的泡沫。一条山道，一条通往村外的山道，一夜之间变成了一条银色的丝带，在这条丝带上，有几张匆匆离去的脚印。谁都会想到，定是那些一大清早赶路的麦客子。

  一路上，不断有柳絮儿滑过脸颊，落在身上。在麦客子的眼里柳絮儿就是他们的信使，他们的同路客。麦客子的路线大致是一定的，根据柳絮儿飘落的天数就能判定，哪些地方的小麦成熟了，而下一个场地他们要赶往哪里。

  柳絮儿不会全飞到麦地里去的，当那些麦客子乘上火车一路南下时，那些洁白的身影就会慢慢地消失。有人说，柳絮儿只负责麦客子的出行，当麦客子一个一个返回来时，柳树已开始舒展绿叶，那些柳絮儿却化成了泥土，悄然消逝了。

  柳絮儿的一生是短暂的，它的一生注定无定所的飘飞。看到柳絮儿，人们更多谈到的却是一个地方的场价和无数个扛着镰刀的麦客子。所以，在并不长的时间里，有人就会将柳絮儿的名字搁在一边，既而换上一个人的名字。也许有人会叹息几声:今年的树毛毛落早了，麦客子搭了几个空场。季节不能同时兼顾，树毛毛淌的时候，麦子就能熟透，这就全看麦客子赶场的经验和判断了。

  柳树越来越少了，以至于整个春天几乎看不到柳絮儿飘飞的情景了，村庄一下子空旷了许多，也有些寂寥。偶尔有几枚柳絮儿轻飘飘地越过村庄的上空，飘到另外一个地方。它们也许是从很远的另一地方飘来的，虽然只有几枚，但它依然传递着一种信息:树毛毛淌，麦客子赶麦场。这个时候，就会有人扛起镰刀，追赶那些已经飘得找不准位置的柳絮儿了。

zhouheng1212

品味孤独  


  渐渐习惯并爱上了孤独，常常在虚静斋阅读、思考、写作，游荡的灵魂伴着心跳一起一伏，思绪进入一种穿越时空的飘渺，浑然忘记了世界和自己的存在。日子就在这种孤独的凄美中延续……
浩淼的宇宙，生命渺若微尘，呈现一种哲学式的孤苦无依的状态。其实孤独是生命的本真。从出生到离去，生命是一个苍茫的孤独苦旅:降临人世，那一声呱呱的啼哭，分明是生命孤独的宣言；随之，生命就像一列火车独自行驶在人生的原野，亲情和友情等情愫，只不过是生命列车窗外给孤独生命以暂时慰藉的景物，它们像鱼儿一般从生命列车旁滑过，渐次消逝于无形；于是，最终生命就在一种静默幽暗的孤寂中，回归那无始无终的漫漫黑夜……人生是一种凄美的孤独！
  从孩童到青年到老年，生命依次走过时光的年轮，而最终走向一种苍凉的孤独。在孩童的眼里，世界就是一个繁忙的港口，蔚蓝色的海洋，以其纯然一色勾起孩童美丽的遐想，港口的喧嚣，热闹的人群，在孩童眼中呈现的是一个博大的世界，什么都是新奇的；到了青年，世界就成了宽阔的草原，洁白的羊群，放牧的同伴，让青年在蓝天白云下，尽情放飞人生的激情；中年，世界遽然变成了一片宁静的湖泊，和着自己的心跳，去独自释放家庭和工作的重担；而进入老年，世界浓缩为家门前那棵和自己一起变老的槐树，挑着几片清晰可数的落寞孤清的叶片，用独自绵长的回忆，感受一种透入骨髓的苍凉……
  孤独让生命渐趋成熟，发酵着酒的醇香。没有刻骨铭心的孤独，就没有对自己真正的认识和把握。什么就活出了自我？我以为，真正的自我不是茫茫人生舞台上作秀的表演，不是众星捧月式的荣耀和张扬，也不是社会强加的各种临时的角色和安排。真正的自我，只能是独居一室时，对灵魂近于歇斯底里的深刻拷问。只有抛弃了生命的外在虚荣后，才有那一种透彻的自省和对人生真正的了悟。天下没有不散的宴席。一切成功与失败，都只是昙花一现，过眼云烟，与自己心灵生活，才是永恒的。只有那种孤独时宁静致远、淡定雅洁的心绪，才是真正长久的幸福。
  有的人整天忙于交际，看以有一种“我很忙”的潇洒，生命对他来说，就像儿童手中不停旋转的柁螺，永无止息，日子被繁杂的事务和无谓的应酬所淹没。其实他并没有活出真正的自我，他最终会发现，现世中，他得到了太多太多，而唯独没有真正的拥有过自己。而只有那些懂得从繁杂的事务中抽身，乃至推掉那些无谓应酬的人，在一种静静的独处中，窥视内心的世界，让一切世俗的身份和包装，退至可笑的角落，让透明的灵魂穿透自我，只有这种人，他才能真正认识自己，并睿智地对自己作出调整，而以一个全新的自我，重新走入人群，于滚滚红尘中，用自我的定力去把握人生的航向……
  伟大的思想来自于孤独。静出智慧，是古人睿智的体验。释加牟尼坐普提树下七天七夜，冥思苦想，才创建了佛教。罗丹的《思想者》，那种艺术的造型，也是来自一种美丽的孤独。思想者孤独地仰望天空，才能触及哲学的灵魂。孤独就像一只蚕，默默的吐出绵长的思想之丝；思想是一只蝶，孤独就是破茧化蝶的独自积蓄和等待。
孤独是一种成功的必由之径。什么是天才？我以为天才只不过是一种刻骨铭心的孤独的忍耐。科学者只有能忍受实验室研究那种日复一日的乏味和孤独，才能享受发明成果的芬芳。求学者，唯有孤独地跋涉知识的高山，才能学富五车，满腹经纶。作家，更是与孤独朝夕相伴，在一种痛苦的孤独中，书写“满纸荒唐言”，零落“一把辛酸泪”。尤其在浮躁之风渗入社会每个角落的今天，更应该大力提倡甘坐冷板凳，钻研学问的好风尚！
孤独是一朵花静静的绽开，孤独是一杯茶氤氲的浓香，孤独是一杯酒飘逸的芳醇。品味孤独，就是品味一种美，品味一种境界，品味人生的原始命题和终极价值！

zhouheng1212

发信人: passer (那些都是很好的，可惜我不喜欢), 信区: Employees
标  题: 投资股票之心得（1）
发信站: 同舟共济站 (Mon Jul 24 19:25:41 2006), 站内


  想想入市也快四年了，有赚有赔，特记下心得一二，以记录心迹，也做抛砖引玉之功。

★卖出原则
之所以买卖股票就是利用低买高卖产生差价而赚得利润（分享经济成长的果实，抵消通货膨胀的风险）。一言以蔽之，就是只有你卖出才有钱赚，所谓落袋为实！
个人以为，要学会投机股票（注意是投机，在中国股市要做到投资很难），首先要学会怎么卖股票。
以下为走过很多弯路总结出来的卖出原则（教训）:

1，学会赔钱的心态，善于割肉
记住:永远没有常胜将军的存在，任何人都有失误。当你买错股票，或者分析错误，公司的基本面发生重大变化（利空）时，没有其他方法，唯有惨痛割肉！一定要坚决，对于我们这种小股民来说，就那么点一亩三分地，不割的话，损失的就不止是绵绵不绝的金钱，还有以后众多的时间成本和机会成本。

2，永远不要奢望卖在高点，见小利而冲动
每个人都希望买在低点，卖在最高点，但事物不是你的想象，往往事与愿违。
割肉不难，割了省心。坏就坏在手上的股票它盈利了，心神荡漾了，心态总是不正了，又想赚更多的钱，又怕明天就跌了，到手的鸭子飞走了，于是乎天天期望想要抓住既得利益，卖出最高点。人生最痛苦得莫过于你以为赚了一笔小钱得时候，卖掉，发现它还在不断得上涨，让你少盈利一大笔。其实很简单，个人总结，它涨由它涨，不去管他，甚至一个小于2个百分点得下跌调整，你都可以不去理会（尤其在整个大盘就不好的时候），只有到了较大下跌，例如－4%时，逢高卖出。表面上看，少盈利一些，可是比起前面的卖出，赚大了！血的教训啊，冲动是魔鬼，理性是天使，顺势而为是王道。最为可耻的是在股票上涨大于7％时卖出，简直就是愚不可及。

3，切记为了买入B而卖出A
当初买入A是有一个良好预期，结果看到B更好，抛出A买入B。
问题在于A的预期还没完成，而市场上总能找到比A更好的东西，此时卖出A不计成本了，
当我们买入B后，又看到C好于B，于是事情就越来越糟了。

4，在别人贪婪的时候我们恐惧
  市场循环成立的基础:人性中的恐惧和贪婪永不改变。巴菲特告诉我们:“我们
也会有恐惧和贪婪，只不过在别人贪婪的时候我们恐惧，在别人恐惧的时候我们贪婪。”
当股市气势如虹的时候，你就该恐惧了，适当的减持或空仓是很有必要的。

5，T＋0积极解套
  没有人不被套住过，如果你对这支股票长期看好，不想割肉，又被死死套住，咋办？
以下为转载:

  顺向的"T+0"操作
  
自从1995年我国股市实行"T+1"交易制度以来，投资者已经不能采取"T+0"操作方式，但如
果手中持有被套的股票，则仍可以变相的使用这种快捷的交易方法。具体方法是:先买入
与被套个股同等数量的股票后，当天就将原先的被套股卖出，由于在获取当日股票差价利
润的同时，持股数前后
没有变化，等于完成了一次盘中"T+0"操作。这种操作方式通过经常性的赚取短线利润，
达到最终降低持仓成本的目的。
  顺向的"T+0"操作属于超短线操作方式，有一定的操作难度和风险，具体应用时要掌
握其操作原则:
  1."T+0"操作必须建立在对个股的长期观察和多次模拟操作的基础上，能够非常熟悉
个股股性和市场规模。
  2."T+0"操作要求投资者必须有适时看盘的时间和条件。还要投资者有一定短线操作
经验和快速的盘中应变能力。
  3."T+0"操作时要快，不仅分析要快，决策要快，还须下单要快，跑道要快。这就要
求投资者注意选择咨询更新及时、交易方式迅速和交易费用低廉的证券公司。
  4."T+0"操作时切忌不能贪心，一旦有所获利，或股价上行遇到阻力，立刻就落袋为
安。这种操作事先不制定具体盈利目标，只以获取盘中震荡差价利润为操作目标。

  反向的趋势操作
  
有些投资者的操作方式比较僵化，炒股只知道买，如果涨了就卖，如果跌了就捂着。其实
，炒股有很多灵活的方式，反向的趋势操作就是其中一种。在熊市中大多时间里大盘和股
价是处于下跌趋势中的，如果投资者只采用先低买，等涨高了再卖出的操作方式，不仅很
难获利，还容易遭遇被
套的现实。实际上，这时候可以采用顺应市场趋势的反向操作方式:先把手中持有的被套
股票趁反弹时逢高卖出，再等股价回落下来时择机买入。
  
这种操作技巧是专门应用于熊市中和投资者有被套牢股票时的一种操作方式，它可以充分
利用弱市中常有的暴跌机会及由此产生的反弹机会，根据股价震荡的节奏顺势而为，高抛
低吸，博取差价，降低持仓成本。这种反向趋势操作方法可以充分发挥被套股票的作用，
提高资金利用效率，也
可以使投资者增加一倍的投资机会，因为它可以使投资者在下跌的熊市中也一样能赚钱。
  
相对于顺向的"T+0"操作而言，反向趋势操作难度较小，对短线操作技术要求不高，但要
求投资者要具备对市场整体趋势的研判能力。因为反向趋势操作只适用于大盘处于下跌趋
势通道时的，其它时期，如大盘处于横向整理阶段或牛市行情阶段都不能采用这种操作技
巧。因此，要求投资者
必须要认清未来趋势的大致运行方向。
  反向趋势操作的另一个要点是要把握好股价运行的节奏，要趁股价反弹时买进，趁股
价暴跌时买入。在熊市的下跌途中经常会出现短暂的反弹行情和跳水般的暴跌行情，投资
者要充分利用这种市场的非理性的变动机会，最大限度的利用股价的宽幅震荡所创造的差
价机会来获取利润。


★★★★★现阶段看好股票:
1，G振华
2，G北新
3，G华侨城
4，G复星

以上不做投资建议，投资有风险，盈亏自负。
--
我走上路
遇到一个坑
我绕道而行
又遇到一个坑
我走上了另一条路


※ 修改:·passer 于 Jul 24 20:42:18 修改本文·[FROM: 211.136.158.*]
※ 来源:·同舟共济站 bbs.tongji.edu.cn·[FROM: 211.136.158.*]


[本篇全文] [回复文章] [回信给作者] [本篇作者:BanBan] [进入讨论区] [返回顶部]  2  

发信人: BanBan (板板不说话了，面壁ing), 信区: Employees
标  题: Re: 投资股票之心得（1）
发信站: BBS 同舟共济站 (Tue Jul 25 09:08:24 2006), 站内

赞啊

【 在 passer (那些都是很好的，可惜我不喜欢) 的大作中提到: 】
: 想想入市也快四年了，有赚有赔，特记下心得一二，以记录心迹，也做抛砖引玉之功。
: ★卖出原则
:  之所以买卖股票就是利用低买高卖产生差价而赚得利润（分享经济成长的果实，抵消通货膨胀的风险）。一言以蔽之，就是只有你卖出才有钱赚，所谓落袋为实！
: ...................



--
心平气和，夹着尾巴做人

※ 来源:·同舟共济站 http://bbs.tongji.edu.cn·[FROM: 218.14.157.*]

zhouheng1212

发信人: combe (今年一年不报告~~要去只去听报告), 信区: Algorithms
标  题: 查表法公历/农历转换(100年)
发信站: 同舟共济站 (2002年03月18日13:27:45 星期一), 站内信件

本函式欢迎各站各版转载, 无须经本人同意. 若对历法有兴趣, 欢迎讨论.
  
/*
  
西历农历转换程式 黄晓鸣 1995,7,25
  
prototype: int CalConv( struct ConvDate * );
  
struct ConvDate
{
int Source; ==0 则输入日期为西历, !=0 则输入为农历
int SolarYear; 输出或输入之西历年份
int SolarMonth; 西历月
int SolarDate; 西历日
int LunarYear; 输出或输入之农历年份
int LunarMonth; 农历月
int LunarDate; 农历日
int Weekday; 该日为星期几 ( 0==星期日, 1==星期一, ... )
int Kan; 该日天干 ( 0==甲, 1==乙, ..., 9==癸 )
int Chih; 该日地支 ( 0==子, 1==丑, ..., 11==亥 )
};
  
呼叫时须设定 Souce 的值, 若为 0 则为西历转农历, 否则为农历转西历. 然後视
输入为西历或农历来设定西历或农历的年月日. 转换後的年月日会填入结构中( 农
历或西历 ), 以及该日为星期几, 天干地支.
若函式的返回值为 0 表示没有错误, 1 为输入之年份错误, 2 为输入之月份错误,
3 为输入之日期错误.
输入之西历年须在 1937 - 2031 间
输入之农历年须在 1936 - 2030 间
若须扩充, 则增加 LunarCal[]
  
*/
  
#define FIRSTYEAR 1936 /* The first year in LunarCal[] */
  
struct ConvDate
{
int Source;
int SolarYear;
int SolarMonth;
int SolarDate;
int LunarYear;
int LunarMonth;
int LunarDate;
int Weekday;
int Kan;
int Chih;
};
  
struct tagLunarCal
{
int BaseDays; /* 到西历 1 月 1 日到农历正月初一的累积日数 */
int Intercalation; /* 闰月月份. 0==此年没有闰月 */
int BaseWeekday; /* 此年西历 1 月 1 日为星期几再减 1 */
int BaseKanChih; /* 此年西历 1 月 1 日之干支序号减 1 */
int MonthDays[13]; /* 此农历年每月之大小, 0==小月(29日), 1==大月(30日) */
};
  
struct tagLunarCal LunarCal[] = {
{ 23, 3, 2, 17, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0 }, /* 1936 */
{ 41, 0, 4, 23, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1 },
{ 30, 7, 5, 28, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1 },
{ 49, 0, 6, 33, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1 },
{ 38, 0, 0, 38, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1 }, /* 1940 */
{ 26, 6, 2, 44, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0 },
{ 45, 0, 3, 49, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 },
{ 35, 0, 4, 54, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1 },
{ 24, 4, 5, 59, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1 }, /* 1944 */
{ 43, 0, 0, 5, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1 },
{ 32, 0, 1, 10, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1 },
{ 21, 2, 2, 15, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1 },
{ 40, 0, 3, 20, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1 }, /* 1948 */
{ 28, 7, 5, 26, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1 },
{ 47, 0, 6, 31, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1 },
{ 36, 0, 0, 36, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 },
{ 26, 5, 1, 41, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1 }, /* 1952 */
{ 44, 0, 3, 47, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1 },
{ 33, 0, 4, 52, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0 },
{ 23, 3, 5, 57, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1 },
{ 42, 0, 6, 2, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1 }, /* 1956 */
{ 30, 8, 1, 8, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0 },
{ 48, 0, 2, 13, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0 },
{ 38, 0, 3, 18, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 },
{ 27, 6, 4, 23, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0 }, /* 1960 */
{ 45, 0, 6, 29, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0 },
{ 35, 0, 0, 34, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1 },
{ 24, 4, 1, 39, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0 },
{ 43, 0, 2, 44, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0 }, /* 1964 */
{ 32, 0, 4, 50, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1 },
{ 20, 3, 5, 55, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0 },
{ 39, 0, 6, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0 },
{ 29, 7, 0, 5, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1 }, /* 1968 */
{ 47, 0, 2, 11, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1 },
{ 36, 0, 3, 16, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0 },
{ 26, 5, 4, 21, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1 },
{ 45, 0, 5, 26, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1 }, /* 1972 */
{ 33, 0, 0, 32, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1 },
{ 22, 4, 1, 37, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1 },
{ 41, 0, 2, 42, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1 },
{ 30, 8, 3, 47, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 }, /* 1976 */
{ 48, 0, 5, 53, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1 },
{ 37, 0, 6, 58, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1 },
{ 27, 6, 0, 3, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0 },
{ 46, 0, 1, 8, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0 }, /* 1980 */
{ 35, 0, 3, 14, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1 },
{ 24, 4, 4, 19, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1 },
{ 43, 0, 5, 24, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1 },
{ 32, 10, 6, 29, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1 }, /* 1984 */
{ 50, 0, 1, 35, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0 },
{ 39, 0, 2, 40, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1 },
{ 28, 6, 3, 45, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0 },
{ 47, 0, 4, 50, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1 }, /* 1988 */
{ 36, 0, 6, 56, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0 },
{ 26, 5, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1 },
{ 45, 0, 1, 6, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0 },
{ 34, 0, 2, 11, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0 }, /* 1992 */
{ 22, 3, 4, 17, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0 },
{ 40, 0, 5, 22, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0 },
{ 30, 8, 6, 27, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1 },
{ 49, 0, 0, 32, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1 }, /* 1996 */
{ 37, 0, 2, 38, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1 },
{ 27, 5, 3, 43, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1 },
{ 46, 0, 4, 48, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1 },
{ 35, 0, 5, 53, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1 }, /* 2000 */
{ 23, 4, 0, 59, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1 },
{ 42, 0, 1, 4, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1 },
{ 31, 0, 2, 9, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0 },
{ 21, 2, 3, 14, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1 }, /* 2004 */
{ 39, 0, 5, 20, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1 },
{ 28, 7, 6, 25, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1 },
{ 48, 0, 0, 30, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1 },
{ 37, 0, 1, 35, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1 }, /* 2008 */
{ 25, 5, 3, 41, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1 },
{ 44, 0, 4, 46, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1 },
{ 33, 0, 5, 51, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1 },
{ 22, 4, 6, 56, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 }, /* 2012 */
{ 40, 0, 1, 2, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 },
{ 30, 9, 2, 7, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1 },
{ 49, 0, 3, 12, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1 },
{ 38, 0, 4, 17, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0 }, /* 2016 */
{ 27, 6, 6, 23, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1 },
{ 46, 0, 0, 28, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0 },
{ 35, 0, 1, 33, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0 },
{ 24, 4, 2, 38, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1 }, /* 2020 */
{ 42, 0, 4, 44, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 },
{ 31, 0, 5, 49, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0 },
{ 21, 2, 6, 54, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1 },
{ 40, 0, 0, 59, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1 }, /* 2024 */
{ 28, 6, 2, 5, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0 },
{ 47, 0, 3, 10, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1 },
{ 36, 0, 4, 15, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1 },
{ 25, 5, 5, 20, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0 }, /* 2028 */
{ 43, 0, 0, 26, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 },
{ 32, 0, 1, 31, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0 },
{ 22, 3, 2, 36, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0 } };
  
#define LASTYEAR (FIRSTYEAR+sizeof(LunarCal)/sizeof(struct tagLunarCal)-1)
  
/* 西历年每月之日数 */
int SolarCal[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  
/* 西历年每月之累积日数, 平年与闰年 */
int SolarDays[2][14] = {
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365, 396 },
{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366, 397 } };
  
/* 求此西历年是否为闰年, 返回 0 为平年, 1 为闰年 */
int GetLeap( int year )
{
if ( year % 400 == 0 )
return 1;
else if ( year % 100 == 0 )
return 0;
else if ( year % 4 == 0 )
return 1;
else
return 0;
}
  
/* 西历农历转换 */
int CalConv( struct ConvDate *cd )
{
int leap, d, sm, y, im, l1, l2, acc, i, lm, kc;
if ( cd->Source == 0 ) /* Solar */
{
if ( cd->SolarYear <= FIRSTYEAR || cd->SolarYear > LASTYEAR )
return 1;
sm = cd->SolarMonth - 1;
if ( sm < 0 || sm > 11 )
return 2;
leap = GetLeap( cd->SolarYear );
if ( sm == 1 )
d = leap + 28;
else
d = SolarCal[sm];
if ( cd->SolarDate < 1 || cd->SolarDate > d )
return 3;
y = cd->SolarYear - FIRSTYEAR;
acc = SolarDays[leap][sm] + cd->SolarDate;
cd->Weekday = ( acc + LunarCal[y].BaseWeekday ) % 7;
kc = acc + LunarCal[y].BaseKanChih;
cd->Kan = kc % 10;
cd->Chih = kc % 12;
if ( acc <= LunarCal[y].BaseDays )
{
y--;
cd->LunarYear = cd->SolarYear - 1;
leap = GetLeap( cd->LunarYear );
sm += 12;
acc = SolarDays[leap][sm] + cd->SolarDate;
}
else
cd->LunarYear = cd->SolarYear;
l1 = LunarCal[y].BaseDays;
for ( i=0; i<13; i++ )
{
l2 = l1 + LunarCal[y].MonthDays[i] + 29;
if ( acc <= l2 )
break;
l1 = l2;
}
cd->LunarMonth = i + 1;
cd->LunarDate = acc - l1;
im = LunarCal[y].Intercalation;
if ( im != 0 && cd->LunarMonth > im )
{
cd->LunarMonth--;
if ( cd->LunarMonth == im )
cd->LunarMonth = -im;
}
if ( cd->LunarMonth > 12 )
cd->LunarMonth -= 12;
}
else /* Lunar */
{
if ( cd->LunarYear < FIRSTYEAR || cd->LunarYear >= LASTYEAR )
return 1;
y = cd->LunarYear - FIRSTYEAR;
im = LunarCal[y].Intercalation;
lm = cd->LunarMonth;
if ( lm < 0 )
{
if ( lm != -im )
return 2;
}
else if ( lm < 1 || lm > 12 )
return 2;
if ( im != 0 )
{
if ( lm > im )
lm++;
else if ( lm == -im )
lm = im + 1;
}
lm--;
if ( cd->LunarDate > LunarCal[y].MonthDays[lm] + 29 )
return 3;
acc = LunarCal[y].BaseDays;
for ( i=0; i acc += LunarCal[y].MonthDays[i] + 29;
acc += cd->LunarDate;
leap = GetLeap( cd->LunarYear );
for ( i=13; i>=0; i-- )
if ( acc > SolarDays[leap][i] )
break;
cd->SolarDate = acc - SolarDays[leap][i];
if ( i <= 11 )
{
cd->SolarYear = cd->LunarYear;
cd->SolarMonth = i + 1;
}
else
{
cd->SolarYear = cd->LunarYear + 1;
cd->SolarMonth = i - 11;
}

leap = GetLeap( cd->SolarYear );
y = cd->SolarYear - FIRSTYEAR;
acc = SolarDays[leap][cd->SolarMonth-1] + cd->SolarDate;
cd->Weekday = ( acc + LunarCal[y].BaseWeekday ) % 7;
kc = acc + LunarCal[y].BaseKanChih;
  
--
╔╦────────────────────────────────────╗
╠╯  +   .      .    +          .    │
│  .  +    .  . + 永恒  。 +   .     ┌┐┌─┐
│   +    .  缤纷 +    .  +   .   ┌─┬─┬──┤└┤  ┤
│  .       。          │  ┤││  │││  ┤
╚──────────────────────────└─┴─┴┴┴┴─┴─┘

zhouheng1212

标  题: 24点
发信站: 同舟共济站 (2002年08月10日23:21:07 星期六), 站内信件

发信人: Colgate (高露洁), 信区: Programming
标  题: 24点问题。我在别的BBS拷贝过来的。不好意思
发信站: BBS 水木清华站 (Wed Nov 28 14:27:06 2001)
  
// RESULT.cpp : Defines the entry point for the console application.
//
//穷尽所有可能的组合
//对每种组合做+,-,* ,/
//不同的运算
#include <stdafx.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <malloc.h>
#define MAX 4
#define RESULT 24
int a[MAX]={5,4,3,2};//原始数据
int A[MAX];//采用的数据相当于stack
int b[MAX];//不同层次，对与a中数据是否已经使用
char  c[MAX];//保存符号
int bFound;//是否发现
int bPrev=0;
void tf(float x,int l);//进行四种运算
void out(float y,int l);//判断是继续运算，还是输出结果
char *PFormat();
int main(int argc, char* argv[])
{
  
  int i;
  for(i=0;i<MAX;i++)//初始化
    A[i]=0;
  bFound=0;
  
  tf(0,0);
  if(bFound==0)
  {
    printf("\n没有发现");
  }
  getchar();
  
  return 0;
}
void tf(float x,int l)
//x,上一次运算的结果
//l,当前所在运算的步数，也即层次
{
  int i;
  float y;
  int B[MAX];
  for(i=0;i<MAX;i++)
    B[i]=0;
  
  
  for(i=0;i<MAX;i++)
  {
    if(b[i]==0 && B[i]==0)
    {
    A[l]=a[i];
    b[i]=1;
    B[i]=1;
    if(l==0)//层次为0，为第一个数
    {
      c[l]=' ';
      y=a[i];
      out(y,l+1);
    }
    else{
      c[l]='+';
      y=x+a[i];
      out(y,l+1);
      c[l]='-';
      y=x-a[i];
      out(y,l+1);
      c[l]='*';
      y=x*a[i];
      out(y,l+1);
      c[l]='/';
      y=x/a[i];
      out(y,l+1);
    }
    b[i]=0;
  
    }
  }
  
}
void out(float y,int l)
//y,上一次运算的结果
//l,当前所在运算的步数，也即层次
{
  int i;
  char *p;
  if(l==MAX)//层次为MAX,已运算到最后，不需继续
  {
    if(y==RESULT)//结果对吗？
    {
    bFound=1;
    printf("\nFound\n");
    //    for(i=0;i<MAX;i++)
    //    {
    //
    //    printf(" %c %d",c[i],A[i]);
    //    }
    p=PFormat();
    printf("%s=%d",p,RESULT);//格式化输出
  
    getchar();
    }
  }
  else
  {
    tf(y,l);//继续运算
  }
  
}
//格式化输出
//当由+,-转向*,/需要加()
char * PFormat()
{
  
  char tmp[1024];
  //(char *)malloc((MAX-2)*2);
  static  char s[1024];
  //=(char *)malloc((MAX-2)*2);
  int i;
  memset(tmp,0x00,sizeof(tmp));
  memset(s,0x00,sizeof(s));
  for(i=0;i<MAX;i++)
  {
  
    if(c[i]=='+'|c[i]=='-')
    {
    bPrev=0;
    sprintf(tmp,"%s",s);
    }
    else if (bPrev==0 && (c[i]=='*' || c[i]=='/'))//优先改变
    {
    sprintf(tmp,"(%s)",s);
    bPrev=1;
    }
    else
    {
    sprintf(tmp,"%s",s);
    bPrev=1;
    }
  
    sprintf(s,"%s %c %d ",tmp,c[i],A[i]);
  
  
  }
  
  return s;
}