How do I extract the differences between two strings

Question

0.00/5 (No votes)

See more:

I am currently trying to convert the following strings into the following formats, but I am hitting a snag. I will send code to the closest thing that works, but it completely misses all but the last character in a change, and it also misses the extra letters that can be at the end of the string.

Here is an example of what I am looking for:

"Apple" and "Epple" should return "[A->E]"
"Epple" and "Apple" should return "[E->A]"
"Apple" and "Aple" should return "[-p]"
"Aple" and "Apple" should return "[+p]"
"Apples" and "Apple" should return "[-s]"
"Apple" and "Apples" should return "[+s]"
"The Apple" and "Apple" should return "[-T] [-h] [-e] [- ]"
"Apple" and "The Apple" should return "[+T] [+h] [+e] [+ ]"
- bonus points if you can "[+The ]" and "[-The ]"

What I have tried:

Here is the code I have so far:

C#

String previous = "Apple";
String current = "The Apple";

List<String> delta = new List<string>();

int i = 0;
int ii = 0;
List<char> section = new List<char>();

for (i = 0; i < previous.Length; i++)
{
    if (ii < current.Length - 1 && previous[i] != current[ii])
    {
        if (i < previous.Length - 1 && previous[i + 1] == current[ii])
        {
            delta.Add("[-" + previous[i] + "]");
            loggedDeltas.Add(false);
            lettersum -= previous.ToUpper()[i] - 64;
            binarysum--;
            //i++;
            ii--;
        }
        else if (ii < current.Length - 1 && previous[i] == current[ii + 1])
        {
            delta.Add("[+" + current[ii] + "]");
            loggedDeltas.Add(true);
            lettersum += current.ToUpper()[ii] - 64;
            binarysum++;
            ii++;
        }

        else if (i < previous.Length - 1 && ii < current.Length - 1 && previous[i + 1] == current[ii + 1])
        {
            delta.Add("[" + previous[i] + ">" + current[ii] + "]");
            lettersum += (current.ToUpper()[ii] - 64) - (previous.ToUpper()[i] - 64);
            if (current.ToUpper()[ii] - previous.ToUpper()[i] > 0)
            {
                loggedDeltas.Add(true);
                binarysum++;
            }
            else
            {
                loggedDeltas.Add(false);
                binarysum--;
            }
        }
    }
    ii++;
}

Posted 16-Jun-24 16:50pm

Daisy Eseyad

Add a Solution

4 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

OriginalGriff · Answer 1 · 2024-06-16T19:27:00

Solution 1

This may help: An O(ND) Difference Algorithm for C#[^]

Posted 16-Jun-24 19:27pm

OriginalGriff

Comments

Daisy Eseyad 17-Jun-24 13:14pm

Thanks, i'll see if I can understand which parts I need for a single line.

Pete O'Hanlon · Answer 2 · 2024-06-16T21:26:00

There are a lot of things that you can do to help yourself here, that will teach you to be a better developer. One of the primary techniques that you need to learn is how to debug code for yourself plus, I see you doing things in there that aren't being asked for in the question (there's no need to do case-sensitive comparisons).

Start small, and put in two character words such as Io and So. Step through your code, line by line and pay attention to the value of the index that you are comparing; this will tell you if you are checking what you think you are checking.

As a professional developer, you will spend a lot of time debugging code. This is your opportunity to start mastering a skill that will see you through the rest of your career. Good luck.

George Swan · Answer 3 · 2024-06-17T21:31:00

Looking at your examples, it seems that there are two types of comparisons taking place between pairs of strings.

If the strings are of the same length, the characters at the same index that do not match each other are being selected.

If the strings are of different lengths, the larger string’s characters are transversed and compared sequentially with characters in the smaller string. If there is a mismatch, the missing character is selected. When this case arises, the larger string’s index position is increased but the smaller string’s index is not. The transversal continues until the end of the larger string is reached. A sign character is attached to the missing character to indicate what string is the smaller, a ‘-’ for the second string and a ‘+’ for the first.

A good approach would be to use a value tuple to store the strings with the left string holding the larger string and a bool to indicate the position sign. (string left, string right, bool isNegative). Tuples are useful as they are easy to deconstruct, lightweight and reduce the need to have to keep indexing into arrays. I would pad the shorter string with trailing spaces to avoid the ‘index out of bounds’ nonsense. The basic set up would be something along these lines.

C#

//step through the list in pairs
for (int i = 0; i < TestData.Count - 1; i += 2)
  {
    //use a Tuple to hold the pairs.
    //Set the isNegative flag if the right length is not greater than the left length
    // put the largest string on the left
    (string left, string right, bool isNegative) = (TestData[i + 1].Length > TestData[i].Length) ?
    (TestData[i + 1], TestData[i], false) : (TestData[i], TestData[i + 1], true);
    //set an isEqualLength flag as equal length strings are treated differently
    bool isEqualLength = left.Length == right.Length;
    //pad out the right string if needed so both are of equal  length
    right = right.PadRight(left.Length);
    int p = 0;
     for (int n = 0; n < left.Length; n++)
      {
   //..........

I hope this is of some help to you. Best wishes.

Maciej Los · Answer 4 · 2024-06-18T06:03:00

Solution 4

What you're looking for is String metric algorithms[^]
There is few of algorithms, such as: Levenshtein distance - Wikipedia[^], Hamming distance - Wikipedia[^], etc.

Good luck!

Posted 18-Jun-24 6:03am

Maciej Los

How do I extract the differences between two strings

4 solutions

Solution 1

Solution 2

Solution 3

Solution 4

Add your solution here

Preview 0