[已解决]求问这个应该怎么写？

fc5igm

1.     if jg1==1:
   
2.         if jg2==1:
   
3.             if jg3==1:
   
4.                 if jg4==1:
   
5.                 else:
   
6.             else:
   
7.                 if jg4==1:
   
8.                 else:
   
9.         else:
   
10.             if jg3==1:
    
11.                 if jg4==1:
    
12.                 else:
    
13.             else:
    
14.                 if jg4==1:
    
15.                 else:
    
16. 
    
17.     else:
    
18.         if jg2==1:
    
19.             if jg3==1:
    
20.                 if jg4==1:
    
21.                 else:
    
22.             else:
    
23.                 if jg4==1:
    
24.                 else:
    
25.         else:
    
26.             if jg3==1:
    
27.                 if jg4==1:
    
28.                 else:
    
29.             else:
    
30.                 if jg4==1:
    
31.                 else:

复制代码

仿照如上例子写一个语句生成器，范围是从jg1到jg20。
在最后一环的判断内，写下return语句。程序中的第一个return写return 1，第二个return写return 2，第三个return写return 3...以此类推

求问以上应该怎么完成？

最佳答案

月排行榜 / 总排行榜

12Tall

2021-7-12 20:53:44

请问你是想要这个效果吗?  

1. #include <stdio.h>
   
2. typedef struct {
   
3.   unsigned int jg0 : 1;
   
4.   unsigned int jg1 : 1;
   
5.   unsigned int jg2 : 1;
   
6.   unsigned int jg3 : 1;
   
7.   unsigned int jg4 : 1;
   
8.   unsigned int jg5 : 1;
   
9.   unsigned int jg6 : 1;
   
10.   unsigned int jg7 : 1;
    
11. } BIT;
    
12. 
    
13. int main() {
    
14.   BIT bit;
    
15.   bit.jg0 = 0;
    
16.   bit.jg1 = 1;
    
17.   bit.jg2 = 1;
    
18.   bit.jg3 = 1;
    
19.   void * pbit = &bit;
    
20.   printf("%d\n", (~(*(char*)pbit)+1)&(0xff>>4));
    
21. 
    
22. // j3j2j1j0, 得到结果
    
23. // 1 1 1 1, 1
    
24. // 1 1 1 0, 2
    
25. // 1 1 0 1, 3
    
26. // 1 1 0 0, 4
    
27. // ... 以此类推
    
28. }

复制代码

上面采用的是C 语言中位域与二进制的运算特性实现的，常见于与硬件打交道的代码。占用的内存只需要四个字节、一个32位整型。大量的if...else...操作还可以用状态机实现。或者用哈希表也是一种比较现实的做法。

跳转到最佳答案楼层

12Tall

请问你是想要这个效果吗?  

1. #include <stdio.h>
   
2. typedef struct {
   
3.   unsigned int jg0 : 1;
   
4.   unsigned int jg1 : 1;
   
5.   unsigned int jg2 : 1;
   
6.   unsigned int jg3 : 1;
   
7.   unsigned int jg4 : 1;
   
8.   unsigned int jg5 : 1;
   
9.   unsigned int jg6 : 1;
   
10.   unsigned int jg7 : 1;
    
11. } BIT;
    
12. 
    
13. int main() {
    
14.   BIT bit;
    
15.   bit.jg0 = 0;
    
16.   bit.jg1 = 1;
    
17.   bit.jg2 = 1;
    
18.   bit.jg3 = 1;
    
19.   void * pbit = &bit;
    
20.   printf("%d\n", (~(*(char*)pbit)+1)&(0xff>>4));
    
21. 
    
22. // j3j2j1j0, 得到结果
    
23. // 1 1 1 1, 1
    
24. // 1 1 1 0, 2
    
25. // 1 1 0 1, 3
    
26. // 1 1 0 0, 4
    
27. // ... 以此类推
    
28. }

复制代码

上面采用的是C 语言中位域与二进制的运算特性实现的，常见于与硬件打交道的代码。占用的内存只需要四个字节、一个32位整型。大量的if...else...操作还可以用状态机实现。或者用哈希表也是一种比较现实的做法。

不能懒

类似递归吗？

fc5igm

12Tall 发表于 2021-7-12 21:35
请问你是想要这个效果吗?  

抱歉。。不会c语言。。
你可以给下效果图么？

fc5igm

