Chinaunix

标题: 据说是微软面试题 [打印本页]

作者: jronald 时间: 2006-12-05 00:45
标题: 据说是微软面试题
圆圈上顺时针排列着1,2,3,....2000 这2000个数. 从1开始,顺时针隔一个拿走一个(1最先被拿走,下一个是3被拿走). 问最后剩下是哪一个数字.

作者: lknh17 时间: 2006-12-05 03:21
1024吗？

作者: lknh17 时间: 2006-12-05 03:23
我是这样想的，不知道对不对
只考虑每次拿的第一个，那么就是2^i(i=0,1,2...)
众所周知2^10=1024,那么2^11>2000
所以是第11次取，就是1024了

作者: langue 时间: 2006-12-05 05:56
不如说是智商测试题。

作者: jronald 时间: 2006-12-05 06:26

原帖由 lknh17 于 2006-12-5 03:21 发表
1024吗？

不对

作者: Edengundam 时间: 2006-12-05 07:46
看Concrete_Mathematics第一章就讲, 递归&生成函数的题

作者: lknh17 时间: 2006-12-05 08:26
没看到“顺时针”

作者: redspider 时间: 2006-12-05 11:26
智力题么？
数据结构啊

作者: flw 时间: 2006-12-05 11:30
唉～
这种题我现在都反应不过来了～

作者: meiyuhan 时间: 2006-12-05 12:19
隔两个拿一个是7
没做过隔一个的

[ 本帖最后由 meiyuhan 于 2006-12-5 12:22 编辑 ]

作者: lauchee 时间: 2006-12-05 12:46
这个问题不错,可以去研究一下.

作者: franklmin 时间: 2006-12-05 12:54
1024

第一次拿走 1，3，5，7。。。。。。1999，剩下 2，4，6，8。。。。2000，下一次从 2 开始
第二次拿走 2，6，10。。。。。。1998（拿走的数%2=0，%4=2）,剩下 4，8，12，16，20。。。。。。2000，下一次从4开始
第三次拿走 4，12，20。。。2000（拿走的数%4=0，%8=4）,剩下8，16，24。。。1992

第 i 次拿走，剩下的数为 2^i ,2^(i+1).........[2^i<2000]

所以第十次拿走，剩下的数为1024

作者: softsongs 时间: 2006-12-05 12:58
我觉得答案是32。
循环次数 0 1 2 3 4 ....
剩下数字的个数(第一个数) 2000(1) 1000(2) 500(4) 250( 8 ) 125(16) ....

循环4次后，还剩125个数，此时剩下的最小数为16， 16的下一个数为32，因为已经出现奇数个数了，所以每次取完还是剩奇数个，32永远不会被取走（永远会被跳过，因为把32看成最后一个数，它总在偶数位，所以永远不会被选中），所以最后剩的数是32。

作者: emacsnw 时间: 2006-12-05 13:10

原帖由 franklmin 于 2006-12-4 20:54 发表
1024

第一次拿走 1，3，5，7。。。。。。1999，剩下 2，4，6，8。。。。2000，下一次从 2 开始
第二次拿走 2，6，10。。。。。。1998（拿走的数%2=0，%4=2）,剩下 4，8，12，16，20。。。。。。2000，下一次 ...

这2000个人围成一个圈，可以循环的。
查了一下这个问题叫Joseph's problem，网上有很多算法去解。

作者: tyc611 时间: 2006-12-05 13:14
我的想法有点笨，不过也说说，大家集思广益嘛

最初的序列为：1，2, 3, 4, ..., 1999, 2000（总数为偶数）
第一次取掉所有奇数，即剩下(2, 4, 6, ..., 1998, 2000) = 2 * ( 1, 2, 3, ..., 999, 1000)（仍为偶数）
第二次取掉剩下数中所有奇数，即剩下2 * (2, 4, 6, ..., 998, 1000) = 2^2 *(1, 2, 3, ..., 499, 500)（偶数）
第三次取掉剩下数中所有奇数，即剩下2^2 * (2, 4, 6, ..., 498, 500) = 2^3 * (1, 2, 3, ..., 249, 250)（偶数）
第四次取掉剩下数中所有奇数，即剩下2^3 * (2, 4, 6, ..., 248, 250) = 2^4 * (1, 2, 3, ..., 124, 125)（注意！为奇数了）
此时再取时，最后一个数2^4 * 125将被取掉，所以将第一个2放到最后，得：
第五次的结果：2^4 * (4, 6, 8, ..., 124, 2) = 2^5 * (2, 3, 4, ... , 62, 1)
为了简单，我们现在只对(2, 3, 4, ...., 62, 1) 取数，最后结果乘2^5即可。

先将(2, 3, 4, ..., 62, 1)序列映射为(1, 2, 3, ...., 61, 0)即原序列每个数减一，对新序列(1, 2, 3, ...., 61, 0)取数得：
第六次取数，得(2, 4, 6, ...., 60, 0) = 2 * (1, 2, 3, ..., 30, 0)（又是奇数了！）
（后面处理方法同上）
第七次取数，得 2 * (4, 6, 8, ..., 30, 2) = 2^2 * (2, 3, 4, ..., 15, 1)

