Lâu nay tôi gặp khó khăn khi tìm từ chung dài nhất trong hai chuỗi. Đầu tiên tôi nghĩ đến việc sử dụng hàm "isspace" để làm việc này nhưng không biết cách tìm một từ thông dụng. Sau đó tôi nghĩ đến "strcmp" nhưng cho đến nay tôi chỉ có thể so sánh hai chuỗi. Tôi đang nghĩ cách nào đó để kết hợp strcmp và isspace để tìm các từ khác nhau, sau đó sử dụng giá trị tạm thời để tìm từ dài nhất, nhưng tôi không thể nghĩ ra mã chính xác để làm điều này.

   #include 

   int strcmp(char s[],char t[]);


 khoảng trống chính()
 {

    char s[20],t[20];
   printf("Nhập vào một chuỗi s.\n");
   được (các);
    printf("Nhập vào một chuỗi t.\n");
    được(t);
   printf("Kết quả so sánh=%d\n",strcmp(s,t));

    return 0;
      }


   int strcmp(char s[],char t[])
  {
   int i;
   for(i=0;s[i]==t[i];i++)
   if(s[i]=='\0')
   trở lại (0);
   return(s[i]-t[i]);
   }

Xin hãy giúp tôi giải quyết vấn đề này. Tất cả các ý tưởng (và mã) đều được chào đón và đánh giá cao. Cảm ơn trước!

biên tập:

Tôi đã vật lộn với vấn đề này một thời gian và tôi nghĩ mình có giải pháp, nhưng đó là một cách tiếp cận rất cứng nhắc. Chương trình có lỗi, có lẽ liên quan đến mảng "ptrArray1", nhưng tôi không thể sửa được.

     #include 
     #include 
     #include 


     int returnArrayOfWords (char* str4Parsing, char* arrayParsed[])
       {
// trả về độ dài của mảng
char seps[] = " \t\n";
char *mã thông báo = NULL;
char *next_token = NULL;
int i = 0;

// Thiết lập chuỗi và nhận token đầu tiên:
token = strtok( str4Parsing, seps);

// Trong khi có các token trong "str4Parsing"
trong khi ((mã thông báo != NULL))
{
    // Nhận mã thông báo tiếp theo:
    arrayParsed[i] = mã thông báo;
    //printf( " %s\n", arrayParsed[i] );//sẽ được bình luận
    mã thông báo = strtok( NULL, seps);
    i++;
}
trả lại tôi;
      }

      void printArr(char *arr[], int n)
     {
int i;
vì (i = 0; i < n; i++)
{
    printf("Phần tử %d là %s \n", i, arr[i]);
}
   }


     void findLargestWord(char *ptrArray1[], int sizeArr1, char *ptrArray2[], int sizeArr2)
{
int maxLength = 0;
char *wordMaxLength = NULL;
int i = 0, j = 0;
char *w1 = NULL, *w2 = NULL /*con trỏ*/
intcurrLength1 = 0, currLength2 = 0;

//printArr(&ptrArray1[0], sizeArr1);
//printArr(&ptrArray2[0], sizeArr2);

cho (i = 0; i < sizeArr1; i++)
    {
    // để tìm từ lớn nhất trong mảng
    w1 = (ptrArray1[i]); // giá trị của địa chỉ (ptrArray1 + i)
    currLength1 = strlen(w1);
    //printf("Từ trong chuỗi đầu tiên là: %s và độ dài của nó là : %d \n", w1, currLength1); // điểm kiểm tra

    cho (j = 0; j < sizeArr2; j++)
        {
        w2 = (ptrArray2[j]); // giá trị của địa chỉ (ptrArray2 + j)
        currLength2 = strlen(w2);
        //printf("Từ trong chuỗi thứ hai là : %s và độ dài của nó là : %d \n", w2, currLength2 // điểm kiểm tra

        if (strcoll(w1, w2) == 0 && currLength1 == currLength2)
            // so sánh các chuỗi
            {
            if (currLength2 >= maxLength)
                // trong biến maxLength -> độ dài của từ dài nhất
                {
                    maxLength = currLength2;
                    wordMaxLength = w2;
                    printf("Từ lớn nhất hiện nay là : %s và độ dài của nó là : %d \n", wordMaxLength, maxLength); // điểm kiểm tra
                }
            }
        }
    }
printf("Từ lớn nhất là: %s \n", wordMaxLength);
printf("Độ dài của nó là: %d \n", maxLength);
    }



     int chính()
      {
int n = 80; /*số từ tối đa trong chuỗi*/
char ArrayS1[80], ArrayS2[80];
char *ptrArray1 = NULL, *ptrArray2 = NULL;
int sizeArr1 = 0, sizeArr2 = 0;

// để cấp phát bộ nhớ:
ptrArray1 = (char*)calloc(80, sizeof(char));
if(ptrArray1 == NULL)
{
    printf("Lỗi! Bộ nhớ cho con trỏ 1 không được cấp phát.");
    thoát (0);
}

ptrArray2 = (char*)calloc(80, sizeof(char));
if(ptrArray2 == NULL)
{
    printf("Lỗi! Bộ nhớ cho con trỏ 2 không được cấp phát.");
    thoát (0);
}

printf("Nhập chuỗi đầu tiên của bạn: ");
fgets(arrS1, 80, stdin);
sizeArr1 = returnArrayOfWords(arrS1, &ptrArray1); // sizeArr1 = số phần tử trong mảng 1

printf("Nhập chuỗi thứ hai của bạn: ");
fgets(arrS2, 80, stdin);
sizeArr2 = returnArrayOfWords(arrS2, &ptrArray2); // sizeArr2 = số phần tử trong mảng 2

findLargestWord(&ptrArray1, sizeArr1, &ptrArray2, sizeArr2);

miễn phí(ptrArray1);
miễn phí(ptrArray2);
return 0;
          }

