review opportunity - 未名空间MITBBS历史存档

国际科技财经博客移民网络热点娱乐民生时事公众号

Redian新闻

>未名空间

>Immigration - 落地生根

review opportunity

review opportunity# Immigration - 落地生根

w*52012-08-27 07:08

1 楼

上次onsite,4轮,自己感觉很好.
HR回信也说: went well so far but still need last code question interview to
end the process
要安排电话面试
结果我说:电面不好,我要求onsite,今天上午就onsite了.
结果, 一看是一个严肃的老印,基本听不懂其在说什么
就一道题:
实现 int Read(int Size, char * buffer) using int Read4(char * buffer)
这题思路很简单的,我当时给了2种方法结果在他的引导上走上了一条不归路,第一次实
现有bug, 没考虑buffer里面留下的部分....汗 ...各种改...(这题原来有过类似的
readLine, 但是自己觉得应该简单没有动手仔细写过, 结果在press下不能写好, 还是
实力不够!!!)
最后老印拍了照,明显要回去Negative的节奏
也许看到了老印,第一感觉就不妙吧,有了心理暗示, 过程中沟通也不是很顺畅. 面到40
分钟的时候,老印就不出题了, 直接叫问问题.汗
郁闷, 悔恨, 临门一脚, 我是中国足球队吗, 对自己的能力深深的怀疑!!!

m*s2012-08-27 07:08

2 楼

III- nitrides materials and Devices.
title" High-temperature electroluminescence of InGaN/GaN light-emitting
devices with multiple quantum barriers".
please email me with your background if you are interested.
Thanks.

p*u2012-08-27 07:08

3 楼

这题啥意思？

to

【在 w***5 的大作中提到】