感谢大家的帮助，问题已经解决。除以上回答者，后面不再采纳新的回复了

fc5igm

12Tall 发表于 2021-7-12 21:35
请问你是想要这个效果吗?  

我的确是想要这种类似的效果，不过很可惜我不会c语言，另外这是用来做判别式的

qq1151985918

你可以用元组或列表当时判断。

12Tall

fc5igm 发表于 2021-7-12 22:37
我的确是想要这种类似的效果，不过很可惜我不会c语言，另外这是用来做判别式的

1. def fun(arr):
   
2.     res = 0
   
3.     for idx, val in enumerate(arr):
   
4.         if(val == 1):
   
5.             res = res + (1 << idx)
   
6.     return 2**len(arr)-res
   
7. '''
   
8.     输入     输出 刚好等于2^4-输入的值
   
9. j3 j2 j1 j0, res
   
10. 1  1  1  1,  1  = 2^4-15
    
11. 1  1  1  0,  2  = 2^4-14
    
12. 1  1  0  1,  3  = 2^4-13
    
13. 1  1  0  0,  4  = 2^4-12
    
14. '''
    
15. 
    
16. jg=[0,1,1]  # 注意数组元素左边为低右边为高
    
17. print(fun(jg))

复制代码

我的这种做法一般来说可移植性不强，只针对于特定场合。上面是经过调整后的Python 代码，算是投机取巧了吧。

fc5igm

12Tall 发表于 2021-7-13 14:01
我的这种做法一般来说可移植性不强，只针对于特定场合。上面是经过调整后的Python 代码，算是投机取 ...

嗯。。貌似不是我想要的样子，不过还是选你吧。
这是我后来搞得代码

1. 
   
2. class Timer():
   
3.     def __init__(self):
   
4.         self.n=1
   
5.     def __add__(self, other):
   
6.         self.n=self.n+other
   
7.         return self.n-1
   
8. 
   
9. timer=Timer()
   
10. 
    
11. 
    
12. # def jg(n):
    
13. #     tab='\t'
    
14. #     if n!=4:
    
15. #         print(tab*(n),f'if jg{n}==1:',sep='')
    
16. #         jg(n+1)
    
17. #         print(tab*(n),'else:',sep='')
    
18. #         jg(n+1)
    
19. #     else:
    
20. #         return print(tab*(n),f'return {timer+1}',sep='')
    
21. # print('if jg0==1:')
    
22. # jg(1)
    
23. 
    
24. def jg(n):
    
25.     tab='\t'
    
26.     if n!=21 and n!=13:                 #最后一个jg编号是n-1
    
27.         f.write(f'{tab*(n+1 if n<13 else n)}if jg{n}==1:\n')
    
28.         jg(n+1)
    
29.         f.write(f'{tab*(n+1 if n<13 else n)}elif jg{n}==0:\n')
    
30.         jg(n+1)
    
31.     elif n==13:
    
32.         jg(n+1)
    
33.     else:
    
34.         f.write(f'{tab*(n+1 if n <13 else n)}return "{timer+1:06}"\n')
    
35. with open('jg_grammer.py','a') as f:
    
36.     f.write('def verify(jg0,jg1,jg2,jg3,jg4,jg5,jg6,jg7,jg8,jg9,jg10,jg11,jg12,jg14,jg15,jg16,jg17,jg18,jg19,jg20):\n')
    
37.     f.write('\tif jg0==1:\n')
    
38. f=open('jg_grammer.py','a')
    
39. jg(1)

复制代码

被注释的部分就是print，不过因为是要做个筛选条件的判断模块出来，所以后边又改了下，改成了写成文件的样子。
通过代码生成的文件节选

1. def verify(jg0,jg1,jg2,jg3,jg4,jg5,jg6,jg7,jg8,jg9,jg10,jg11,jg12,jg14,jg15,jg16,jg17,jg18,jg19,jg20):
   
2.         if jg0==1:
   
3.                 if jg1==1:
   
4.                         if jg2==1:
   
5.                                 if jg3==1:
   
6.                                         if jg4==1:
   
7.                                                 if jg5==1:
   
8.                                                         if jg6==1:
   
9.                                                                 if jg7==1:
   
10.                                                                         if jg8==1:
    
11.                                                                                 if jg9==1:
    
12.                                                                                         if jg10==1:
    
13.                                                                                                 if jg11==1:
    
14.                                                                                                         if jg12==1:
    
15.                                                                                                                 if jg14==1:
    
