高中学业水平考试成绩s是什么意思_百度知道
高中学业水平考试成绩s是什么意思
我有更好的答案
Satisfied. 满意的意思。不好不坏。
其他类似问题
为您推荐：
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁感觉自己的作文水平不高,老师在平时的作文中也并未给予我太高成绩,但我语文考试作文分数却不低这是什么原因?
考场作文和平日里改分的作文是有所区别的.考场作文的改分是很快浏览的,到高考的时候都是十几秒一篇,这是一点都没有夸张的.所以老师在改分时会对这些作文给高分：①字写得好的,第一印象好,容易打高,我想你的字迹一定达到了清秀及以上.②脉络清晰,循环点题.这是考场作文中很重要的一点,我猜想你在这里肯定做的比较到位.③文笔优美.在初中作文改分中,一些名句的引用,然后用一些辞藻的堆砌作开头结尾等等,阅卷老师往往给高分.④小标题式,整体文章以并列的结构写,层次分明.有题记、后记等,容易打高分.而平时作文,老师可能会倾向于看你的思想、主旨.我想也许你在立意中有待提高,现在是初中,还可以抽出时间来增加阅读量,增加自己的涵养,作文思想自然而然就上去了,腹有诗书气自华,对之后的人生也有所裨益.你能把考场作文写得很好,这已经是很多同学拼命想要做到却做不到的了.现在年纪还小,相信你能在写作一途上有所造诣.
老师也说过我的作文立意不足，自己的思想还不够，细节描写不够细致，我比较擅长用侧面描写，请问怎么样弥补这些缺陷？
我觉得增加阅读量是最好的方法，如果急于求成一些，那就建议你去看一些作文选，尤其是近年的高考作文选。高考作文选无论在立意，形式，还是内容上，都还是比较适合你平时的作文的。如果可以的话，可以养成摘抄的习惯，分门别类地整理好，写作前可以看看这些句子，看看同类作文，在初始阶段，可以借鉴别人的立意；久而久之，你自己的思想自然也有了，看到文题就可以找到一些别人看不到的，深刻的角度。细节描写我认为你也可以从高考作文中寻找，模仿。当然，如果你有足够的时间，去看一些名家的散文等等，会更有一些潜移默化的帮助。
为您推荐：
其他类似问题
扫描下载二维码深圳高中水平测试查询说没有你的成绩资料是什么意思_百度知道
深圳高中水平测试查询说没有你的成绩资料是什么意思
　　不用急。　　成绩学校总会发下来的。　　牛掰的画直接找校长。​　　问一下年级辅导员啊，老师啊　　要不去官网上看下，　　可以去官网看一下要不
来自团队：
其他类似问题
为您推荐：
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁招人的时候看中的又不是他那几块ACM的奖牌，把一个奖牌放进山一样多的patent cube里面不会增添任何光彩。最重要的是他通过了搞acm，增强了自信心，然后弃暗投明，最后学会了正确的写代码技巧。这几个阶段缺一不可。有很多人只是停留在了搞acm，哪怕学会了很多算法，但是却不能跟别人一起写同事都能看得懂又厉害的程序，自然是要被历史的车轮碾压抛弃的。有很多人acm搞了一半，没有搞下去，但是通过自己的聪明才智最终学会了正确的写代码的技巧，这种人显然比光搞acm 要强多了。acm这种东西，拿不到赛区金牌进final可以唬一唬别人的话，你学到的编程技巧多半对以后的职业生涯也没什么用。当然我并没有说算法学了没用，但是如果目标是学那几个破算法的话，根本不需要花费那么大的精力去刷题，性价比太低了，而且还很容易误入歧途。以前还有很多人跟我说，搞了acm虽然什么都没得到但是最后收获了快乐什么的，我觉得这纯属玩物丧志。玩物丧志在你还在玩的时候也是很开心的，就像那些玩了几年wow结果找不到工作的人一样。======================================你们这些大学生啊，不要妄图把衡量编程技巧这么复杂的问题退化为几个指标，以为这样就可以让自己学习的轻松一点，道路正确一点，迷茫少一点，负罪感少一点。这么做最终都是要失败的。
&b&能仅通过 acm成绩和算法水平衡量一个人编程水平吗？&/b&&br&&br&&br&不能，但很值得参考。&br&&br&ACM竞赛题与实际工程问题差距非常大，代码要求也十分不同。例如：&br&&ul&&li&竞赛中的问题定义清晰明确；而实际工程中绝大部分问题都是模糊的，需要大量的探索和试错。&/li&&li&竞赛中用到的算法总体来讲并不复杂，套路明显；实际问题所用到的算法常常与特定领域或者场景相关，有各种例外和优化。&/li&&li&竞赛所要求的知识和能力其实只是CS非常小的一部分，即便是算法领域，深度也非常不够；实际问题要求更广的知识面和对某些领域更深的了解，也要求快速学习的能力。&/li&&li&竞赛中的团队协作比较简单（三个人，几个小时）；实际工程对团队协作的要求更高。&/li&&li&竞赛对代码风格的要求非常低，容易导致不良习惯；实际项目对代码的可读性要求更高。&/li&&/ul&但是，和高考以及所有竞赛一样，ACM对智力和毅力的要求很高，优秀ACM选手的平均能力是高出普通在校生的。再加上国内本科学生的工作机会（论文、实习、开源、创业等）不多，ACM成绩是一个有效的甄别手段。&br&&br&我面试过和一同工作过的ACMer里有些非常优秀，也有不少难堪重用。以下凭印象列举几个例子。&br&&ol&&li&代码风格。其实绝大多数学生（包括我自己）的代码风格都非常不好。问题在于，一小部分ACMer不但不重视改正，还引以为豪，在面试中完全不注意可读性，被指出后也不做修正。&/li&&li&思维定势。一些ACMer习惯于算法套路，并没有把基础算法彻底吃透。我曾经用过一道面试题，一些ACMer看一眼就往DP凑，而其实稍稍考虑一下就能发现是一个分治问题。优秀的ACMer当然没有这个问题，但半桶子水的人并不少。&/li&&li&基础知识。有一些同学花了太多时间练习竞赛，甚至荒废了其他一些基础课，其实得不偿失。比较极端的例子：ACM成绩很不错，面试中的算法题得分很高，但对操作系统和计算机底层几乎没有了解。这样的同学，在实际工程团队里很难发挥太大的价值。&/li&&li&工作态度。有极少数的同学，竞赛非常优秀，但工作中态度消极，醉心于解决所谓的算法难题，把脏活累活撂到一边；更极端的，白天上班睡觉，晚上熬夜刷题。这样的人虽然极少，却是每个工程团队的大敌。托媒体之福，很多人幼稚的把“恃才傲物”当作褒义。就我所见，优秀的程序员虽然多少有些ego，但都谦虚和勤奋的可怕。&/li&&/ol&&b&编程高手是怎么定义的？&/b&&br&&br&没有定义。见过和合作过的越多，定义就越清晰。&br&&br&&b&各大公司招聘 acm选手是明智的吗？&/b&&br&&br&如前述，在缺少科研、实习、创业或开源经历而GPA无法跨校比较的情况下，ACM成绩几乎是最快捷有效的指标。更何况互联网公司的面试题与竞赛题非常接近，对ACMer有利。但是好的公司不会把ACM成绩作为唯一指标。另一方面，ACM成绩不是特别突出而又没有其他亮点的同学反而不容易引起注意；好的科研项目、实习经历或者开源作品却常常能从一堆ACM的简历中脱颖而出。
能仅通过 acm成绩和算法水平衡量一个人编程水平吗？不能，但很值得参考。ACM竞赛题与实际工程问题差距非常大，代码要求也十分不同。例如：竞赛中的问题定义清晰明确；而实际工程中绝大部分问题都是模糊的，需要大量的探索和试错。竞赛中用到的算法总体来讲…
题主的问题有三句。第一个问句留给别人去吵，第二个问句我答不上来，只评论一下第三句：“公司招聘ICPC选手是明智的吗？”&br&&br&1. 基本没有哪个公司在招聘时是只看着ICPC选手招的（不排除有些只有几个人的初创公司因为团队成员的个人偏好而这么干，这种情况暂不考虑），ICPC比赛的获奖经历，只是让这份简历能通过初筛拿到个笔试面试机会而已，NB项目经历或是NB学校或是高GPA同样可以达到这个效果。到底能不能拿offer，最终要看面试表现。我认识很多成绩很不错的ACMer却没拿到好offer，也认识从来没参加过ICPC的同学轻松通过google面试。&br&&br&2. 很多人觉得现在面试里的“算法题”太多，所以ICPC选手占了大便宜。实际上，大家所谓的面试中的“算法题”，不过是教科书上的基本知识。不论是国内的BAT还是国外的FLAG，他们的面试“算法题”和ICPC里的算法题完全就是两个概念好么。如果真的拿和ICPC比赛里类似的题来面试，非ACMer就真的别想答上来了你信不信？另一方面，面试时如果问同样基本难度的OS问题、数据库问题、网络问题，ICPC选手就一定答得比别人差？&br&&br&3. 可能到了最后，通过面试的人里确实有很大部分是有过ACM经历的，所以这说明什么呢？说明“ACM获奖”和“技能点与潜力值达到公司要求”这两者有一定的相关性，这可能是因为他们真有直接的因果关系——ACM比赛恰好训练出了公司需要的技能，也可能是因为其他的关联方式——比如满足公司要求的人里面总有一大部分在上学时精力过剩无处发泄只好去搞ACM。总之，我的观点是公司招聘ICPC选手是果而不是因。
题主的问题有三句。第一个问句留给别人去吵，第二个问句我答不上来，只评论一下第三句：“公司招聘ICPC选手是明智的吗？”1. 基本没有哪个公司在招聘时是只看着ICPC选手招的（不排除有些只有几个人的初创公司因为团队成员的个人偏好而这么干，这种情况暂不…
已有帐号？
无法登录？
社交帐号登录
专业造轮子，前排已拉黑。gaclib.net能仅通过ACM/ICPC成绩和算法水平衡量一个人编程水平吗？编程高手是怎么定义的？公司招聘ICPC选手是明智的吗？
按投票排序
能仅通过 acm成绩和算法水平衡量一个人编程水平吗？不能，但很值得参考。ACM竞赛题与实际工程问题差距非常大，代码要求也十分不同。例如：竞赛中的问题定义清晰明确；而实际工程中绝大部分问题都是模糊的，需要大量的探索和试错。竞赛中用到的算法总体来讲并不复杂，套路明显；实际问题所用到的算法常常与特定领域或者场景相关，有各种例外和优化。竞赛所要求的知识和能力其实只是CS非常小的一部分，即便是算法领域，深度也非常不够；实际问题要求更广的知识面和对某些领域更深的了解，也要求快速学习的能力。竞赛中的团队协作比较简单（三个人，几个小时）；实际工程对团队协作的要求更高。竞赛对代码风格的要求非常低，容易导致不良习惯；实际项目对代码的可读性要求更高。但是，和高考以及所有竞赛一样，ACM对智力和毅力的要求很高，优秀ACM选手的平均能力是高出普通在校生的。再加上国内本科学生的工作机会（论文、实习、开源、创业等）不多，ACM成绩是一个有效的甄别手段。我面试过和一同工作过的ACMer里有些非常优秀，也有不少难堪重用。以下凭印象列举几个例子。代码风格。其实绝大多数学生（包括我自己）的代码风格都非常不好。问题在于，一小部分ACMer不但不重视改正，还引以为豪，在面试中完全不注意可读性，被指出后也不做修正。思维定势。一些ACMer习惯于算法套路，并没有把基础算法彻底吃透。我曾经用过一道面试题，一些ACMer看一眼就往DP凑，而其实稍稍考虑一下就能发现是一个分治问题。优秀的ACMer当然没有这个问题，但半桶子水的人并不少。基础知识。有一些同学花了太多时间练习竞赛，甚至荒废了其他一些基础课，其实得不偿失。比较极端的例子：ACM成绩很不错，面试中的算法题得分很高，但对操作系统和计算机底层几乎没有了解。这样的同学，在实际工程团队里很难发挥太大的价值。工作态度。有极少数的同学，竞赛非常优秀，但工作中态度消极，醉心于解决所谓的算法难题，把脏活累活撂到一边；更极端的，白天上班睡觉，晚上熬夜刷题。这样的人虽然极少，却是每个工程团队的大敌。托媒体之福，很多人幼稚的把“恃才傲物”当作褒义。就我所见，优秀的程序员虽然多少有些ego，但都谦虚和勤奋的可怕。编程高手是怎么定义的？没有定义。见过和合作过的越多，定义就越清晰。各大公司招聘 acm选手是明智的吗？如前述，在缺少科研、实习、创业或开源经历而GPA无法跨校比较的情况下，ACM成绩几乎是最快捷有效的指标。更何况互联网公司的面试题与竞赛题非常接近，对ACMer有利。但是好的公司不会把ACM成绩作为唯一指标。另一方面，ACM成绩不是特别突出而又没有其他亮点的同学反而不容易引起注意；好的科研项目、实习经历或者开源作品却常常能从一堆ACM的简历中脱颖而出。
题主的问题有三句。第一个问句留给别人去吵，第二个问句我答不上来，只评论一下第三句：“公司招聘ICPC选手是明智的吗？”1. 基本没有哪个公司在招聘时是只看着ICPC选手招的（不排除有些只有几个人的初创公司因为团队成员的个人偏好而这么干，这种情况暂不考虑），ICPC比赛的获奖经历，只是让这份简历能通过初筛拿到个笔试面试机会而已，NB项目经历或是NB学校或是高GPA同样可以达到这个效果。到底能不能拿offer，最终要看面试表现。我认识很多成绩很不错的ACMer却没拿到好offer，也认识从来没参加过ICPC的同学轻松通过google面试。2. 很多人觉得现在面试里的“算法题”太多，所以ICPC选手占了大便宜。实际上，大家所谓的面试中的“算法题”，不过是教科书上的基本知识。不论是国内的BAT还是国外的FLAG，他们的面试“算法题”和ICPC里的算法题完全就是两个概念好么。如果真的拿和ICPC比赛里类似的题来面试，非ACMer就真的别想答上来了你信不信？另一方面，面试时如果问同样基本难度的OS问题、数据库问题、网络问题，ICPC选手就一定答得比别人差？3. 可能到了最后，通过面试的人里确实有很大部分是有过ACM经历的，所以这说明什么呢？说明“ACM获奖”和“技能点与潜力值达到公司要求”这两者有一定的相关性，这可能是因为他们真有直接的因果关系——ACM比赛恰好训练出了公司需要的技能，也可能是因为其他的关联方式——比如满足公司要求的人里面总有一大部分在上学时精力过剩无处发泄只好去搞ACM。总之，我的观点是公司招聘ICPC选手是果而不是因。
ACM/ICPC成绩跟「不会编程 -& 基本能码code」这个进阶过程中的编程水平还是正相关的。在我看来，ACM/ICPC竞赛练习是一个相对可靠易行的基础编程训练方法：门槛低，不用找人带，不用面试去实习，有台能上网的电脑会写 A+B Problem 就可以开始了。有题库，持续提供有挑战性的问题。有标准化水平判定方法：我觉得这对信息闭塞的中国大学生尤其重要，看看你自己刷过了多少题，就很清楚自己水平去到哪里了。在 OJ 刷题，自己老实点别刷水题和重复题，我算平均 50 行不重复的 C++ 代码解决一个问题吧，刷个 1000 题，你就写了 5 万行代码了。学编程，除非你天赋异禀不然基本就是靠练，5 万行的练习其实已经相当不错了。这种练习方法肯定不是最有效的，还有知识面太窄，跟实际工程脱节等等问题。但比起普通中国大学生能接触到的门槛同样低的其他机会，它还是可靠多了。—— 这其他机会，包括学习 Web 实用开发技术，学习新语言，学习 Linux, 学习 Hadoop...... 首先这些学习方式没有标准化的水平判定方法，难以确定目标和衡量自己的水平，更糟糕的是，因为无标准，在信息闭塞的条件下，学生很容易被无良书籍和一些所谓「大牛」忽悠走。其次，学习这些让人眼花缭乱的技术的时候，你自己写的，不重复的，有挑战性的代码，到底有多少？不管学什么，写够 5 万行代码再说。那么公司招聘 ICPC 选手明智吗？我大学毕业工作以来每年都参加校园招聘，我所经历的公司都是非常工程化的互联网大公司（百度、腾讯、Google），我觉得这些公司对大学毕业生（尤其是本科）的要求都是非常基本的，简单点说就是能码code, 给个问题能逻辑清晰地给出解决思路然后能写成代码，就行了，至于对学生的算法水平要求，绝对不会超过本科数据结构和算法课程的范畴。但仅是这个要求招人就很难。ACM/ICPC 成绩没有加分作用，但面试到最后，剩下的学生确实很大一部分都有 ACM/ICPC 训练经历（仅是训练，不是拿奖，这些学生的占比通常不过半吧，但其他candidate的经历就五花八门没啥共通性了），而许多简历上有各种牛逼闪闪的项目经历的学生，往往一个稍微复杂一点的程序都写不下来。我们不是要招 ICPC 选手，只是他们经历的编程训练相对靠谱，更有机会能满足这些公司的最低要求而已。写到这里我必须抱怨，中国大学计算机系太容易毕业了！教学计划看起来像模像样国际接轨，还有直接使用英文教材的，专业课编程大作业看来也都挺有挑战性，但执行下来真不是那回事。我是985院校本科毕业，大作业要求数据结构写个文本编辑器，数据库写个简单查询引擎，编译原理是递归下降分析器，人工智能 ID3 和神经网络任选，这些作业如果学生能从头独立完成，代码量和知识面覆盖其实也相当可观。但真正执行时，文本编辑器拉个控件做个炫点的 UI，过关；数据库做个 SQL Server 的前端 GUI，过关；「借」同学代码然后改个 UI，当然过关。我的很多同学到毕业时都没法自己写一个能实用的软件，就我了解国内除了 Top 2 其他院校状况也相去不远。编程真的只能靠练的，平日课业没有接受足够的编程训练，就只好轮到 ACM/ICPC 等等或低效率或不可靠的训练方法。另外也可以解释一下为什么在国外大公司不会这么集中的招来一大批 ACM/ICPC 选手。原因是他们能接触更可靠、质量更高、知识覆盖面更广的编程训练方法。比如好好写完课程作业，比如给开源软件做点真正的贡献，比如刷硅谷公司实习。他们也能更快更准确地接触来自工业界的信息，知道自己真正应该学什么做什么 —— 中国学生至少还得先学英语和翻墙。我经常引用 Joel Spolsky 的一篇文章 ，里面就说到大学计算机课程难度越来越低的问题；而他的
也强调了编程训练的重要性，对这两篇文章我举双手双脚赞同。前不久我的母校出了个小新闻，软件学院在编程课期中考把全班学生都挂掉了，我真是无比欣慰。不过后来他们搞了换算标准分平息众怒，让我小失望一把。
你们来感受下 ACM 职业选手，东北第一单刷王
写的 C++……反正我没他人肉讲解那堆该死的宏我看不懂这东西。/** Micro Mezz Macro Flation -- Overheated Economy ., Last Update: Sep. 17th 2014 **/ //{
/** Header .. **/ //{
#pragma comment(linker, "/STACK:")
//#pragma GCC optimize ("O2")
#define LOCAL
//#include "testlib.h"
#include &functional&
#include &algorithm&
#include &iostream&
#include &fstream&
#include &sstream&
#include &iomanip&
#include &numeric&
#include &cstring&
#include &climits&
#include &cassert&
#include &complex&
#include &cstdio&
#include &string&
#include &vector&
#include &bitset&
#include &queue&
#include &stack&
#include &cmath&
#include &ctime&
#include &list&
#include &set&
#include &map&
//#include &tr1/unordered_set&
//#include &tr1/unordered_map&
//#include &array&
using namespace std;
#define REP(i, n) for (int i=0;i&n;++i)
#define FOR(i, a, b) for (int i=a;i&b;++i)
#define DWN(i, b, a) for (int i=b-1;i&=a;--i)
#define REP_1(i, n) for (int i=1;i&=n;++i)
#define FOR_1(i, a, b) for (int i=a;i&=b;++i)
#define DWN_1(i, b, a) for (int i=b;i&=a;--i)
#define REP_C(i, n) for (int n____=n,i=0;i&n____;++i)
#define FOR_C(i, a, b) for (int b____=b,i=a;i&b____;++i)
#define DWN_C(i, b, a) for (int a____=a,i=b-1;i&=a____;--i)
#define REP_N(i, n) for (i=0;i&n;++i)
#define FOR_N(i, a, b) for (i=a;i&b;++i)
#define DWN_N(i, b, a) for (i=b-1;i&=a;--i)
#define REP_1_C(i, n) for (int n____=n,i=1;i&=n____;++i)
#define FOR_1_C(i, a, b) for (int b____=b,i=a;i&=b____;++i)
#define DWN_1_C(i, b, a) for (int a____=a,i=b;i&=a____;--i)
#define REP_1_N(i, n) for (i=1;i&=n;++i)
#define FOR_1_N(i, a, b) for (i=a;i&=b;++i)
#define DWN_1_N(i, b, a) for (i=b;i&=a;--i)
#define REP_C_N(i, n) for (int n____=(i=0,n);i&n____;++i)
#define FOR_C_N(i, a, b) for (int b____=(i=0,b);i&b____;++i)
#define DWN_C_N(i, b, a) for (int a____=(i=b-1,a);i&=a____;--i)
#define REP_1_C_N(i, n) for (int n____=(i=1,n);i&=n____;++i)
#define FOR_1_C_N(i, a, b) for (int b____=(i=a,b);i&=b____;++i)
#define DWN_1_C_N(i, b, a) for (int a____=(i=b,a);i&=a____;--i)
#define ECH(it, A) for (__typeof(A.begin()) it=A.begin(); it != A.end(); ++it)
#define REP_S(i, str) for (char*i=*i;++i)
#define REP_L(i, hd, suc) for (int i=i;i=suc[i])
#define REP_G(i, u) REP_L(i,hd[u],suc)
#define REP_SS(x, s) for (int x=s;x;x=(x-1)&s)
#define DO(n) for ( int ____n = ____n--&0; )
#define REP_2(i, j, n, m) REP(i, n) REP(j, m)
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m)
#define REP_3(i, j, k, n, m, l) REP(i, n) REP(j, m) REP(k, l)
#define REP_3_1(i, j, k, n, m, l) REP_1(i, n) REP_1(j, m) REP_1(k, l)
#define REP_4(i, j, k, ii, n, m, l, nn) REP(i, n) REP(j, m) REP(k, l) REP(ii, nn)
#define REP_4_1(i, j, k, ii, n, m, l, nn) REP_1(i, n) REP_1(j, m) REP_1(k, l) REP_1(ii, nn)
#define ALL(A) A.begin(), A.end()
#define LLA(A) A.rbegin(), A.rend()
#define CPY(A, B) memcpy(A, B, sizeof(A))
#define INS(A, P, B) A.insert(A.begin() + P, B)
#define ERS(A, P) A.erase(A.begin() + P)
#define LBD(A, x) (lower_bound(ALL(A), x) - A.begin())
#define UBD(A, x) (upper_bound(ALL(A), x) - A.begin())
#define CTN(T, x) (T.find(x) != T.end())
#define SZ(A) int((A).size())
#define PB push_back
#define MP(A, B) make_pair(A, B)
#define PTT pair&T, T&
#define Ts *this
#define rTs return Ts
#define fi first
#define se second
#define re real()
#define im imag()
#define Rush for(int ____T=RD(); ____T--;)
#define Display(A, n, m) {
REP(i, n){
REP(j, m-1) cout && A[i][j] && " ";
cout && A[i][m-1] &&
#define Display_1(A, n, m) {
REP_1(i, n){
REP_1(j, m-1) cout && A[i][j] && " ";
cout && A[i][m] &&
typedef long long LL;
//typedef long double DB;
typedef double DB;
typedef unsigned uint;
typedef unsigned long long uLL;
typedef vector&int& VI;
typedef vector&char& VC;
typedef vector&string& VS;
typedef vector&LL& VL;
typedef vector&DB& VF;
typedef set&int& SI;
typedef set&string& SS;
typedef map&int, int& MII;
typedef map&string, int& MSI;
typedef pair&int, int& PII;
typedef pair&LL, LL& PLL;
typedef vector&PII& VII;
typedef vector&VI& VVI;
typedef vector&VII& VVII;
template&class T& inline T& RD(T &);
template&class T& inline void OT(const T &);
//inline int RD(){ return RD(x);}
inline LL RD(){LL x; return RD(x);}
inline DB& RF(DB &);
inline DB RF(){DB x; return RF(x);}
inline char* RS(char *s);
inline char& RC(char &c);
inline char RC();
inline char& RC(char &c){scanf(" %c", &c); return c;}
inline char RC(){char c; return RC(c);}
//inline char& RC(char &c){c = getchar();}
//inline char RC(){return getchar();}
template&class T& inline T& RDD(T &);
inline LL RDD(){LL x; return RDD(x);}
template&class T0, class T1& inline T0& RD(T0 &x0, T1 &x1){RD(x0), RD(x1); return x0;}
template&class T0, class T1, class T2& inline T0& RD(T0 &x0, T1 &x1, T2 &x2){RD(x0), RD(x1), RD(x2); return x0;}
template&class T0, class T1, class T2, class T3& inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3){RD(x0), RD(x1), RD(x2), RD(x3); return x0;}
template&class T0, class T1, class T2, class T3, class T4& inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); return x0;}
template&class T0, class T1, class T2, class T3, class T4, class T5& inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); return x0;}
template&class T0, class T1, class T2, class T3, class T4, class T5, class T6& inline T0& RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); return x0;}
template&class T0, class T1& inline void OT(const T0 &x0, const T1 &x1){OT(x0), OT(x1);}
template&class T0, class T1, class T2& inline void OT(const T0 &x0, const T1 &x1, const T2 &x2){OT(x0), OT(x1), OT(x2);}
template&class T0, class T1, class T2, class T3& inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3){OT(x0), OT(x1), OT(x2), OT(x3);}
template&class T0, class T1, class T2, class T3, class T4& inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);}
template&class T0, class T1, class T2, class T3, class T4, class T5& inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);}
template&class T0, class T1, class T2, class T3, class T4, class T5, class T6& inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3, const T4 &x4, const T5 &x5, const T6 &x6){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);}
inline char& RC(char &a, char &b){RC(a), RC(b); return a;}
inline char& RC(char &a, char &b, char &c){RC(a), RC(b), RC(c); return a;}
inline char& RC(char &a, char &b, char &c, char &d){RC(a), RC(b), RC(c), RC(d); return a;}
inline char& RC(char &a, char &b, char &c, char &d, char &e){RC(a), RC(b), RC(c), RC(d), RC(e); return a;}
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f); return a;}
inline char& RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g); return a;}
inline DB& RF(DB &a, DB &b){RF(a), RF(b); return a;}
inline DB& RF(DB &a, DB &b, DB &c){RF(a), RF(b), RF(c); return a;}
inline DB& RF(DB &a, DB &b, DB &c, DB &d){RF(a), RF(b), RF(c), RF(d); return a;}
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e){RF(a), RF(b), RF(c), RF(d), RF(e); return a;}
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f); return a;}
inline DB& RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f, DB &g){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g); return a;}
inline void RS(char *s1, char *s2){RS(s1), RS(s2);}
inline void RS(char *s1, char *s2, char *s3){RS(s1), RS(s2), RS(s3);}
template&class T0,class T1&inline T0& RDD(T0&a, T1&b){RDD(a),RDD(b); return a;}
template&class T0,class T1,class T2&inline T1& RDD(T0&a, T1&b, T2&c){RDD(a),RDD(b),RDD(c); return a;}
template&class T& inline void RST(T &A){memset(A, 0, sizeof(A));}
template&class T& inline void FLC(T &A, int x){memset(A, x, sizeof(A));}
template&class T& inline void CLR(T &A){A.clear();}
template&class T0, class T1& inline void RST(T0 &A0, T1 &A1){RST(A0), RST(A1);}
template&class T0, class T1, class T2& inline void RST(T0 &A0, T1 &A1, T2 &A2){RST(A0), RST(A1), RST(A2);}
template&class T0, class T1, class T2, class T3& inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3){RST(A0), RST(A1), RST(A2), RST(A3);}
template&class T0, class T1, class T2, class T3, class T4& inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);}
template&class T0, class T1, class T2, class T3, class T4, class T5& inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);}
template&class T0, class T1, class T2, class T3, class T4, class T5, class T6& inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);}
template&class T0, class T1& inline void FLC(T0 &A0, T1 &A1, int x){FLC(A0, x), FLC(A1, x);}
template&class T0, class T1, class T2& inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x);}
template&class T0, class T1, class T2, class T3& inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);}
template&class T0, class T1, class T2, class T3, class T4& inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);}
template&class T0, class T1, class T2, class T3, class T4, class T5& inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);}
template&class T0, class T1, class T2, class T3, class T4, class T5, class T6& inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x), FLC(A6, x);}
template&class T& inline void CLR(priority_queue&T, vector&T&, less&T& & &Q){while (!Q.empty()) Q.pop();}
template&class T& inline void CLR(priority_queue&T, vector&T&, greater&T& & &Q){while (!Q.empty()) Q.pop();}
template&class T& inline void CLR(stack&T& &S){while (!S.empty()) S.pop();}
template&class T& inline void CLR(queue&T& &Q){while (!Q.empty()) Q.pop();}
template&class T0, class T1& inline void CLR(T0 &A0, T1 &A1){CLR(A0), CLR(A1);}
template&class T0, class T1, class T2& inline void CLR(T0 &A0, T1 &A1, T2 &A2){CLR(A0), CLR(A1), CLR(A2);}
template&class T0, class T1, class T2, class T3& inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3){CLR(A0), CLR(A1), CLR(A2), CLR(A3);}
template&class T0, class T1, class T2, class T3, class T4& inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);}
template&class T0, class T1, class T2, class T3, class T4, class T5& inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);}
template&class T0, class T1, class T2, class T3, class T4, class T5, class T6& inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);}
template&class T& inline void CLR(T &A, int n){REP(i, n) CLR(A[i]);}
template&class T& inline bool EPT(T &a){return a.empty();}
template&class T& inline T& SRT(T &A){sort(ALL(A)); return A;}
template&class T, class C& inline T& SRT(T &A, C B){sort(ALL(A), B); return A;}
template&class T& inline T& RVS(T &A){reverse(ALL(A)); return A;}
template&class T& inline T& UNQQ(T &A){A.resize(unique(ALL(A))-A.begin());return A;}
template&class T& inline T& UNQ(T &A){SRT(A);return UNQQ(A);}
/** Constant List .. **/ //{
const int MOD = int(1e9) + 7;
const int INF = 0x3f3f3f3f;
const LL INFF = 0x3f3f3f3f3f3f3f3fLL;
const DB EPS = 1e-9;
const DB OO = 1e20;
const DB PI = acos(-1.0); //M_PI;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
/** Add On .. **/ //{
// &&= '0. Nichi Joo ., //{
template&class T& inline T& checkMin(T &a,const T b){if (b&a) a=b;return a;}
template&class T& inline T& checkMax(T &a,const T b){if (a&b) a=b;return a;}
template&class T& inline T& checkMin(T &a, T &b, const T x){checkMin(a, x), checkMin(b, x);return a;}
template&class T& inline T& checkMax(T &a, T &b, const T x){checkMax(a, x), checkMax(b, x);return a;}
template &class T, class C& inline T& checkMin(T& a, const T b, C c){if (c(b,a)) a = b;return a;}
template &class T, class C& inline T& checkMax(T& a, const T b, C c){if (c(a,b)) a = b;return a;}
template&class T& inline T min(T a, T b, T c){return min(min(a, b), c);}
template&class T& inline T max(T a, T b, T c){return max(max(a, b), c);}
template&class T& inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));}
template&class T& inline T max(T a, T b, T c, T d){return max(max(a, b), max(c, d));}
template&class T& inline T min(T a, T b, T c, T d, T e){return min(min(min(a,b),min(c,d)),e);}
template&class T& inline T max(T a, T b, T c, T d, T e){return max(max(max(a,b),max(c,d)),e);}
template&class T& inline T sqr(T a){return a*a;}
template&class T& inline T cub(T a){return a*a*a;}
template&class T& inline T ceil(T x, T y){return (x - 1) / y + 1;}
template&class T& T abs(T x){return x&0?x:-x;}
inline int sgn(DB x){return x & -EPS ? -1 : x & EPS;}
inline int sgn(DB x, DB y){return sgn(x - y);}
inline DB cos(DB a, DB b, DB c){return (sqr(a)+sqr(b)-sqr(c))/(2*a*b);}
inline DB cot(DB x){return 1./tan(x);};
inline DB sec(DB x){return 1./cos(x);};
inline DB csc(DB x){return 1./sin(x);};
// &&= '1. Bitwise Operation ., //{
namespace BO{
inline bool _1(int x, int i){return bool(x&1&&i);}
inline bool _1(LL x, int i){return bool(x&1LL&&i);}
inline LL _1(int i){return 1LL&&i;}
inline LL _U(int i){return _1(i) - 1;};
inline int reverse_bits(int x){
x = ((x && 1) & 0x) | ((x && 1) & 0xaaaaaaaa);
x = ((x && 2) & 0x) | ((x && 2) & 0xcccccccc);
x = ((x && 4) & 0x0f0f0f0f) | ((x && 4) & 0xf0f0f0f0);
x = ((x && 8) & 0x00ff00ff) | ((x && 8) & 0xff00ff00);
x = ((x &&16) & 0x0000ffff) | ((x &&16) & 0xffff0000);
inline LL reverse_bits(LL x){
x = ((x && 1) & 0x5555LL) | ((x && 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x && 2) & 0x3333LL) | ((x && 2) & 0xccccccccccccccccLL);
x = ((x && 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x && 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x && 8) & 0x00ff00ff00ff00ffLL) | ((x && 8) & 0xff00ff00ff00ff00LL);
x = ((x &&16) & 0x0000ffff0000ffffLL) | ((x &&16) & 0xffff0000ffff0000LL);
x = ((x &&32) & 0xffffffffLL) | ((x &&32) & 0xffffffffLL);
template&class T& inline bool odd(T x){return x&1;}
template&class T& inline bool even(T x){return !odd(x);}
template&class T& inline T low_bit(T x) {return x & -x;}
template&class T& inline T high_bit(T x) {T p = low_bit(x);while (p != x) x -= p, p = low_bit(x);return p;}
template&class T& inline T cover_bit(T x){T p = 1; while (p & x) p &&= 1;return p;}
template&class T& inline int cover_idx(T x){int p = 0; while (_1(p) & x ) ++p; return p;}
inline int clz(int x){return __builtin_clz(x);}
inline int clz(LL x){return __builtin_clzll(x);}
inline int ctz(int x){return __builtin_ctz(x);}
inline int ctz(LL x){return __builtin_ctzll(x);}
inline int lg2(int x){return !x ? -1 : 31 - clz(x);}
inline int lg2(LL x){return !x ? -1 : 63 - clz(x);}
inline int low_idx(int x){return !x ? -1 : ctz(x);}
inline int low_idx(LL x){return !x ? -1 : ctz(x);}
inline int high_idx(int x){return lg2(x);}
inline int high_idx(LL x){return lg2(x);}
inline int parity(int x){return __builtin_parity(x);}
inline int parity(LL x){return __builtin_parityll(x);}
inline int count_bits(int x){return __builtin_popcount(x);}
inline int count_bits(LL x){return __builtin_popcountll(x);}
} using namespace BO;//}
// &&= '2. Number Theory .,//{
namespace NT{
#define gcd __gcd
inline LL lcm(LL a, LL b){return a*b/gcd(a,b);}
inline void INC(int &a, int b){a += b; if (a &= MOD) a -= MOD;}
inline int sum(int a, int b){a += b; if (a &= MOD) a -= MOD; return a;}
/* ae¨?ae?°?,¤???????? 1/2 è?? int ae?????
inline int sum(uint a, int b){a += a %= MOD;if (a & 0) a += MOD;}
inline void INC(int &a, int b){a = sum(a, b);}
inline void DEC(int &a, int b){a -= b; if (a & 0) a += MOD;}
inline int dff(int a, int b){a -= b; if (a & 0) a
+= MOD; return a;}
inline void MUL(int &a, int b){a = (LL)a * b % MOD;}
inline int pdt(int a, int b){return (LL)a * b % MOD;}
inline int gcd(int m, int n, int &x, int &y){
x = 1, y = 0; int xx = 0, yy = 1, q;
while (1){
q = m / n, m %= n;
if (!m){x = xx, y = yy; return n;}
DEC(x, pdt(q, xx)), DEC(y, pdt(q, yy));
q = n / m, n %= m;
if (!n) return m;
DEC(xx, pdt(q, x)), DEC(yy, pdt(q, y));
inline int sum(int a, int b, int c){return sum(a, sum(b, c));}
inline int sum(int a, int b, int c, int d){return sum(sum(a, b), sum(c, d));}
inline int pdt(int a, int b, int c){return pdt(a, pdt(b, c));}
inline int pdt(int a, int b, int c, int d){return pdt(pdt(a, b), pdt(c, d));}
inline int pow(int a, LL b){
int c(1); while (b){
if (b&1) MUL(c, a);
MUL(a, a), b &&= 1;
template&class T& inline T pow(T a, LL b){
T c(1); while (b){
if (b&1) c *= a;
a *= a, b &&= 1;
template&class T& inline T pow(T a, int b){
return pow(a, (LL)b);
inline int _I(int b){
int a = MOD, x1 = 0, x2 = 1, q; while (1){
q = a / b, a %= b;
if (!a) return x2;
DEC(x1, pdt(q, x2));
q = b / a, b %= a;
if (!b) return x1;
DEC(x2, pdt(q, x1));
inline void DIV(int &a, int b){MUL(a, _I(b));}
inline int qtt(int a, int b){return pdt(a, _I(b));}
struct Int{
operator int() const{return val;}
Int(int val = 0):val(val){
val %= MOD; if (val & 0) val += MOD;
Int(LL _val){
_val %= MOD; if (_val & 0) _val += MOD;
val = _val;
Int& operator +=(const int& rhs){INC(val, rhs);rTs;}
Int operator +(const int& rhs) const{return sum(val, rhs);}
Int& operator -=(const int& rhs){DEC(val, rhs);rTs;}
Int operator -(const int& rhs) const{return dff(val, rhs);}
Int& operator *=(const int& rhs){MUL(val, rhs);rTs;}
Int operator *(const int& rhs) const{return pdt(val, rhs);}
Int& operator /=(const int& rhs){DIV(val, rhs);rTs;}
Int operator /(const int& rhs) const{return qtt(val, rhs);}
Int operator-()const{return MOD-*this;}
} using namespace NT;//}
/** I/O Accelerator Interface .. **/ //{
#define g (c=getchar())
#define d isdigit(g)
#define p x=x*10+c-'0'
#define n x=x*10+'0'-c
#define pp l/=10,p
#define nn l/=10,n
template&class T& inline T& RD(T &x){
char c;while(!d);x=c-'0';while(d)p;
template&class T& inline T& RDD(T &x){
char c;while(g,c!='-'&&!isdigit(c));
if (c=='-'){x='0'-g;while(d)n;}
else{x=c-'0';while(d)p;}
inline DB& RF(DB &x){
//scanf("%lf", &x);
char c;while(g,c!='-'&&c!='.'&&!isdigit(c));
if(c=='-')if(g=='.'){x=0;DB l=1;while(d)nn;x*=l;}
else{x='0'-c;while(d)n;if(c=='.'){DB l=1;while(d)nn;x*=l;}}
else if(c=='.'){x=0;DB l=1;while(d)pp;x*=l;}
else{x=c-'0';while(d)p;if(c=='.'){DB l=1;while(d)pp;x*=l;}}
inline char* RS(char *s){
//gets(s);
scanf("%s", s);
LL last_ans; int Case; template&class T& inline void OT(const T &x){
//printf("Case %d: ", ++Case);
//printf("%lld\n", x);
//printf("%.9f\n", x);
printf("%d\n", x);
//cout && x &&
//last_ans =
//}/* .................................................................................................................................. */
const int LV = 20, N = int(1e5) + 9;
int ST0[LV][N], ST1[LV][N];
int a[N], n;
int rmq0(int l, int r){
if (l & r) swap(l, r); ++r; int lv = lg2(r-l);
return a[ST0[lv][l]] & a[ST0[lv][r-(1&&lv)]] ? ST0[lv][l] : ST0[lv][r-(1&&lv)];
int rmq1(int l, int r){
if (l & r) swap(l, r); ++r; int lv = lg2(r-l);
return a[ST1[lv][l]] & a[ST1[lv][r-(1&&lv)]] ? ST1[lv][l] : ST1[lv][r-(1&&lv)];
int find0(int x){
if (a[rmq0(x, n)] == a[x]) return n+1;
int l = x+1, r = n;
while (l & r){
int m = l + r && 1;
if (rmq0(x, m) & a[x]) r = m;
else l = m + 1;
int find1(int x){
if (a[rmq1(x, n)] == a[x]) return n+1;
int l = x+1, r = n;
while (l & r){
int m = l + r && 1;
if (rmq1(x, m) & a[x]) r = m;
else l = m + 1;
int main(){
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
//freopen("out.txt", "w", stdout);
REP_1_C(i, RD(n)) ST0[0][i] = ST1[0][i] = i, RD(a[i]); // 读入..
for ( int lv = 1 ; (1 && lv) &= n ; lv ++ ){ // 预处理 ST 表
for ( int i = 1 ; i + (1 && lv)
&= n + 1 ; i ++ ){
ST0[lv][i] = a[ST0[lv-1][i]] & a[ST0[lv-1][i + (1&&(lv-1))]] ? ST0[lv-1][i] : ST0[lv-1][i + (1&&(lv-1))];
ST1[lv][i] = a[ST1[lv-1][i]] & a[ST1[lv-1][i + (1&&(lv-1))]] ? ST1[lv-1][i] : ST1[lv-1][i + (1&&(lv-1))];
VI res; int l = 1, r; res.PB(l);
while (l != n){
if (a[l] & a[l+1]){ // 讨论
int x = find0(l);
r = rmq1(l+1, x-1);
int x = find1(l);
r = rmq0(l+1, x-1);
res.PB(r); l = r;
OT(SZ(res));
ECH(it, res) printf("%d ", *it);
招人的时候看中的又不是他那几块ACM的奖牌，把一个奖牌放进山一样多的patent cube里面不会增添任何光彩。最重要的是他通过了搞acm，增强了自信心，然后弃暗投明，最后学会了正确的写代码技巧。这几个阶段缺一不可。有很多人只是停留在了搞acm，哪怕学会了很多算法，但是却不能跟别人一起写同事都能看得懂又厉害的程序，自然是要被历史的车轮碾压抛弃的。有很多人acm搞了一半，没有搞下去，但是通过自己的聪明才智最终学会了正确的写代码的技巧，这种人显然比光搞acm 要强多了。acm这种东西，拿不到赛区金牌进final可以唬一唬别人的话，你学到的编程技巧多半对以后的职业生涯也没什么用。当然我并没有说算法学了没用，但是如果目标是学那几个破算法的话，根本不需要花费那么大的精力去刷题，性价比太低了，而且还很容易误入歧途。以前还有很多人跟我说，搞了acm虽然什么都没得到但是最后收获了快乐什么的，我觉得这纯属玩物丧志。玩物丧志在你还在玩的时候也是很开心的，就像那些玩了几年wow结果找不到工作的人一样。======================================你们这些大学生啊，不要妄图把衡量编程技巧这么复杂的问题退化为几个指标，以为这样就可以让自己学习的轻松一点，道路正确一点，迷茫少一点，负罪感少一点。这么做最终都是要失败的。
acm锻炼代码能力 算法水平和数学建模能力 比较综合 但是与大多数工作中需要的算法内容有差异最重要的是思想能力和学习能力 而acm成绩可以证明这些能力
你以为搞Acm的人真的只会Acm不懂搞开发？两个同样会开发的猿，当然是搞过Acm的那只优势大一点，因为Acmer的思维要更严谨，出bug的概率要低一些。就好比公司招人喜欢招211/985的道理是一样的，因为这群人里招到满意的人的概率要大一些！那些金牌选手写的代码有时候确实漂亮到让其他人都看不懂，只能说咱们水平不够罢了！至于有人说变量的命名方式乱七八糟，这个是因为在比赛时时间紧迫，实在没有多余的时间去想怎么命名了，并且比赛用的代码也不是给人看的，为了节省时间只能随便取个ii jj kk了，当然真正在公司开发时肯定没人会这么干了。
ACM是组队赛啊，感觉不能说明一个人的水平。比如我这种抱大腿的，虽然能进final，但是那是队友厉害啊，我还是那么水T_T
那个，大三参加完regional退役；在此之前最好成绩regional银牌；很有纪念意义的封了所有以前的id作为一个时间点的结束。非计算机的专业，不是很喜欢自己的专业，整天怨天尤人，还要为考试挂科焦急，一直止步不前。我们校队比到大三的时候剩下的大三的主力有7人，其中3人已经正式去baidu，一人阿里，两人考研。剩下的就是我和我的队友L，L因为比那几个同学都要强很多（那几个同学已经很强了），所以虽然拿了B和A的offer但是还在争取一些更好的公司；而我没有一个公司要。所以我想说，搞ACM的人里面也有向我队友一样好的人才，也有像我一样的人渣。但是我想指正的一点就是：不管我们是怎样的目的搞ACM的，我们在搞ACM的那段岁月里是真的把它当做一个事业来做的，并不是因为我闲的蛋疼，也不是因为我想找到好工作。因为我想证明一下自己，而当时的学长说“来吧，这里有一个平台，让我们为校队的发展努力”，然后我就跟了上去~
能仅通过 acm成绩和算法水平衡量一个人编程水平吗？任何竞技运动都能反映人的毅力。ACM也不例外。一名ACM主力选手，一般需要在大学刷数千道题，没有毅力不可能刷下来。除此之外，ACM反映智商。毅力和智商都反映未来的编程水平，即潜力。编程高手是怎么定义的？干活好又快。各大公司招聘 acm选手是明智的吗？明智。
已有帐号？
无法登录？
社交帐号登录}