7-6 计算符号函数的值 (10 分)
 对于任一整数n，符号函数sign(n)的定义如下：
 
 
请编写程序计算该函数对任一输入整数的值。
 
输入格式:
 输入在一行中给出整数n。
 
输出格式:
 在一行中按照格式“sign(n) = 函数值”输出该整数n对应的函数值。
 
输入样例1:
 10
 输出样例1:
 sign(10) = 1
 输入样例2:
 0
 输出样例2:
 sign(0) = 0
 输入样例3:
 -98
 输出样例3:
 sign(-98) = -1
 
#include<stdio.h>
int main(int argc,char* argv[])
{
	int n;
	int result;
	scanf("%d",&n);
	if(n<0)
	result=-1;
	else if(n==0)
	result=0;
	else
	result=1;
	printf("sign(%d) = %d",n,result);
	return 0;
}

请编写程序检查C语言源程序中下列符号是否配对：/* 与 */、(与)、[与]、{与}。
 
输入格式: 
 输入为一个C语言源程序。当读到某一行中只有一个句点.和一个回车的时候，标志着输入结束。程序中需要检查配对的符号不超过100个。
 
输出格式: 
 首先，如果所有符号配对正确，则在第一行中输出YES，否则输出NO。然后在第二行中指出第一个不配对的符号：如果缺少左符号，则输出?-右符号；如果缺少右符号，则输出左符号-?。
 
输入样例1：
 
void test()
{
    int i, A[10];
    for (i=0; i<10; i++) /*/
        A[i] = i;
}
 
输出样例1：
 
NO
/*-?
 
输入样例2：
 
void test()
{
    int i, A[10];
    for (i=0; i<10; i++) /**/
        A[i] = i;
}]
.
 
输出样例2：
 
NO
?-]
 
输入样例3：
 
void test()
{
    int i
    double A[10];
    for (i=0; i<10; i++) /**/
        A[i] = 0.1*i;
}
.
 
输出样例3：
 
YES
 
代码如下：
 
#include<iostream>
#include<stdio.h>
#include<string>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
using namespace std;

char c;
typedef struct
{
    char *base;
    char *top;
    int stacksize;
} SqStack;
Status InitStack(SqStack &S)
{
    S.base=new char[MAXSIZE];
    if(!S.base)
        return OVERFLOW;
    S.top=S.base;
    S.stacksize=MAXSIZE;
    return OK;
}
Status push(SqStack &S,char e)
{
    if(S.top-S.base==S.stacksize)
        return ERROR;
    *S.top++=e;
    return OK;
}
Status pop(SqStack &S,char e)
{
    if(S.top==S.base)
        return ERROR;
    e=*--S.top;
    return OK;
}
char GetTop(SqStack S)
{
    if(S.top!=S.base)
    {
        return *(S.top-1);
    }
}
bool StackEmpty(SqStack &S)
{
    if(S.top==S.base)
        return true;
    else
        return false;
}

