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

fc5igm · 发表于 2021-7-12 20:53:43

    if jg1==1:
        if jg2==1:
            if jg3==1:
                if jg4==1:
                else:
            else:
                if jg4==1:
                else:
        else:
            if jg3==1:
                if jg4==1:
                else:
            else:
                if jg4==1:
                else:

    else:
        if jg2==1:
            if jg3==1:
                if jg4==1:
                else:
            else:
                if jg4==1:
                else:
        else:
            if jg3==1:
                if jg4==1:
                else:
            else:
                if jg4==1:
                else:

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

求问以上应该怎么完成？

最佳答案

月排行榜 / 总排行榜

12Tall

2021-7-12 20:53:44

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

#include <stdio.h>
typedef struct {
  unsigned int jg0 : 1;
  unsigned int jg1 : 1;
  unsigned int jg2 : 1;
  unsigned int jg3 : 1;
  unsigned int jg4 : 1;
  unsigned int jg5 : 1;
  unsigned int jg6 : 1;
  unsigned int jg7 : 1;
} BIT;

int main() {
  BIT bit;
  bit.jg0 = 0;
  bit.jg1 = 1;
  bit.jg2 = 1;
  bit.jg3 = 1;
  void * pbit = &bit;
  printf("%d\n", (~(*(char*)pbit)+1)&(0xff>>4));

// j3j2j1j0, 得到结果
// 1 1 1 1, 1
// 1 1 1 0, 2
// 1 1 0 1, 3
// 1 1 0 0, 4
// ... 以此类推
}

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

跳转到最佳答案楼层

12Tall · 发表于 2021-7-12 20:53:44

这个最佳答案由 12Tall 给出，感谢 12Tall 的回答。

单击隐藏图章

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

#include <stdio.h>
typedef struct {
  unsigned int jg0 : 1;
  unsigned int jg1 : 1;
  unsigned int jg2 : 1;
  unsigned int jg3 : 1;
  unsigned int jg4 : 1;
  unsigned int jg5 : 1;
  unsigned int jg6 : 1;
  unsigned int jg7 : 1;
} BIT;

int main() {
  BIT bit;
  bit.jg0 = 0;
  bit.jg1 = 1;
  bit.jg2 = 1;
  bit.jg3 = 1;
  void * pbit = &bit;
  printf("%d\n", (~(*(char*)pbit)+1)&(0xff>>4));

// j3j2j1j0, 得到结果
// 1 1 1 1, 1
// 1 1 1 0, 2
// 1 1 0 1, 3
// 1 1 0 0, 4
// ... 以此类推
}

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

不能懒 · 发表于 2021-7-12 21:01:30

类似递归吗？

fc5igm · 发表于 2021-7-12 21:50:58

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

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

fc5igm · 发表于 2021-7-12 22:10:00

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

fc5igm · 发表于 2021-7-12 22:37:40

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

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

qq1151985918 · 发表于 2021-7-12 22:53:45

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

12Tall · 发表于 2021-7-13 14:01:56

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

def fun(arr):
    res = 0
    for idx, val in enumerate(arr):
        if(val == 1):
            res = res + (1 << idx)
    return 2**len(arr)-res
'''
    输入     输出 刚好等于2^4-输入的值
j3 j2 j1 j0, res
1  1  1  1,  1  = 2^4-15
1  1  1  0,  2  = 2^4-14
1  1  0  1,  3  = 2^4-13
1  1  0  0,  4  = 2^4-12
'''

jg=[0,1,1]  # 注意数组元素左边为低右边为高
print(fun(jg))

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

fc5igm · 发表于 2021-7-14 22:03:57

本帖最后由 fc5igm 于 2021-7-14 22:05 编辑

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

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

class Timer():
    def __init__(self):
        self.n=1
    def __add__(self, other):
        self.n=self.n+other
        return self.n-1

timer=Timer()