Tôi cũng đã thử sử dụng hai giải pháp được đăng sau nhưng gặp phải vấn đề khi sử dụng chúng, như được giải thích bên dưới.

Bất kỳ trợ giúp nào về mã của tôi, sử dụng giải pháp sau cho vấn đề của tôi hoặc đề xuất một giải pháp mới đều được hoan nghênh. Cảm ơn tất cả các bạn trước!

tái bút Tôi xin lỗi nếu mã của tôi được đặt không đúng chỗ. Tôi vẫn chưa giỏi lắm trong việc sử dụng các vị trí.

câu trả lời hay nhất

Có nhiều cách để giải quyết vấn đề này. Dưới đây, một con trỏ tới từng ký tự trong một trong các chuỗi được sử dụng bằng cách sử dụng strchr Tìm kiếm các ký tự phù hợp trong một chuỗi khác. Sau khi tìm thấy ký tự trùng khớp, một vòng lặp so sánh sẽ được chạy, nâng từng con trỏ lên độ dài của chuỗi con công khai hiện tại (nếu có).

Các quy trình, khớp ký tự, kiểm tra độ dài chuỗi con, lặp lại, chỉ strchr Trả về một con trỏ hợp lệ và tiếp tục. Mỗi lần tìm thấy một chuỗi con dài hơn,max Độ dài được cập nhật để trả về và được sử dụng strncpy Và không kết thúc Sao chép chuỗi con hiện có vào r, để văn bản của chuỗi công khai dài nhất có sẵn cho hàm gọi chủ yếu Đây rồi.

Đây là một cách tiếp cận khá thô bạo và có thể yêu cầu một số điều chỉnh bổ sung để nâng cao hiệu quả. Bản thân chức năng này là:

/** trả về độ dài của chuỗi con chung dài nhất trong 'a' và 'b'.
 * bằng cách tìm kiếm từng ký tự trong 'a' cho mỗi kết quả phù hợp
 * trong 'b' và so sánh các chuỗi con có ở mỗi trận đấu.
 * trả về kích thước của chuỗi con dài nhất, việc kiểm tra chuỗi con
 * chuỗi con chung dài nhất được sao chép vào 'r' và được cung cấp
 * trong hàm gọi (độ dài cũng phải được thông qua).
 * để xác nhận, nhưng đó chỉ là bài tập)
 */
size_t maxspn (const char *a, const char *b, char *r)
{
    if (!a||!b||!*a||!*b) trả về 0; /* xác thực tham số */

    char *ap = (char *)a; /* con trỏ tới a */
    size_t max = 0; /* char chuỗi con tối đa */

    for (; *ap; ap++) { /* cho mỗi char trong một */
        char *bp = (char *)b; /* tìm kết quả khớp trong b với strchr */
        for (; *bp && (bp = strchr (bp, *ap)); bp++) {
            char *spa = ap, *spb = bp; /* tìm kiếm khởi tạo ptr */
            size_t len ​​​​= 0; /* tìm chuỗi con len */
            for (; *spa && *spb && *spa == *spb; spa++, spb++) len++;
            if (len > max) { /* if max, sao chép vào r */
                strncpy(r, ap, (max = len));
                r[max] = 0; /* kết thúc nul r */
            }
        }
    }

    return max;
}

Độ dài trả vềmax, sau đó cập nhật thànhrdẫn đếnrLưu chuỗi liên kết với chuỗi con dài nhất khớp.