再将(2, 3, 4, ..., 15, 1)映射为(1, 2, 3, ..., 14, 0)（原序列减一）
第八次取数，得 ( 4, 6, ..., 14, 2)……进行下去此序列得到最终值14

所以最终结果为 ((14+1)* 2^2+1)*2^5 = 1952

不知道算错没有，做得好麻烦啊

[ 本帖最后由 tyc611 于 2006-12-5 13:30 编辑 ]

作者: jronald 时间: 2006-12-05 13:26

原帖由 tyc611 于 2006-12-5 13:14 发表
我的想法有点笨，不过也说说，大家集思广益嘛
最初的序列为：1，2, 3, 4, ..., 1999, 2000（总数为偶数）
第一次取掉所有奇数，即剩下(2, 4, 6, ..., 1998, 2000) = 2 * ( 1, 2, 3, ..., 999, 1000)（ ...

1952正确

作者: tyc611 时间: 2006-12-05 13:29

原帖由 jronald 于 2006-12-5 13:26 发表

1952正确

写那么长花了我好长时间的，不过按那方法算越来也蛮快的，收敛速度还行

作者: geel 时间: 2006-12-05 15:26
为什么我直接模拟这个过程得出来的是1024？

<?php
for ($array = array(), $i=0; $i<2000; array_push($array, ++$i));
while (count($array)>1)
{
unset($array[key($array)]);
if(next($array) === false) /* unset之后指针后移，一次next即可 */
reset($array);
}
print_r($array);
?>
/* 结果是1024 */

复制代码

2006年12月6日更新：确实是1952，我上面的程序有bug

修正过的程序如下：

<?php
for ($array = array(), $i=0; $i<2000; array_push($array, ++$i));
while (count($array)>1)
{
unset($array[key($array)]);
if (!current($array)) /* 如果刚删除的是最后一个元素，从头开始的时候就要跳过一个 */
{
reset($array);
next($array);
}
elseif(next($array) === false) /* 如果删除的是倒数第二个元素，从头开始 */
{
reset($array);
}
}
print_r($array);
/* 结果是 1952 */
?>

复制代码

[ 本帖最后由 geel 于 2006-12-6 13:26 编辑 ]

作者: franklmin 时间: 2006-12-05 15:43
在vs2003上用笨笨的办法作了一下验证：

思路如下
（1）生成一个存有2000个节点的循环链表
（2）依次删除节点
（3）剩下最后一个数，打印

#include <stdlib.h>
#include <stdio.h>

//链表节点
struct circleListNode{
int data;
struct circleListNode *next;
struct circleListNode *prev;
};

//生成一个不带头尾的循环链表

circleListNode* makelist(int maxnum)
{
   circleListNode *tempHead,*currNode,*preNode;

//tempHead用于保存开始的值，
   tempHead=new circleListNode;
   tempHead->data=0;
   tempHead->next=NULL;
   tempHead->prev=NULL;

printf("Cirle list make Begin!\n");

for(int i=0;i<maxnum;i++)
{
//初始情况
if(i==0)
{
preNode=tempHead;
}

      //一般情况
currNode=new circleListNode;
currNode->data=i+1;
currNode->prev=preNode;
preNode->next=currNode;
preNode=currNode;


   //最后一个节点
if(i==maxnum-1)
{
currNode->next=tempHead->next;
tempHead->next->prev=currNode;
delete tempHead;

}

printf("%d ",currNode->data);

}

printf("\nCirle list make completed!\n");

currNode=currNode->next;//将指针放到第一个节点上

return currNode;

}

//依次隔一个，删一个
void joblist(circleListNode* plist)
{
circleListNode *curr,*prev,*next;

curr=plist;
prev=plist->prev;
next=plist->next;

while(curr)
{
//删除当前节点
printf("%d deleted\t",curr->data);
delete curr;

//将前一个节点与后面的节点连接。
prev->next=next;
next->prev=prev;

//删除一个元素后各指针值

curr=next->next;//跳过下一个节点
next=curr->next;
prev=curr->prev;

//如果只剩下一个，就退出
      if(curr->next==curr)
break;

}

printf("\nThe data remained is %d\n",curr->data);

}

int main()
{
circleListNode *p=makelist(2000);

joblist(p);

system("pause");
return 0;

}

结果是 1952！

[ 本帖最后由 franklmin 于 2006-12-5 15:56 编辑 ]

作者: geel 时间: 2006-12-05 15:44
楼上的，结果是？

作者: xxandxx 时间: 2006-12-05 20:31
1952

int fun(int n)
{
int first=1, last=n, i;
int *b = (int *)malloc(2*n*sizeof(int));

for (i = 1; i <= n; ++i)
      b[i] = i;

while(last-first != 1) {
      b[++last] = b[++first];
      ++first;
}
i = b[last];
free(b);
return i;
}

int main()
{
printf("%d\n", fun(2000));
getch();
return 0;
}

[[i] 本帖最后由 xxandxx 于 2006-12-5 20:46 编辑 [/i]]

作者: zwylinux 时间: 2006-12-06 00:09

原帖由 jronald 于 2006-12-5 00:45 发表
圆圈上顺时针排列着1,2,3,....2000 这2000个数. 从1开始,顺时针隔一个拿走一个(1最先被拿走,下一个是3被拿走). 问最后剩下是哪一个数字.