# def jg(n):
#     tab='\t'
#     if n!=4:
#         print(tab*(n),f'if jg{n}==1:',sep='')
#         jg(n+1)
#         print(tab*(n),'else:',sep='')
#         jg(n+1)
#     else:
#         return print(tab*(n),f'return {timer+1}',sep='')
# print('if jg0==1:')
# jg(1)

def jg(n):
    tab='\t'
    if n!=21 and n!=13:                 #最后一个jg编号是n-1
        f.write(f'{tab*(n+1 if n<13 else n)}if jg{n}==1:\n')
        jg(n+1)
        f.write(f'{tab*(n+1 if n<13 else n)}elif jg{n}==0:\n')
        jg(n+1)
    elif n==13:
        jg(n+1)
    else:
        f.write(f'{tab*(n+1 if n <13 else n)}return "{timer+1:06}"\n')
with open('jg_grammer.py','a') as f:
    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')
    f.write('\tif jg0==1:\n')
f=open('jg_grammer.py','a')
jg(1)

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

def verify(jg0,jg1,jg2,jg3,jg4,jg5,jg6,jg7,jg8,jg9,jg10,jg11,jg12,jg14,jg15,jg16,jg17,jg18,jg19,jg20):
        if jg0==1:
                if jg1==1:
                        if jg2==1:
                                if jg3==1:
                                        if jg4==1:
                                                if jg5==1:
                                                        if jg6==1:
                                                                if jg7==1:
                                                                        if jg8==1:
                                                                                if jg9==1:
                                                                                        if jg10==1:
                                                                                                if jg11==1:
                                                                                                        if jg12==1:
                                                                                                                if jg14==1:
                                                                                                                        if jg15==1:
                                                                                                                                if jg16==1:
                                                                                                                                        if jg17==1:
                                                                                                                                                if jg18==1:
                                                                                                                                                        if jg19==1:
                                                                                                                                                                if jg20==1:
                                                                                                                                                                        return "000001"
                                                                                                                                                                elif jg20==0:
                                                                                                                                                                        return "000002"
                                                                                                                                                        elif jg19==0:
                                                                                                                                                                if jg20==1:
                                                                                                                                                                        return "000003"
                                                                                                                                                                elif jg20==0:
                                                                                                                                                                        return "000004"
                                                                                                                                                elif jg18==0:
                                                                                                                                                        if jg19==1:
                                                                                                                                                                if jg20==1:
                                                                                                                                                                        return "000005"
                                                                                                                                                                elif jg20==0:
                                                                                                                                                                        return "000006"
                                                                                                                                                        elif jg19==0:
                                                                                                                                                                if jg20==1:
                                                                                                                                                                        return "000007"
                                                                                                                                                                elif jg20==0:
                                                                                                                                                                        return "000008"
                                                                                                                                        elif jg17==0:
                                                                                                                                                if jg18==1:
                                                                                                                                                        if jg19==1:
                                                                                                                                                                if jg20==1:
                                                                                                                                                                        return "000009"
                                                                                                                                                                elif jg20==0:
                                                                                                                                                                        return "000010"
                                                                                                                                                        elif jg19==0:
                                                                                                                                                                if jg20==1:
                                                                                                                                                                        return "000011"
                                                                                                                                                                elif jg20==0:
                                                                                                                                                                        return "000012"
                                                                                                                                                elif jg18==0:

12Tall · 发表于 2021-7-15 23:09:16

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

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

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

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

def fun(arr):
    res = 0
    for idx, val in enumerate(arr):
        if(val == 1):
            res = res + (1 << idx)
    return 2**len(arr)-res

jg=[jg0,jg1,...,jg20]  
print(fun(jg))

fc5igm · 发表于 2021-7-16 00:42:14

本帖最后由 fc5igm 于 2021-7-16 01:21 编辑

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 · 发表于 2021-7-16 00:47:13

本帖最后由 fc5igm 于 2021-7-16 00:49 编辑

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

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

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

账号		自动登录	找回密码
密码			立即注册