C K&；运动挤压函数

因此，这里的练习是设计一个程序，它接受一个字符串并删除该字符串中出现在第二个字符串中的所有字符。因此，对于我在下面选择的字符串，其中第一个字符串是abc，第二个字符串是cde，我希望得到

ab

的输出，而不是

abc

我已经看到了一个非常简洁的方法来实现这个压缩函数，它只需要两个简单的for循环，但我想知道为什么我的冗长方法不起作用

#include<stdio.h>

void squeeze(char s1[], char s2[]);
void copy(char to[], char from[]);

int k=0;

main()
{
    char array1[4]="abc";
    char array2[4]="cde";
    squeeze(array1, array2);
    printf("%s", array1);
}

void squeeze(char s1[], char s2[])
{
    int j,i,m;
    m=j=i=0;
    char s3[1000];
    while(s1[i]!='\0')   //What I'm doing here is taking a character in the string
    {                      //and comparing it with all characters in the second string.
        copy(s3,s1);       //If it exists in the second string I'm 'deleting' that letter
        while(s2[j]!='\0') //from the first string. Then I start all over again with the
        {                 // next letter in line. Or at least that's the plan.
            if (s1[i]==s2[j])
            {
                k=1;
            }
            ++j;
        }

        if (k==1)
        {
            m=i;
            while(s3[m+1]!='\0')
            {
                s1[m]=s3[m+1];  //I'm 'deleting' the letter by pushing each character
                ++m;            //that is to the right of the deleted character to the  
            }                   //left of the array.
        }

        if(k!=1)
        {
            ++i;
        }
    }
    s1[i]='\0';
 }

void copy(char to[], char from[])
{
    int i;
    i=0;

    while(from[i]!='\0')
    {
        to[i]= from[i];
        ++i;
    }
    to[i]=='\0';
}

#包括
空隙挤压（半焦s1[]，半焦s2[]）；
无效副本（字符到[]，字符从[]）；
int k=0；
main（）
{
字符数组1[4]=“abc”；
字符数组2[4]=“cde”；
挤压（阵列1、阵列2）；
printf（“%s”，数组1）；
}
空隙挤压（字符s1[]，字符s2[]
{
int j，i，m；
m=j=i=0；
chars3[1000]；
while（s1[i]！='\0'）//我在这里做的是在字符串中取一个字符
{//并将其与第二个字符串中的所有字符进行比较。
复制（s3，s1）；//如果它存在于第二个字符串中，我将“删除”该字母
而（s2[j]！='\0'）//从第一个字符串开始。然后我用
{//下一个字母。或者至少这是计划。
if（s1[i]==s2[j]）
{
k=1；
}
++j；
}
如果（k==1）
{
m=i；
而（s3[m+1]！='\0'）
{
s1[m]=s3[m+1]；//我通过按每个字符来“删除”字母
++m、 //位于已删除字符的右侧
}//数组的左边。
}
如果（k！=1）
{
++一,；
}
}
s1[i]='\0'；
}
无效副本（字符到[]，字符从[]）
{
int i；
i=0；
while（从[i]！='\0'）
{
to[i]=从[i]；
++一,；
}
至[i]=='\0'；
}

当您应将“j”重置为零时，将其置于外部

如果“k”等于1，则不再增加“i”。如果第二次运行挤压（），则不会再次初始化“k”

---

切勿使用全局变量（或模块局部变量），如“k”。这使得您的代码线程不安全。

在外部线程中，而您应该将“j”重置为零

如果“k”等于1，则不再增加“i”。如果第二次运行挤压（），则不会再次初始化“k”

切勿使用全局变量（或模块局部变量），如“k”。这使您的代码线程不安全。

high five--我也在读这一章。我想我已经读了4遍了，无论如何我真的需要边做边学，我在几个小时内就把所有的内容都忘了。这就是为什么我几乎完成了那一章的所有练习——下一章是第三章

这是我的解决方案——压缩函数与getline函数不兼容（

/0'

正在强制

printf

不打印到标准输出

在gcc 4.7.2上编译

gcc-Wall-std=c99-pedantic squence.c

