在C中合并两个不同大小的字符串

如何将两个大小不同的字符串逐个字符合并到

A

的第n个元素和

B

的第m个元素。当它们的大小相同时，我可以很容易地做到这一点（假设这里

n=m

）。但无法确定如何处理此异常

我的工作代码如下：

char * zip(char *A, char *B, int n)
{
    char *C;
    int i;

    C = malloc((2*n) * sizeof *A);

    for(i=0; i<n; i++) {
            C[(2*i)]=A[i];
            C[(2*i)+1]=B[i];
    }

    return C;
}

char*zip（char*A，char*B，int-n）
{
char*C；
int i；
C=malloc（（2*n）*sizeof*A）；
对于（i=0；i，您可以循环直到字符用尽，而不是循环到某个长度。C字符串的末尾有一个空字符，因此在分配内存后，您可以循环，只要这两个字符都不是空字符。您只需在输出字符串中添加非空字符即可

#include <stdio.h>  /* printf */
#include <stdlib.h> /* malloc, free */
#include <string.h> /* strlen */

char *zip(char *a, char *b)
{
    char *c = malloc( (strlen(a)+strlen(b)+1) * sizeof(char) ), *p = c;
    if(c)
    {
      while(*a || *b) /* while either string has characters */
      {
        if(*a) *p++ = *a++; /* add a character from a if non-null */
        if(*b) *p++ = *b++; /* add a character from b if non-null */
      }
      *p='\0'; /* finish the string with a null character */
    }
    return c;
}

int main()
{
  char *a = "This is a string";
  char *b = "This is another longer string";
  char *c = zip(a,b);
  if(c)
  {
    printf("zip(%s,%s) = %s\n",a,b,c);
    free(c);
  }
  return 0;
}

#包括/*printf*/
#包括/*malloc，免费*/
#包括/*斯特伦*/
char*zip（char*a，char*b）
{
char*c=malloc（（strlen（a）+strlen（b）+1）*sizeof（char）），*p=c；
如果（c）
{
while（*a | |*b）/*而任一字符串都有字符*/
{
if（*a）*p++=*a++；/*如果非空，则从中添加一个字符*/
如果（*b）*p++=*b++；/*如果非空，则从b添加一个字符*/
}
*p='\0'；/*用空字符结束字符串*/
}
返回c；
}
int main（）
{
char*a=“这是一个字符串”；
char*b=“这是另一个较长的字符串”；
char*c=zip（a，b）；
如果（c）
{
printf（“zip（%s，%s）=%s\n”，a、b、c）；
免费（c）；
}
返回0；
}
不必循环到某个长度，您可以循环到字符用完为止。C字符串的末尾有一个空字符，因此在分配内存后，您可以循环，只要这两个字符都不是空字符。您只需在输出字符串中添加非空字符即可

#include <stdio.h>  /* printf */
#include <stdlib.h> /* malloc, free */
#include <string.h> /* strlen */

char *zip(char *a, char *b)
{
    char *c = malloc( (strlen(a)+strlen(b)+1) * sizeof(char) ), *p = c;
    if(c)
    {
      while(*a || *b) /* while either string has characters */
      {
        if(*a) *p++ = *a++; /* add a character from a if non-null */
        if(*b) *p++ = *b++; /* add a character from b if non-null */
      }
      *p='\0'; /* finish the string with a null character */
    }
    return c;
}

int main()
{
  char *a = "This is a string";
  char *b = "This is another longer string";
  char *c = zip(a,b);
  if(c)
  {
    printf("zip(%s,%s) = %s\n",a,b,c);
    free(c);
  }
  return 0;
}

#包括/*printf*/
#包括/*malloc，免费*/
#包括/*斯特伦*/
char*zip（char*a，char*b）
{
char*c=malloc（（strlen（a）+strlen（b）+1）*sizeof（char）），*p=c；
如果（c）
{
while（*a | |*b）/*而任一字符串都有字符*/
{
if（*a）*p++=*a++；/*如果非空，则从中添加一个字符*/
如果（*b）*p++=*b++；/*如果非空，则从b添加一个字符*/
}
*p='\0'；/*用空字符结束字符串*/
}
返回c；
}
int main（）
{
char*a=“这是一个字符串”；
char*b=“这是另一个较长的字符串”；
char*c=zip（a，b）；
如果（c）
{
printf（“zip（%s，%s）=%s\n”，a、b、c）；
免费（c）；
}
返回0；
}
像这样：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

char *new_zip(char *A, char *B, int n, int m){
    assert(A != NULL && B != NULL && n >= 0 && m >= 0);
    char *C = malloc(n + m + 1);//+1 for NUL
    if(!C){
        perror("malloc:");
        return NULL;
    }
    int i = 0;

    while(n + m > 0){
        if(n > 0 && *A){
            C[i++] = *A++;
            --n;
        }
        if(m > 0 && *B){
            C[i++] = *B++;
            --m;
        }
    }
    C[i] = 0;
    return C;
}

int main (void){
    char *result = new_zip("rslxyzkw", "eutingxyz", 3, 6);
    printf("'%s'\n", result);
    free(result);
    return 0;
}

#包括
#包括
#包括
char*new_-zip（char*A，char*B，int n，int m）{
断言（A！=NULL&&B！=NULL&&n>=0&&m>=0）；
char*C=malloc（n+m+1）；//+1表示NUL
如果（！C）{
佩罗尔（“马洛克：”）；
返回NULL；
}
int i=0；
而（n+m>0）{
如果（n>0&&*A）{
C[i++]=*A++；
--n；
}
如果（m>0&&B）{
C[i++]=*B++；
--m；
}
}
C[i]=0；
返回C；
}
内部主（空）{
char*result=new_-zip（“rslxyzkw”，“eutingxyz”，3,6）；
printf（“%s”\n”，结果）；
自由（结果）；
返回0；
}
像这样：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

char *new_zip(char *A, char *B, int n, int m){
    assert(A != NULL && B != NULL && n >= 0 && m >= 0);
    char *C = malloc(n + m + 1);//+1 for NUL
    if(!C){
        perror("malloc:");
        return NULL;
    }
    int i = 0;

    while(n + m > 0){
        if(n > 0 && *A){
            C[i++] = *A++;
            --n;
        }
        if(m > 0 && *B){
            C[i++] = *B++;
            --m;
        }
    }
    C[i] = 0;
    return C;
}

int main (void){
    char *result = new_zip("rslxyzkw", "eutingxyz", 3, 6);
    printf("'%s'\n", result);
    free(result);
    return 0;
}

#包括
#包括
#包括
char*new_-zip（char*A，char*B，int n，int m）{
断言（A！=NULL&&B！=NULL&&n>=0&&m>=0）；
char*C=malloc（n+m+1）；//+1表示NUL
如果（！C）{
佩罗尔（“马洛克：”）；
返回NULL；
}
int i=0；
而（n+m>0）{
如果（n>0&&*A）{
C[i++]=*A++；
--n；
}
如果（m>0&&B）{
C[i++]=*B++；
--m；
}
}
C[i]=0；
返回C；
}
内部主（空）{
char*result=new_-zip（“rslxyzkw”，“eutingxyz”，3,6）；
printf（“%s”\n”，结果）；
自由（结果）；
返回0；
}
以下方法可能有效

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* zip(char* A, char* B) {
    char *C;
    int k = 0;

    C = (char*)malloc(strlen(A)+strlen(B)+1);

    while (*A != '\0' || *B != '\0') {
        if (*A != '\0') {
            C[k++] = *A;
            ++A;
        }
        if (*B != '\0') {
            C[k++] = *B;
            ++B;
        }
    }
    C[k] = '\0';

    return C;
}



int main() {
    char *A = "123456", *B = "abcd", *C;

    C = zip(A, B);

    puts(C);

    return 0;
}

#包括
#包括
#包括
char*zip（char*A，char*B）{
char*C；
int k=0；
C=（char*）malloc（strlen（A）+strlen（B）+1）；
而（*A！='\0'|*B！='\0'）{
如果（*A！='\0'）{
C[k++]=*A；
++A；
}
如果（*B！='\0'）{
C[k++]=*B；
++B；
}
}
C[k]='\0'；
返回C；
}
int main（）{
char*A=“123456”、*B=“abcd”、*C；
C=压缩（A，B）；
（C）；
返回0；
}
以下方法可能有效

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* zip(char* A, char* B) {
    char *C;
    int k = 0;

    C = (char*)malloc(strlen(A)+strlen(B)+1);

    while (*A != '\0' || *B != '\0') {
        if (*A != '\0') {
            C[k++] = *A;
            ++A;
        }
        if (*B != '\0') {
            C[k++] = *B;
            ++B;
        }
    }
    C[k] = '\0';

    return C;
}



int main() {
    char *A = "123456", *B = "abcd", *C;

    C = zip(A, B);

    puts(C);

    return 0;
}

#包括
#包括
#包括
char*zip（char*A，char*B）{
char*C；
int k=0；
C=（char*）malloc（strlen（A）+strlen（B）+1）；
而（*A！='\0'|*B！='\0'）{
如果（*A！='\0'）{
C[k++]=*A；
++A；
}
如果（*B！='\0'）{
C[k++]=*B；
++B；
}
}
C[k]='\0'；
返回C；
}
int main（）{
char*A=“123456”、*B=“abcd”、*C；
C=压缩（A，B）；
（C）；
返回0；
}
以下代码将按以下方式工作：

首先，根据m和n的最小值，交替合并字符串s1和s2。
第二部分将负责附加s1或s2中的其余元素

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char* merge (char *s1, char *s2, int m, int n)
{
    char *s = (char *) malloc(m + n + 1);

    int min = (m < n)? m: n;
    int i = 0, j = 0, k = 0;

    int count = 0;

    /* Alternate merge from s1 and s2 to s*/
    while (count < 2 * min) {
        if (count % 2 == 0) {
            s[k++] = s1[i++];
        } else {
            s[k++] = s2[j++];
        }
        count++;
    }

    /* Append the remaining elements from s1 or s2 to s*/
    if (m > min) {
        for (count = 0; count < m - min; count++) {
            s[k++] = s1[i++];
        }
    } else if (n > min) {
        for (count = 0; count < n - min; count++) {
            s[k++] = s2[j++];
        }
    }
    s[k++] = '\0';
    return s;
}

int main()
{
    char *s1 = "rslxyzkw";
    char *s2 = "eutingxyz";

    char *s = merge(s1, s2, 3, 6);
    printf ("%s\n", s);
}

#包括
#包括
#包括
字符*合并（字符*s1，字符*s2，整数m，整数n）
{
char*s=（char*）malloc（m+n+1）；
int min=（mmin）{
对于（计数=0；计数min）{
对于（计数=0；计数
以下代码将在