bool Matching(SqStack &S)
{
    int flag=1,t=1,i;
    char str[1000];
    while(gets(str))
    {
        if(str[0]=='.'&&str[1]==0)
            break;
        for(i=0; str[i]!='\0'; i++)
        {
            if(str[i]=='('||str[i]=='['||str[i]=='{')
                push(S,str[i]);
            if(str[i]=='/'&&str[i+1]=='*')
            {
                push(S,str[i]);
                push(S,str[i+1]);
                i+=2;
            }
            if(str[i]==')')
            {
                if(!StackEmpty(S)&&GetTop(S)=='(')
                    pop(S,'(');
                else
                {
                    c=str[i];
                    flag=0;
                    break;
                }
            }
            if(str[i]==']')
            {
                if(!StackEmpty(S)&&GetTop(S)=='[')
                    pop(S,'[');
                else
                {
                    c=str[i];
                    flag=0;
                    break;
                }
            }
            if(str[i]=='}')
            {
                if(!StackEmpty(S)&&GetTop(S)=='{')
                    pop(S,'{');
                else
                {
                    c=str[i];
                    flag=0;
                    break;
                }
            }
            if(str[i]=='*'&&str[i+1]=='/')
            {
                if(!StackEmpty(S)&&GetTop(S)=='*')
                {
                    pop(S,'*');
                    if(!StackEmpty(S)&&GetTop(S)=='/')
                        pop(S,'/');
                    else
                    {
                        c=str[i];
                        flag=0;
                        break;
                    }
                }
                else
                {
                    c=str[i];
                    flag=0;
                    break;
                }
            }
            /*if(StackEmpty(S))
            {
                if(str[i]==')'||str[i]=='}'||str[i]==']')
                {
                    c=str[i];
                    t=0;
                }
                else if(str[i]=='*'&&str[i+1]=='/')
                {
                    c=str[i];
                    t=0;
                }
                //cout<<c<<endl;
            }*/
        }
    }
    if(StackEmpty(S)&&(flag==1))
        return true;
    else
        return false;
}
int main()
{
    SqStack A;
    InitStack(A);
    if(Matching(A))
        cout<<"YES"<<endl;
    else
    {
        cout<<"NO"<<endl;
        if(!StackEmpty(A))
        {
            if(GetTop(A)=='(')
                cout<<'('<<'-'<<'?'<<endl;
            else if(GetTop(A)=='[')
                cout<<'['<<'-'<<'?'<<endl;
            else if(GetTop(A)=='{')
                cout<<'{'<<'-'<<'?'<<endl;
            else if(GetTop(A)=='*')
                cout<<'/'<<'*'<<'-'<<'?'<<endl;
        }
        else
        {
            if(c==')')
                cout<<'?'<<'-'<<')'<<endl;
            else if(c==']')
                cout<<'?'<<'-'<<']'<<endl;
            else if(c=='}')
                cout<<'?'<<'-'<<'}'<<endl;
            else if(c=='*')
                cout<<'?'<<'-'<<'*'<<'/'<<endl;
        }
    }
}

原文链接：http://tecdat.cn/?p=3172
 
原文出处：拓端数据部落公众号
 
 
在这篇文章中，我们将探索比较两组依赖（即配对）定量数据的检验：Wilcoxon符号秩检验和配对学生t检验。这些检验之间的关键区别在于Wilcoxon的检验是非参数检验，而t检验是参数检验。在下文中，我们将探讨这种差异的后果。
 
睡眠数据集
 
我们来考虑睡眠数据集。数据集通过提供服用药物后睡眠时间与基线相比的变化来对比两种催眠药物（即安眠药）的效果：
 
extra表示与基线测量相比睡眠中的增加/减少（正/负值），组表示药物，ID表示患者ID。为了更清楚，我将组重命名为药物：
 
##    extra group ID
## 1    0.7     1  1
## 2   -1.6     1  2
## 3   -0.2     1  3
## 4   -1.2     1  4
## 5   -0.1     1  5
## 6    3.4     1  6
## 7    3.7     1  7
## 8    0.8     1  8
## 9    0.0     1  9
## 10   2.0     1 10
## 11   1.9     2  1
## 12   0.8     2  2
## 13   1.1     2  3
## 14   0.1     2  4
## 15  -0.1     2  5
## 16   4.4     2  6
## 17   5.5     2  7
## 18   1.6     2  8
## 19   4.6     2  9
## 20   3.4     2 10
 
注意，睡眠数据集包含每个患者的两个测量值。因此，它适合于展示配对检验，例如我们正在处理的检验。
 
我们检验的是什么？
 
假设我们在一家制药公司工作，这些是刚从临床试验中获得的数据。现在，我们必须决定你应该推出哪两种药物用于市场。选择药物的合理方法是确定表现更好的药物。
 
