#!/bin/ksh
DATE=`date +%Y%m%d`
export ORACLE_HOME=/oracle/app/db
export NLS_LANG="SIMPLIFIED CHINESE_CHINA.ZHS16GBK"
DATE=`date +%Y%m%d`
/oracle/app/db/bin/exp boss_v2/ owner=boss_v2 compress=n direct=y recordlength=65535 file=./boss_v2$DATE.dmp log=./log/boss_v2$DATE.log
if [ -f boss_v2$DATE.dmp ]
then
rm -f old.dmp
mv new.dmp old.dmp
mv boss_v2$DATE.dmp new.dmp
fi
posted @
2009-12-11 13:57 poower 阅读(195) |
评论 (2) |
编辑 收藏
另外，
FireFox的
收藏夹（书签）也可以通过菜单选项直接导出，具体方法是：打开
Firefox，点击“书签 -> 书签管理”启动书签管理器，点击“文件 -> 导出”来备份现有的书签。在另一台机器上，再用书签的“导入”功能把备份的书签导入到新的
Firefox的配置中即可。
posted @
2009-11-20 21:34 poower 阅读(165) |
评论 (0) |
编辑 收藏
轻松面试找到理想员工－非官方的面试技术指南
简述:
本文作者Joel Spolsky 是纽约市一家软件公司Fog Creek Software的创始人。他毕业于耶鲁大学，曾分别在美国微软、Viacom、Juno等公司任软件设计师、经理职位。本文来自于《祖儿谈软件》，文章原名为《轻松面试找到理想员工——非官方的面试技术指南》，作者最初本意是针?/p>
作者:周思博 (Joel Spolsky 更新日期:2005-05-22
来源:chinese.joelonsoftware.com 浏览次数:
译： Chen Bin 编辑： Rick Ju 2000年3月23日
雇佣合适的人对于Fog Creek软件公司来说是非常关键的。在我们这个领域，有三类人可以挑选。在一个极端, 是哪些混进来的, 甚至缺乏最基本的工作技巧. 只要问这类人两三个简单的问题，再读一下他们的简历，就可以轻易地剔除他们。另一个极端的类型是 才华横溢的超级明星 这些人仅仅为了好玩就用汇编语言为Palm Pilot（一种手掌电脑）写了一个Lisp（一种人工智能编程语言）编译器。在这两种极端类型中间的是一大群不能确定水平的候选者，也许他们中的某些人能干些什么？这里的关键是明白超级明星和那一大堆属于中间类型的人的区别，因为Fog Creek软件公司只雇佣超级明星。下面我要介绍一些找出超级明星的技巧。
Fog Creek公司最重要的雇佣标准是:
有头脑, 并且
完成工作
就是这些了。符合这样标准的人就是我们公司需要的员工了。 记住这条标准。 每天上床前背诵这条标准。我们公司的目标之一就是雇佣拥有这样的潜质的人，而不是雇佣懂某些技术的人。任何人所拥有的某些具体技术都会在几年内过时，所以，雇佣有能力学习新技术的人，要比雇佣那些只在这一分钟知道SQL编程是怎么回事的人对公司更划算一点。
有头脑确实是一个很难定义的品质。但是让我们看一些在面试时能提问的一些问题，通过这些提问，我们可以找出拥有这种品质的人。完成工作非常关键。看起来有头脑但是不能完成工作的人经常拥有博士学位，在大公司工作过，但是在公司中没有人听他们的建议，因为他们是完全脱离实际的。比起准时交活儿，他们宁愿对于一些学院派的东西沉思。这些人由以下特性而可以识别出来。他们总是爱指出两个根本不同的概念间的相似性。例如，他们会说“Spreadsheets是一种特殊的编程语言”,然后花一个礼拜写一篇动人的，智慧的白皮书。这篇白皮书论述了，作为一个编程语言，spreadsheet关于计算语言特性的方方面面。聪明，但是没用。
现在，我们来谈谈完成工作但是没有头脑的人。他们爱做蠢事。从来也没有考虑过将来得靠他们自己或者别的什么人来亡羊补牢。通过制造新的工作，他们成为了公司的负债而不是资产。因为他们不仅没有为公司贡献价值，还浪费了好员工的时间。这些人通常到处粘贴大堆的代码，而不愿意写子程序。他们是完成了工作，但是不是以最聪明的方式完成工作。
面试时最重要的法则是:
做决定
在面试结束时，对于被面试者，你不得不做一个直截了当的决定。这个决定只有两个结果：雇佣或者不雇佣. 回到你的电脑前，立刻用电子邮件通知招聘负责人你的决定。电子邮件的主题应该是雇佣或者不雇佣。接着你需要在正文中写两段来支持你的决定.
没有其他的答案。永远不要说，“雇佣你，但是不能在我的团队中”。这是非常粗鲁的，因为你在暗示应试者没有聪明到能有和你一起工作的资格，但是以他的头脑适合进入那些天生输家队伍。如果你发觉自己被诱惑，想说出那句“雇佣你，但是不能在我的队伍中”，那么就简单的把这句话变成“不雇佣”再说出口。这样就没事了。甚至如果某个人在特定领域很能干，但是在别的队伍中将会表现不好，也是不雇佣。事物变化的如此之快，我们需要的是在任何地方都能成功的人。如果某些情况下你发现了一个白痴专家（拥有某些特殊能力的白痴），这个专家对于SQL非常，非常，非常的精通，但是除此之外什么也学不会，不雇佣。在Fog Creek公司他们没有将来。
永远不要说，“也许，我吃不准”。如果你吃不准，意味着不雇佣。看，比你想象的容易的多。吃不准？就说不！同样，如果你不能作出决定，那意味着不雇佣。不要说，”嗯，雇佣，我想是这样的。但是关于...，我想知道 ...”。这种情况就是不雇佣。
最重要的是记住这点，放弃一个可能的好人要比招进一个坏人强（译者按：中国有位哲人说过，宁可错杀一千，不可放过一个，呵呵）。一个不合格的求职者如果进入了公司，将要消耗公司大量的金钱和精力。其他优秀员工的还要浪费时间来修复这个人的错误。如果现在你还在犹豫，不雇佣。
如果你是Fog Creek公司的面试官，当你拒绝了大量的应聘者时，不要为Fog Creek公司将因此雇不到任何人了而忧虑。这不是你的问题。这是招聘负责人的问题。这是人力资源部的问题。这是Joel（译者注: Fog Creek公司的老板，本文作者）的问题。但不是你的问题。不停地问自己，哪种情况更糟糕？一种情况是我们变成了一个庞大的，糟糕的软件公司，充斥着许多脑袋空空如可可果壳的家伙，另一种情况是我们是一个小而高品质的公司。当然，找到优秀的应聘者（并聘用他们）是很重要的。找到有头脑而且完成工作的人是公司中的每个员工的日常工作之一。但是当你作为Joel Creek公司的一员真的开始面试一个应聘者时，要装作现在正有很多优秀的人想打破头挤进Fog Creek公司。总之，无论找到一个不错的应聘者是多么的难，永远不要降低你的标准。
但是你如何作出雇佣或者不雇佣这样艰难的决定？你只要在面试过程中不停地问自己：这个人有头脑吗？这个人能完成工作吗？要作出正确的回答，在面试时你必须问对问题。
开个玩笑，下面我要问个有史以来最差的面试问题: “Oracle 8i中的数据类型varchar和varchar2有什么区别”这是一个可怕的问题。掌握这种琐碎的技术细节和Fog Creek公司想雇佣你之间没有任何联系。谁会去记这种东西？如果有在线帮助，你可以在15秒内找到答案。
实际上，还有更差的问题，等会儿我会谈到的。
现在我们要谈到有趣的部分了：面试时提哪些问题。我的面试问题清单来自于我去微软公司找第一份工作的经历。这里实际上有几百个微软面试问题。每个人都有偏爱的问题。你也可以发展一套自己的面试问题以及面试的个人风格，这样你就可以比较容易地作出雇佣/不雇佣的决定。以下是我成功使用过的一些面试技巧，
在面试前，我读一遍应试者的简历，然后在一张纸片上随便写以下我的面试计划。这个计划实际上就是我要问的问题清单。以下是一个例子（用来面试程序员的）：
- 介绍
- 应试者参加过的项目
- 无法回答的问题
- C语言函数
- 你满意吗？
- 设计问题
- 挑战
- 你还有什么问题？
在面试前，我非常，非常当心，避免自己先入为主。如果在面试前你就已经想当然地认为，一个麻省理工的博士一定是一个有头脑的人。那么在接下来的一小时的面试时间内，无论那个麻省理工的博士说什么都不能改变你的最初印象。如果在面试前你就认为这个应试者是个傻瓜，那么他面试时说什么也无济于事。面试就象一个非常精巧的天平。一小时的面试结束后就要对一个人下结论是不容易的（但是你又必须在面试结束后得出结论）。一些不起眼的细节可能会影响最后的结论。如果你在面试开始前对于应试者有了一点了解的话，就好比天平的某一端加上了重重的砝码。这样面试本身就会变得没有用处了。以前有一次在面试前，一个招聘负责人跑进我的房间说，“你肯定会爱上这个家伙的!" 对一个男孩? 天哪，这简直让我发疯。我本来应该说，“嗯，如果你这么确定我会喜欢他，为什么你不干脆雇佣他,何必让我浪费时间来面试？”但是那时我还太年轻幼稚, 所以还是面试了那个人。当这个家伙开始说一些蠢话时，我对自己说，“哇塞，这应该是个例外情况，也许是大智若愚。”我开始带着玫瑰色眼镜看他了。于是我以说“雇佣”结束了面试，虽然他是一个糟糕的面试者。接下来发生了什么事？除了我，其他的面试官都说，不要雇佣这个人。教训是，不要听别的人的话，在面试应试者前不要四处打探这个面试者的情况。最重要的是不要和别的面考官谈论应试者，除非你们都已经作出了独立的判断。这才是科学的做法。
作为面试步骤的第一步，介绍的目的是让应试者放轻松。我通常花30秒钟，讲一下我是谁，接下来面试会如何进行。我总是使得应试者确信，我们关心的是他（她）如何解决问题的，而不是他（她）的最终答案是对还是错。顺便说一下，面试时，你不要和应试者隔着一个桌子坐着，否则在你和面试者之间就有了一个障碍，并且暗示着一种比较正式严肃的气氛，这样应试者就很难放松了。更好的办法是把桌子靠墙放着，或者和应试者坐在桌子的同一边，这样有助于应试者放松。只有应试者不会因为紧张而表现失常，你才能更有效的进行面试.
第二步的内容就是问应试者最近做了些什么项目。对刚毕业的学生, 如果有论文就问问论文, 没有的话, 就问问他们做过什么很喜欢的大作业.例如，有时候我会问一下，“你最喜欢上学期哪门课程？不一定要和计算机相关的。”事实上，如果应试者回答的课程和计算机没有关系，我会比较高兴。有时候你会发现这个计算机系应届生选择了尽可能少的计算机相关课程，但是却选修了很多和音乐相关的课程。但是他（她）却说最喜欢的课程是《面向对象数据库》。哼哼，不错啊. 不过如果你直接承认你喜欢音乐胜于计算机, 而不是在这儿胡说八道的话, 我会更高兴一点。
当面试有工作经验的人时，你可以让他们谈一下前一份工作。
我问这个问题的目的是在寻找一样品质：热情。在应试者谈到他（她）最近做过的项目时，你观察到以下迹象都是不错的：
- 谈到他们做过的项目时变得热情洋溢；他们的语速更快，语言更生动活泼。这说明他们对某些东西有兴趣，有热情（因为现实中有许多人对所做的项目根本漠不关心呢）。即使他们激动地表达对做过的项目的负面感情，这也是一个好的信号。“我曾经为上一个老板安装Foo Bar Mark II，但他是个傻瓜！”表现出热情的人就是我们要雇佣的人。差的应试者对工作根本就不关心，所以根本不会激动。一个非常好的信号是当应试者很激动地谈论上一份工作，以至于暂时忘记了他们正在被面试。有时候应试者刚开始面试时表现的很紧张 -- 这是很正常的现象，所以我通常忽略不计。但是当他们谈到单色计算艺术（Computational Monochromatic Art）时，这个家伙变得极端兴奋, 一点都不紧张了。不错，我喜欢这样的应试者，因为他们关心他们做的事。（什么是单色计算艺术？拔掉你的电脑显示器的电源就可以看到了）
- 能认真地去解释事情。某些人被我拒掉的原因就是他们不会用普通人能明白的语言去解释他们做过的项目。很多工科专业的人总是以为所有人都知道Bates理论（译者注: Bates Theorem，一种经济学的理论）或者Peano公理组（译者注: Peano's Axioms，数论中的一些定理）是什么。如果应试者开始满口行话了，让他们停一停，然后你说，“能帮我个忙吗？就是为了练习一下，你能把刚才说的用我老祖母也能理解的话说一遍吗？”但即便如此, 有些人还是继续用那些术语, 而且根本没法让人明白他们在说什么。天哪！
- 如果这个项目是一个团队项目，看看他们是否在有承担领导责任的迹象？一个应试者可能会说：“我们用的是X方法，但是老板说应该是Y，而客户说应该是Z。”我会问，“那么你怎么做的？”一个好的回答可能是“我设法和团队中别的人开了个会，然后一起搞出个办法...”坏的回答看起来象，“嗯，我什么也不能做。这样的问题我解决不了。”记住，聪明并且能完成工作。要搞清楚某人是否能完成工作的一个办法就是看看他（她）过去是否倾向于完成任务。事实上，你可以主动要求他们给你个例子证明他们能担任领导作用，完成任务。－例如克服公司的陈规陋习。
现在我们谈谈清单上的第三款，无法回答的问题。这很有趣。这个主意的关键在于问一些不可能有答案的问题，就是想看一下应试者怎么办。“西雅图有多少眼科医生？”“华盛顿纪念碑有多重？”“洛杉机有多少加油站？”“纽约有多少钢琴调音师？”
- 聪明的应试者猜到你不是要测验他们的专业知识，他们会积极地给出一个估计。“嗯，洛杉机的人口是七百万；每个人平均拥有2.5辆轿车...”当然如果他们的估计完全错误了也没有关系。重要的是他们能积极地试着回答问题。他们可能会试着搞清楚每个加油站的储量。“嗯，需要四分钟给一个储油罐加满油，一个加油站有十个油泵每天运行十八个小时...”他们也可能试着从占地面积来估计。有时, 他们的想法的创造力让你吃惊. 而有时, 他们直接要一个LA的黄页去查。这都是好迹象。
- 不聪明的应试者则被难住了。他们目瞪口呆地望着你，好像你来自火星。你不得不提示：“嗯，如果你想建立一个象洛杉机那么大的城市，你需要建立多少个加油站？”你还可以提示他们：“加满一个储油罐要多长时间？”不过，这些榆木疙瘩脑袋还是只会坐在那里发呆，你得拖着他们往前走才行。这类人不会解决问题，我们可不要这样的人。
关于编程问题，我通常要求应试者用C语言写一些小函数。以下是我通常会出的题目：
- 将一个字符串逆序
- 将一个链表（linked list）逆序
- 计算一个字节（byte）里有多少bit被置1
- 搜索给定的字节（byte）
- 在一个字符串中找到可能的最长的子字符串，该字符串是由同一字符组成的
- 字符串转换成整数
- 整数转换成字符串（这个问题很不错，因为应试者要用到堆栈或者strev函数）
注意，通常你不会希望他们写的代码多于5行，因为你没有时间理解太长的代码。
现在我们来详细看一看其中几个问题: 第一个问题: 逆序一个字符串。我这辈子还没有见过那个面试者能把这题目一次做对。所有的应试者都试图动态生成缓冲区，然后将逆序的字符串输出到该缓冲区中。问题的关键在于，谁负责分配这个缓冲区？谁又负责释放那个缓冲区？通过这个问题，我发现了一个有趣的事实，就是大多数认为自己懂C的人实际上不理解指针和内存的概念。他们就是不明白。这真叫人吃惊，无法想象这种人也能做程序员。但他们真的就是！这个问题可以从多个角度判断应试者：
- 他们的函数运行快吗？看一下他们多少此调用了strlen函数。我曾经看到应试者写的strrev的算法竟然只有O(n^2) 的效率，而标准的算法效率应该是O(n)，效率如此底下的原因是因为他们在循环中一次又一次调用strlen函数。
- 他们使用指针运算吗（译者按：原文为pointer arithmetic，指的是加减指针变量的值）？使用指针运算是个好现象。许多所谓的“C程序员”竟然不知道如何使用指针运算（pointer arithmetic）。当然，我在前文说过我不会因为应试者不掌握一种特定的技巧而拒绝他。但是，理解C语言中的指针不是一种技巧，而是一种与生俱来的才能。每年一所大学要招进200多个计算机系的新生，所有这些小孩子4岁就开始用BASIC语言在Atari 800s写冒险游戏了。在大学里他们还学Pascal语言，学得也很棒。直到有一天他们的教授讲了指针的概念，突然，他们开始搞不懂了。他们就是不能再理解C语言中的任何东西了。于是90%的计算机系学生转系去学政治学。为了挽回面子，他们告诉朋友，他们之所以转系是因为他们计算机系英俊貌美的异性太少。许多人注定脑子里就没有理解指针的那根弦。所以说理解指针是一种与生俱来的品质，而不是一种单纯的技巧。理解指针需要脑子转好几个弯，某些人天生不擅长转这几个弯。
第三个问题可以考考面试者对C的位运算的掌握，但这是一种技巧，不是一种品质，所以你可以帮助他们。有趣的等他们建立了一个子函数用来计算byte中为1的位的数目，然后你要求他们优化这个子函数，尽量加快这个函数的运行速度。聪明的应试者会使用查表算法（毕竟这个表只有 256个元素，用不了多少内存），整个表只需要建立一次。跟聪明的应试者讨论一下提高时间／空间效率的不同策略是十分有意思的事情. 进一步告诉他们你不想在程序启动时初始化查询表。聪明的面试者可能会建议使用缓冲机制，对于一个特定的byte，只有在第一次被查询时进行计算，然后计算结果会被放入查询表。这样以后再被查询时直接查表就行了。而特别特别聪明的面试这会尝试有没有建立查询表的捷径，如一个byte和它的置1的bit数之间有没有规律可循？
当你观察应试者写C代码时，以下一些技巧会对你有帮助：
- 事先向应试者说明，你完全理解，没有一个好的编辑器光在纸上写代码是困难的，所以你不在乎他们手写的代码是否看上去不整洁。你也完全明白没有好的编译器和调试器，很难第一次就写出完全没有bug的程序，所以请他们不必为此担心。
- 好程序员的标志：好程序员写完“{”符号后，通常立刻跟上“}”符号，然后再在当中填上代码。他们也倾向于使用命名规则，虽然这个规则可能很原始。如果一个变量用作循环语句的索引，好程序员通常使用尽可能少的字符为它命名。如果他们的循环语句的索引变量的名字是CurrentPagePositionLoopCounter，显而易见他们写代码的经验还不够多。偶尔，你会看到一个C程序员写下象if (0==strlen(x))一样的代码，常量被放在==的左边。这是非常好的现象。这说明他因为总是把＝和＝＝搞混，已经强迫自己养成这种习惯以避免犯错。
- 好的程序员在写代码前会订一个计划，特别是当他们的代码用到了指针时。例如，如果你要求逆序一个链表，好程序员通常会在纸的一边画上链表的草图，并表明算法中的索引指针当前移动到的位置。他们不得不这样做。正常人是不可能不借助草图就开始写一个逆序链表的程序的。差的程序员立刻开始写代码。
不可避免的，你会在他们的程序中发现bug，于是我们现在来到了第五个问题：你对代码满意吗？ 你可能想问，“好吧，bug在哪里？”这是来自地狱的一针见血的问题，要回答这个问题可要大费口舌。所有的程序员都会犯错误，这不是问题。但他们必须能找到错误。对于字符串操作的函数，他们通常会忘记在输出缓冲区加上字符串结束符。所有的函数，他们都会犯off-by-one错误（译者按：指的是某个变量的最大值和最小值可能会和正常值差1)。他们会忘掉正常的C语句结尾的分号。如果输入是零长度字符串，他们的函数会运行错误。如果malloc调用失败而他们没有为此写好错误处理代码，程序会崩溃。一次就能把所有事情做对的程序员非常,非常,非常地少.不过要是真的碰上一个的话, 提问就更有意思了. 你说,"还有Bug"。他们会再仔细地检查一遍代码。这个时候, 观察一下他们内心是否开始动摇了, 只是表面上勉强坚持说代码没有问题。总之，在程序员写完代码后，问一下他们是否对代码满意是个好主意。就像Regis那样问他们！（译者按，Regis Philbin是美国ABC电视网的游戏电视节目主持人，他的口头禅是“这是你的最后的答案吗？”）
第六部分：关于设计的问题。让应试者设计某样东西。Jabe Blumenthal，Excel的原始设计者，喜欢让应试者设计房子。Jabe说，曾经有一个应试者跑到白板前，画了一个方块，这就是他的全部设计。天哪，一个方块！立刻拒绝这样的家伙。你喜欢问什么样的设计问题？
- 好的程序员会问更多的信息。房子为谁造的？我们公司的政策是，我们不会雇佣那些在设计前不问为谁设计的人。通常，我会很烦恼我得打断他们的设计，说“事实上，你忘记问这个房子是给谁设计的了。这个房子是给一群长颈鹿造的。”
- 笨笨的应试者认为设计就像画画，你想画什么就画什么。聪明的应试者明白设计的过程是一系列艰难的权衡。一个很棒的设计问题是：设计一个放在街角的垃圾箱。想一想你得做多少权衡！垃圾箱必须易于清空，但是很难被偷走；易于放进垃圾，但是碰到狂风大作，里面的垃圾不会被吹出来；垃圾箱必须坚固而便宜。在某些城市，垃圾箱必须特别设计，以防恐怖分子在里面藏一个定时炸弹。
- 有创造力的应试者会给出有趣而独特的设计。我最喜欢的问题之一是为盲人设计一个放调味品的架子（译者按：原文为spice rack，老外的厨房里有个专门放调味品的架子,上面放了很多小罐罐，里面装了各种各样的调料）通常许多应试者的建议是把布莱叶文（一种盲人使用的文字）刻在放调料的罐子上，这样文字会卷起来而变形。我碰到一个应试者，他的设计是把调料放在抽屉里，因为他觉得水平地感知布莱叶文比垂直地做更方便。（试试看！）这个答案这样有创意，使我震惊！我面试了有一打得程序员，从来没有人想到过类似的答案。这样有创意的答案确实跃过了普通人考虑问题的条条框框。仅仅因为这个答案太有创意了，而且应试者别的方面还过得去，我雇佣了这个应试者，他现在已经成为Excel团队中一个优秀的项目经理了（译者按，本文作者曾在微软工作过）。
- 总是争取一个确定的了结。这也是完成工作的特质的一部分。有时候应试者会犹犹豫豫不能作出一个决定,试图回避困难的问题，留着困难的问题不作决定就直接向下进行,这很不好。好的应试者有一种推动事情自然地前进的倾向，即使你有意把他们拖回来。如果关于某个话题的讨论开始原地打转变得没有意义了，好的应试者会说，“嗯，我们可以整天谈论这个，但是我们得做点什么。为什么我们不开始...”
于是我们来到了第七部分，挑战。这部分很好玩。在面试中留心一下, 当面试者的回答绝对的百分之百毫无争议时, 你可以说: " 嗯, 等一下等一下." 然后花上两分钟玩一下魔鬼的游戏（译者按，原文为devil's advocate，魔鬼代言人指的是违背自己的良知，为错误邪恶的观点辩护）. 记住一定要在你可以肯定他正确时和他争论。
这个很有意思.
- 软弱的应试者会屈服。那我就和他说拜拜了。
- 坚定的应试者会找到一个办法说服你。他们会以肯尼迪总统的口才来说服你，“也许我误会了你的意思，”他们这样开头，但是正文仍是坚定地站稳立场。这样的人我就雇佣。
不得不承认，面试双方的地位并不是平等的。有可能应试者由于害怕你的权力而不敢于你争辩。但是，好的应试者有足够的热情和勇气坚持正确的观点，他们由于热切希望说服你而会暂时忘记正在被面试。这样的人就是我们要雇佣的人。
最后，可以问一下应试者有什么想问的。一些人喜欢看看应试者这时是否会问一些聪明的问题。这是市面上流行的面试书籍的标准技巧。我个人不在乎应试者问什么，因为这时我已经做了决定。麻烦在于，应试者也许已经见了5、6个人，进行了好几轮面试，他们可能很累了，以至于不能为每轮面试都准备一个聪明而独特的问题。所以如果他们没有可问的，没关系。
我总是留下面试的最后5分钟来推销我的公司。这很重要。即使我不打算雇佣眼前这个应试者。如果你幸运的找到一个很棒的应试者，你当然愿意做任何事情说服他（她）来你的公司。即使他们不是好的应试者，你也要尽力让他们为Fog Creek公司激动，这样面试结束时他们会对Fog Creek公司留下一个很好的印象。记住，应试者并不仅仅是可能的雇员，他们也是顾客，也是我们公司的推销员。如果他们觉得我们的公司很棒，他们也许会推荐朋友来面试。
啊哈，我记得我说过我会给出一些应该避免的非常不好的反面的试题例子。
首先，避免不合法的问题。有关种族，宗教，性别，出生国，年龄，服役记录，是否老兵，性取向，生理障碍的问题都是不合法的。即使他们的简历说他们1990年在军中服役，也不要问有关问题。也许这会让他们愉快地谈论在海湾战争中的经历。但是你的问题还是不合法的。如果简历上写着他们上过Technion in Haifa, 不要问他们是否是以色列人, 即使只是为了闲谈, 因为这是违法的. 下面有一个很好的不合法的例子。点击这里有很多关于什么是违法的讨论。（但是这个网站的其余问题够愚蠢的。）
其次，不要在问题中给予应试者暗示，我们公司喜欢或者不喜欢什么样的员工。我能想到的一个例子是问应试者是否有小孩或者是否结婚了。应试者也许会想我们不喜欢有家庭拖累的员工。
最后，不要问那些脑筋急转弯的题目，例如6根火柴怎么拼出4个三角形。象这样的灵机一动的问题是不能看出应试者是否有“有头脑/完成工作”的品质。
面试与其说是科学不如说是艺术。但是只要你记住有头脑/完成工作这个原则，你就可以应对自如。有机会就问问你的同事他们喜欢的面试问题和答案。这是我们公司员工午饭时热衷的话题之一。
本文最先用英文出版，题为 The Guerrilla Guide to Interviewing
作者简介 Joel Spolsky 是纽约市一家小软件公司，Fog Creek Software, 的创始人。他毕业于耶鲁大学，曾在美国微软公司，Viacom, Juno 任软件设计师及经理。
[显示打印版本]
相关文章
posted @
2008-11-04 21:29 poower 阅读(215) |
评论 (0) |
编辑 收藏
想成为嵌入式程序员应知道的0x10个基本问题
简述:
这是嵌入式C程序员的基本知识。作者在Embedded Systems Programming杂志上发表了很多嵌入式系统开发方面的文章。
作者:Jones Nigel 更新日期:2005-04-08
来源:internet 浏览次数:
C语言测试是招聘嵌入式系统程序员过程中必须而且有效的方法。这些年，我既参加也组织了许多这种测试，在这过程中我意识到这些测试能为面试者和被面试者提供许多有用信息，此外，撇开面试的压力不谈，这种测试也是相当有趣的。
从被面试者的角度来讲，你能了解许多关于出题者或监考者的情况。这个测试只是出题者为显示其对ANSI标准细节的知识而不是技术技巧而设计吗？这是个愚蠢的问题吗？如要你答出某个字符的ASCII值。这些问题着重考察你的系统调用和内存分配策略方面的能力吗？这标志着出题者也许花时间在微机上而不是在嵌入式系统上。如果上述任何问题的答案是"是"的话，那么我知道我得认真考虑我是否应该去做这份工作。
从面试者的角度来讲，一个测试也许能从多方面揭示应试者的素质：最基本的，你能了解应试者C语言的水平。不管怎么样，看一下这人如何回答他不会的问题也是满有趣。应试者是以好的直觉做出明智的选择，还是只是瞎蒙呢？当应试者在某个问题上卡住时是找借口呢，还是表现出对问题的真正的好奇心，把这看成学习的机会呢？我发现这些信息与他们的测试成绩一样有用。
有了这些想法，我决定出一些真正针对嵌入式系统的考题，希望这些令人头痛的考题能给正在找工作的人一点帮助。这些问题都是我这些年实际碰到的。其中有些题很难，但它们应该都能给你一点启迪。
这个测试适于不同水平的应试者，大多数初级水平的应试者的成绩会很差，经验丰富的程序员应该有很好的成绩。为了让你能自己决定某些问题的偏好，每个问题没有分配分数，如果选择这些考题为你所用，请自行按你的意思分配分数。
预处理器（Preprocessor）
1 . 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在这想看到几件事情：
1) #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）
2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。
3) 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
4) 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。
2 . 写一个"标准"宏MIN ，这个宏输入两个参数并返回较小的一个。
#define MIN(A,B) （（A） <= (B) ? (A) : (B))
这个测试是为下面的目的而设的：
1) 标识#define在宏中应用的基本知识。这是很重要的。因为在
嵌入(inline)操作符 变为标准C的一部分之前，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。
2)三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。
3) 懂得在宏中小心地把参数用括号括起来
4) 我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？
least = MIN(*p++, b);
3. 预处理器标识#error的目的是什么？
如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。
死循环（Infinite loops）
4. 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？
这个问题用几个解决方案。我首选的方案是：
while(1)
{
}
一些程序员更喜欢如下方案：
for(;;)
{
}
这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案，我将用这个作为一个机会去探究他们这样做的基本原理。如果他们的基本答案是："我被教着这样做，但从没有想到过为什么。"这会给我留下一个坏印象。
第三个方案是用 goto
Loop:
...
goto Loop;
应试者如给出上面的方案，这说明或者他是一个汇编语言程序员（这也许是好事）或者他是一个想进入新领域的BASIC/FORTRAN程序员。
数据声明（Data declarations）
5. 用变量a给出下面的定义
a) 一个整型数（An integer）
b)一个指向整型数的指针（ A pointer to an integer）
c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r
d)一个有10个整型数的数组（ An array of 10 integers）
e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers）
f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers）
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）
答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer
人们经常声称这里有几个问题是那种要翻一下书才能回答的问题，我同意这种说法。当我写这篇文章时，为了确定语法的正确性，我的确查了一下书。但是当我被面试的时候，我期望被问到这个问题（或者相近的问题）。因为在被面试的这段时间里，我确定我知道这个问题的答案。应试者如果不知道所有的答案（或至少大部分答案），那么也就没有为这次面试做准备，如果该面试者没有为这次面试做准备，那么他又能为什么出准备呢？
Static
6. 关键字static的作用是什么？
这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：
1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。
Const
7．关键字const有什么含意？
我只要一听到被面试者说："const意味着常数"，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着"只读"就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）
如果应试者能正确回答这个问题，我将问他一个附加的问题：
下面的声明都是什么意思？
const int a;
int const a;
const int *a;
int * const a;
int const * a const;
/******/
前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
1) 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）
2) 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
3) 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。
Volatile
8. 关键字volatile有什么含意?并给出三个不同的例子。
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
1) 并行设备的硬件寄存器（如：状态寄存器）
2) 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
3) 多线程应用中被几个任务共享的变量
回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。
假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
1)一个参数既可以是const还可以是volatile吗？解释为什么。
2); 一个指针可以是volatile 吗？解释为什么。
3); 下面的函数有什么错误：
int square(volatile int *ptr)
{
return *ptr * *ptr;
}
下面是答案：
1)是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
2); 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
3) 这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：
int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}
位操作（Bit manipulation）
9. 嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。
对这个问题有三种基本的反应
1)不知道如何下手。该被面者从没做过任何嵌入式系统的工作。
2) 用bit fields。Bit fields是被扔到C语言死角的东西，它保证你的代码在不同编译器之间是不可移植的，同时也保证了的你的代码是不可重用的。我最近不幸看到 Infineon为其较复杂的通信芯片写的驱动程序，它用到了bit fields因此完全对我无用，因为我的编译器用其它的方式来实现bit fields的。从道德讲：永远不要让一个非嵌入式的家伙粘实际硬件的边。
3) 用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法，是应该被用到的方法。最佳的解决方案如下：
#define BIT3 (0x1 << 3)
static int a;
void set_bit3(void)
{
a |= BIT3;
}
void clear_bit3(void)
{
a &= ~BIT3;
}
一些人喜欢为设置和清除值而定义一个掩码同时定义一些说明常数，这也是可以接受的。我希望看到几个要点：说明常数、|=和&=~操作。
访问固定的内存位置（Accessing fixed memory locations）
10. 嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。
这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下：
int *ptr;
ptr = (int *)0x67a9;
*ptr = 0xaa55;
A more obscure approach is:
一个较晦涩的方法是：
*(int * const)(0x67a9) = 0xaa55;
即使你的品味更接近第二种方案，但我建议你在面试时使用第一种方案。
中断（Interrupts）
11. 中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字 __interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR)，请评论一下这段代码的。
__interrupt double compute_area (double radius)
{
double area = PI * radius * radius;
printf("\nArea = %f", area);
return area;
}
这个函数有太多的错误了，以至让人不知从何说起了：
1)ISR 不能返回一个值。如果你不懂这个，那么你不会被雇用的。
2) ISR 不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。
3) 在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。
4) 与第三点一脉相承，printf()经常有重入和性能上的问题。如果你丢掉了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了。
代码例子（Code examples）
12 . 下面的代码输出是什么，为什么？
void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b > 6) ? puts("> 6") : puts("<= 6");
}
这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是 ">6"。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。
13. 评价下面的代码片断：
unsigned int zero = 0;
unsigned int compzero = 0xFFFF;
/*1's complement of zero */
对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下：
unsigned int compzero = ~0;
这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里，好的嵌入式程序员非常准确地明白硬件的细节和它的局限，然而PC机程序往往把硬件作为一个无法避免的烦恼。
到了这个阶段，应试者或者完全垂头丧气了或者信心满满志在必得。如果显然应试者不是很好，那么这个测试就在这里结束了。但如果显然应试者做得不错，那么我就扔出下面的追加问题，这些问题是比较难的，我想仅仅非常优秀的应试者能做得不错。提出这些问题，我希望更多看到应试者应付问题的方法，而不是答案。不管如何，你就当是这个娱乐吧...
动态内存分配（Dynamic memory allocation）
14. 尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？
这里，我期望应试者能提到内存碎片，碎片收集的问题，变量的持行时间等等。这个主题已经在ESP杂志中被广泛地讨论过了（主要是 P.J. Plauger, 他的解释远远超过我这里能提到的任何解释），所有回过头看一下这些杂志吧！让应试者进入一种虚假的安全感觉后，我拿出这么一个小节目：
下面的代码片段的输出是什么，为什么？
char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts("Got a null pointer");
else
puts("Got a valid pointer");
这是一个有趣的问题。最近在我的一个同事不经意把0值传给了函数malloc，得到了一个合法的指针之后，我才想到这个问题。这就是上面的代码，该代码的输出是"Got a valid pointer"。我用这个来开始讨论这样的一问题，看看被面试者是否想到库例程这样做是正确。得到正确的答案固然重要，但解决问题的方法和你做决定的基本原理更重要些。
Typedef
15 Typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子：
#define dPS struct s *
typedef struct s * tPS;
以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？
这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。思考下面的例子：
dPS p1,p2;
tPS p3,p4;
第一个扩展为
struct s * p1, p2;
.
上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。
晦涩的语法
16 . C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？
int a = 5, b = 7, c;
c = a+++b;
这个问题将做为这个测验的一个愉快的结尾。不管你相不相信，上面的例子是完全合乎语法的。问题是编译器如何处理它？水平不高的编译作者实际上会争论这个问题，根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理成：
c = a++ + b;
因此, 这段代码持行后a = 6, b = 7, c = 12。
如果你知道答案，或猜出正确答案，做得好。如果你不知道答案，我也不把这个当作问题。我发现这个问题的最大好处是这是一个关于代码编写风格，代码的可读性，代码的可修改性的好的话题。
好了，伙计们，你现在已经做完所有的测试了。这就是我出的C语言测试题，我怀着愉快的心情写完它，希望你以同样的心情读完它。如果是认为这是一个好的测试，那么尽量都用到你的找工作的过程中去吧。天知道也许过个一两年，我就不做现在的工作，也需要找一个。
作者介绍:
Nigel Jones 是一个顾问，现在住在Maryland，当他不在水下时，你能在多个范围的嵌入项目中找到他。 他很高兴能收到读者的来信，他的email地址是: NAJones@compuserve.com
参考文献
1) Jones, Nigel, "In Praise of the #error directive," Embedded Systems Programming, September 1999, p. 114.
2) Jones, Nigel, " Efficient C Code for Eight-bit MCUs ," Embedded Systems Programming, November 1998, p. 66.
[显示打印版本]
相关文章
-
leslie [2005-04-08]
挺考验基本知识的
posted @
2008-11-04 21:27 poower 阅读(181) |
评论 (0) |
编辑 收藏
#include "stdio.h"
#include "conio.h"
#include <dos.h>
#include<graphics.h>
/*****
Key struct:
position:x1,y1,x2,y2
State:isdown
white or black key:iswhite
nearby key:lwbk,rwbk
*******/
typedef struct _Key{
int x1;
int y1;
int x2;
int y2;
int isdown;
int iswhite;
int lwbk;
int rwbk;
} Key;
/*****
static grobal Variables statement:
7 white keys:wk[7]
5 black keys:bk[5]
width,height:kw,kh
frequant:frequ[8]
pcfrequant:pcfre
keynum
count
*******/
static wknum=14;
static Key wk[14];
static bknum=10;
static Key bk[10];
static int kw=32,kh=160;
static int leftwidth=2*32;
int frequ[8]={262, 294, 330, 349, 392, 440, 494, 524};
static long int pcfre=1190000;
static int keyindex;
static int count;
/*****
function statement:
makesound():
initkey();
change key state:setup(),setdown()
initdrawkey();
*******/
void makesound();
Key set(int x1,int w,int h);
void setup(Key *k);
void setdown(Key *k);
void keyinit();
void initdrawkey();
/*initkey*/
Key initset(int x1,int w,int h,int isw,int lwbk,int rwbk){
Key k;
k.x1=x1;
k.y1=0;
k.x2=x1+w;
k.y2=h;
k.isdown=0;
k.iswhite=isw;
k.lwbk=lwbk;
k.rwbk=rwbk;
return k;
}
/*keyinit()*/
void keyinit(){
wk[0]=initset(leftwidth+0*kw,kw,kh,1,-1,0);
wk[1]=initset(leftwidth+1*kw,kw,kh,1,0,1);
wk[2]=initset(leftwidth+2*kw,kw,kh,1,1,-1);
wk[3]=initset(leftwidth+3*kw,kw,kh,1,-1,2);
wk[4]=initset(leftwidth+4*kw,kw,kh,1,2,3);
wk[5]=initset(leftwidth+5*kw,kw,kh,1,3,4);
wk[6]=initset(leftwidth+6*kw,kw,kh,1,4,-1);
wk[7]=initset(leftwidth+7*kw,kw,kh,1,-1,6);
wk[8]=initset(leftwidth+8*kw,kw,kh,1,6,7);
wk[9]=initset(leftwidth+9*kw,kw,kh,1,7,-1);
wk[10]=initset(leftwidth+10*kw,kw,kh,1,-1,8);
wk[11]=initset(leftwidth+11*kw,kw,kh,1,8,9);
wk[12]=initset(leftwidth+12*kw,kw,kh,1,9,10);
wk[13]=initset(leftwidth+13*kw,kw,kh,1,10,-1);
bk[0]= initset(leftwidth+kw-kw/4,kw/2,kh/2,0,0,1);
bk[1]= initset(leftwidth+kw*2-kw/4,kw/2,kh/2,0,1,2);
bk[2]= initset(leftwidth+kw*4-kw/4,kw/2,kh/2,0,3,4);
bk[3]= initset(leftwidth+kw*5-kw/4,kw/2,kh/2,0,4,5);
bk[4]= initset(leftwidth+kw*6-kw/4,kw/2,kh/2,0,5,6);
bk[5]= initset(leftwidth+kw*8-kw/4,kw/2,kh/2,0,7,8);
bk[6]= initset(leftwidth+kw*9-kw/4,kw/2,kh/2,0,8,9);
bk[7]= initset(leftwidth+kw*11-kw/4,kw/2,kh/2,0,10,11);
bk[8]= initset(leftwidth+kw*12-kw/4,kw/2,kh/2,0,11,12);
bk[9]= initset(leftwidth+kw*13-kw/4,kw/2,kh/2,0,12,13);
}
/*draw black key*/
void drawblackkey(Key *k){
if(!(*k).isdown){
setfillstyle(SOLID_FILL,DARKGRAY);
bar((*k).x1,(*k).y1,(*k).x2,(*k).y2);
}
else{
setfillstyle(SOLID_FILL,LIGHTBLUE);
bar((*k).x1,(*k).y1,(*k).x2,(*k).y2);
}
}
/*draw white key*/
void drawwhitekey(Key *k){
if(!(*k).isdown){
setfillstyle(SOLID_FILL,WHITE);
bar((*k).x1,(*k).y1,(*k).x2,(*k).y2);
setcolor(DARKGRAY);
rectangle((*k).x1,(*k).y1,(*k).x2,(*k).y2);
/*draw nearby key*/
if(!(*k).lwbk>-1){
drawblackkey(&bk[(*k).lwbk]);
}
if(!(*k).rwbk>-1){
drawblackkey(&bk[(*k).rwbk]);
}
}
else{
setfillstyle(SOLID_FILL,LIGHTBLUE);
bar((*k).x1,(*k).y1,(*k).x2,(*k).y2);
setcolor(DARKGRAY);
rectangle((*k).x1,(*k).y1,(*k).x2,(*k).y2);
/*draw nearby key*/
if(!(*k).lwbk>-1){
drawblackkey(&bk[(*k).lwbk]);
}
if(!(*k).rwbk>-1){
drawblackkey(&bk[(*k).rwbk]);
}
}
}
/*setdown() and setup()*/
void setdown(Key *k){
(*k).isdown=1;
if((*k).iswhite)
drawwhitekey(k);
else
drawblackkey(k);
}
void setup(Key *k){
(*k).isdown=0;
if((*k).iswhite)
drawwhitekey(k);
else
drawblackkey(k);
}
/*initdrawkey()*/
void initdrawkey(){
int gdriver,gmode,i;
gdriver=DETECT;
initgraph(&gdriver,&gmode,"c:\\tc");
setbkcolor(YELLOW);
cleardevice();
for(i=0;i<wknum;i++){
setfillstyle(SOLID_FILL,WHITE);
bar(wk[i].x1,wk[i].y1,wk[i].x2,wk[i].y2);
setcolor(DARKGRAY);
rectangle(wk[i].x1,wk[i].y1,wk[i].x2,wk[i].y2);
}
for(i=0;i<bknum;i++){
setfillstyle(SOLID_FILL,DARKGRAY);
bar(bk[i].x1,bk[i].y1,bk[i].x2,bk[i].y2);
}
}
/*makesound()*/
void makesound(){
count=(int)(pcfre/frequ[keyindex]);
asm mov al, 10110110b
asm out 43h, al
asm mov ax,count
asm out 42h, al
asm mov al, ah
asm out 42h, al
asm in al, 61h
asm or al, 03h
asm out 61h, al
delay(0xfffff000);
asm in al, 61h
asm and al, 11111100b
asm out 61h, al
}
void main(){
keyinit();
initdrawkey();
settextstyle(4, 0, 10);
outtextxy(200, 230, "Interface Principle Course Design");
outtextxy(200, 250, "------------Piano----------------");
outtextxy(200, 270, "-------Input 1...7 Play----------");
outtextxy(200, 290, "-------Input CTRL+C Exit---------");
outtextxy(200, 310, "-------Auther:Ying Wenjie--------");
outtextxy(200, 340, "---------Date:2008-7-3-----------");
while(1){
keyindex=getch();
if(keyindex==3)
break;
keyindex=keyindex-0x30;
if(keyindex<1||keyindex>8)
continue;
keyindex--;
setdown(&wk[keyindex]);
makesound();
setup(&wk[keyindex]);
}
}
posted @
2008-07-02 16:35 poower 阅读(214) |
评论 (0) |
编辑 收藏
author: scruffybear
release time: 28/10/2006
company: Watchdata
如有转载，请注明出处，并保持文章的完整性，谢谢！
做java卡开发需要用到JNI,也就是本地化接口,说白了java程序要用到其它语言代码,这样就可以使用JNI来进行达到调用的目的,暂时理解到这里,还没有时间细究。网上看到了一篇很好的介绍JNI的文章《JNI入门介绍上》、《JNI入门介绍下》，只研究了前一篇，进行了实践，后一篇实践觉得写得不好，没有花时间进行实践。
1．简介
JNI是Java Native Interface的缩写，它的设计目的是：
The standard Java class library may not support the platform-dependent features needed by your application.
You may already have a library or application written in another programming language and you wish to make it accessible to Java applications.
You may want to implement a small portion of time-critical code in a lower-level programming language, such as assembly, and then have your Java application call these functions
2．JNI的书写步骤
编写带有native声明的方法的java类
使用javac命令编译所编写的java类
使用javah -jni java类名生成扩展名为h的头文件
使用C/C++实现本地方法
将C/C++编写的文件生成动态连接库
ok
1) 编写java程序：
这里以HelloWorld为例。
代码1：
class HelloWorld {
public native void displayHelloWorld();
static {
System.loadLibrary("hello");
}
public static void main(String[] args) {
new HelloWorld().displayHelloWorld();
}
}
声明native方法：如果你想将一个方法做为一个本地方法的话，那么你就必须声明改方法为native的，并且不能实现。其中方法的参数和返回值在后面讲述。
Load动态库：System.loadLibrary("hello");加载动态库（我们可以这样理解：我们的方法displayHelloWorld()没有实现，但是我们在下面就直接使用了，所以必须在使用之前对它进行初始化）这里一般是以static块进行加载的。同时需要注意的是System.loadLibrary();的参数“hello”是动态库的名字。
main()方法
2) 编译没有什么好说的了
javac HelloWorld.java
这里是运行不了的，因为这时候目录下面没有hello.dll文件供调用，如果输入java HelloWorld会出现以下错误：
C:\Documents and Settings\huilin.xiong\桌面>java HelloWorld
Exception in thread "main" java.lang.UnsatisfiedLinkError: no hello in java.library.path
at java.lang.ClassLoader.loadLibrary(Unknown Source)
at java.lang.Runtime.loadLibrary0(Unknown Source)
at java.lang.System.loadLibrary(Unknown Source)
at HelloWorld.<clinit>(HelloWorld.java:5)
下面就用c语言生成hello.dll文件供java语言来调用。如下：
3) 生成扩展名为h的头文件
javah -jni HelloWorld
在这里自动生成文件名为HelloWorld.h的头文件。
头文件的内容：
/* DO NOT EDIT THIS FILE - it is machine generated */
#include
/* Header for class HelloWorld */
#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplu*
**tern "C" {
#endif
/*
* Class: HelloWorld
* Method: displayHelloWorld
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld
(JNIEnv *, jobject);
#ifdef __cplusplus
}
#endif
#endif
（这里我们可以这样理解：这个h文件相当于我们在java里面的接口，这里声明了一个Java_HelloWorld_displayHelloWorld (JNIEnv *, jobject);方法，然后在我们的本地方法里面实现这个方法，也就是说我们在编写C/C++程序的时候所使用的方法名必须和这里的一致）。
4) 编写本地方法
实现和由javah命令生成的头文件里面声明的方法名相同的方法。
代码2：
#include <jni.h>
#include "HelloWorld.h"
#include <stdio.h>
JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorld(JNIEnv *env,jobject obj)
{
printf("Hello world!\n");
return;
}
注意代码2中的第1行，需要将jni.h（该文件可以在%JAVA_HOME%/include文件夹下面找到）文件引入，因为在程序中的JNIEnv、jobject等类型都是在该头文件中定义的；另外在第2行需要将HelloWorld.h头文件引入（我是这么理解的：相当于我们在编写java程序的时候，实现一个接口的话需要声明才可以，这里就是将HelloWorld.h头文件里面声明的方法加以实现。当然不一定是这样）。然后保存为HelloWorldImpl.c就ok了。
5) 生成动态库
这里以在Windows中为例，需要生成dll文件。在保存HelloWorldImpl.c文件夹下面，使用VC的编译器cl成。
cl -I%java_home%\include -I%java_home%\include\win32 -LD HelloWorldImp.c -Fehello.dll
注意：生成的dll文件名在选项-Fe后面配置，这里是hello，因为在HelloWorld.java文件中我们loadLibary的时候使用的名字是hello。当然这里修改之后那里也需要修改。另外需要将-I%java_home%\include -I%java_home%\include\win32参数加上，因为在第四步里面编写本地方法的时候引入了jni.h文件。
这里在实际的操作中找不到头文件<stdio.h>，找不出原因，检查了我的环境变量设置也没有错，没办法，只有从目录D:\Software\Microsoft Visual Studio .NET\Vc7\include目录下拷贝过来，另外又找不到stdarg.h，一并拷贝过来。头文件都找不到后，又出现了找不到好几个LIB文件，分别为libcmt.lib，oldnames.lib，kernel32.lib，检查环境变量也没错，没办法，只能从D:\Software\Microsoft Visual Studio.NET\Vc7\lib拷贝过来。最后在目录下生成了这样几个文件：HelloWorldImpl.obj，hello.dll，hello.exp，hello.lib，当然，只有hello.dll是有用的，它是被HelloWorld.class所调用。
6) 运行程序
java HelloWorld，输出了硕大的“Hello world!”。:-)
/************************************************************************
转至:http://blog.csdn.net/scruffybear/archive/2007/12/01/1910418.aspx
posted @
2008-06-30 10:00 poower 阅读(622) |
评论 (0) |
编辑 收藏/*sound.h*/
/*http://blog.csdn.net/scs2000/archive/2006/09/14/1221079.aspx*/
#include <stdio.h>
#include <conio.h>
#define NOO 1450
int music1[8][6]={
{262,262,294,262,349},
{330,262,262,294,262},
{392,349,262,262,523},
{440,349,262,262,466},
{466,440,262,392,349}
};
int time1[8][6]={
{100,100,200,200,200},
{200,200,100,100,200},
{200,200,200,200,200},
{200,200,200,200,200},
{100,200,200,200,200}
};
int music2[3][10]={
{330,392,330,294,330,392,330,294,330,330},
{330,392,330,294,262,294,330,392,294,294},
{262,262,220,196,196,220,262,294,332,262}
};
int time2[3][11]={
{200,200,200,100,100,200,100,100,200,200},
{200,200,100,100,200,200,100,100,200,200},
{200,100,100,200,100,100,200,100,100,400}
};
int music3[4][11]={
{441,393,330,393,131,441,393,441,441,1450,1450},
{330,393,441,393,330,262,882,393,330,294,294},
{294,330,393,393,441,330,294,262,262,1450,1450},
{393,330,294,262,882,262,786,786,786,1450,1450}
};
int time3[4][11]={
{200,100,200,200,200,100,100,200,200,0,0},
{200,100,100,200,200,100,100,100,100,200,200},
{200,100,200,100,100,200,200,200,200,0,0},
{200,100,100,100,100,100,200,200,200,0,0}
};
const char * process_file[]={
" ",
"┌───┬┬┐┌┬┐┌┬┐┌┬┐┌┬┐┌┬┐┌┬┐┌┬┬───┐",
"│ ├接┤├口┤├技┤├术┤├课┤├程┤├设┤├计┤ │",
"├───┴┴┘└┴┘└┴┘└┴┘└┴┘└┴┘└┴┘└┴┴───┤",
"│ 《音乐发生器》 │",
"├──────────────────────────────┤",
"│ │",
"├──────────────────────────────┤",
"│ │",
"│ A.播放第一首音乐 │",
"│ B.播放第二首音乐 │",
"│ C.播放第三首音乐 │",
"│ Q.退出该程序 │",
"│ │",
"├──────────────────────────────┤",
"│ 制作：王康 │",
"│ 日期：年月日 │",
"│ │",
"└──────────────────────────────┘"};
const char * end_file[]={
" ",
"┌─────┐ ┌─┐┌─┐ ┌─┐┌─┐ ┌─────┐",
"│★★★★★├☆☆┤个││人├☆☆☆┤简││介├☆☆┤★★★★★│",
"├─────┘ └─┘└─┘☆└─┘└─┘ └─────┤",
"├───────────────☆───────────────┤",
"│姓名：王康 │",
"├───────────────────────────────┤",
"│性别：男 │",
"├───────────────────────────────┤",
"│班级： │",
"├───────────────────────────────┤",
"│电话：--XXXXXXXX │",
"├───────────────────────────────┤",
"│QQ号： │",
"├───────────────────────────────┤",
"│邮箱：wkjs@163.com │",
"├───────────────────────────────┤",
"│ 谢谢您的使用 │",
"└───────────────────────────────┘"};
void light(int a)
{
asm MOV DX,283H
asm MOV AL,80H
asm OUT DX,AL
asm MOV DX,280H
asm MOV AL,0H;
asm OUT DX,AL
switch(a)
{
case 262:
case 131:
asm MOV AL,01H
asm OUT DX,AL
break;
case 294:
asm MOV AL,03H
asm OUT DX,AL
break;
case 330:
asm MOV AL,07H
asm OUT DX,AL
break;
case 350:
asm MOV AL,0FH
asm OUT DX,AL
break;
case 393:
case 786:
asm MOV AL,1FH
asm OUT DX,AL
break;
case 441:
case 882:
asm MOV AL,3FH
asm OUT DX,AL
break;
case 495:
asm MOV AL,7FH
asm OUT DX,AL
break;
};
}
void sound_A(int a,int b)
{
int i=0;
asm MOV DI,a /*选择号计数器，先写低字节，后写高字节，选择工作方式，二进制*/
asm MOV AL,10110110B
asm MOV DX,12H
asm MOV AX,34DEH
asm DIV DI
asm OUT 42H,AL /*先送低字节到号计数器*/
asm MOV AL,AH /*取高字节送AL*/
asm OUT 42H,AL /*后送高字节到号计数器*/
asm IN AL,61H /*读入的PB口原输出值*/
asm MOV AH,AL
asm OR AL,3 /*8255的PB0口PB1口输出有效*/
asm OUT 61H,AL
/*调用灯亮函数*/
light(a);
/*时间延迟*/
for(i=0;i<b;i++)
{
delay(2000);
}
/*关闭扬声器*/
asm MOV AL,AH
asm OUT 61H,AL
}
void sound(char a)
{
int i,j;
if(a=='a')
{
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
sound_A(music1[i][j],time1[i][j]);
}
}
}
else if(a=='b')
{
for(i=0;i<3;i++)
{
for(j=0;j<11;j++)
{
sound_A(music2[i][j],time2[i][j]);
}
}
}
else if(a=='c')
{
for(i=0;i<4;i++)
{
for(j=0;j<11;j++)
{
sound_A(music3[i][j],time3[i][j]);
}
}
}
else
{
printf("\t对不起，没有该音乐！\n");
}
}
void face()
{
int i;
system("cls");
for(i=0;i<19;i++)
{
printf("\t%s\n",process_file[i]);
delay(20000);
}
printf("\t请输入您的指令：");
}
void endface()
{
int i;
system("cls");
for(i=0;i<19;i++)
{
printf("\t%s\n",end_file[i]);
delay(20000);
}
printf("\t");
}
void operate()
{
char a;
face();
while(1)
{
a=getche();
switch(a)
{
case 'a':
case 'A':
sound('a');
printf("\n\t音乐播放结束，谢谢你的收听，点任意键继续！");
getch();
face();
break;
case 'b':
case 'B':
sound('b');
printf("\n\t音乐播放结束，谢谢你的收听，点任意键继续！");
getch();
face();
break;
case 'c':
case 'C':
sound('c');
printf("\n\t音乐播放结束，谢谢你的收听，点任意键继续！");
getch();
face();
break;
case 'q':
case 'Q':
endface();
exit(1);
break;
default:
printf("\t您的输入有误,请核实，谢谢！");
getch();
face();
break;
}
}
}
/*sound.c*/
void main()
{
operate();
}
posted @
2008-06-30 09:58 poower 阅读(664) |
评论 (0) |
编辑 收藏
public class bigadd {
/**
* @param args
*/
//***********************两个相等数相加**********************************88
public static String add(String s){
char c[]=s.toCharArray();
for(int i=0;i<c.length/2;i++){
char t=c[i];
c[i]=c[c.length-1-i];
c[c.length-1-i]=t;
}
int r[]=new int[c.length+1];
int carry=0;
for(int i=0;i<c.length;i++){
int t=Integer.parseInt(c[i]+"")+Integer.parseInt(c[i]+"")+carry;
carry=t/10;
r[i]=t%10;
}
r[c.length]=carry;
String sr;
if(r[c.length]==0)
sr="";
else
sr="1";
for(int j=r.length-2;j>=0;j--){
sr+=r[j];
}
return sr;
}
//*******************************两个不同数相加*****************************************
public static String adddif(String s1,String s2){
char c1[] ;
char c2[] ;
if (s1.length() >= s2.length()) {
c1 = s1.toCharArray();
c2 = s2.toCharArray();
}
else{
c2 = s1.toCharArray();
c1 = s2.toCharArray();
}
for(int i=0;i<c1.length/2;i++){
char t=c1[i];
c1[i]=c1[c1.length-1-i];
c1[c1.length-1-i]=t;
}
for(int i=0;i<c2.length/2;i++){
char t=c2[i];
c2[i]=c2[c2.length-1-i];
c2[c2.length-1-i]=t;
}
int r[]=new int[c1.length+1];
int carry=0;
for(int i=0;i<c2.length;i++){
int t=Integer.parseInt(c1[i]+"")+Integer.parseInt(c2[i]+"")+carry;
carry=t/10;
r[i]=t%10;
}
for(int i=c2.length;i<c1.length;i++){
int t=Integer.parseInt(c1[i]+"")+carry;
carry=t/10;
r[i]=t%10;
}
r[c1.length]=carry;
String sr;
if(r[c1.length]==0)
sr="";
else
sr="1";
for(int j=r.length-2;j>=0;j--){
sr+=r[j];
}
return sr;
}
//*************************求2的N次幂*********************************8
public static String pow(int n){
if(n==0)
return "1";
else if(n==1)
return "2";
else
return add(pow(n-1));
}
public static String sumpow(int p1,int n,int q){
String sum="";
String pre=pow(p1);
for(int i=p1;i<=n;i=i+q){
sum=adddif(sum,pre);
for(int j=1;j<=2;j++)
pre=add(pre);
}
return sum;
}
//************************************相减***********************************
public static String minus(String s1,String s2){
char c1[] ;
char c2[] ;
if (s1.length() >= s2.length()) {
c1 = s1.toCharArray();
c2 = s2.toCharArray();
}
else{
c2 = s1.toCharArray();
c1 = s2.toCharArray();
}
for(int i=0;i<c1.length/2;i++){
char t=c1[i];
c1[i]=c1[c1.length-1-i];
c1[c1.length-1-i]=t;
}
for(int i=0;i<c2.length/2;i++){
char t=c2[i];
c2[i]=c2[c2.length-1-i];
c2[c2.length-1-i]=t;
}
int r[]=new int[c1.length];
int carry=0;
for(int i=0;i<c2.length;i++){
int t=Integer.parseInt(c1[i]+"")-Integer.parseInt(c2[i]+"")-carry;
if(t<0){
r[i]=Integer.parseInt(c1[i]+"")-Integer.parseInt(c2[i]+"")+10-carry;
carry=1;
}
else{
r[i]=t;
carry=0;
}
}
for(int i=c2.length;i<c1.length;i++){
int t=Integer.parseInt(c1[i]+"")-carry;
if(t<0){
carry=1;
r[i]=9;
}
else{
r[i]=t;
carry=0;
}
}
String str;
if(r[c1.length-1]==0){
str="";
}
else{
str=""+r[c1.length-1];
}
for(int j=r.length-2;j>=0;j--){
str+=r[j];
}
return str;
}
//**********************************减1****************************************
public static String minus1(String s){
char c[]=s.toCharArray();
int i;
for(i=0;i<c.length/2;i++){
char t=c[i];
c[i]=c[c.length-1-i];
c[c.length-1-i]=t;
}
int t=0;
for(i=0;i<c.length;i++){
t=Integer.parseInt(c[i]+"");
if(t>0){
t=t-1;
break;
}
}
c[i]=(t+"").charAt(0);
System.out.println(t+" "+i);
String str;
if(c[c.length-1]=='0')
str="";
else
str=c[c.length-1]+"";
for(int j=c.length-2;j>=i;j--)
str=str+c[j];
for(int j=i-1;j>=0;j--)
str+=9;
return str;
}
//*************************************加1************************************
public static String add1(String s){
char c[]=s.toCharArray();
int i;
for(i=0;i<c.length/2;i++){
char t=c[i];
c[i]=c[c.length-1-i];
c[c.length-1-i]=t;
}
int t=0;
for(i=0;i<c.length;i++){
t=Integer.parseInt(c[i]+"");
if(t<9){
t=t+1;
break;
}
}
String str;
if(i==c.length)
str="1";
else{
c[i]=(t+"").charAt(0);
str="";
}
for(int j=c.length-1;j>=i;j--)
str=str+c[j];
for(int j=i-1;j>=0;j--)
str+=0;
return str;
}
public static void main(String[] args) {
// TODO 自动生成方法存根
//System.out.println(pow(1000));
//System.out.println(pow(999));
//System.out.println(adddif(pow(999),pow(999)));
//System.out.println(adddif("19","999"));
System.out.println(sumpow((4-3),(1000-3),2));
//System.out.println(minus(pow(1000),pow(999)));
//System.out.println(add1(pow(1000)));
}
}
posted @
2008-06-13 13:36 poower 阅读(433) |
评论 (0) |
编辑 收藏
中学就学过排列,组合 ,比如 C5,2 = 10; C6,2 = 15
如果用算法实现的话,难道也要先做一连串的乘法,然后再相除吗? 比如: C5,2 = (5*4*3*2)/(3*2)
如果数很大的话,又是乘又做除的,多牛的计算机才能搞定呢?
先看看简单的:
2个数选2个,共有1种方法
3个数选2个,共有3种方法
4个数选2个,共有6种方法
n个数选2个,共有多少种方法?
F(n,2) = F(n-1,2) + F(n-1,1) //这样写看的更清楚些.
那么N个数选M出来,有多少种选择呢?
F(N,M) = F(N-1,M) + F(N-1,M-1)
到此处,DP的递归解空间已经出来了.
F(N,M) = 1 M=0 or N=0 or N=M
F(N,M) = N M=1
F(N,M) = F(N-1,M) + F(N-1,M-1) M!=N 当然N>M
剩下的工作就是程序实现了.但是还有个小问题,就是在DP迭代的过程中是否需要记忆.在这个算法当然需要记忆.
实现的过程中,可以做些小优化,比如N=5 M=3 可以求C5,2的组合数就是要少递归几次.
#include "stdafx.h"
#include <iostream>
using namespace std;
__int64 Aug[200][200] = {0};
__int64 getComposite(int m,int n)
{
__int64 preResult0;
__int64 preResult1;
if (m==0 || n== 0 || m== 1 || m == n)
return 1;
if (Aug[m][n] != 0)
return Aug[m][n];
else
{
preResult0 = getComposite(m-1,n);
Aug[m-1][n] = preResult0;
preResult1 = getComposite(m-1,n-1);
Aug[m-1][n-1] = preResult1;
}
return preResult0 + preResult1;
}
int main()
{
int count;
int m,n;
int m0,n0;
cin >> n >> m;
m0 = m >= n ? m : n;
n0 = m >= n ? n : m;
n0 = m0 - n0 >= n0 ? n0 : m0-n0;
cout << getComposite(m0,n0) << endl;
return 0;
}
//*********************************************************************************
注:其实我没看明白......
posted @
2008-06-11 00:58 poower 阅读(832) |
评论 (0) |
编辑 收藏