Những cải tiến khác là loại bỏ được, nó đã bị xóa trong C11 mà không bị phản đối do các rủi ro bảo mật. Nó không còn được sử dụng bởi bất kỳ lập trình viên lành mạnh nào nữa (sẽ chiếm khoảng 40% trong số chúng ta). Đặt các bit còn lại lại với nhau, một đoạn mã kiểm tra nhỏ có thể là:

#include 
#include 

#defineMAXC 128

size_t maxspn (const char *a, const char *b, char *r);
void rmlf (char *s);

int chính (void) {

    char res[MAXC] = "", s[MAXC] = "", t[MAXC] = "";

    printf("Nhập vào một chuỗi 's': ");
    if (!fgets (s, MAXC, stdin)) { /* xác thực 's' */
        fprintf (stderr, "error: đầu vào không hợp lệ cho 's'.\n");
        return 1;
    }
    rmlf (s); /* xóa dòng mới ở cuối */
    printf ("Nhập chuỗi 't': ");
    if (!fgets (t, MAXC, stdin)) { /* xác thực 't' */
        fprintf (stderr, "error: đầu vào không hợp lệ cho 's'.\n");
        return 1;
    }
    rmlf (t); /* xóa dòng mới ở cuối */

    /* lấy chuỗi con chung dài nhất giữa 's' và 't' */
    printf ("\nChuỗi chung dài nhất là : %zu ('%s')\n",
            maxspn(s,t,res),res);

    return 0;
}

/** trả về độ dài của chuỗi con chung dài nhất trong 'a' và 'b'.
 * bằng cách tìm kiếm từng ký tự trong 'a' cho mỗi kết quả phù hợp
 * trong 'b' và so sánh các chuỗi con có ở mỗi trận đấu.
 * trả về kích thước của chuỗi con dài nhất, việc kiểm tra chuỗi con
 * chuỗi con chung dài nhất được sao chép vào 'r' và được cung cấp
 * trong hàm gọi (độ dài cũng phải được thông qua).
 * để xác nhận, nhưng đó chỉ là bài tập)
 */
size_t maxspn (const char *a, const char *b, char *r)
{
    if (!a||!b||!*a||!*b) trả về 0; /* xác thực tham số */

    char *ap = (char *)a; /* con trỏ tới a */
    size_t max = 0; /* char chuỗi con tối đa */

    for (; *ap; ap++) { /* cho mỗi char trong một */
        char *bp = (char *)b; /* tìm kết quả khớp trong b với strchr */
        for (; *bp && (bp = strchr (bp, *ap)); bp++) {
            char *spa = ap, *spb = bp;
            size_t len ​​​​= 0; /* tìm chuỗi con len */
            for (; *spa && *spb && *spa == *spb; spa++, spb++) len++;
            if (len > max) { /* if max, sao chép vào r */
                strncpy(r, ap, (max = len));
                r[max] = 0; /* kết thúc nul r */
            }
        }
    }

    return max;
}

