精华内容
下载资源
问答
  • 语法分析器之递归子程序法

    千次阅读 2016-10-25 21:58:42
    表达式语法分析——递归子程序法 递归子程序法是一种确定的自顶向下语法分析方法,要求文法是LL(1)文法。它的实现思想是对应文法中每个非终结符编写一个递归过程,每个过程的功能是识别由该非终结符推出的串,当某...

    表达式语法分析——递归子程序法

    Time Limit: 1000MS  Memory Limit: 65536KB

    Problem Description

     

    递归子程序法是一种确定的自顶向下语法分析方法,要求文法是LL(1)文法。它的实现思想是对应文法中每个非终结符编写一个递归过程,每个过程的功能是识别由该非终结符推出的串,当某非终结符的产生式有多个候选式时能够按LL(1)形式唯一地确定选择某个候选式进行推导。请根据下面的表达式LL(1)文法,构造递归子程序,完成对表达式的语法分析。

    表达式文法如下:

        ETG

        G+TG | ε

        TFS

        S*FS | ε

        F(E) | i


    对于给定的输入串(长度不超过50个符号),请输出分析过程中用到的所有产生式,并指明该输入串是否为该文法能生成的表达式,
    输出共11行,前10行每行两个数据用空格隔开,表示推导时所用产生式顺序号(从0开始),最后一行是accept,表示i+i*i是文法能生成的合法表达式。注:其中&符号代表文法中的ε符号。
    例如:

    i+i*i是文法能生成的一个表达式,输出格式如下:

    0 E-->TG

    1 T-->FS

    2 F-->i

    3 S-->&

    4 G-->+TG

    5 T-->FS

    6 F-->i

    7 S-->*FS

    8 F-->i

    9 S-->&

    10 G-->&

    accept


    i@i不是文法能生成的表达式,
    输出共5行,前5行每行两个数据用空格隔开,表示推导时所用产生式序号(从0开始),最后一行是error,表示i@i不是文法能生成的表达式。@不是合法的文法符号,输出格式举例:

    0 E-->TG

    1 T-->FS

    2 F-->i

    3 S-->&

    4 G-->&

    error

     

    (i+i*i不是文法能生成的表达式,存在括号不匹配的语法错误,输出格式举例:

    0 E-->TG

    1 T-->FS

    2 F-->(E)

    3 E-->TG

    4 T-->FS

    5 F-->i

    6 S-->&

    7 G-->+TG

    8 T-->FS

    9 F-->i

    10 S-->*FS

    11 F-->i

    12 S-->&

    13 G-->&

    error

    Input

     

    输入数据只有一行,代表待分析的符号串,以#号结束

    Output

     

    输出推导过程中所有的产生式,按照使用顺序给出。输出详细说明见题目描述中的例子。



    这道题目有点坑,就是F(E)时,只应该输出一次就可以了,但是这道题却要在识别"("时输出一次,在识别")"输出一次。

    还好重判 了。


    //因为题目要求只输入一组,所以此代码在遇到错误表达式时执行exit(0)操作,所以会退出程序
    #include<stdio.h>
    #include<stdlib.h>  //exit(0)函数头文件
    
    
    char st[60];	//输入字符串
    int h=0;	//当前处理字符
    int i=0;	//输出序列标记
    
    
    void E();
    void T();
    void G();
    void F();
    void S();
    
    
    void E()
    {
        printf("%d E-->TG\n",i++);
        T();
        G();
    }
    
    
    void T()
    {
        printf("%d T-->FS\n",i++);
        F();
        S();
    }
    
    
    void S()
    {
        if(st[h]=='*')
        {
            printf("%d S-->*FS\n",i++);
            h++;
            F();
            S();
        }
        else
        {
            printf("%d S-->&\n",i++);
        }
    }
    
    
    void G()
    {
        if(st[h]=='+')
        {
            printf("%d G-->+TG\n",i++);
            h++;
            T();
            G();
        }
        else
        {
            printf("%d G-->&\n",i++);
        }
    }
    
    
    void F()
    {
        if(st[h]=='i')
        {
            printf("%d F-->i\n",i++);
            h++;
        }
        else if(st[h]=='(')
        {
            printf("%d F-->(E)\n",i++);
            h++;
            E();
            if(st[h]==')')
            {
                //printf("%d F-->(E)\n",i++);//有疑问
                h++;
            }
            else
            {
                //printf("括号不匹配\n");
                printf("error\n");
                exit(0) ; //终止程序
            }
        }
        else
        {
            // printf("非法字符或括号不匹配\n");
            printf("error\n");
            exit(0) ; //终止程序
        }
    }
    
    
    int main()
    {
        scanf("%s",st);
        //int len=strlen(st);
    
    
        E();	//从文法开始符E开始
    
    
        // if(h<len-1)
        //   printf("非法字符\n");
        // else
        if(st[h]!='#')	//如果结束符不是'#',则表达式不正确
        {
            // printf("无终结符'#'\n");
            printf("error\n");
        }
        else printf("accept\n");
        return 0;
    }
    

    //若想多组输入,可以这样
    #include<iostream>  
    #include<cstdio>  
    #include<cstring>  
    #include<string>  
    #include<algorithm>  
    #include<map>  
    #include<stack>  
    #include<queue>  
    #include<cmath>  
      
    using namespace std;  
      
    string in;  
    int I,pos;  
    bool error,over;  
    void __S();  
    void __F();  
    void __G();  
    void __T();  
    void __E()  
    {  
    //    cout<<"___________E"<<endl;  
        if(error)  
            return;  
        printf("%d E-->TG\n",I++);  
        __T();  
        __G();  
    }  
    void __T()  
    {  
    //    cout<<"___________T"<<endl;  
        if(error)  
            return;  
        printf("%d T-->FS\n",I++);  
        __F() ;  
        __S();  
    }  
    void __G()  
    {  
    //    cout<<"___________G"<<endl;  
        if(error)  
            return;  
        if(in[pos]=='+')  
        {  
            printf("%d G-->+TG\n",I++);  
            pos++;  
            __T() ;  
            __G();  
            return;  
        }  
        printf("%d G-->&\n",I++);  
        if(in[pos]=='#')  
            over=true;  
    }  
    void __F()  
    {  
    //    cout<<"___________F"<<endl;  
        if(error)  
            return;  
        if(in[pos]=='(')  
        {  
            printf("%d F-->(E)\n",I++);  
            pos++;  
            __E();  
            if(in[pos]!=')')  
                error=true;  
            //else  
                //printf("%d F-->(E)\n",I++);  
            pos++;  
            return;  
        }  
        if(in[pos]=='i')  
        {  
            printf("%d F-->i\n",I++);  
            pos++;  
            return;  
        }  
        error=true;  
    }  
    void __S()  
    {  
    //    cout<<"___________S"<<error<<endl;  
        if(error)  
            return;  
        if(in[pos]=='*')  
        {  
            printf("%d S-->*FS\n",I++);  
            pos++;  
            __F();  
            __S();  
            return;  
        }  
        if(in[pos]=='#')  
            over=true;  
        printf("%d S-->&\n",I++);  
    }  
    int main()  
    {  
        while(cin>>in)  
        {  
            I=0;  
            error=over=false;  
            pos=0;  
            __E();  
            if(error || !over)  
                printf("error\n");  
            else  
                printf("accept\n");  
        }  
    }  
    //PS:非本人


    展开全文
  • 编译原理-递归子程序法

    千次阅读 2017-12-05 21:54:43
    0x01 题目描述递归子程序法是一种确定的自顶向下语法分析方法,要求文法是LL(1)文法。它的实现思想是对应文法中每个非终结符编写一个递归过程,每个过程的功能是识别由该非终结符推出的串,当某非终结符的产生式有多...

    0x01 题目描述

    递归子程序法是一种确定的自顶向下语法分析方法,要求文法是LL(1)文法。它的实现思想是对应文法中每个非终结符编写一个递归过程,每个过程的功能是识别由该非终结符推出的串,当某非终结符的产生式有多个候选式时能够按LL(1)形式唯一地确定选择某个候选式进行推导。请根据下面的表达式LL(1)文法,构造递归子程序,完成对表达式的语法分析。
    
    表达式文法如下:
    
        E→TG
    
        G→+TG | ε
    
        T→FS
    
        S→*FS | ε
    
        F→(E) | i
    
    
    对于给定的输入串(长度不超过50个符号),请输出分析过程中用到的所有产生式,并指明该输入串是否为该文法能生成的表达式,输出共11行,前10行每行两个数据用空格隔开,表示推导时所用产生式顺序号(从0开始),最后一行是accept,表示i+i*i是文法能生成的合法表达式。注:其中&符号代表文法中的ε符号。
    例如:
    
    i+i*i是文法能生成的一个表达式,输出格式如下:
    
    0 E-->TG
    
    1 T-->FS
    
    2 F-->i
    
    3 S-->&
    
    4 G-->+TG
    
    5 T-->FS
    
    6 F-->i
    
    7 S-->*FS
    
    8 F-->i
    
    9 S-->&
    
    10 G-->&
    
    accept
    
    
    i@i不是文法能生成的表达式,输出共5行,前5行每行两个数据用空格隔开,表示推导时所用产生式序号(从0开始),最后一行是error,表示i@i不是文法能生成的表达式。@不是合法的文法符号,输出格式举例:
    
    0 E-->TG
    
    1 T-->FS
    
    2 F-->i
    
    3 S-->&
    
    4 G-->&
    
    error
    
    
    
    (i+i*i不是文法能生成的表达式,存在括号不匹配的语法错误,输出格式举例:
    
    0 E-->TG
    
    1 T-->FS
    
    2 F-->(E)
    
    3 E-->TG
    
    4 T-->FS
    
    5 F-->i
    
    6 S-->&
    
    7 G-->+TG
    
    8 T-->FS
    
    9 F-->i
    
    10 S-->*FS
    
    11 F-->i
    
    12 S-->&
    
    13 G-->&
    
    error
    Input
    
    
    输入数据只有一行,代表待分析的符号串,以#号结束
    Output
    
    
    输出推导过程中所有的产生式,按照使用顺序给出。输出详细说明见题目描述中的例子。
    Example Input
    
    i+i*i#
    
    Example Output
    
    0 E-->TG
    1 T-->FS
    2 F-->i
    3 S-->&
    4 G-->+TG
    5 T-->FS
    6 F-->i
    7 S-->*FS
    8 F-->i
    9 S-->&
    10 G-->&
    accept
    
    

    代码

    #include<bits/stdc++.h>
    int len,cnt,x;
    char str[55];
    
    int de();
    int dg();
    int dt();
    int ds();
    int df();
    int main()
    {
        scanf("%s",str);
        len = strlen(str) - 1;
        if(de() && x == len && str[x] == '#')
        {
            printf("accept\n");
        }
        else
        {
            printf("error\n");
        }
        return 0;
    }
    int dg()
    {
        if(str[x] == '+')
        {
            printf("%d G-->+TG\n",cnt++);
            x ++;
            return dt()&&dg();
        }
        else
        {
            printf("%d G-->&\n",cnt++);
        }
        return 1;
    }
    int dt()
    {
        printf("%d T-->FS\n",cnt++);
        return df()&&ds();
    }
    int de()
    {
        printf("%d E-->TG\n",cnt++);
        return dt()&&dg();
    }
    int ds()
    {
        if(str[x] == '*')
        {
            printf("%d S-->*FS\n",cnt++);
            x ++;
            return df()&&ds();
        }
        else
        {
            printf("%d S-->&\n",cnt++);
        }
        return 1;
    }
    int df()
    {
        if(str[x] == '(')
        {
            printf("%d F-->(E)\n",cnt++);
            x ++;
            return de()&&str[x++] == ')';
        }
        else if(str[x] == 'i')
        {
            printf("%d F-->i\n",cnt++);
            x ++;
            return 1;
        }
        return 0;
    }
    
    展开全文
  • 橡皮鸭程序调试

    万次阅读 热门讨论 2009-12-01 14:12:00
    原文:http://coolshell.cn/?p=1719 (酷壳) 下面,让我来为你介绍一个程序调试大——“橡皮鸭程序调试”,这个方法在调试界是很出众的,实施起来相当方便和简易,几乎可以随时随地地实验,几乎不需要借助...

    原文:http://coolshell.cn/?p=1719 (酷壳

     

    Rubber Duck Debugging下面,让我来为你介绍一个程序调试大法——“橡皮鸭程序调试法”,这个方法在调试界是很出众的,实施起来相当方便和简易,几乎可以随时随地地实验,几乎不需要借助任何的软件和硬件的支持,你甚至可以把你的程序打印出来,在纸面上进行调试。

    那么,为什么这个方法要叫做橡皮鸭呢?因为橡皮鸭子是西方人在泡澡时最喜欢玩的一个小玩具,所以,这个东西应该家家户户都必备的。因为,这个方法由西方人发明,所以,就被取名为“橡皮鸭”了。

    好了,话不多说,下面是整个调试方法的流程。

    1. 找一个橡皮鸭子。你可以去借,去偷,去抢,去买,自己制作……反正你要搞到一个橡皮鸭子。
    2. 把这个橡皮鸭子放在你跟前。标准做法是放在你的桌子上,电脑显示器边,或是键盘边,反正是你的跟前,面朝你。
    3. 然后,打开你的源代码。不管是电脑里的还是打印出来的。
    4. 对着那只橡皮鸭子,把你写下的所有代码,一行一行地,精心地,向这只橡皮鸭子解释清楚。记住,这是解释,你需要解释出你的想法,思路,观点。不然,那只能算是表述,而不是解释。
    5. 当你在向这只始终保持沉默的橡皮鸭子解释的过程中,你会发现你的想法,观点,或思路和实际的代码相偏离了,于是你也就找到了代码中的bug。
    6. 找到了BUG,一定要记得感谢一下那个橡皮鸭子哦。

    什么?你觉得这个方法太“愚蠢”,太“弱智”了?是的,看上去,会这样做的人脑子好像是有点毛病。不过,我要告诉你的是,这个方法的确有效。因为,这就是“Code Review”的雏形!下面让我来给你解释一下。

     

    Once a problem is described in sufficient detail, its solution is obvious.

    上面这句话的意思是

    一旦一个问题被充分地描述了他的细节,那么解决方法也是显而易见的。

    我相信在座的各位都有过这样的经历,当你死活都找不到问题的原因的时候,当你寻求他人的帮助时,对别人解释整个你的想法和意图或是问题背景的时候,你自己都没有解释完,就已经找到问题的原因了。这样的经历,相信大家一定有过。这就是这个方法的意义所在。

    所以,“橡皮鸭”只是一个形式,其主要目的是要你把自己写的代码做“自查”,也就是自己解释给自己听。当然,为了不让你像个“精神分裂”的程序员,引入“橡皮鸭”是很有必要的(虽然这样还是有点精神病,但比起精神分裂来说算是好的了,嘻嘻)。所以,真实的本质是Code Review。关于代码评审,大家可以看一下我的这篇文章《Code Review中的几个提示》,你会明白其中更多的东西的。

    最后,我想和大家说一下道具“橡皮鸭”。是的,在我们的身边,你不一定能找得“橡皮鸭”,但你可以找到你你的同事,你的朋友,来做这个“橡皮鸭”,当然,他们并不一定有“橡皮鸭”好使,因为你的那些同事或朋友一定会在你解释的时候,随意地发表意见和看法,相当的令人annoying。《Code Review中的几个提示》和《结对编程的利与弊》也谈到了一些,供你借鉴。

    (全文完)

    展开全文
  • 编写无溢出除的汇编子程序

    万次阅读 多人点赞 2013-12-21 00:15:11
    一、为什么除会溢出 ...在汇编中,如果要使用除运算,我们可以使用div指令,它实现的就是除的功能,但是它是一个非常容易,甚至说不可避免会发生溢出的指令,下面来看看它的工作方式,我们就能知道个中源由
    一、为什么除法会溢出
    看到这个标题,你可能会问汇编中不是有div指令来实现除法运算吗?为什么我们还要自己写一个子程序来实现除法?为了说明我们为什么需要自己写一个实现除法的子程序,还得从除法为什么会发生溢出说起。

    在汇编中,如果要使用除法运算,我们可以使用div指令,它实现的就是除法的功能,但是它是一个非常容易,甚至说不可避免会发生溢出的指令,下面来看看它的工作方式,我们就能知道个中源由。注:这里所说的除法溢出并不是指分母为0而发生溢出的情况。

    div的工作方式:
    (1)除数:有8位和16位两种,在一个寄存器或内存单元中
    (2)被除数:默认放在AX或DX和AX中,如果除数为8位,则被除数为16位,默认在AX中存放;如果除数为16位,被除数为32位,在DX和AX中存放,DX存放高16位,AX存放低16位
    (3)结果:如果除数为8位,则AL(AX的低8位)存储除法操作的商,AH(AX的高8位)存储除法操作的余数;如果除数为16们,则AX存储除法操作的商,DX存放除法操作的余数。

    用一个表格来表示上述的工作方式,如下表所示:
    除数
    被除数
    结果
    8位
    16位,AX
    商:AL,余数:AH
    16位
    32位,DX(高16位)+AX(低16位)
    商:AX,余数:DX

    就这么一看似乎还没有什么问题,下面我就以一个例子来说明一下种工作方式下的除法的致命缺陷。

    为了更加容易地说明,我们以除数为8位的情况来说明,假设我们的被除数为65535(16位的最大值)存储在AX中,除数为1,存储在CL中,然后执行除法指令: div CL。根据上面的说法,结果都是放在AX中的,余数为0,当然这没有问题,然而商为65535要放在AL中却是放不下的,因为AL能存放的最大值只为255,所以此时就会发生溢出。我们可以看到65535/1 = 255,这显然与我位正常的除法结果不符。

    在这里你可以认为我举了一个非常极端的例子,但是这种情况却并不是极端的情况,对于除数为8位的除法,只要商在255以上就会发生这种溢出。除数为16位的原理及情况与这里相同,只是它是当商为65535以上是就会发生溢出而已。

    二、如何解决这个溢出问题
    既然我们知道了问题的根源,要解决它就不困难了。为了统一而且不发生溢出,我们可以把所有的除法的商都用32位来保存,即所有的被除数都用32位,所有的除数都用16位,所有的商都用32位,所有的余数都用16位来保存,就可以解决这个问题,因为一个数除以一个整数后,不可能大于其之前的值。而对于8位的除法,除数和被除数的高位全用0补全即可。为了达到这个目的,我们就不能使用默认的除法指令div了,而需要我们写代码来实现我们自定义的除法。

    考虑到除法是一个常用的操作,所以我们可以编写一个子程序来实现除法,在进行除法运算时,直接调用我们自己定义的子程序来完成任务,而不直接使用div指令。

    三、如何实现这个功能
    要实现除法还得使用div指令,只是我们可以做一些特殊的处理,让我们自定义的除法不发生溢出,因为我们使用的是除数为16位的除法,也就是说,我们只要能保证除法的商不大于65535就不会发生问题。为了实现这个功能,我们首先要知道一个关于除法的公式(H表示X的高位,L表示X的低位):
    X/N = int(H/N)* 2^16 + [rem(H/N)* 2^16+L]/N

    这个公式告诉我们32位的被除数与16位的除数,可以拆分为两个除数和被除数都为16位的数的除法,然后通过加法来得到同样的结果,这个是非常重要的。因为我们可以把H和L独立起来考虑,当进行H/N时,因为H存储在DX中,我们可以先把DX中的内容复制到AX中(操作之前把AX的内容保存好),再把DX的内容置为0,这样产生的除法操作的商就一定能放在一个16位的寄存器AX中。对于公式中的其他除法运算也采用相同的操作,然后通过把除法之前产生的结果进行相加,就能产生我们的无溢出除法子程序。

    四、实现代码
    基于这个公式,我们实现的代码如下:
    ;子程序名称:divdw
    ;功能:进行不会产生溢出的除法运算,被除数为dword型
    ;	   除数为word型,结果为dword型
    ;参数:	(ax)=dword型数据的低16位
    ;		(dx)=dword型数据的高16位
    ;		(cx)=除数
    ;返回:	(dx)=结果的高16位,(ax)=结果的低16位
    ;		(cx)=余数
    ;计算公式:X/N=int(H/N)*2^16+[rem(H/N)*2^16+L]/N
    divdw:
    	jcxz divdw_return	;除数cx为0,直接返回
    	push bx			;作为一个临时存储器使用,先保存bx的值
    		
    	push ax			;保存低位
    	mov ax, dx		;把高位放在低位中
    	mov dx, 0		;把高位置0
    	div cx			;执行H/N,高位相除的余数保存在dx中
    	mov bx, ax		;把商保存在bx寄存器中
    	pop ax			;执行rem(H/N)*2^16+L
    	div cx			;执行[rem(H/N)*2^16+L]/N,商保存在ax中
    	mov cx, dx		;用cx寄存器保存余数
    	mov dx, bx		;把bx的值复制到dx,即执行int(H/N)*2^16
    						;由于[rem(H/N)*2^16+L]/N已保存于ax中,
    						;即同时完成+运算
    	pop bx			;恢复bx的值
    	divdw_return:
    	ret
    

    五、程序分析
    1、
    为了消除分母为0的情况,我们在子程序的一开始处就判断分母CX的值,若其值为0,则直接返回。

    2、在分析时一定要记住,div把DX当作高16位来看,把AX当作低16来看,我们的子程序的调用者也是如此。所以当程序解释DX的值时,其值为真实值乘以2^16,例如DX中的值为1,AX中的值也为1,则因为DX为高16位,所以被解释为1*2^16 = 65536,则AX作为低16位来处理,其值为1。所以32位的数的值为65536+1 = 65537,也就是说32位数的值为DX*2^16+AX。

      push ax ;保存低位
      mov ax, dx ;把高位放在低位中
      mov dx, 0 ;把高位置0
      div cx ;执行H/N,高位相除的余数保存在dx中
    就是前面所说的把把H和L独立起来考虑,当H/N时,先把DX中的内容(即H)复制到AX中,再把DX的内容置为0,然后再与CX相除。

    3、
      pop ax ;执行rem(H/N)*2^16+L
      div cx ;执行[rem(H/N)*2^16+L]/N,商保存在ax中
    因为前面的除法操作即H/N的余数保存在DX中,又由于在除法操作div时,DX是当高位来处理的,所以在DX中的余数的值就会相当于其原来的值乘以2^16,然后再把之前保存在栈中的X的低位L恢复到ax中来,div指令把AX当作低16位来处理,所以也就相当于DX*2^16+AX,也就是rem(H/N)*2^16+L,之后的除法就不用解释了。

    4、
      mov cx, dx ;用cx寄存器保存余数
    把前面div操作中产生的余数(保存在dx中)复制到cx中来,因为根据函数的说明,我们是用cx来保存余数的,而不是默认的dx。

    5、
      mov dx, bx
    由于bx先前保存着H/N的商,而DX又是高16位,所以把bx的值恢复到dx中就相当于int(H/N)*2^16,由于AX是低16位,而之前的操作又已经把结果(即[rem(H/N)*2^16+L]/N的商)保存在AX中,所以这步结束后,也就相当于执行完int(H/N)*2^16+[rem(H/N)*2^16+L]/N的整个操作完成了。

    可以看到,这段看来小小的代码就这样有非常巧妙的方式,利用了div指令的特性,把DX看作高16位和把AX看作低16位和余数保存在DX中,商保存在AX中的特性,从而实现了我们的无溢出除法的功能了。


    PS:本人有幸成为了CSDN博客之星的候选人之一,如果你觉得我写的博客还可以,欢迎投上你宝贵的一票,谢谢大家的支持!我的投票地址为:

    展开全文
  • 零基础入门微信小程序开发

    万次阅读 多人点赞 2018-07-03 02:45:07
    本课程是一个系列入门教程,目标是从 0 开始带领读者上手实战,课程以微信小程序的核心概念作为主线,介绍配置文件、页面样式文件、JavaScript 的基本知识并以指南针为例对基本知识进行扩展,另外加上开发工具的安装...
  • 有限差分MATLAB程序

    万次阅读 多人点赞 2018-04-22 19:05:01
    利用超松弛法程序如下: d=zeros(1,10); h=0; for e=1:0.1:1.9 a=zeros(21,41); a(1,:)=100; b=zeros(19,39); c=eye(19,39); count=1; g=0; while(count==1) m=0; for i=2:1:20 for j=2:1:40 b(i-1,j-1)=a(i,j);...
  • 程序中的除取余

    千次阅读 2015-10-08 08:09:17
    下面八道题,估计很多人会栽在这 (-7)/3 = -3 7/(-3) = -3 (-7)/(-3) = 2 7/3 = 2(-7)%3 = 2 7%(-3) = -2 (-7)%(-3) = -1 7%3 = 1
  • 世界上最好的学习:费曼学习

    万次阅读 多人点赞 2019-09-27 19:15:09
    当然,也可以通过优秀的学习来进行学习,比如今天讲的“费曼学习”,可以将你的学习效率极大的提高。 费曼学习是由加拿大物理学家费曼所发明的一种高效的学习方法,费曼本身是一个天才,13岁自学微积分,24岁...
  • 每一个Android应用程序都在它自己的进程中运行,不一定拥有一个独立 的Dalvik虚拟机实例.而每一个DVM都是在Linux中的一个进程,所以说可以认为是同一个概念.b DVM指dalvik的虚拟机.每一个Android应用程序都在它自己...
  • 那么你们了解过哪些音乐猜歌小程序呢?下面是小编带来的3个猜歌名小程序,我们一起来玩吧! 1.挑战猜歌王 全民都在玩儿的猜歌小程序,听音乐我是歌手,嘻哈,中国风,怀旧,pop,快来跟好友一起猜歌! 挑战猜歌王小...
  • 牛顿迭代 matlab程序

    万次阅读 2009-01-04 20:14:00
    1.功能本程序采用牛顿,求实系数高次代数方程f(x)=a0xn+a1xn-1+…+an-1x+an=0 (an≠0 ) (1)的在初始值x0附近的一个根。2.使用说明(1)函数语句Y=NEWTON_1(A,N,X0,NN,EPS1)调用M文件newton_1.m。(2)...
  • 数值积分原理及matlab程序实现

    万次阅读 2016-04-16 10:14:48
    数值积分是求定积分的近似值的数值方法。即用被积函数的有限个抽样值的离散或加权平均近似值代替定积分的值。  求某函数的定积分时,在多数情况下,被积函数的原函数很难用初等函数表达出来,另外,许多实际问题...
  • 在Mac上运行Windows程序

    万次阅读 2016-11-17 13:03:08
    Wine 本来是 Linux 下一款跑 Windows 程序(EXE)的不是模拟器的模拟器,是一套模拟 Windows 的 APIs 实现,免费开源。像之前 Mac 下比较有名的 CrossOver 就是基于 Wine 的一款商业软件,之前用来跑过腾讯的 RTX...
  • 10分钟入门 - 微信小程序开发

    万次阅读 多人点赞 2019-01-09 21:33:14
    注册微信小程序 如果你还没有微信公众平台的账号,请先进入微信公众平台首页,点击 “立即注册” 按钮进行注册。注册的账号类型可以是订阅号、服务号、小程序以及企业微信,我们选择 “小程序” 即可。 接着填写...
  • 经纬度映射校正鱼眼图像 程序

    万次阅读 热门讨论 2015-09-02 17:52:22
     这个经纬映射校正总体还可以 但并不是对所有的都非常适合 就像一种插值方法不可能适用于所有的图像一样 这个经纬度校正以及cubic插值也不是对所有图像都有很好的校正效果 比如下面的: 原图和效果图 可以...
  • 【文章标题】: HOOK大实现不修改程序代码给程序添加功能 【文章作者】: 0x18c0 【软件名称】: Scylla 【使用工具】: OD、Stub_PE、ResHacker 【版权声明】: 本文原创于0x18c0, 转载请注明作者并保持文章的完整...
  • 采用冒泡编写51单片机排序程序

    千次阅读 2016-01-25 11:41:49
    试设计一个子程序,其功能为将(R0)指出的内部RAM中...========================================最佳答案:下列程序使用冒泡排序,经过KEIL仿真测试通过。 ORG 0000H;------------------------下面先准备6个数字 
  • 程序+新零售,行业新玩

    千次阅读 2018-06-12 11:07:00
    随着消费升级和商业模式的不断革新,线上线下融合...下面跟随道爷一起进入探索吧!小程序+新零售零售行业面临新挑战近年来,受中国经济增速放缓、电商冲击、租金成本攀升、人们消费习惯改变等多重因素影响,零售企业...
  • office找到此应用程序的许可证 解

    万次阅读 2016-07-09 17:10:35
    office找到此应用程序的许可证 一、问题描述 今天打开excel突然出现下面的问题: 有种想卸载office的冲动…… 最后还是找度娘解决了,再次感叹度娘的强大啊! 二、解决方法 下面记录一下解决方法。 其实很简单...
  • 下面程序的功能是将"mov ax,4c00h"之前的指令复制到内容0:200处,补全程序assume cs:codecode segmentmov ax,csmov ds,axmov ax,0020hmov es,axmov bx,0mov cx,____s:mov al,[bx]mov es:[bx],alinc bxloop smov ax
  • 今天想用 .net core做个小程序。却意外的发现没有可视化编辑器!!!(重要的事情用三个感叹号) 虽然我搞了十多年的 .net 开发,但是我确实从来没有自己编辑过 Designer.cs 这个文件。微软不是不让我编辑么! /// ...
  • 一个matlab遗传算程序

    万次阅读 多人点赞 2011-05-15 11:20:00
    对于初学者,尤其是还没有编程经验的非常有用的一个文件 遗传算法实例 <br />% 下面举例说明遗传算法 % % 求下列函数的最大值 % % f(x)=10*sin(5x)+7*cos(4x) x∈[0,10] % % 将 x 的...
  • nohup大程序在服务器后台运行

    万次阅读 2016-11-27 16:44:23
    linux下通常部署完程序,需要让它一直在后台运行,否则ssh一旦断开,整个进程就挂了。今天要介绍的就是一个关于让程序在后台运行的命令nohup!!!网上的许多文章对于nohup这个命令有非常细致的讲解,然而我认为在...
  • 单片机程序架构--时间片轮询

    万次阅读 多人点赞 2016-03-17 14:28:54
    对于单片机程序来说,大家都不陌生,但是真正使用架构,考虑架构的恐怕并不多,随着程序开发的不断增多,本人觉得架构是非常必要的。前不就发帖与大家一起讨论了一下《谈谈怎样架构你的单片机程序》,发现真正使用...
  • 一、匈牙利命名:广泛应用于象Microsoft Windows这样的环境中。   Windows 编程中用到的变量(还包括宏)的命名规则匈牙利命名,这种命名技术是由一位能干的 Microsoft 程序员查尔斯·西蒙尼(Charles Simonyi...
  • 一个快速求素数的程序

    千次阅读 2006-05-10 23:16:00
    闲暇时写了一个找出小于某个数字的素数的程序。最常见的方法是筛选吧。原理大致如下:若要求得16以内的所有素数,1)在数组中存放一下数据: 2 3
  • 游戏是我们生活中必不可少的一部分,不仅能让我们心情得以放松,还是能在无聊的时候消遣时间的法宝,下面让小编介绍3个好玩又有趣的游戏给大家! 1.超强冒险火柴人奔跑吧大逃亡游戏 超强冒险火柴人奔跑吧大逃亡游戏...
  • matlab练习程序(二值图像连通区域标记,一步)  这个只需要遍历一次图像就能够完全标记了。我主要参考了WIKI和这位兄弟的博客,这两个把原理基本上该介绍的都介绍过了,我也不多说什么了。一步代码相比...
  • 黑盒测试(Black-box Testing,又称为功能测试或数据驱动测试)是把测试对象看作一个黑盒子,利用黑盒测试进行动态测试时,需要...等价类划分:是把所有可能的输入数据,即程序的输入域划分成若干部分(子集),然后从

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 345,405
精华内容 138,162
关键字:

下面哪些是程序法