: 上次onsite,4轮,自己感觉很好.
: HR回信也说: went well so far but still need last code question interview to
: end the process
: 要安排电话面试
: 结果我说:电面不好,我要求onsite,今天上午就onsite了.
: 结果, 一看是一个严肃的老印,基本听不懂其在说什么
: 就一道题:
: 实现 int Read(int Size, char * buffer) using int Read4(char * buffer)
: 这题思路很简单的,我当时给了2种方法结果在他的引导上走上了一条不归路,第一次实
: 现有bug, 没考虑buffer里面留下的部分....汗 ...各种改...(这题原来有过类似的

y*l2012-08-27 07:08

4 楼

sent to u. thanks.

w*52012-08-27 07:08

5 楼

就是 Read4(char*buff),每次读取4个tytes.
然后利用这个函数实现 Read(int size, char *buffer).

【在 p*u 的大作中提到】

: 这题啥意思？
:
: to

m*s2012-08-27 07:08

6 楼

有好几位同学已经给我发了站内信。我会尽快选几位backgroud match 的同学发邀请。
另外，我是这一期special issue "III-Nitride Devices for Infrared Application
" 的lead guest editor.所以会有多篇相关领域的manuscripts 需要review. 如果您感
兴趣，请留下您的联系方式和简单背景。
谢谢。

z*82012-08-27 07:08

7 楼

貌似比用Read4096实现readline要容易些

【在 w***5 的大作中提到】

: 就是 Read4(char*buff),每次读取4个tytes.
: 然后利用这个函数实现 Read(int size, char *buffer).

p*d2012-08-27 07:08

8 楼

哪两种方法。我就看到把(size/4+1)次Read4再读最后一次size%4 byte的方法。还有什
么方法？如何被烙印误导的？

to

【在 w***5 的大作中提到】

u*o2012-08-27 07:08

9 楼

提LZ感觉可惜。。不行要求一下重新面吧！

g*e2012-08-27 07:08

10 楼

to
一般拍照了是没啥好结果
我上次面FB也被拍照了最后估计挂在那哥们手上了

【在 w***5 的大作中提到】

w*52012-08-27 07:08

11 楼

我说两个办法:
1. 就是你的这个,不断的读read4. read4太有迷惑性了,还不如是 read4K呢
2. 我说开一个大的buffer,不断的填充buffer, 不够的时候再去读, 每次先从buffer里
面读
我问他写第一种情况ok? 他说好的. 结果最后过case的时候,来了一个 read(2), read
(5) 那不是傻眼了吗, 肯定得在buffer里面存着
然后就想改成2的情况, 一紧张, 就没法写好了.

【在 p********d 的大作中提到】

: 哪两种方法。我就看到把(size/4+1)次Read4再读最后一次size%4 byte的方法。还有什
: 么方法？如何被烙印误导的？
:
: to

P*b2012-08-27 07:08

12 楼

可以开个buf[4]的静态变量吗？

read

【在 w***5 的大作中提到】

: 我说两个办法:
: 1. 就是你的这个,不断的读read4. read4太有迷惑性了,还不如是 read4K呢
: 2. 我说开一个大的buffer,不断的填充buffer, 不够的时候再去读, 每次先从buffer里
: 面读
: 我问他写第一种情况ok? 他说好的. 结果最后过case的时候,来了一个 read(2), read
: (5) 那不是傻眼了吗, 肯定得在buffer里面存着
: 然后就想改成2的情况, 一紧张, 就没法写好了.

w*52012-08-27 07:08

13 楼

其实我觉得本身的问题还是出在交流上边:
1. Read4太有迷惑性了,才读4types 也许是最小的单位了. 哪里想到调用 Read(int
size, char * buffer) 时候会有 read(2, buffer), read(1,buffer)这样的情况. 如
果直接上来说调用的function是 Read4K 那就一目了然了
2. 如果我这个地方不清楚,应该早点提出来得到确认, 而不是最后让他指出来, 自己就
慌了阵脚
感觉他就在后面盯着我出错的感觉, 有了错误还让继续往这个方向上走下去, 最后才来
告诉你你的思路有问题.
Anyway, 心有不甘而有毫无办法.
bless后面的人

to

【在 w***5 的大作中提到】

s*u2012-08-27 07:08

14 楼

我觉得第二种办法有点多此一举吧。我觉得这道题的本意就是说，4这个buff很小，然
后你要把这些很小的数据存到一个大的buffer里去，也就是read（size，char *buffer
）。比如read（4000，buffer）就相当于read4k（buffer）
额。。这个read（2）和read（5）也没想到，不过应该能想到剩下的东西，还应该在
4buff里呆着，下次read（size）的时候还要用。跟那个readline的题一样
“(size/4+1)次Read4再读最后一次size%4 byte的方法”这句话是普遍适用的，不过如
果当前4buff不为空，应该要先把上次剩下的渣渣读进来吧。
这个题感觉第一次碰到的话很难做好，有点刁难。

read

【在 w***5 的大作中提到】

w*52012-08-27 07:08

15 楼

一上来就按照这个写,虽然边边角角多点还是能写对的,大不了仔细点.
可是写完了之后被指出read(2)和read(5)的情况之后,在原来的code上做修改几乎是不
可能的. 后来也没下决心重新组织思路去写code. 犹犹豫豫就造成了悲剧的结果
还不如一狠心重新写完了.

buffer

【在 s********u 的大作中提到】

: 我觉得第二种办法有点多此一举吧。我觉得这道题的本意就是说，4这个buff很小，然
: 后你要把这些很小的数据存到一个大的buffer里去，也就是read（size，char *buffer
: ）。比如read（4000，buffer）就相当于read4k（buffer）
: 额。。这个read（2）和read（5）也没想到，不过应该能想到剩下的东西，还应该在
: 4buff里呆着，下次read（size）的时候还要用。跟那个readline的题一样
: “(size/4+1)次Read4再读最后一次size%4 byte的方法”这句话是普遍适用的，不过如
: 果当前4buff不为空，应该要先把上次剩下的渣渣读进来吧。
: 这个题感觉第一次碰到的话很难做好，有点刁难。
:
: read

l*n2012-08-27 07:08

16 楼

话说，上次剩下的渣渣用什么存比较好？好像必须用一个class的本地变量来进行缓存。

buffer

【在 s********u 的大作中提到】

T*e2012-08-27 07:08

17 楼

对lz表示惋惜。顺便问一句，那个两个函数里返回值int是返回的什么值？

d*k2012-08-27 07:08

18 楼

沒關係，樓主繼續加油啊，我連面試機會都木有。
int Read(int size, char* buffer) {
char buf[4];
int ret = 0;
while (ret < size) {
int sz = Read4(buf);
if (sz == 0) {
break;
}
int cp_size = min(sz, size - ret);
memcpy(buffer + ret, buf, cp_size);
ret += cp_size;
}
return ret;
}

d*k2012-08-27 07:08

19 楼

看了大家的討論，優化下內存拷貝次數
int Read(int size, char* buffer) {
int n = size / 4;
int ret = 0;
for (int i = 0; i < n; ++i) {
int t = Read4(buffer + ret);
ret += t;
if (t < 4) {
return ret;
｝
}
int left = size % 4;
char buf[4];
int sz = min(left, Read4(buf));
memcpy(buffer + ret, sz);
ret += sz;
return ret;
}

n*e2012-08-27 07:08

20 楼

楼主加油！

n*e2012-08-27 07:08

21 楼

楼主加油！

w*52012-08-27 07:08

22 楼

read(2) 然后在read(2)能处理吗

【在 d*k 的大作中提到】

: 看了大家的討論，優化下內存拷貝次數
: int Read(int size, char* buffer) {
: int n = size / 4;
: int ret = 0;
: for (int i = 0; i < n; ++i) {
: int t = Read4(buffer + ret);
: ret += t;
: if (t < 4) {
: return ret;
: ｝

w*52012-08-27 07:08

23 楼

谢谢
返回的int代表实际读取到的大小

【在 T******e 的大作中提到】

: 对lz表示惋惜。顺便问一句，那个两个函数里返回值int是返回的什么值？

b*52012-08-27 07:08

24 楼

那就把buf[4]变成static，然后最后copy到buffer以后，再move up。。。

【在 w***5 的大作中提到】

: read(2) 然后在read(2)能处理吗

w*52012-08-27 07:08

25 楼

和static没啥关系吧
我觉得就是无论这个buffer多大,得维护这个buffer当前读到什么位置, 每次新的read
进来先从buffer里面读,不够的话再填满buffer从头上拿.
我当时应该冷静理理思路从头开始写.

【在 b**********5 的大作中提到】

: 那就把buf[4]变成static，然后最后copy到buffer以后，再move up。。。

s*u2012-08-27 07:08

26 楼

这个不太对吧。至少应该要将ret定义成static变量

【在 d*k 的大作中提到】

: 沒關係，樓主繼續加油啊，我連面試機會都木有。
: int Read(int size, char* buffer) {
: char buf[4];
: int ret = 0;
: while (ret < size) {
: int sz = Read4(buf);
: if (sz == 0) {
: break;
: }
: int cp_size = min(sz, size - ret);

b*52012-08-27 07:08

27 楼

可以啊。变成static，你一开始的时候，就先查一下那个 char[4] buf里有没有什
么东西。有东西，先copy到那个input buffer里面

read

【在 w***5 的大作中提到】

: 和static没啥关系吧
: 我觉得就是无论这个buffer多大,得维护这个buffer当前读到什么位置, 每次新的read
: 进来先从buffer里面读,不够的话再填满buffer从头上拿.
: 我当时应该冷静理理思路从头开始写.

s*u2012-08-27 07:08

28 楼

还是需要的。就是你read4（）最后会有一个余量。就是4-size%4。这个应该存在
static char*buff里，而不是buffer里，因为buffer存到size之后就不存了。
如果一开始就考虑到这个的话，无论buffer大小多少，逻辑都是一样的，只不过size/4
是否为0而已。

read

【在 w***5 的大作中提到】

b*52012-08-27 07:08

29 楼

ret怎么会要static？

【在 s********u 的大作中提到】

: 这个不太对吧。至少应该要将ret定义成static变量

s*u2012-08-27 07:08

30 楼

这是readline那个题我参照网上的代码写的。比这个要复杂一些，因为一个line的字符
是不确定的。
#define MAX_LEN 4096
int read(char* buf, int len);
char *readLine(){

static bool EOF = false;
char *str = NULL;
int i, size = 0;

static int currentPos = MAX_LEN;

static char* buffer = new char[MAX_LEN];

while(!EOF || currentPos != MAX_LEN ){

// buffer is not empty, handle buffer first
if(currentPos != MAX_LEN){

for(i = currentPos; i < MAX_LEN; i++)
if( buffer[i] == '\0' || buffer[i] == '\n' ){
i++;
break;
}

int oldsize = (str == NULL)? 0: strlen(str);

//resize the size of str;
size += i - currentPos;
str = (char*) realloc(str,sizeof(char)*(size + 1));

//copy the buffer into str;
memcpy(s + oldsize,buffer + currentPos,i - currentPos);
str[size] = '\0';
currentPos = i;

if( buffer[i-1] == '\0' || buffer[i-1] == '\n' )
return str;
}else{

int size = read( buf, MAX_LEN);
currentPos = 0;
if( size < MAX_LEN )
EOF = 1;
}
}

return str;
}

s*u2012-08-27 07:08

31 楼

记住你上次的4buff里还剩多少啊。否则每次都要去维护那个buf，realloc么

【在 b**********5 的大作中提到】

: ret怎么会要static？

w*52012-08-27 07:08

32 楼

恩,我明白你说的意思了
我当时是写了一个类,用了一个固定长度的buffer作为成员变量的
和static char * buffer作用是一样的

/4

【在 s********u 的大作中提到】

: 还是需要的。就是你read4（）最后会有一个余量。就是4-size%4。这个应该存在
: static char*buff里，而不是buffer里，因为buffer存到size之后就不存了。
: 如果一开始就考虑到这个的话，无论buffer大小多少，逻辑都是一样的，只不过size/4
: 是否为0而已。
:
: read

w*52012-08-27 07:08

33 楼

明白你的意思了,你说的对.
thanks

【在 b**********5 的大作中提到】

: 可以啊。变成static，你一开始的时候，就先查一下那个 char[4] buf里有没有什
: 么东西。有东西，先copy到那个input buffer里面
:
: read

s*u2012-08-27 07:08

34 楼

嗯作为类的变量也行不过我所说的static的是4的那个buf，而不是输出的buffer。输
出那个buffer是个参数，应该是可以用户来给定的，或者相当于一个返回值。这个题应
该是这个意思。所以你不能把余下来的东西存在buffer里，而要存在buf里。。。。好绕

【在 w***5 的大作中提到】

: 恩,我明白你说的意思了
: 我当时是写了一个类,用了一个固定长度的buffer作为成员变量的
: 和static char * buffer作用是一样的
:
: /4

s*u2012-08-27 07:08

35 楼

anyway，lz move on吧，连onsite都过了，已经证明lz实力，其他offer也能轻松拿的

w*52012-08-27 07:08

36 楼

恩,我说的也是临时用的buf, 返回的参数的buffer当然不能用来做存余下的渣渣了

好绕

【在 s********u 的大作中提到】

: 嗯作为类的变量也行不过我所说的static的是4的那个buf，而不是输出的buffer。输
: 出那个buffer是个参数，应该是可以用户来给定的，或者相当于一个返回值。这个题应
: 该是这个意思。所以你不能把余下来的东西存在buffer里，而要存在buf里。。。。好绕

b*52012-08-27 07:08

37 楼

那个buf，就是个char[4] buf吧，一共就四个char的memory，查一查里面有什么
valid char，不就行了？

【在 s********u 的大作中提到】

: 记住你上次的4buff里还剩多少啊。否则每次都要去维护那个buf，realloc么

w*52012-08-27 07:08

38 楼

我说的也是buf, 返回的参数buffer当然不能存余下的渣渣

好绕

【在 s********u 的大作中提到】

s*u2012-08-27 07:08

39 楼

那相当于你每次读走东西，每个char值还要更新成某个invalid的char，不太好吧。还
要用个东西来标示渣渣和非渣渣。。

【在 b**********5 的大作中提到】

: 那个buf，就是个char[4] buf吧，一共就四个char的memory，查一查里面有什么
: valid char，不就行了？

l*n2012-08-27 07:08

40 楼

你发明的渣渣这词太nb了。

【在 s********u 的大作中提到】

: 那相当于你每次读走东西，每个char值还要更新成某个invalid的char，不太好吧。还
: 要用个东西来标示渣渣和非渣渣。。

s*u2012-08-27 07:08

41 楼

理解能力比较差，所以经常靠类比。
比如linkedhashmap也就是lru cache我就想象成一条河，一边是阀门+瀑布会掉下去。
。然后有个机器手在天上可以吊走任何一条鱼或者插入一条鱼。。。

【在 l*n 的大作中提到】

: 你发明的渣渣这词太nb了。

r*n2012-08-27 07:08

42 楼

char* buffer= (char*)malloc(size);
void read(int size,char*buffer){
int times=size/4;
int rem = size%4;
int k=0;
char buffer4[4];
for(int i=0; i
read4(buffer);
memcpy(buffer+k, buffer4, 4);
k+=4;
}
read4(buffer);
memcpy(buffer+k, buffer4, rem);

}

【在 w***5 的大作中提到】

: 就是 Read4(char*buff),每次读取4个tytes.
: 然后利用这个函数实现 Read(int size, char *buffer).

d*k2012-08-27 07:08

43 楼

這種需求第一次寫的時候如果沒說，之後他指出，你再加上也算可以吧？要是要求一次
就寫出來有點成心黑你啊。
改一下我的，我覺得還比較好改啊。
int Read(int size, char* buffer) {
static char extra[4];
static extra_len = 0;
int ret = 0;
if (extra_len > 0) {
int t = min(extra_len, size);
memcpy(buffer, extra, t);
ret += t;
extra_len -= t;
size -= t;
}
int n = size / 4;

for (int i = 0; i < n; ++i) {
int t = Read4(buffer + ret);
ret += t;
if (t < 4) {
return ret;
｝
}
int left = size % 4;
char buf[4];
int last_read = Read4(buf);
int sz = min(left, last_read);
memcpy(buffer + ret, buf, sz);
ret += sz;
memcpy(extra, buf + sz, last_read - sz);
extra_len = last_read - sz;
return ret;
}

【在 w***5 的大作中提到】

: read(2) 然后在read(2)能处理吗

z*s2012-08-27 07:08

44 楼

可惜啊。
我觉得题没有问题，挺正常的。
要说栽了，就只能怨烙了。

p*o2012-08-27 07:08

45 楼

it is not correct with "read (2), read(1)", is it?

【在 d*k 的大作中提到】

: 這種需求第一次寫的時候如果沒說，之後他指出，你再加上也算可以吧？要是要求一次
: 就寫出來有點成心黑你啊。
: 改一下我的，我覺得還比較好改啊。
: int Read(int size, char* buffer) {
: static char extra[4];
: static extra_len = 0;
: int ret = 0;
: if (extra_len > 0) {
: int t = min(extra_len, size);
: memcpy(buffer, extra, t);

d*p2012-08-27 07:08

46 楼

我怎么觉得这题我以前在哪见过呢？并不难，你之前过了好几轮，最后用这题否定你，
感觉是故意黑你的节奏，拍照就是为了留证据了。有时候真是没办法的事儿，找工作运
气也是很大一部分。
我之前的那个老东家，我根本就没报任何希望，结果呢，那个部门经理居然也是Mxxxx
club的会员，以前还一起玩过桌游。
有些东西就是可遇不可求，move on吧，offer就在你不经意间就来了，可能还是会给呢
。

w*52012-08-27 07:08

47 楼

谢谢,不管如何,只能move on了
确实,实力是一部分,运气也是一大部分, 我们所能做的只能是增强实力.

Mxxxx

【在 d*****p 的大作中提到】

: 我怎么觉得这题我以前在哪见过呢？并不难，你之前过了好几轮，最后用这题否定你，
: 感觉是故意黑你的节奏，拍照就是为了留证据了。有时候真是没办法的事儿，找工作运
: 气也是很大一部分。
: 我之前的那个老东家，我根本就没报任何希望，结果呢，那个部门经理居然也是Mxxxx
: club的会员，以前还一起玩过桌游。
: 有些东西就是可遇不可求，move on吧，offer就在你不经意间就来了，可能还是会给呢
: 。

w*52012-08-27 07:08

48 楼

是啊, 回过头来想其实挺正常的
有了先入为主的思维定势, 然后中间浪费了时间
沟通也不理想, 对方完全没给任何提示
挂了也是无可奈何的事情只能继续增强实力了

【在 z****s 的大作中提到】

: 可惜啊。
: 我觉得题没有问题，挺正常的。
: 要说栽了，就只能怨烙了。

s*u2012-08-27 07:08

49 楼

写了一下感觉真的挺难，要考虑的太多了，比如以前剩下的渣渣，size到顶了也要
return，或者read4（）进来如果返回值不为4是不是意味着后面就没数据了？那么size
还没到就要return。
写了一下，应该还能优化：
int Read4(char *buffer);
int Read(char *str, int max_size){
static int curPos = 0;
static char *buffer = new char[4];

int size = 0;

int readSize = 0;
int saveSize = 0;

if( curPos != 0){
readSize = 4 - curPos;
saveSize = min( readSize, max_size - size );
memcpy( str + size, buffer, saveSize );
size += saveSize;
}

curPos = 0;
readSize = 0;

while( size < max_size || readSize != 4){

readSize = Read4( buffer );
saveSize = min( readSize, max_size - size );
memcpy( str + size, buffer, saveSize );
size += saveSize;

}

curPos = (curPos + saveSize)%4;
return size;
}

d*k2012-08-27 07:08

50 楼

如果left是0的話應該立即return，原帖已改，謝謝提醒。

【在 p****o 的大作中提到】

: it is not correct with "read (2), read(1)", is it?

d*k2012-08-27 07:08

51 楼

一直關注這帖子，我幫你review一下啊。
直改了邏輯錯誤，都在註釋裡。因為你的實現有bug，可能更改方式不只一種。我只在
註釋裡寫了一種我認為正確的改法。
===============================================
int Read4(char *buffer);
int Read(char *str, int max_size){
static int curPos = 0;
static char *buffer = new char[4];

int size = 0;

int readSize = 0;
int saveSize = 0;
/*
下面這個if裡是錯的，比如你沒有更新max_size，而且memcpy不能從頭開始
copy buffer等等。另外，過於繁瑣。按照你的變量設計，好一點的寫法是
if (curPos > 0) {
int readSize = 4 - curPos;
saveSize = min(readSize, max_size);
memcpy(str, buffer + curPos, saveSize);
size += saveSize;
max_size -= saveSize;
curPos = (curPos + saveSize) % 4;
｝
*/
if( curPos != 0){
readSize = 4 - curPos;
saveSize = min( readSize, max_size - size );
memcpy( str + size, buffer, saveSize );
size += saveSize;
}

curPos = 0;
readSize = 0; // 如果你想用下面的循環結構，應該是readSize = 4;
// 並且把while裡的改成readSize == 4

while( size < max_size || readSize != 4){

readSize = Read4( buffer );
saveSize = min( readSize, max_size - size );
memcpy( str + size, buffer, saveSize );
size += saveSize;

}

curPos = (curPos + saveSize)%4; // 直接curPos = saveSize % 4是一樣的
return size;
}

size

【在 s********u 的大作中提到】

: 写了一下感觉真的挺难，要考虑的太多了，比如以前剩下的渣渣，size到顶了也要
: return，或者read4（）进来如果返回值不为4是不是意味着后面就没数据了？那么size
: 还没到就要return。
: 写了一下，应该还能优化：
: int Read4(char *buffer);
: int Read(char *str, int max_size){
: static int curPos = 0;
: static char *buffer = new char[4];
:
: int size = 0;

s*u2012-08-27 07:08

52 楼

多谢更正，把下面的东西粘上来的时候粘错了。我在想把buffer想象成循环的话，能不
能通过一个while就搞定，因为第一个if和后面的while，做的很多事情是重复的。
不过max_size不用更新，我就是设计成固定的，不是rem_size的意思。因为sizesize是终止条件。

【在 d*k 的大作中提到】

: 一直關注這帖子，我幫你review一下啊。
: 直改了邏輯錯誤，都在註釋裡。因為你的實現有bug，可能更改方式不只一種。我只在
: 註釋裡寫了一種我認為正確的改法。
: ===============================================
: int Read4(char *buffer);
: int Read(char *str, int max_size){
: static int curPos = 0;
: static char *buffer = new char[4];
:
: int size = 0;

s*u2012-08-27 07:08

53 楼

大致是这样，可能还是会有bug：
int Read4(char *buffer);
int Read(char *str, int max_size){
static int curPos = 0;
static char *buffer = new char[4];

int size = 0;

int readSize = 4;
int saveSize = 0;
bool left = (curPos != 0);

while( left || size < max_size || readSize == 4){

if(left){
readSize = 4 - curPos;
left = false;
}
else
readSize = Read4( buffer );

saveSize = min( readSize, max_size - size );
memcpy( str + size, buffer+curPos, saveSize );
size += saveSize;
curPos = (curPos + saveSize)%4;
}

return size;
}

【在 s********u 的大作中提到】

: 多谢更正，把下面的东西粘上来的时候粘错了。我在想把buffer想象成循环的话，能不
: 能通过一个while就搞定，因为第一个if和后面的while，做的很多事情是重复的。
: 不过max_size不用更新，我就是设计成固定的，不是rem_size的意思。因为size: size是终止条件。

j*p2012-08-27 07:08

54 楼

4轮面试?不去也罢了吧?

t*a2012-08-27 07:08

55 楼

你为什么不觉的烙印就是不想要你进来呢？
专门挑一个容易出错的题，然后给你错误的引导，再照相留证因为你上次onsite4轮
都过了。。。
你进来了，他的兄弟姐妹就少了一个名额

to

【在 w***5 的大作中提到】

d*k2012-08-27 07:08

56 楼

I really hate to be the one pointing it out.
For one thing your condition in the while clause is obviously wrong. You'll
overflow str until read4() is exhausted. For another, consider the case when
read4 is exhausted and returned 2. Suppose your code did return right
answer for the current call. Then curPos will be 2. In the next call you'll
first move the last two bytes in buffer to str, these two bytes are not what
you believe they are.
I'm sure there are other cases that your code can't pass. Keep it on!
==========================================
int Read4(char *buffer);
int Read(char *str, int max_size){
static int curPos = 0;
static char *buffer = new char[4];

int size = 0;

int readSize = 4;
int saveSize = 0;

while( curPos != 0 || size < max_size || readSize == 4){

if(curPos != 0)
readSize = 4 - curPos;
else
readSize = Read4( buffer );

saveSize = min( readSize, max_size - size );
memcpy( str + size, buffer+curPos, saveSize );
size += saveSize;
curPos = (curPos + saveSize)%4;

}

return size;
}

【在 s********u 的大作中提到】

: 大致是这样，可能还是会有bug：
: int Read4(char *buffer);
: int Read(char *str, int max_size){
: static int curPos = 0;
: static char *buffer = new char[4];
:
: int size = 0;
:
: int readSize = 4;
: int saveSize = 0;

p*32012-08-27 07:08

57 楼

就是撞上了不拿手的题，就是当时脑袋一下没转过来，就这么简单。
没什么好增强的，没什么好总结的,也没啥好悔恨的。

【在 w***5 的大作中提到】

: 是啊, 回过头来想其实挺正常的
: 有了先入为主的思维定势, 然后中间浪费了时间
: 沟通也不理想, 对方完全没给任何提示
: 挂了也是无可奈何的事情只能继续增强实力了

d*k2012-08-27 07:08

58 楼

贊三爺！

【在 p*****3 的大作中提到】

:
: 就是撞上了不拿手的题，就是当时脑袋一下没转过来，就这么简单。
: 没什么好增强的，没什么好总结的,也没啥好悔恨的。

w*52012-08-27 07:08

59 楼

三爷就是霸气

【在 p*****3 的大作中提到】

:
: 就是撞上了不拿手的题，就是当时脑袋一下没转过来，就这么简单。
: 没什么好增强的，没什么好总结的,也没啥好悔恨的。

p*o2012-08-27 07:08

60 楼

well, but i think you also have to update extra array after you read it
. e.g., test case "read(2), read(1), read(1)"

【在 d*k 的大作中提到】

: 如果left是0的話應該立即return，原帖已改，謝謝提醒。

d*k2012-08-27 07:08

61 楼

That's embarrassing...
I've updated the post. Soppose memcpy is clear enough to deal with
overlapping.

【在 p****o 的大作中提到】

: well, but i think you also have to update extra array after you read it
: . e.g., test case "read(2), read(1), read(1)"

p*o2012-08-27 07:08

62 楼

should be
memcpy(extra, extra + t, extra_len - t);
or in a safer way:
memmove(extra, extra + t, extra_len - t);

【在 d*k 的大作中提到】

: That's embarrassing...
: I've updated the post. Soppose memcpy is clear enough to deal with
: overlapping.

d*k2012-08-27 07:08

63 楼

Yeah, that's right. I was too tired last night. Thanks for the chance of
reviewing memcpy and memmove!

【在 p****o 的大作中提到】

: should be
: memcpy(extra, extra + t, extra_len - t);
: or in a safer way:
: memmove(extra, extra + t, extra_len - t);

c*y2012-08-27 07:08

64 楼

这不算啥，有次我去面试，12轮过后，最后一个CXO电面的时候behavior傻了，反问了
一下对方。
然后挂了。

to

【在 w***5 的大作中提到】

m*p2012-08-27 07:08

65 楼

没啥，这题挺偏的。这年头，不是做系统的，问这干吗。呀是找抽。
I renamed some vars in the code for easy understanding:
int Read(char *dest, int MAX_SIZE){
static int offset = 0;
static char *buffer = new char[4];

int size = 0, copySize = 0;
int readSize = 4;
while( offset != 0 || size < MAX_SIZE || readSize == 4){
readSize = offset ? 4 - offset : Read4(buffer);
copySize = min( readSize, max_size - size );
memcpy( dest + size, buffer + offset, copySize );
size += saveSize;
offset = (offset + copySize)%4;
}

return size;
}

z*u2012-08-27 07:08

66 楼

感觉楼主还是clarity的问题没有问好，其实你的第二种情况才是必须考虑的呀，第一
种情况只是优化而已。在写代码之前就应该问清楚有那些test case，test case都不了
解怎么敢往下写啊？不然写下来肯定有问题的。
这个老印也确实很坏，把你往错误的方向引导。

【在 w***5 的大作中提到】

: 一上来就按照这个写,虽然边边角角多点还是能写对的,大不了仔细点.
: 可是写完了之后被指出read(2)和read(5)的情况之后,在原来的code上做修改几乎是不
: 可能的. 后来也没下决心重新组织思路去写code. 犹犹豫豫就造成了悲剧的结果
: 还不如一狠心重新写完了.
:
: buffer