#include <stdio.h>
#define LIM 100

void squeeze(char[], char[]);
int ggetline(char[], int);

int main()
{
    //the getline function is buggy; it would produce null strings.
    char line1[LIM] = "hello";
    char line2[LIM] = "hello2";
    squeeze(line1, line2);
    printf("%s %s\n", line1, line2);

return 0;

}


/* getline: reads line into s, returns length */
int ggetline(char s[], int lim)
{
    int c, i;

    for (i = 0; i < lim-1 && (c = getchar()) != EOF && c!='\n'; ++i)
        s[i] = c;
    if (c == '\n') {
        s[i] = c;
        ++i;
    }
    s[i] = '\0';
    return i;
}

void squeeze(char s1[], char s2[])
{
    int j, l, i, k;

    for (i = 0; s2[i] != '\0'; i++) {
        for (k = l = 0; s2[j] != '\0'; j++) {
            if (s1[j] != s2[i])
                s1[k++] = s1[j];
        }
        s2[k] = '\0';

    }
}

#包括
#定义LIM 100
空隙挤压（char[]，char[]）；
int-ggetline（char[]，int）；
int main（）
{
//getline函数有缺陷；它将生成空字符串。
char line1[LIM]=“你好”；
字符行2[LIM]=“hello2”；
挤压（第1行、第2行）；
printf（“%s%s\n”，第1行，第2行）；
返回0；
}
/*getline：将行读入s，返回长度*/
int ggetline（字符s[]，int lim）
{
int c，i；
对于（i=0；i

祝你好运！

high five--我也在读那一章。我想我已经读了大约4遍了，无论如何我真的需要边做边学，我在几个小时内就忘记了所有的内容。这就是为什么我几乎完成了那一章中的所有练习-下一章是第3章

这是我的解决方案——压缩函数与getline函数不兼容（

/0'

正在强制

printf

不打印到标准输出

在gcc 4.7.2上编译

gcc-Wall-std=c99-pedantic squence.c

#include <stdio.h>
#define LIM 100

void squeeze(char[], char[]);
int ggetline(char[], int);

int main()
{
    //the getline function is buggy; it would produce null strings.
    char line1[LIM] = "hello";
    char line2[LIM] = "hello2";
    squeeze(line1, line2);
    printf("%s %s\n", line1, line2);

return 0;

}


/* getline: reads line into s, returns length */
int ggetline(char s[], int lim)
{
    int c, i;

    for (i = 0; i < lim-1 && (c = getchar()) != EOF && c!='\n'; ++i)
        s[i] = c;
    if (c == '\n') {
        s[i] = c;
        ++i;
    }
    s[i] = '\0';
    return i;
}

void squeeze(char s1[], char s2[])
{
    int j, l, i, k;

    for (i = 0; s2[i] != '\0'; i++) {
        for (k = l = 0; s2[j] != '\0'; j++) {
            if (s1[j] != s2[i])
                s1[k++] = s1[j];
        }
        s2[k] = '\0';

    }
}

#包括
#定义LIM 100
空隙挤压（char[]，char[]）；
int-ggetline（char[]，int）；
int main（）
{
//getline函数有缺陷；它将生成空字符串。
char line1[LIM]=“你好”；
字符行2[LIM]=“hello2”；
挤压（第1行、第2行）；
printf（“%s%s\n”，第1行，第2行）；
返回0；
}
/*getline：将行读入s，返回长度*/
int ggetline（字符s[]，int lim）
{
int c，i；
对于（i=0；i

---

祝你好运！

+1对于“从不使用全局变量”的注释。这是一个稍微夸张的语句，但在这里是准确的，

k

只在一个函数内部使用。只有当需要从函数外部访问变量时，才允许在函数外部访问它。好的，谢谢！顺便说一句，我没有增加“I”因为如果我“删除”了该字符，那么下一个字符将位于数组中的当前位置“I”。这不是吗？+1表示“从不使用全局变量”注释。这是一个略微过多的语句，但在这里是准确的，其中

k

仅在一个函数内使用。只有当变量为n时，才能在函数外访问该变量从函数外部访问的EED。Al