/** xóa dòng mới ở cuối 's'.
khoảng trống rmlf (char *s)
{
    if (!s || !*s) trả về;
    for (; *s && *s != '\n'; s++) {}
    *s = 0;
}

Ví dụ sử dụng/đầu ra

$ ./bin/strspn
Nhập vào một chuỗi 's': một chuỗi có màu123456789 toàn màu xanh
Nhập chuỗi 't': chuỗi không có màu1234567890 toàn màu đỏ

Chuỗi chung dài nhất là: 16 ('colors123456789')

Hoặc, một cái khác có thể dễ hình dung hơn:

$ ./bin/strspn
Gõ vào chuỗi 's': lươn xanh
Gõ vào chuỗi 't': thép xanh lạnh

Chuỗi chung dài nhất là: 3 ('eel')

Nhìn vào mã và so sánh với các câu trả lời khác. Nếu bạn có bất kỳ câu hỏi nào khác xin vui lòng cho tôi biết. Một số xác nhận bổ sung cũng cần được thêm vào để đảm bảo rằng văn bản không vượt quá cuối bộ đệm, v.v. Hy vọng điều này sẽ cung cấp một số trợ giúp hoặc một giải pháp thay thế.

chuỗi con bổ sung

Để chắc chắn rằng bạn và tôi đang nhìn thấy điều tương tự, tôi đã đưa thêm nhiều ví dụ sử dụng hơn vào bên dưới. Không có lỗi và mã thực thi như mong đợi. Nếu bạn gặp khó khăn khi sửa đổi mã của mình, hãy cho tôi biết bạn đang cố gắng làm gì và tôi có thể trợ giúp. Mọi gia tăng con trỏ trong mã của tôi ở trên đều được xác minh. Nếu bạn thay đổi mức tăng của con trỏ hoặcchấm dứt vô hiệu Bất cứ điều gì, mã sẽ không hoạt động trừ khi bạn cũng tính đến những thay đổi trong quá trình xác thực.

$ ./bin/strspn
Nhập chuỗi 's': 1
Nhập chuỗi 't':

Chuỗi chung dài nhất là: 0 ('')

$ ./bin/strspn
Gõ vào chuỗi 's': A man a plan a Canal Panama
Nhập chuỗi 't': a man a plan a river panama

Chuỗi chung dài nhất là: 14 ('man a plan a')

$ ./bin/strspn
Nhập vào một chuỗi 's': đây là chuỗi tôi yêu thích
Nhập chuỗi 't': đây là chuỗi tôi yêu thích

Chuỗi chung dài nhất là: 18 ('đây là chuỗi yêu thích của tôi')

$ ./bin/strspn
Nhập một chuỗi 's': không giống nhau cho đến đây
Nhập chuỗi 't': không thể bằng nhau cho đến đây

Chuỗi chung dài nhất là: 6 ('l here')

$ ./bin/strspn
Nhập một chuỗi 's': một số str có 10 ở giữa
Nhập chuỗi 't': chuỗi thường bị bỏ qua

Chuỗi chung dài nhất là: 5 ('ten i')

từ chung dài nhất

Được rồi, bây giờ tôi đã hiểu bạn muốn đạt được điều gì, bạn có thể thực hiện việc này tại 'S' Và ' Chọn giữa hai chuỗi nàytừ chung dài nhất ' Bằng cách sử dụng strtoktoken hóa Đối với mỗi chuỗi, hãy lưu một con trỏ tới mỗi từ trong mỗi chuỗi trong một mảng con trỏ riêng biệt và chỉ cần lặp lại mảng con trỏ để chọn từ chung dài nhất (nếu có nhiều từ chung có cùng độ dài) cho từ đầu tiên ). Tất cả những gì bạn cần là một cái gì đó đơn giản như dưới đây.

Để ý strtok Sửa đổi chuỗi'S' Và't', nên nếu sao chép bạn cần giữ nguyên bản gốc.

/** trả về độ dài của từ chung dài nhất trong 'a' và 'b'.
 * bằng cách mã hóa từng từ trong 'a' & 'b' và lặp lại
 * mỗi cái, trả về độ dài của trận đấu lớn nhất và cập nhật
 * 'r' để chứa từ phổ biến dài nhất.
 */
size_t maxspnwhole (char *a, char *b, char *r)
{
    if (!a||!b||!*a||!*b) trả về 0; /* xác thực tham số */

    char *arra[MAXC] = {NULL}, *arrb[MAXC] = {NULL};
    char *ap = a, *bp = b /* trỏ tới a & b */
    char *delim = " .,-;\t\n"; /* dấu phân cách từ */
    size_t i, j, len, max, na, nb /* len, max, n-words */
    len = max = na = nb = 0;

    /* mã hóa cả hai chuỗi thành mảng con trỏ */
    cho (ap = strtok (a, delim); ap; ap = strtok (NULL, delim))
        mảng[na++] = ap;

    cho (bp = strtok (b, delim); bp; bp = strtok (NULL, delim))
        arb[nb++] ​​​​= bp;

    for (i = 0; i < na; i++) /* chọn từ chung dài nhất */
        vì (j = 0; j < nb; j++)
            if (*arra[i] == *arrb[j]) /* Ký tự đầu tiên khớp */
                if (!strcmp (arra[i], arrb[j])) { /* kiểm tra từ */
                    len = strlen(arra[i]);
                    if (len > max) { /* if dài nhất */
                        max = len /* cập nhật tối đa */
                        strcpy (r, arra[i]); /* sao chép vào r */
                    }
                }

    return max;
}

Tích hợp nó với mã khác và bạn có thể so sánh kết quả như sau:

#include 
#include 

#defineMAXC 128

size_t maxspn (const char *a, const char *b, char *r);
size_t maxspnwhole (char *a, char *b, char *r);
void rmlf (char *s);

