精华内容
下载资源
问答
  • 某宾馆使用4位数字安排房间号,数字4和9不使用,0001开始排,0330号房间是第几个房间? 举例: 1号房间号 0001 2号房间号 0002 3号房间号 0003 4号房间号 0005 5号房间号 0006 6号房间号 0007 7号房间号 ...

    某宾馆使用4位数字安排房间号,数字4和9不使用,从0001开始排,第0330号房间是第几个房间?

    举例:

    1号房间号 0001

    2号房间号 0002

    3号房间号 0003

    4号房间号 0005

    5号房间号 0006

    6号房间号 0007

    7号房间号 0008

    9号房间号 0010

    。。。

     

    我看到这个题目,真是一点儿思路也某有啊?

    各位有啥思路吗?

    我合计有效位数得话,个位只有8个,十位只有8个,百位只有4个

    所有有效房间号应该就是8*8*4=256

    所以房间0330的话,就应该是第256个房间了吧???

    请问我上面的思路有何问题?

     

    1,思路1

    我在下面写了点儿程序来验证了这个事情,大概要这么理解。算是事后诸葛亮吧。

    以1~10为一组,330的话,一共33组。

    每组8个有效数字,所以一共是33*8->264个有效数字。

    但是4和9是特殊的,它们一个有效的都没有,一共这样的数字有40,90,140,190,240,290这6组,48个数字。

    所以有效的就是264-48=216。

     

    2,思路2

    就着上面的这个8*8*4=256的思路。

    其实这个在0~100,100~200,200~300都没有问题的,但是300~400那一段,只有到330啊,没到400哦,

    所以要减少一部分。

    具体就是8*8*3+8*3=216

     

    3,思路3 这个最牛。

    看答案如下:

    因为4和9不能使用,所以可以以8进制来考虑问题。

    具体如下:※上面是房间号,下面是8进制

    这样的话,就可以把求0330号房间位于第几号简化为求8进制转化为10进制了。

    即3*8^2+3*8^1+0=3*64+24=216

     

    写点程序验证一下吧。

            Integer iM1=0; //个位求模

            Integer iM10=0;//10位求模

            for(Integer i=1;i<=330;i++){

                iM1=Math.Mod(i,10);

                iM10=Math.Mod(i/10,10);

                if(i==4 || i==9 || iM1==4 || iM1==9|| iM10==4 || iM10==9){

                    System.debug('4 or 9--'+i);

                }else{

                    System.debug('Normal--'+i);

                }

            }

     

    得到的结果是:有效房间号确实是216个。

    Normal--1
    Normal--2
    Normal--3
    4 or 9--4
    Normal--5
    Normal--6
    Normal--7
    Normal--8
    4 or 9--9
    Normal--10
    Normal--11
    Normal--12
    Normal--13
    4 or 9--14
    Normal--15
    Normal--16
    Normal--17
    Normal--18
    4 or 9--19
    Normal--20
    Normal--21
    Normal--22
    Normal--23
    4 or 9--24
    Normal--25
    Normal--26
    Normal--27
    Normal--28
    4 or 9--29
    Normal--30
    Normal--31
    Normal--32
    Normal--33
    4 or 9--34
    Normal--35
    Normal--36
    Normal--37
    Normal--38
    4 or 9--39
    4 or 9--40
    4 or 9--41
    4 or 9--42
    4 or 9--43
    4 or 9--44
    4 or 9--45
    4 or 9--46
    4 or 9--47
    4 or 9--48
    4 or 9--49
    Normal--50
    Normal--51
    Normal--52
    Normal--53
    4 or 9--54
    Normal--55
    Normal--56
    Normal--57
    Normal--58
    4 or 9--59
    Normal--60
    Normal--61
    Normal--62
    Normal--63
    4 or 9--64
    Normal--65
    Normal--66
    Normal--67
    Normal--68
    4 or 9--69
    Normal--70
    Normal--71
    Normal--72
    Normal--73
    4 or 9--74
    Normal--75
    Normal--76
    Normal--77
    Normal--78
    4 or 9--79
    Normal--80
    Normal--81
    Normal--82
    Normal--83
    4 or 9--84
    Normal--85
    Normal--86
    Normal--87
    Normal--88
    4 or 9--89
    4 or 9--90
    4 or 9--91
    4 or 9--92
    4 or 9--93
    4 or 9--94
    4 or 9--95
    4 or 9--96
    4 or 9--97
    4 or 9--98
    4 or 9--99
    Normal--100
    Normal--101
    Normal--102
    Normal--103
    4 or 9--104
    Normal--105
    Normal--106
    Normal--107
    Normal--108
    4 or 9--109
    Normal--110
    Normal--111
    Normal--112
    Normal--113
    4 or 9--114
    Normal--115
    Normal--116
    Normal--117
    Normal--118
    4 or 9--119
    Normal--120
    Normal--121
    Normal--122
    Normal--123
    4 or 9--124
    Normal--125
    Normal--126
    Normal--127
    Normal--128
    4 or 9--129
    Normal--130
    Normal--131
    Normal--132
    Normal--133
    4 or 9--134
    Normal--135
    Normal--136
    Normal--137
    Normal--138
    4 or 9--139
    4 or 9--140
    4 or 9--141
    4 or 9--142
    4 or 9--143
    4 or 9--144
    4 or 9--145
    4 or 9--146
    4 or 9--147
    4 or 9--148
    4 or 9--149
    Normal--150
    Normal--151
    Normal--152
    Normal--153
    4 or 9--154
    Normal--155
    Normal--156
    Normal--157
    Normal--158
    4 or 9--159
    Normal--160
    Normal--161
    Normal--162
    Normal--163
    4 or 9--164
    Normal--165
    Normal--166
    Normal--167
    Normal--168
    4 or 9--169
    Normal--170
    Normal--171
    Normal--172
    Normal--173
    4 or 9--174
    Normal--175
    Normal--176
    Normal--177
    Normal--178
    4 or 9--179
    Normal--180
    Normal--181
    Normal--182
    Normal--183
    4 or 9--184
    Normal--185
    Normal--186
    Normal--187
    Normal--188
    4 or 9--189
    4 or 9--190
    4 or 9--191
    4 or 9--192
    4 or 9--193
    4 or 9--194
    4 or 9--195
    4 or 9--196
    4 or 9--197
    4 or 9--198
    4 or 9--199
    Normal--200
    Normal--201
    Normal--202
    Normal--203
    4 or 9--204
    Normal--205
    Normal--206
    Normal--207
    Normal--208
    4 or 9--209
    Normal--210
    Normal--211
    Normal--212
    Normal--213
    4 or 9--214
    Normal--215
    Normal--216
    Normal--217
    Normal--218
    4 or 9--219
    Normal--220
    Normal--221
    Normal--222
    Normal--223
    4 or 9--224
    Normal--225
    Normal--226
    Normal--227
    Normal--228
    4 or 9--229
    Normal--230
    Normal--231
    Normal--232
    Normal--233
    4 or 9--234
    Normal--235
    Normal--236
    Normal--237
    Normal--238
    4 or 9--239
    4 or 9--240
    4 or 9--241
    4 or 9--242
    4 or 9--243
    4 or 9--244
    4 or 9--245
    4 or 9--246
    4 or 9--247
    4 or 9--248
    4 or 9--249
    Normal--250
    Normal--251
    Normal--252
    Normal--253
    4 or 9--254
    Normal--255
    Normal--256
    Normal--257
    Normal--258
    4 or 9--259
    Normal--260
    Normal--261
    Normal--262
    Normal--263
    4 or 9--264
    Normal--265
    Normal--266
    Normal--267
    Normal--268
    4 or 9--269
    Normal--270
    Normal--271
    Normal--272
    Normal--273
    4 or 9--274
    Normal--275
    Normal--276
    Normal--277
    Normal--278
    4 or 9--279
    Normal--280
    Normal--281
    Normal--282
    Normal--283
    4 or 9--284
    Normal--285
    Normal--286
    Normal--287
    Normal--288
    4 or 9--289
    4 or 9--290
    4 or 9--291
    4 or 9--292
    4 or 9--293
    4 or 9--294
    4 or 9--295
    4 or 9--296
    4 or 9--297
    4 or 9--298
    4 or 9--299
    Normal--300
    Normal--301
    Normal--302
    Normal--303
    4 or 9--304
    Normal--305
    Normal--306
    Normal--307
    Normal--308
    4 or 9--309
    Normal--310
    Normal--311
    Normal--312
    Normal--313
    4 or 9--314
    Normal--315
    Normal--316
    Normal--317
    Normal--318
    4 or 9--319
    Normal--320
    Normal--321
    Normal--322
    Normal--323
    4 or 9--324
    Normal--325
    Normal--326
    Normal--327
    Normal--328
    4 or 9--329
    Normal--330

     

    展开全文
  • 在顺序数组中找一个数,得到它是第几个数 用折半查找法 int arr[]={1,2,3,4,5,6,7,8,9,10,11,12}; int low=0;//最小的下标 int hight=len-1;//最大的下标=长度-1,因为下标是从0开始,长度1开始; int mid;//中间下标...

    在顺序数组中找一个数,得到它是第几个数

    用折半查找法
    int arr[]={1,2,3,4,5,6,7,8,9,10,11,12};

    int low=0;//最小的下标
    int hight=len-1;//最大的下标=长度-1,因为下标是从0开始,长度从1开始;
    int mid;//中间下标
    mid=(low+hight)/2;//中间下标等于最低加最高下标再除以2
    

    eg:
    找12这个数,起初low=0,hight=11;

    判断mid=(0+11)/5=5下标的数是不是12
    arr[mid]=arr[5]=6//不是12;
    因为12比6大,那么12这个数一定在arr[mid]的右边
    所以让low=mid+1=6;

    再判断mid=(6+12)/2=9下标的数是不是12
    arr[mid]=arr[9]=10//还不是12
    因为12比10还大,那么12这个数一定还在arr[mid]的右边
    所以再让low=mid+1=10;

    再判断mid=(10+12)/2=11下标的数是不是12
    arr[mid]=arr[11]=12//是12,那么此时的mid就是12这个数的下标

    eg:
    找4这个数起初low=0,hight=12

    判断mid=(0+11)/2=5下标的数是不是4
    arr[mid]=arr[5]=6//不是4;
    因为4比6小,那么这个数一定在arr[mid]的左边
    所以让hight=mid-1=4

    再判断mid=(0+4)/2=2下标的数是不是4
    arr[mid]=arr[2]=3//不是4
    因为4比3大,那么4这个数一定在arr[mid]的右边
    所以让low=mid+1=4;

    再判断mid=(3+4)/2=3下标的数是不是3
    arr[mid]=arr[3]=4//是4,那么此时的mid就是4这个数的下标,

    #include<stdio.h>
    int Show(int arr[],int len,int key)//len是数组的长度 len=sizeof(arr)/sizeof(arr[0]),key是准备查找的数
    {
       int low=0;//最小的下标
       int hight=len-1;//最大的下标=长度-1,因为下标是从0开始,长度从1开始;
       int mid;//中间下标
       while(low<=hight)
       {
           mid=(low+hight)/2;
           if(key==arr[mid])
           {
              return mid;
           }
           else if(key>arr[mid])
           {
              low=mid+1;
           }
           else if(key<arr[mid])
           {
              hight=mid-1;
           }
       }
       return -1;//找不到就返回-1
    }
    int main()
    {
       int arr[]={1,2,3,4,5,6,7,8,9,10,11,12};
       printf("%d\n",Show(arr,sizeof(arr)/sizeof(arr[0]),12));
       printf("%d\n",Show(arr,sizeof(arr)/sizeof(arr[0]),4));
       return 0;
    }

    在这里插入图片描述

    展开全文
  • 从第一个人开始1到3报), 凡报到3的人退出圈子,问最后留下的原来第几号的那位。 分析: 将每人编上坐标,并且给每人定下最开始的下标,等只剩下最后一人的时候,用他的坐标去找相应人的...

    有10个人围成一圈,顺序排号。从第一个人开始报数(从1到3报数),

    凡报到3的人退出圈子,问最后留下的是原来第几号的那位。

     

    分析:

    将每个人编上坐标,并且给每个人定下最开始的下标,等只剩下最后一个人的时候,用他的坐标去找相应人的编号

    下标        0 1 2 3 4 5 6 7 8 9
    编号        1 2 3 4 5 6 7 8 9 10
    第一次  1   1 2 - 1 2 - 1 2 - 1
    第二次  2   2 -   1 2   - 1   2
    第三次  3   -     1 2     -   1
    第四次  4         2 -         1
    第五次  5         2           -
     

     

     

    
    public class CallNumber {
        public static void main(String[] args) {
    
            int value = callSurvivalNumber(1);
            System.out.println(value);
        }
    
        
        public static int callSurvivalNumber(int count) {
            if (count <= 0) {
                throw new IllegalArgumentException("Count must >0");
            }
            boolean[] status = new boolean[count];
            for (int i = 0; i < status.length; i++) {
                status[i] = true;
            }
            int index = -1;
            int counter = 0; //当前退出的人数 n-1
            int current = 0; //当前人报的数
            while (counter < status.length - 1) {
                //index 成环
                index = (index + 1) % status.length;//0
                if (!status[index]) {
                    continue;
                }
                //报数
                current = (current + 1) % 3;   //1
                //退出
                if (current == 0) {
                    counter++;
                    status[index] = false;
                }
            }
            for (int i = 0; i < status.length; i++) {
                if (status[i]) {
                    return i + 1;//1-n 0-(n-1)
                }
            }
            throw new RuntimeException("Not found");
        }
    }
    

     

    展开全文
  • 问题描述 有n个人围成一圈,顺序排号(编号为1到n)。从第1个人开始(1到3报),凡报到3的人退出圈子。下一开始继续报,直到... 1 2 4 5 6 7 8 (现在4开始)  2次报之后,6退出,剩下: ...

    问题描述

    有n个人围成一圈,顺序排号(编号为1到n)。从第1个人开始报数(从1到3报数),凡报到3的人退出圈子。从下一个人开始继续报数,直到剩下最后一个人,游戏结束。
      问最后留下的是原来第几号的那位。
      举个例子,8个人围成一圈:
      1 2 3 4 5 6 7 8
      第1次报数之后,3退出,剩下:
      1 2 4 5 6 7 8 (现在从4开始报数)
      第2次报数之后,6退出,剩下:
      1 2 4 5 7 8 (现在从7开始报数)
      第3次报数之后,1退出,剩下:
      2 4 5 7 8 (现在从2开始报数)
      第4次报数之后,5退出,剩下:
      2 4 7 8 (现在从7开始报数)
      第5次报数之后,2退出,剩下:
      4 7 8 (现在从4开始报数)
      第6次报数之后,8退出,剩下:
      4 7 (现在从4开始报数)
      最后一次报数之后,4退出,剩下:
      7.
      所以,最后留下来的人编号是7。
    输入格式
      一个正整数n,(1<n<10000)
    输出格式
      一个正整数,最后留下来的那个人的编号。
    例子

    样例输入
    8
    样例输出
    7

    跟前几天写那个狡猾的老鼠那道题99%一样,代码放上了,就是巧妙的模拟就是了。

    #include <stdio.h>
    #define m 3
    int main ()
    {
    	int n,n1,step,i;
    	scanf("%d",&n);
    	int a[n];
    	for(i=0;i<n;i++)
    		a[i]=0;
    	n1=n;
    	i=0;
    	while(n1>1)
    	{
    		step=m;
    		while(1)
    		{
    			i++; 
    			if(i==n)
    				i=0;
    			if(a[i]==0)
    				step--;
    			if(step==0)
    				break;
    		 } 
    		a[i]=1;
    		n1--;
    	}
    	for(i=0;i<n;i++)
    	{
    		if(a[i]==0)
    			printf("%d\n",i);
    	}
    	return 0; 
    }
    

    在其他博主那看到另一种表达,也很不错呢:
    他的思路:定义一维数组, 数组下标表示人的编号, 值表示是否出局(1为出局), 先将数组元素全部初始化为0, 然后定义两个整型变量 num 表示人的编号和 count 其所报的数(i 在0~2循环, 0即表示报数为3,则出局),再定义一个整型变量left记录剩余人数, 剩余1人时退出循环。此人为胜者并输出其编号。

    #include <stdio.h>
    
    int main(){
        int a[10000] = {0};
        int sum;  //总人数 
        int num, count, left;
        scanf("%d", &sum);
        left = sum;
        for(num=0,count=1; ; num=(num+1)%sum){
            if(a[num] == 1)  //若此人出局则继续找下一位未出局的人 
                continue;
            if(count==0){   //若此人报数为 0 则此人出局 
                a[num] = 1;
                left--;
                if(left == 1)
                    break;
            }
            count=(count+1)%3;
        }
        for(num=0; num < sum; num++)  //在数组中找到唯一未出局的人 
            if(a[num]==0)break;
        printf("%d", num+1);
        return 0;
    }
    
    展开全文
  • #include&lt;stdio.h&gt; 2 ... 6 int a[100]; 7 int i,p=0,q,n; 8 printf("n="); 9 scanf("%d",&amp;n); 10 q=n; 11 for(i=0;i&lt;n;i++) 12 a...
  • 附加: while 循环跑的过程k = 1 [1,2,3,4,5,6,7,8,9,10] num[0] = 1 k +=1 i += 1 ==> k = 1 i = 1 m = 0k = 2 [1,2,3,4,5,6,7,8,9,10] num[1] = 2 k +=1 i += 1 ==> k = 2 i ...
  • 二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。 三行包含一个整数a,为待查找的数。 输出格式 如果a在数列中出现了,输出它一次出现的位置(位置1开始编号),否则输出-1。 样例输入 6 1 ...
  • 二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。 三行包含一个整数a,为待查找的数。 输出格式 如果a在数列中出现了,输出它一次出现的位置(位置1开始编号),否则输出-1。 样例输入 6 1 ...
  • 二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。 三行包含一个整数a,为待查找的数。 输出格式 如果a在数列中出现了,输出它一次出现的位置(位置1开始编号),否则输出-1。 样例输入 6 1 ...
  • 二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。 三行包含一个整数a,为待查找的数。 输出格式 如果a在数列中出现了,输出它一次出现的位置(位置1开始编号),否则输出-1。 样例输入 6 1 ...
  • 二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。 三行包含一个整数a,为待查找的数。 输出格式 如果a在数列中出现了,输出它一次出现的位置(位置1开始编号),否则输出-1。 样例输入 6 1 ...
  • 二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。 三行包含一个整数a,为待查找的数。 输出格式 如果a在数列中出现了,输出它一次出现的位置(位置1开始编号),否则输出-1。 样例输入 6 1 ...
  • 二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。 三行包含一个整数a,为待查找的数。 输出格式 如果a在数列中出现了,输出它一次出现的位置(位置1开始编号),否则输出-1。 样例输入 6 1 ...
  • 之查找

    2020-11-28 19:28:53
    输入10个互不相等的不大于5位的正整数,编程输出这10个数中大于并最接近平均值的数,以及该数是第几个输入的数(1开始计数),两个数都使用%6d格式输出。 例如输入: 50 60 70 80 90 95 85 75 65 55 大于并最接近...
  • 蓝桥杯——数字筛选

    2017-01-08 15:11:00
    问题描述 有n个人围成一圈,顺序排号(编号为1到n)。... 举例子,8个人围成一圈: 1 2 3 4 5 6 7 8 1次报之后,3退出,剩下: 1 2 4 5 6 7 8 (现在4开始) 2次报之后,6退出,剩下: 1 2 ...
  • 剑指offer——丑

    2019-11-23 23:04:12
    题目:我们把只包含因子2,3,5的数称作丑数(Ugly Number)。求从小到大顺序的1500个丑数。例如6,8都是丑数,但14不是,因为它...如果一个数是丑数,那么它被2,3,5中的一个或者个肯定能够除尽。 代码1: ...
  • 靠谱的数字

    2021-03-01 20:04:58
    数字1开始,遇到数字7就会跳过,比如6后边直接是8,69后边直接80,现在给你个数字,问是第几位?(代码见文末) 比如输入8,输出7,就是7个数8 7 用时:0天0小时0分钟0秒1毫秒 88 70 用时:0天0小时0分钟...
  • 可以记录下递推过程中遇到的每一个数。例如对 n=3 进行验证的时候,我们需要计算 3、5、8、4、2、1,则当我们对 n=5、8、4、2 进行验证的时候,就可以直接判定卡拉兹猜想的真伪,...
  • 解题思路:我一个想法先将前面个丑数加进去然后7开始遍历,每一个数都判断它是不是丑数,如果就将它加进容器然后判断容器的大小是不是等于N。但是判断一个数是不是丑数非常的麻烦,注意题目的意思只包含...
  • 【蓝桥杯】查找

    2020-02-14 11:16:55
    二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。 三行包含一个整数a,为待查找的数。 输出格式 如果a在数列中出现了,输出它一次出现的位置(位置1开始编号),否则输出-1。 样例输入 6 1 ...
  • n人围成一圈报问题

    千次阅读 多人点赞 2016-11-21 17:03:03
    思路:假如是8人,则需要一数组将8个人的1到8依次记下每人位数,还需要一模拟报口令的变量该变量最初为0,1到2在到3,当该变量为3时,此时对应编号的人就要退出 那么一次报,3号退出,6号退出,有一...
  • 围圈报

    2013-01-08 01:09:00
    4 从第一个人开始1报到m(m<=9)),凡报到m的人退出圈子, 5 问最后留下的原来第几号的那位? 6 解题思路: 7 1、定义一长度为100数组a,初始化为0; 8 2、接收键盘输入值n,m,数组a的前n-1...
  • 题目:爬楼梯,每次可以爬1个或着2个台阶或者更多个台阶,共有种爬法。...观察上表不难发现,从第三个台阶开始,当前的台阶数等于前两个数之和。这也就是斐波那契数列,得到这些信息后,编程就很容易了。 public
  • 二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。 三行包含一个整数a,为待查找的数。 输出格式 如果a在数列中出现了,输出它一次出现的位置(位置1开始编号),否则输出-1。 样例输入 6 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 918
精华内容 367
关键字:

从8开始数第6个数是几