为了直观了解这两种药物的有效性，让我们绘制相应的值：
 
 
该图显示药物1的睡眠时间的中值增加接近0，而药物2的中值增加接近2小时。因此，根据这些数据，似乎药物2比药物1更有效。但是，我们仍需要确定我们的发现是否具有统计学意义。
 
零假设
 
 
检验的零假设是，两种药物之间的额外睡眠时间没有任何差别。由于我们想知道药物2是否优于药物1，所以我们不需要双尾检验（检验任何一种药物是否具有优越性能），而是需要单尾检验。因此，备选假设是，药物2比药物1更优。
 
 Wilcoxon符号秩检验
 
 由于检验统计量是基于排名而不是测量值本身，因此Wilcoxon符号秩检验可以被认为是检验两组之间中值变化。
 
 
要在R中执行检验，我们可以使用该wilcox.test。但是，我们必须明确设置配对参数，以表明我们正在处理匹配的观察。要指定单尾检验，我们将替代参数设置为更大。以这种方式，检验的替代方案是药物2是否与睡眠持续时间增加相关联而不是药物1。
 
wilcox(x, y, paired = TRUE, 
                   alternative = "greater" 

 
 警告
 
在获得结果之前，我们应该调查执行检验所产生的两个警告。
 
警告1：关系
 
第一个警告产生的原因是，该测试对成对的额外数值的差异进行排名。如果两对有相同的差异，在排名时就会出现并列。我们可以通过计算配对之间的差异来验证这一点
 
x - y

##  [1] 1.2 2.4 1.3 1.3 0.0 1.0 1.8 0.8 4.6 1.4
 
并发现第3和第4对都有相同的差值1.3。为什么并列是一个问题？分配给并列关系的等级是基于它们所跨越的等级的平均值。因此，如果有许多并列，这就降低了测试统计的表现力，使Wilcoxon测试不合适。由于我们这里只有一个并列，这不是一个问题。 
 
警告2：零值
 
第二个警告涉及差异为0的对。在睡眠数据集中，来自第5个患者的情况就是这种情况（见上文）。为什么零是个问题？请记住，零假设是对的差异以0为中心。但是，观察值恰好为0的差异并不能为我们提供任何拒绝零的信息。因此，在计算检验统计量时丢弃这些配对。如果许多配对的情况如此，则检验的统计效果将大幅下降。同样，这不是问题，因为只存在一个零值。
 
调查结果
 
检验的主要结果是它的p值，可以通过以下方式获得：
 
res$p.value

## [1] 0.004545349
 
由于p值小于5%的显著性水平，这意味着我们可以拒绝无效假设。因此，我们倾向于接受备选假设，即药物2优于药物1。 
 
配对学生的t检验
 
配对Student's t检验是对两组配对定量测量方法的参数检验。这里，参数意味着t检验假设样本之间的平均差异是正态分布的。检验依赖于确定两组的测量值的平均差异，X¯d大于 μd， μd通常设置为0查找是否存在任何差异。 
 
 
 
在R中，我们可以用t.test函数进行配对t检验。请注意，t.test假定人口变异是不相等的。在这种情况下，该检验也被称为韦尔奇的t检验。要获得假定种群方差相等的原始t检验，我们可以直接将equal.var参数设置为TRUE。在这里，我们将只使用默认设置。
 
print(t.result$p.value)
## [1] 0.001416
 
同样，P值小于0.05。因此，我们倾向于接受另一个假设：药物2比药物1在平均睡眠时间上有更大的增长。 
 
检查学生t检验的假设
 
t检验要求样本均值是正态分布。根据中心极限定理，在有足够数量的样本时，群体中的样本均值接近正态分布。因此，只要有足够数量的样本，即使对于非正态测量，也能满足t检验的假设。由于睡眠数据只包含10个成对的测量值，应该有理由担心。因此，我们应该检查测量值之间的差异是否为正态分布，以验证t检验是否有效。
 

ggplot(diff.df, aes(x = diff)) 
 
 
 
 
看一下直方图，数据似乎相当均匀，而不是正态分布。为了更仔细地观察，我们用Q-Q图将差异与正态分布的期望值进行比较。
 
 qqp(diff.df$diff) 
 
 
QQ图显示，除了重尾之外，差异相当符合正态模型。由此，我们可以得出结论，t检验的假设得到了充分的满足。不过，我们还是对t检验是否是这些数据最合适的选择感到不确定。
 
总结：Wilcoxon符号秩检验与配对学生t检验
 
在这项分析中，Wilcoxon符号秩检验和配对学生t检验导致拒绝零假设。但总的来说，哪种检验更合适？答案是，这取决于几个标准：
 
假设：学生t检验是比较平均值的检验，而Wilcoxon检验是检验数据的排序。例如，如果你在分析有许多离群值的数据，如个人财富（少数亿万富翁会极大地影响结果），Wilcoxon检验可能更合适。
解释：虽然也可以为Wilcoxon检验计算置信区间，但在t检验中争论平均数的置信区间可能比Wilcoxon检验的假说更自然。
假设的实现： 对于小规模的样本，学生t检验的假设可能无法满足。在这种情况下，选择一个非参数检验往往是比较安全的。然而，如果满足t检验的假设，它的统计能力比Wilcoxon检验大。
由于睡眠数据集的样本量较小，对于这些数据，我更倾向于采用Wilcoxon的检验。
 
你会用哪种检验？
 

一、什么是符号
 
定义
 
符号是指代码中的变量与函数。代码中的关键字不属于符号。 
 
种类
 
符号分为以下4种： 
 （1）可引出符号 
 由本模块定义，且能被本模块和其它模块引用的符号 
 非Static全局函数，非static全局变量都是可引出符号 
 （2）外部符号 
 由其它模块定义，但被本模块引用了的符号。 
 其它模块的可引出符号，如果被本模块使用了，就是本模块的外部符号 
 外部符号变量由extern修饰 
 （3）静态符号 
 由本模块定义，且只能被本模块引用的符号 
 带static的全局变量和全局函数都是静态符号 
 （4）局部符号 
 在函数内部定义的非static变量 
 
种类举例
 
extern int buf[];
static int *bufp0 = &buf[0];
int *bufp1;
void swap()
{
    int temp;
    bufp1 = &buf[1];
    temp = *bufp0;
    *bufp0 = *bufp1;
    *bufp1 = temp;
}
 
运用上面的内容，对这段代码中的符号分类
 
符号名
符号类型
buf
外部符号
bufp0
静态符号
bufp1
可引出符号
swap
可引出符号
temp
局部符号
 
二、符号解析
 
符号解析是指，把符号的定义和引用联系起来。 
 不同的符号类型，解析的策略不同。为了方便理解，这里打乱次序，从最简单的说起。 
 - 4.局部符号 
 链接器对局部符号一点都不关心，因为局部符号是在栈里管理的。 
 - 3.静态符号 
 链接器对静态符号的处理比较简单，因为静态符号的定义和引用肯定是在同一个模块中的，只要保证模块中一个符号只有一个定义就好了。 
 - 2.外部符号 
 编译器发现模块中的符号没有定义时，就会把它放到一个符号表中，链接器从其它模块中找出这些符号的定义。 
 - 1.可引出符号 
 可引出符号的处理比较复杂，要从所有模块中搜索这个符号的定义，还要处理重定义的问题。 
 
三、符号重定义
 
在外部符号和可引出符号的解析过程中，都有可能遇到符号重定义的问题。 
 当链接器发现符号重定义时会怎么处理吗？它会报错吗？ 不要这么急着下结论。 
 本着“实践是检验真理的唯一标准”的原则，我们一起做几个实验。 
 g++/ld中的符号重定义