int chính (void) {

    char res[MAXC] = "", s[MAXC] = "", t[MAXC] = "";

    printf("Nhập vào một chuỗi 's': ");
    if (!fgets (s, MAXC, stdin)) { /* xác thực 's' */
        fprintf (stderr, "error: đầu vào không hợp lệ cho 's'.\n");
        return 1;
    }
    rmlf (s); /* xóa dòng mới ở cuối */
    printf ("Nhập chuỗi 't': ");
    if (!fgets (t, MAXC, stdin)) { /* xác thực 't' */
        fprintf (stderr, "error: đầu vào không hợp lệ cho 's'.\n");
        return 1;
    }
    rmlf (t); /* xóa dòng mới ở cuối */

    /* lấy chuỗi con chung dài nhất giữa 's' và 't' */
    printf ("\nChuỗi chung dài nhất là : %zu ('%s')\n",
            maxspn(s,t,res),res);

    /* lấy từ chung dài nhất giữa 's' và 't' */
    printf ("\nTừ thông dụng dài nhất là : %zu ('%s')\n",
            maxspnwhole (s, t, res), res);

    return 0;
}

/** trả về độ dài của từ chung dài nhất trong 'a' và 'b'.
 * bằng cách mã hóa từng từ trong 'a' & 'b' và lặp lại
 * mỗi cái, trả về độ dài của trận đấu lớn nhất và cập nhật
 * 'r' để chứa từ phổ biến dài nhất.
 */
size_t maxspnwhole (char *a, char *b, char *r)
{
    if (!a||!b||!*a||!*b) trả về 0; /* xác thực tham số */

    char *arra[MAXC] = {NULL}, *arrb[MAXC] = {NULL};
    char *ap = a, *bp = b /* trỏ tới a & b */
    char *delim = " .,-;\t\n"; /* dấu phân cách từ */
    size_t i, j, len, max, na, nb /* len, max, n-words */
    len = max = na = nb = 0;

    /* mã hóa cả hai chuỗi thành mảng con trỏ */
    cho (ap = strtok (a, delim); ap; ap = strtok (NULL, delim))
        mảng[na++] = ap;

    cho (bp = strtok (b, delim); bp; bp = strtok (NULL, delim))
        arb[nb++] ​​​​= bp;

    vì (i = 0; i < na; i++)
        vì (j = 0; j < nb; j++)
            nếu (*arra[i] == *arrb[j])
                if (!strcmp (arra[i], arrb[j])) {
                    len = strlen(arra[i]);
                    nếu (len > tối đa) {
                        max = len;
                        strcpy (r, mảng [i]);
                    }
                }

    return max;
}

/** trả về độ dài của chuỗi con chung dài nhất trong 'a' và 'b'.
 * bằng cách tìm kiếm từng ký tự trong 'a' cho mỗi kết quả phù hợp
 * trong 'b' và so sánh các chuỗi con có ở mỗi trận đấu.
 * trả về kích thước của chuỗi con dài nhất, việc kiểm tra chuỗi con
 * chuỗi con chung dài nhất được sao chép vào 'r' và được cung cấp
 * trong hàm gọi (độ dài cũng phải được thông qua).
 * để xác nhận, nhưng đó chỉ là bài tập)
 */
size_t maxspn (const char *a, const char *b, char *r)
{
    if (!a||!b||!*a||!*b) trả về 0; /* xác thực tham số */

    char *ap = (char *)a; /* con trỏ tới a */
    size_t max = 0; /* char chuỗi con tối đa */

    for (; *ap; ap++) { /* cho mỗi char trong một */
        char *bp = (char *)b; /* tìm kết quả khớp trong b với strchr */
        for (; *bp && (bp = strchr (bp, *ap)); bp++) {
            char *spa = ap, *spb = bp;
            size_t len ​​​​= 0; /* tìm chuỗi con len */
            for (; *spa && *spb && *spa == *spb; spa++, spb++) len++;
            if (len > max) { /* if max, sao chép vào r */
                strncpy(r, ap, (max = len));
                r[max] = 0; /* kết thúc nul r */
            }
        }
    }

    return max;
}

/** xóa dòng mới ở cuối 's'.
khoảng trống rmlf (char *s)
{
    if (!s || !*s) trả về;
    for (; *s && *s != '\n'; s++) {}
    *s = 0;
}

Ví dụ sử dụng/đầu ra

$ ./bin/strlongestcmn
Gõ vào chuỗi 's': Tôi có một chiếc thuyền lớn.
Gõ vào chuỗi 't': Tôi có một chiếc thuyền nhỏ.

Chuỗi chung dài nhất là: 9 ('Tôi có một ')

Từ thông dụng dài nhất là: 4 ('have')

Hãy đọc kỹ và cho tôi biết nếu bạn có thêm bất kỳ câu hỏi nào.

Về c - Ngôn ngữ C để tìm từ chung (công khai) dài nhất trong hai chuỗi? , chúng tôi đã tìm thấy một câu hỏi tương tự trên Stack Overflow: https://stackoverflow.com/questions/37235367/