这个和约瑟夫问题有什么区别没？

作者: jronald 时间: 2006-12-06 00:14

原帖由 zwylinux 于 2006-12-6 00:09 发表

这个和约瑟夫问题有什么区别没？

不知道约瑟夫问题啊

作者: 灰色骆驼 时间: 2006-12-06 00:17
就是约瑟夫环

作者: jronald 时间: 2006-12-06 00:19

原帖由 灰色骆驼 于 2006-12-6 00:17 发表
就是约瑟夫环

知道那就没意思了

作者: W.Z.T 时间: 2006-12-06 12:08
找出规律:

1,3,5,...,2n-1,..,1999 1000/1000

2,6,10,..,2(2n-1),...,1998 500/500

4,12,.4(2n-1),1996,250/250

8,24,40,8(2n-1),125/125

16,48,80,16(2n-1),1984 63/62

32,96,160,32(2n-1),1952,(196

31/31

作者: geel 时间: 2006-12-06 13:27
大家正确，结果确实是1952，我前面的程序有bug
修正过的程序如下：

<?php
for ($array = array(), $i=0; $i<2000; array_push($array, ++$i));
while (count($array)>1)
{
unset($array[key($array)]);
if (!current($array)) /* 如果刚删除的是最后一个元素，从头开始的时候就要跳过一个 */
{
reset($array);
next($array);
}
elseif(next($array) === false) /* 如果删除的是倒数第二个元素，从头开始 */
{
reset($array);
}
}
print_r($array);
/* 结果是 1952 */
?>

复制代码

作者: meilinxiaoxue 时间: 2006-12-06 13:41
用数组来做,可以指定步长:

#include<stdio.h>
#include<stdbool.h>
int josephus(int * input, size_t count, unsigned int step)
{
int i,n_step,result;
bool flag = true;
n_step = 0;
result = input[0];
while (flag)
{
flag = false;
for (i=0; i<count; i++)
{
if (input[i])
{
if (0 == n_step%step)
{
n_step = 1;
input[i] = 0;
}
else
{
n_step++;
result = input[i];
flag = true;
#ifdef _DEBUG
printf("mid:%d\n",result);
#endif
}
}
}
}
return result;
}
void main(void)
{
int test[2000];
int i,j;
for (i=0; i<2000; i++)
{
test[i] = i+1;
}
j = josephus(test, 2000, 2);
printf("result:%d\n", j);
}

复制代码

作者: shxliang 时间: 2006-12-06 15:46

原帖由 xxandxx 于 2006-12-5 20:31 发表
1952

int fun(int n)
{
int first=1, last=n, i;
int *b = (int *)malloc(2*n*sizeof(int));

for (i = 1; i <= n; ++i)
b = i;

while(last-first != 1) {
...

这种算法我没想到过，呵呵，牛.........学习了
作者: jronald 时间: 2006-12-06 16:57

原帖由 xxandxx 于 2006-12-5 20:31 发表
1952

int fun(int n)
{
int first=1, last=n, i;
int *b = (int *)malloc(2*n*sizeof(int));

for (i = 1; i <= n; ++i)
      b = i;

while(last-first != 1) {
   ...

有创意
作者: qlks 时间: 2006-12-06 17:48

原帖由 xxandxx 于 2006-12-5 20:31 发表
1952

int fun(int n)
{
int first=1, last=n, i;
int *b = (int *)malloc(2*n*sizeof(int));

for (i = 1; i <= n; ++i)
      b = i;

while(last-first != 1) {
   ...

如果fun(5)
为什么得到的是2？
不是第二次应该是4？
作者: tyc611 时间: 2006-12-06 17:56

原帖由 qlks 于 2006-12-6 17:48 发表

如果fun(5)
为什么得到的是2？
不是第二次应该是4？

你算错了
作者: JColder 时间: 2006-12-06 19:23
public class FindLeaveNum {

/**

   * @param args

   */

public static void main(String[] args) {

// TODO Auto-generated method stub

            final int CAPABILITY = 2000;
Vector v = new Vector(CAPABILITY );

for (int i = 0; i < v.capacity(); i++) {

v.add(i, new Integer(i+1));

}

int i = 0;

int beforeLast = Integer.parseInt(v.lastElement().toString());

while (v.size()!= 1) {

for (int c = i; c < v.size(); c++) {

v.remove(c);

}

System.out.print("剩下"+v.size()+"个： ");

for(int j=0;j<v.size();j++)

{

System.out.print(v.get(j)+" ");

}

System.out.println();

int nowLast=Integer.parseInt(v.lastElement().toString());

if(nowLast==beforeLast)

{

i=0;

}

else i=1;

beforeLast =nowLast;

}

}

}

结果是 1952
作者: diabolo 时间: 2006-12-06 21:35
标题: 我写的，不如楼上的那位简洁。
typedef struct tagRingElement {
tagRingElement * prev;
tagRingElement * next;
int data;
} RingElement_t;

const  int COUNT = 2000;

void main()
{
RingElement_t * num = new RingElement_t[COUNT];

RingElement_t * curdel, * nextdel, * prev, * next, * last;

// num[0]
num[0].data = 1;
num[0].prev = num + COUNT - 1;
num[0].next = num + 1;

// num[1999]
num[COUNT - 1].data = COUNT;
num[COUNT - 1].prev = num + COUNT - 2;
num[COUNT -1].next = num;

for (int i = 1; i < COUNT - 1; i++)
{
num.prev = num + i - 1;
num.next = num + i + 1;
num.data = i + 1;
}

curdel = num;
while (curdel->next != curdel->prev)
{
// store curdel->next->next;
next = curdel->next;
prev = curdel->prev;
nextdel = next->next;

// delete curdel
next->prev = curdel->prev;
prev->next = curdel->next;

curdel = nextdel;
}

last = curdel->next;

cout << last->data << endl;

delete [] num;
}

忘了释放内存了，重贴一遍。

[ 本帖最后由 diabolo 于 2006-12-6 21:39 编辑 ]
作者: zjbluefox 时间: 2006-12-07 09:40
1952

import java.util.ArrayList;

import java.util.List;

/**

*

* @author Zhao

*/

public class count {

/** Creates a new instance of count */

private static List<Integer> data = new ArrayList<Integer>();

public static void main(String args[]) {

      for(int i=1;i<=2000;i++){

         data.add(i);

      }



      boolean FlagSize = false;



      while(data.size() > 1){

         int intSize = data.size();

         for(int i=0;i<intSize;i++){

            if(i>=data.size()){

                  break;

            }

            if(FlagSize){

                  FlagSize = false ;

                  i++;

            }

            if(i==(data.size()-1)){

                  FlagSize =true;

            }

            data.remove(i);

         }

      }

      System.out.println(data.get(0));



}

}

复制代码

[ 本帖最后由 zjbluefox 于 2006-12-7 10:50 编辑 ]
作者: crspo 时间: 2006-12-07 12:02
(2000循环左移1)-1=1952

2000: 11111010000
2000循环左移1:11110100001
2000循环左移1-1:11110100000=1952
作者: tyc611 时间: 2006-12-07 12:19

原帖由 crspo 于 2006-12-7 12:02 发表
(2000循环左移1)-1=1952

2000: 11111010000
2000循环左移1:11110100001
2000循环左移1-1:11110100000=1952

赞一个先！能说下为啥吗？
作者: decwang 时间: 2006-12-07 14:26
1953 用程序算出来的,为啥和上面不一样呢?

[ 本帖最后由 decwang 于 2006-12-7 14:31 编辑 ]
作者: decwang 时间: 2006-12-07 14:58
看错题了,呵呵

[ 本帖最后由 decwang 于 2006-12-7 14:59 编辑 ]
作者: crspo 时间: 2006-12-07 17:06

原帖由 tyc611 于 2006-12-7 12:19 发表

赞一个先！能说下为啥吗？

约瑟夫问题的小变体，可以参考concrete mathematics第一章
作者: mlmyf 时间: 2006-12-08 10:51
1024绝对正确
作者: epegasus 时间: 2006-12-08 11:36
标题: 2进制问题
2进制问题
作者: shxliang 时间: 2006-12-08 14:37

原帖由 crspo 于 2006-12-7 12:02 发表
(2000循环左移1)-1=1952

2000: 11111010000
2000循环左移1:11110100001
2000循环左移1-1:11110100000=1952

而且对其它的都有用，譬如说是200，
200：11001000
循环左移：10010001
减一：10010000＝144

用程序算也是144
作者: xiaocongwjb123 时间: 2006-12-08 15:17
标题: 哈哈，就是没有变体的约瑟夫问题
原帖由 jronald 于 2006-12-5 00:45 发表
圆圈上顺时针排列着1,2,3,....2000 这2000个数. 从1开始,顺时针隔一个拿走一个(1最先被拿走,下一个是3被拿走). 问最后剩下是哪一个数字.

   请大家再看看下面的一道全国计算机等级考试三级C语言上机考题：

设有n个人围坐一圈并按顺时针方向从1到n编号,从第s个人开始进行1到m的报数, 报数到第m个人, 此人出圈, 再从他的下一个人重新开始1到m的报数,如此进行下去直到所有的人都出圈为止。现要求按出圈次序,给出这n个人的顺序表p。

我相信很多朋友都熟悉这道经典的计算机上机考试题目吧。

于是我对上面的所谓微软面试题改一下，如下：

设有1999个人个人围坐一圈并按顺时针方向从2到2000编号,从第1个人开始进行1到2的报数, 报数到第2个人, 此人出圈, 再从他的下一个人重新开始1到2的报数,如此进行下去直到所有的人都出圈为止。现要求按出圈次序，给出这1999个人的顺序表；并求出最后出圈的人的编号是多少？

最后出圈的人的编号就是楼主问题的答案。

[ 本帖最后由 xiaocongwjb123 于 2006-12-8 15:21 编辑 ]
作者: 天行健！！ 时间: 2006-12-08 15:38
最后一个值是1952。
下面是我的推理：
（1：第一步是去掉所有奇数，即剩下2，4，6，8～～～～2000。
（2：将所有数除2，得到1，2，3～～～～1000。因上一步最后一个数未被取走，所以仍从“1”开始取。
（3：剩下2，4，6～～～1000。同理除以2得到1，2，3，4～～～500。上一步最后一个数（即最大的数）“1000”未被取走，所以仍从“1”开始取（这点很重要，若最后一个数被取走，则不能从最小的数开始取）。
（4：剩下2，4，6～～～500。同理除以2得到1，2，3，4～～～250。仍从“1”开始取。
（5：剩下2，4，6～～～250。同理除以2得到1，2，3，4～～～125。仍从“1”开始取。
（6：剩下2，4，6～～～124。同理除以2得到1，2，3，4～～～62。因为上一步最后一个数（即最大的数）“125”被取走，所以这次要从2开始取（因为要隔一个取一次）。即这次顺序为：2，3， 4～～～62，1（注意这里最后一个为1）。
（7：剩下3，5，7～～～～61，1。所有数加1除2，得到2，3～～～～31，1。因为上一步最后一个数“1”未被取走，所以这次要从2开始取，即这次顺序为：2，3，4～～31，1。
（8：剩下3，5，7～～31。所有数减1除2，得到1，2，3～～～～15。因为上一步最后一个数“1”被取走，所以这次也要从2开始取，即这次顺序为：2，3，4～～15，1。
（9：剩下3，5，7～～15。所有数减1除2，得到1，2，3～～～～7。因为上一步最后一个数“1”被取走，所以这次也要从2开始取，即这次顺序为：2，3，4～～7，1。
（10：剩下3，5，7。因为上一步最后一个数“1”被取走，所以这次要从5开始取，剩下7。
（11：把7还原，即做以上各步的反运算：｛[（7＊2＋1）＊2＋1]＊2－1｝＊2＊2＊2＊2＊2＝1952

写的不是很清楚，还请见谅！
作者: trp111 时间: 2006-12-08 16:03
1952

[ 本帖最后由 trp111 于 2006-12-8 16:28 编辑 ]
作者: ArXoR 时间: 2006-12-08 16:37
循环左移...
步长大于1的暂时没有close form的公式
作者: liqxy 时间: 2006-12-08 18:06
“回”字有四种写法！！！！
作者: langue 时间: 2006-12-08 19:56

原帖由 天行健！！ 于 2006-12-8 15:38 发表
最后一个值是1952。
下面是我的推理：
（1：第一步是去掉所有奇数，即剩下2，4，6，8～～～～2000。
（2：将所有数除2，得到1，2，3～～～～1000。因上一步最后一个数未被取走，所以仍从“1”开始取。
（3：剩下2，4，6～～～1000。同理除以2得到1，2，3，4～～～500。上一步最后一个数（即最大的数）“1000”未被取走，所以仍从“1”开始取（这点很重要，若最后一个数被取走，则不能从最小的数开始取）。
（4：剩下2，4，6～～～500。同理除以2得到1，2，3，4～～～250。仍从“1”开始取。
（5：剩下2，4，6～～～250。同理除以2得到1，2，3，4～～～125。仍从“1”开始取。
（6：剩下2，4，6～～～124。同理除以2得到1，2，3，4～～～62。因为上一步最后一个数（即最大的数）“125”被取走，所以这次要从2开始取（因为要隔一个取一次）。即这次顺序为：2，3， 4～～～62，1（注意这里最后一个为1）。
（7：剩下3，5，7～～～～61，1。所有数加1除2，得到2，3～～～～31，1。因为上一步最后一个数“1”未被取走，所以这次要从2开始取，即这次顺序为：2，3，4～～31，1。
（8：剩下3，5，7～～31。所有数减1除2，得到1，2，3～～～～15。因为上一步最后一个数“1”被取走，所以这次也要从2开始取，即这次顺序为：2，3，4～～15，1。
（9：剩下3，5，7～～15。所有数减1除2，得到1，2，3～～～～7。因为上一步最后一个数“1”被取走，所以这次也要从2开始取，即这次顺序为：2，3，4～～7，1。
（10：剩下3，5，7。因为上一步最后一个数“1”被取走，所以这次要从5开始取，剩下7。
（11：把7还原，即做以上各步的反运算：｛[（7＊2＋1）＊2＋1]＊2－1｝＊2＊2＊2＊2＊2＝1952

写的不是很清楚，还请见谅！

我怎么觉得这就像转换二进制时候用的短除法呀，呵呵
作者: jiajs 时间: 2006-12-09 13:20
int arr[2000], cnt = 0;
char flag = 0;
memset(arr, 0, sizeof(arr));

for(int i = 0; ; i++)
{
if(flag == 0 && arr[i%2000] == 0)
{
arr[i%2000] = 1;
flag =  1;
cnt++;
if(cnt == 2000)
{
//find it
printf("%d", i%2000);
}
}else if(flag == 1 && arr[i%2000] == 0){
flag = 0;
}

}
作者: ymerlin 时间: 2006-12-10 20:45
标题: python解此题很简洁
a = [i+1 for i in range(2000)]

flag = 1

while len(a) > 1:

last = a[-1]

a = [a[i] for i in range(len(a)) if i%2==flag]

if a[-1] == last:

      flag = 1

else:

      flag = 0

print a
复制代码

答案是1952
作者: donghao_ruby 时间: 2007-08-12 18:25
我觉得你们都好牛哦，我什么都不会，好难过，现在自学C，因为上学期没有好好听老师讲课
作者: yacare 时间: 2007-08-13 14:01

原帖由 langue 于 2006-12-5 05:56 发表
不如说是智商测试题。

是啊，好像和算法或者coding没啥关系
作者: yuangong 时间: 2007-08-13 14:14
我贴我写的.

#include <stdio.h>

typedef struct test {

      struct  test* next;

      struct  test* prev;

      int          value;

}test;

fun()

{

      test*          list;

      test*          node;

      test*          p;

      test*          q;

      list = (test*)malloc(sizeof(struct test));

      list->value = 1;

      list->next = NULL;

      list->prev = NULL;

      int i = 2;

      for(i; i <= 2000; i++) {

            node = (test*)malloc(sizeof(struct test));

            node->value = i;

            if(list->next == NULL) {

                     list ->next = node;

                     list ->prev = node;

                     node->next = list;

                     node->prev = list;

            }

            else {

                     node->prev = list->prev;

                     node->next = list;

                     list->prev->next = node;

                     list->prev = node;

            }

      }

      p = list;

      while(p ->next != p) {

            q = p;

            p ->prev->next = p ->next;

            p->next->prev = p ->prev;

            p = p->next->next;

            free(q);

      }

      printf("the value:%d\n", p->value);

}

int main()

{

      fun();

      return 0;

}

复制代码

答案为 the value:1952

[ 本帖最后由 yuangong 于 2007-8-13 14:18 编辑 ]
作者: sjh_311 时间: 2007-08-13 14:50

原帖由 langue 于 2006-12-8 19:56 发表

我怎么觉得这就像转换二进制时候用的短除法呀，呵呵

这个方法我喜欢。
作者: tyzqqq 时间: 2011-01-21 23:29
very good
作者: amarant 时间: 2011-01-22 08:08
口算 (*^__^*) 嘻嘻
作者: empty141 时间: 2011-01-22 10:44

(2000循环左移1)-1=1952

2000: 11111010000
2000循环左移1:11110100001
2000循环左移1-1:11110100000= ...
crspo 发表于 2006-12-07 12:02

  看到题感觉应该可以用位运算，但是想了半天也每个头绪。。。
作者: 0o天道酬勤o0 时间: 2011-01-22 11:53
2000
作者: rain_fish 时间: 2011-01-22 19:51
记得数据结构中学过吧
作者: mpstat 时间: 2011-01-27 14:00
我也来凑个热闹~~~
#include <stdio.h>

#define CNT 2000

int loop(bool& islastGet, int arr[])

{

printf("\n");

int revertCnt=0;

int j;

if(islastGet)

      j=0;

else

      j=-1;

for(int i=0; i<CNT; ++i)

{

      if(arr[i]==0)

         continue;

      else

         ++j;

      if(j%2==0)

      {

         arr[i]=0;

         ++revertCnt;

         islastGet=true;

         printf("%d ", i);

         j=0;

      }

      else

         islastGet=false;

}

printf("\n\n");

return revertCnt;

}

int main(int argc, char* argv[])

{

int arr[CNT];

for(int i=0; i<CNT; ++i)

      arr[i]=1;

bool islastGet=false;

while(loop(islastGet, arr));

return 0;

}
复制代码
[iscs@linux-sp1]:/users/iscs/rt21/src/test>$ g++ -o ss  ss.cpp
[iscs@linux-sp1]:/users/iscs/rt21/src/test>$ ./ss

0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98 100 102 104 106 108 110 112 114 116 118 120 122 124 126 128 130 132 134 136 138 140 142 144 146 148 150 152 154 156 158 160 162 164 166 168 170 172 174 176 178 180 182 184 186 188 190 192 194 196 198 200 202 204 206 208 210 212 214 216 218 220 222 224 226 228 230 232 234 236 238 240 242 244 246 248 250 252 254 256 258 260 262 264 266 268 270 272 274 276 278 280 282 284 286 288 290 292 294 296 298 300 302 304 306 308 310 312 314 316 318 320 322 324 326 328 330 332 334 336 338 340 342 344 346 348 350 352 354 356 358 360 362 364 366 368 370 372 374 376 378 380 382 384 386 388 390 392 394 396 398 400 402 404 406 408 410 412 414 416 418 420 422 424 426 428 430 432 434 436 438 440 442 444 446 448 450 452 454 456 458 460 462 464 466 468 470 472 474 476 478 480 482 484 486 488 490 492 494 496 498 500 502 504 506 508 510 512 514 516 518 520 522 524 526 528 530 532 534 536 538 540 542 544 546 548 550 552 554 556 558 560 562 564 566 568 570 572 574 576 578 580 582 584 586 588 590 592 594 596 598 600 602 604 606 608 610 612 614 616 618 620 622 624 626 628 630 632 634 636 638 640 642 644 646 648 650 652 654 656 658 660 662 664 666 668 670 672 674 676 678 680 682 684 686 688 690 692 694 696 698 700 702 704 706 708 710 712 714 716 718 720 722 724 726 728 730 732 734 736 738 740 742 744 746 748 750 752 754 756 758 760 762 764 766 768 770 772 774 776 778 780 782 784 786 788 790 792 794 796 798 800 802 804 806 808 810 812 814 816 818 820 822 824 826 828 830 832 834 836 838 840 842 844 846 848 850 852 854 856 858 860 862 864 866 868 870 872 874 876 878 880 882 884 886 888 890 892 894 896 898 900 902 904 906 908 910 912 914 916 918 920 922 924 926 928 930 932 934 936 938 940 942 944 946 948 950 952 954 956 958 960 962 964 966 968 970 972 974 976 978 980 982 984 986 988 990 992 994 996 998 1000 1002 1004 1006 1008 1010 1012 1014 1016 1018 1020 1022 1024 1026 1028 1030 1032 1034 1036 1038 1040 1042 1044 1046 1048 1050 1052 1054 1056 1058 1060 1062 1064 1066 1068 1070 1072 1074 1076 1078 1080 1082 1084 1086 1088 1090 1092 1094 1096 1098 1100 1102 1104 1106 1108 1110 1112 1114 1116 1118 1120 1122 1124 1126 1128 1130 1132 1134 1136 1138 1140 1142 1144 1146 1148 1150 1152 1154 1156 1158 1160 1162 1164 1166 1168 1170 1172 1174 1176 1178 1180 1182 1184 1186 1188 1190 1192 1194 1196 1198 1200 1202 1204 1206 1208 1210 1212 1214 1216 1218 1220 1222 1224 1226 1228 1230 1232 1234 1236 1238 1240 1242 1244 1246 1248 1250 1252 1254 1256 1258 1260 1262 1264 1266 1268 1270 1272 1274 1276 1278 1280 1282 1284 1286 1288 1290 1292 1294 1296 1298 1300 1302 1304 1306 1308 1310 1312 1314 1316 1318 1320 1322 1324 1326 1328 1330 1332 1334 1336 1338 1340 1342 1344 1346 1348 1350 1352 1354 1356 1358 1360 1362 1364 1366 1368 1370 1372 1374 1376 1378 1380 1382 1384 1386 1388 1390 1392 1394 1396 1398 1400 1402 1404 1406 1408 1410 1412 1414 1416 1418 1420 1422 1424 1426 1428 1430 1432 1434 1436 1438 1440 1442 1444 1446 1448 1450 1452 1454 1456 1458 1460 1462 1464 1466 1468 1470 1472 1474 1476 1478 1480 1482 1484 1486 1488 1490 1492 1494 1496 1498 1500 1502 1504 1506 1508 1510 1512 1514 1516 1518 1520 1522 1524 1526 1528 1530 1532 1534 1536 1538 1540 1542 1544 1546 1548 1550 1552 1554 1556 1558 1560 1562 1564 1566 1568 1570 1572 1574 1576 1578 1580 1582 1584 1586 1588 1590 1592 1594 1596 1598 1600 1602 1604 1606 1608 1610 1612 1614 1616 1618 1620 1622 1624 1626 1628 1630 1632 1634 1636 1638 1640 1642 1644 1646 1648 1650 1652 1654 1656 1658 1660 1662 1664 1666 1668 1670 1672 1674 1676 1678 1680 1682 1684 1686 1688 1690 1692 1694 1696 1698 1700 1702 1704 1706 1708 1710 1712 1714 1716 1718 1720 1722 1724 1726 1728 1730 1732 1734 1736 1738 1740 1742 1744 1746 1748 1750 1752 1754 1756 1758 1760 1762 1764 1766 1768 1770 1772 1774 1776 1778 1780 1782 1784 1786 1788 1790 1792 1794 1796 1798 1800 1802 1804 1806 1808 1810 1812 1814 1816 1818 1820 1822 1824 1826 1828 1830 1832 1834 1836 1838 1840 1842 1844 1846 1848 1850 1852 1854 1856 1858 1860 1862 1864 1866 1868 1870 1872 1874 1876 1878 1880 1882 1884 1886 1888 1890 1892 1894 1896 1898 1900 1902 1904 1906 1908 1910 1912 1914 1916 1918 1920 1922 1924 1926 1928 1930 1932 1934 1936 1938 1940 1942 1944 1946 1948 1950 1952 1954 1956 1958 1960 1962 1964 1966 1968 1970 1972 1974 1976 1978 1980 1982 1984 1986 1988 1990 1992 1994 1996 1998

1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61 65 69 73 77 81 85 89 93 97 101 105 109 113 117 121 125 129 133 137 141 145 149 153 157 161 165 169 173 177 181 185 189 193 197 201 205 209 213 217 221 225 229 233 237 241 245 249 253 257 261 265 269 273 277 281 285 289 293 297 301 305 309 313 317 321 325 329 333 337 341 345 349 353 357 361 365 369 373 377 381 385 389 393 397 401 405 409 413 417 421 425 429 433 437 441 445 449 453 457 461 465 469 473 477 481 485 489 493 497 501 505 509 513 517 521 525 529 533 537 541 545 549 553 557 561 565 569 573 577 581 585 589 593 597 601 605 609 613 617 621 625 629 633 637 641 645 649 653 657 661 665 669 673 677 681 685 689 693 697 701 705 709 713 717 721 725 729 733 737 741 745 749 753 757 761 765 769 773 777 781 785 789 793 797 801 805 809 813 817 821 825 829 833 837 841 845 849 853 857 861 865 869 873 877 881 885 889 893 897 901 905 909 913 917 921 925 929 933 937 941 945 949 953 957 961 965 969 973 977 981 985 989 993 997 1001 1005 1009 1013 1017 1021 1025 1029 1033 1037 1041 1045 1049 1053 1057 1061 1065 1069 1073 1077 1081 1085 1089 1093 1097 1101 1105 1109 1113 1117 1121 1125 1129 1133 1137 1141 1145 1149 1153 1157 1161 1165 1169 1173 1177 1181 1185 1189 1193 1197 1201 1205 1209 1213 1217 1221 1225 1229 1233 1237 1241 1245 1249 1253 1257 1261 1265 1269 1273 1277 1281 1285 1289 1293 1297 1301 1305 1309 1313 1317 1321 1325 1329 1333 1337 1341 1345 1349 1353 1357 1361 1365 1369 1373 1377 1381 1385 1389 1393 1397 1401 1405 1409 1413 1417 1421 1425 1429 1433 1437 1441 1445 1449 1453 1457 1461 1465 1469 1473 1477 1481 1485 1489 1493 1497 1501 1505 1509 1513 1517 1521 1525 1529 1533 1537 1541 1545 1549 1553 1557 1561 1565 1569 1573 1577 1581 1585 1589 1593 1597 1601 1605 1609 1613 1617 1621 1625 1629 1633 1637 1641 1645 1649 1653 1657 1661 1665 1669 1673 1677 1681 1685 1689 1693 1697 1701 1705 1709 1713 1717 1721 1725 1729 1733 1737 1741 1745 1749 1753 1757 1761 1765 1769 1773 1777 1781 1785 1789 1793 1797 1801 1805 1809 1813 1817 1821 1825 1829 1833 1837 1841 1845 1849 1853 1857 1861 1865 1869 1873 1877 1881 1885 1889 1893 1897 1901 1905 1909 1913 1917 1921 1925 1929 1933 1937 1941 1945 1949 1953 1957 1961 1965 1969 1973 1977 1981 1985 1989 1993 1997

3 11 19 27 35 43 51 59 67 75 83 91 99 107 115 123 131 139 147 155 163 171 179 187 195 203 211 219 227 235 243 251 259 267 275 283 291 299 307 315 323 331 339 347 355 363 371 379 387 395 403 411 419 427 435 443 451 459 467 475 483 491 499 507 515 523 531 539 547 555 563 571 579 587 595 603 611 619 627 635 643 651 659 667 675 683 691 699 707 715 723 731 739 747 755 763 771 779 787 795 803 811 819 827 835 843 851 859 867 875 883 891 899 907 915 923 931 939 947 955 963 971 979 987 995 1003 1011 1019 1027 1035 1043 1051 1059 1067 1075 1083 1091 1099 1107 1115 1123 1131 1139 1147 1155 1163 1171 1179 1187 1195 1203 1211 1219 1227 1235 1243 1251 1259 1267 1275 1283 1291 1299 1307 1315 1323 1331 1339 1347 1355 1363 1371 1379 1387 1395 1403 1411 1419 1427 1435 1443 1451 1459 1467 1475 1483 1491 1499 1507 1515 1523 1531 1539 1547 1555 1563 1571 1579 1587 1595 1603 1611 1619 1627 1635 1643 1651 1659 1667 1675 1683 1691 1699 1707 1715 1723 1731 1739 1747 1755 1763 1771 1779 1787 1795 1803 1811 1819 1827 1835 1843 1851 1859 1867 1875 1883 1891 1899 1907 1915 1923 1931 1939 1947 1955 1963 1971 1979 1987 1995

7 23 39 55 71 87 103 119 135 151 167 183 199 215 231 247 263 279 295 311 327 343 359 375 391 407 423 439 455 471 487 503 519 535 551 567 583 599 615 631 647 663 679 695 711 727 743 759 775 791 807 823 839 855 871 887 903 919 935 951 967 983 999 1015 1031 1047 1063 1079 1095 1111 1127 1143 1159 1175 1191 1207 1223 1239 1255 1271 1287 1303 1319 1335 1351 1367 1383 1399 1415 1431 1447 1463 1479 1495 1511 1527 1543 1559 1575 1591 1607 1623 1639 1655 1671 1687 1703 1719 1735 1751 1767 1783 1799 1815 1831 1847 1863 1879 1895 1911 1927 1943 1959 1975 1991

15 47 79 111 143 175 207 239 271 303 335 367 399 431 463 495 527 559 591 623 655 687 719 751 783 815 847 879 911 943 975 1007 1039 1071 1103 1135 1167 1199 1231 1263 1295 1327 1359 1391 1423 1455 1487 1519 1551 1583 1615 1647 1679 1711 1743 1775 1807 1839 1871 1903 1935 1967 1999

63 127 191 255 319 383 447 511 575 639 703 767 831 895 959 1023 1087 1151 1215 1279 1343 1407 1471 1535 1599 1663 1727 1791 1855 1919 1983

95 223 351 479 607 735 863 991 1119 1247 1375 1503 1631 1759 1887

31 287 543 799 1055 1311 1567 1823

159 671 1183 1695

415 1439

927

1951
作者: johntsu 时间: 2011-01-29 11:53
呵呵，约瑟夫问题的一个变种

欢迎光临 Chinaunix (http://bbs.chinaunix.net/) Powered by Discuz! X3.2