Tôi đang tạo một chương trình kiểm tra xem một từ có phải là một từ được đơn giản hóa hay không (txt, msg, v.v.) và nếu đó là một từ được đơn giản hóa thì nó sẽ tìm ra cách viết đúng như txt=text, msg=message. Tôi đang sử dụng phương pháp gợi ý NHunspell trong C# và nó gợi ý tất cả các kết quả có thể xảy ra.

Vấn đề là, nếu tôi gõ "txt", kết quả là văn bản, tat, tot, v.v. Tôi không biết chọn từ ngữ sao cho phù hợp. Tôi đã sử dụng khoảng cách Levenshtein ( C# - So sánh độ giống nhau của chuỗi ), nhưng kết quả vẫn là 1.

Dữ liệu vào: txt Kết quả: text = 1, ext = 1 tit = 1

Bạn có thể giúp tôi hiểu nghĩa hoặc viết đúng chính tả của từ đơn giản được không? Ví dụ: Tin nhắn

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

Tôi đã kiểm tra thông tin đầu vào của bạn bằng dữ liệu mẫu và chỉ text có khoảng cách là 25, trong khi cái còn lại có khoảng cách là 33. Đây là mã của tôi:

đầu vào chuỗi = "TXT";
chuỗi[] từ = mới[]{"văn bản","tat","tot"};
var levenshtein = new levenshtein();  
const int maxDistance = 30;

var khoảng cáchNhóm = từ
        .Select(w => mới
        {
            Từ = w,
            Khoảng cách = levenshtein.iLD(w.ToUpperInvariant(), input)
        })
        .Where(x => x.Distance <= maxDistance)
        .GroupBy(x => x.Khoảng cách)
        .OrderBy(g => g.Key)
        .ToList();
foreach (var topCandidate trong distanceGroups.First())
    Console.WriteLine("Word:{0} Khoảng cách:{1}", topCandidate.Word, topCandidate.Distance);

Đây là lớp levenshtein:

lớp công cộng Levenshtein
{
    ///***************************
    /// Tính khoảng cách Levenshtein 
    /// Phiên bản hiệu quả về bộ nhớ
    ///***************************
    public int iLD(Chuỗi sRow, Chuỗi sCol)
    {
        int RowLen = sRow.Length; // độ dài của sRow
        int ColLen = sCol.Length; // độ dài của sCol
        int RowIdx; // lặp qua sRow
        int ColIdx; // lặp qua sCol
        char Row_i; // ký tự thứ i của sRow
        char Col_j; // ký tự thứ j của sCol
        giá int; // giá

        /// Kiểm tra độ dài chuỗi
        if (Math.Max(sRow.Length, sCol.Length) > Math.Pow(2, 31))
            ném (Ngoại lệ mới("\nĐộ dài chuỗi tối đa trong Levenshtein.iLD là " + Math.Pow(2, 31) + ".\nCủa bạn là " + Math.Max(sRow.Length, sCol.Length) + ".") );

        // Bước 1

        nếu (RowLen == 0)
        {
            returnColLen;
        }

        nếu (ColLen == 0)
        {
            trả về RowLen;
        }

        /// Tạo hai vectơ
        int[] v0 = new int[RowLen + 1];
        int[] v1 = new int[RowLen + 1];
        int[] vTmp;



        /// Bước 2
        /// Khởi tạo vector đầu tiên
        cho (RowIdx = 1; RowIdx <= RowLen; RowIdx++)
        {
            v0[RowIdx] = RowIdx;
        }

        // Bước 3

        /// Trước mỗi cột
        cho (ColIdx = 1; ColIdx <= ColLen; ColIdx++)
        {
            /// Đặt phần tử thứ 0 thành số cột
            v1[0] = ColIdx;

            Col_j = sCol[ColIdx - 1];


            // Bước 4

            /// Trước mỗi hàng
            cho (RowIdx = 1; RowIdx <= RowLen; RowIdx++)
            {
                Row_i = sRow[RowIdx - 1];


                // Bước 5

                nếu (Hàng_i == Col_j)
                {
                    chi phí = 0;
                }
                khác
                {
                    chi phí = 1;
                }

                // Bước 6

                /// Tìm giá trị nhỏ nhất
                int m_min = v0[RowIdx] + 1;
                int b = v1[RowIdx - 1] + 1;
                int c = v0[RowIdx - 1] + chi phí;

                nếu (b < m_min)
                {
                    m_min = b;
                }
                nếu (c < m_min)
                {
                    m_min = c;
                }

                v1[RowIdx] = m_min;
            }

            /// Hoán đổi các vectơ
            vTmp = v0;
            v0 = v1;
            v1 = vTmp;

        }

        // Bước 7

        /// Giá trị trong khoảng 0 - 100
        /// 0==kết hợp hoàn hảo 100==hoàn toàn khác
        /// 
        /// Các vectơ được hoán đổi lần cuối ở cuối vòng lặp cuối cùng,
        /// đó là lý do tại sao kết quả bây giờ là v0 chứ không phải v1
        //System.Console.WriteLine("iDist=" + v0[RowLen]);
        int max = System.Math.Max(RowLen, ColLen);
        return ((100 * v0[RowLen]) / max);
    }


    ///***************************
    /// Tính số phút
    ///***************************

    int riêng tư Tối thiểu(int a, int b, int c)
    {
        int mi = a;

        nếu (b < mi)
        {
            mi = b;
        }
        nếu (c < mi)
        {
            mi = c;
        }

        returnmi;
    }

    ///***************************
    /// Tính khoảng cách Levenshtein         
    ///***************************
    public int LD(Chuỗi sMới, Chuỗi bánOld)
    {
        ma trận int[,];
        int sNewLen = sNew.Length; // độ dài của sNew
        int sOldLen = sOld.Length; // độ dài của sOld
        int sNewIdx; // lặp qua sNew
        int sOldIdx; // lặp qua sOld
        char sNew_i; // ký tự thứ i của sNew
        char sOld_j; // ký tự thứ j của sOld
        giá int; // giá

        /// Kiểm tra độ dài chuỗi
        if (Math.Max(sNew.Length, sOld.Length) > Math.Pow(2, 31))
            ném (Ngoại lệ mới("\nĐộ dài chuỗi tối đa trong Levenshtein.LD là " + Math.Pow(2, 31) + ".\nCủa bạn là " + Math.Max(sNew.Length, sOld.Length) + ".") );

        // Bước 1

        nếu (sNewLen == 0)
        {
            trả lại sOldLen;
        }

        nếu (sOldLen == 0)
        {
            trả về sNewLen;
        }

        ma trận = new int[sNewLen + 1, sOldLen + 1];

        // Bước 2

        cho (sNewIdx = 0; sNewIdx <= sNewLen; sNewIdx++)
        {
            ma trận[sNewIdx, 0] = sNewIdx;
        }

        cho (sOldIdx = 0; sOldIdx <= sOldLen; sOldIdx++)
        {
            ma trận[0, sOldIdx] = sOldIdx;
        }

        // Bước 3

        cho (sNewIdx = 1; sNewIdx <= sNewLen; sNewIdx++)
        {
            sNew_i = sNew[sNewIdx - 1];

            // Bước 4

            cho (sOldIdx = 1; sOldIdx <= sOldLen; sOldIdx++)
            {
                sOld_j = sOld[sOldIdx - 1];

                // Bước 5

                nếu (sNew_i == sOld_j)
                {
                    chi phí = 0;
                }
                khác
                {
                    chi phí = 1;
                }

                // Bước 6

                ma trận[sNewIdx, sOldIdx] = Tối thiểu(matrix[sNewIdx - 1, sOldIdx] + 1, ma trận[sNewIdx, sOldIdx - 1] + 1, ma trận[sNewIdx - 1, sOldIdx - 1] + chi phí);

            }
        }

        // Bước 7

        /// Giá trị trong khoảng 0 - 100
        /// 0==kết hợp hoàn hảo 100==hoàn toàn khác
        //System.Console.WriteLine("Dist=" + ma trận[sNewLen, sOldLen]);
        int max = System.Math.Max(sNewLen, sOldLen);
        return (100 * ma trận[sNewLen, sOldLen]) / max;
    }
}

Về C# - cách đo độ giống nhau của 2 chuỗi ngoài việc tính khoảng cách, 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/17748969/