16.                                                                                                                         if jg15==1:
    
17.                                                                                                                                 if jg16==1:
    
18.                                                                                                                                         if jg17==1:
    
19.                                                                                                                                                 if jg18==1:
    
20.                                                                                                                                                         if jg19==1:
    
21.                                                                                                                                                                 if jg20==1:
    
22.                                                                                                                                                                         return "000001"
    
23.                                                                                                                                                                 elif jg20==0:
    
24.                                                                                                                                                                         return "000002"
    
25.                                                                                                                                                         elif jg19==0:
    
26.                                                                                                                                                                 if jg20==1:
    
27.                                                                                                                                                                         return "000003"
    
28.                                                                                                                                                                 elif jg20==0:
    
29.                                                                                                                                                                         return "000004"
    
30.                                                                                                                                                 elif jg18==0:
    
31.                                                                                                                                                         if jg19==1:
    
32.                                                                                                                                                                 if jg20==1:
    
33.                                                                                                                                                                         return "000005"
    
34.                                                                                                                                                                 elif jg20==0:
    
35.                                                                                                                                                                         return "000006"
    
36.                                                                                                                                                         elif jg19==0:
    
37.                                                                                                                                                                 if jg20==1:
    
38.                                                                                                                                                                         return "000007"
    
39.                                                                                                                                                                 elif jg20==0:
    
40.                                                                                                                                                                         return "000008"
    
41.                                                                                                                                         elif jg17==0:
    
42.                                                                                                                                                 if jg18==1:
    
43.                                                                                                                                                         if jg19==1:
    
44.                                                                                                                                                                 if jg20==1:
    
45.                                                                                                                                                                         return "000009"
    
46.                                                                                                                                                                 elif jg20==0:
    
47.                                                                                                                                                                         return "000010"
    
48.                                                                                                                                                         elif jg19==0:
    
49.                                                                                                                                                                 if jg20==1:
    
50.                                                                                                                                                                         return "000011"
    
51.                                                                                                                                                                 elif jg20==0:
    
52.                                                                                                                                                                         return "000012"
    
53.                                                                                                                                                 elif jg18==0:

复制代码

12Tall

fc5igm 发表于 2021-7-14 22:03
嗯。。貌似不是我想要的样子，不过还是选你吧。
这是我后来搞得代码

我试了你生成的代码，首先是生成的文件很大，运行起来比较卡，然后是在运行时，发现得不到期待的结果。

1. print(verify(0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1))
   
2. # 输出None

复制代码

我建议你还是试一试我这个，看哪里和预期不一样，然后再做调整：

1. def fun(arr):
   
2.     res = 0
   
3.     for idx, val in enumerate(arr):
   
4.         if(val == 1):
   
5.             res = res + (1 << idx)
   
6.     return 2**len(arr)-res
   
7. 
   
8. jg=[jg0,jg1,...,jg20]  
   
9. print(fun(jg))

复制代码

fc5igm

12Tall 发表于 2021-7-15 23:09
我试了你生成的代码，首先是生成的文件很大，运行起来比较卡，然后是在运行时，发现得不到期待的结果。
...

首先之所以输出为None是因为第一个参数是jg0的，而jg0默认只为1，不可为0
所以没有写elif jg0==0的部分，故而为None
如果你想写这部分，你把我写的最后的生成公式jg(1)改为jg(0)就好,还有把第37行代码注释掉,34行的06改成07
其次文件的确不小，不过运行慢这一点有待商榷吧。你看着文件很大，但是在加载之后实际上不过是只执行20个if语句。而不是52万个if语句。（如前边的if或elif被触发，则后续的elif与else判断都会直接跳过）。所以其实并不会卡。我这边做了单进程的多线程，50个一轮，每秒至少能跑2轮。而且每个线程实际上该判断语句是要跑3次的。所以可以看出来其实并不会卡，至少相对于python而言。

fc5igm

12Tall 发表于 2021-7-15 23:09
我试了你生成的代码，首先是生成的文件很大，运行起来比较卡，然后是在运行时，发现得不到期待的结果。
...

我这里加载的东西比较杂，不过貌似的确在文件最开始运行的时候都会等一段时间。可能是我的前置运算耽误的时间，不过也很有可能import这个判断文件也花了不少时间。不过等他加载完毕之后后面运行就很快了

我试着在console页面单独加载了一下，还是很快的，至少import没超过一秒