Reverse a String Without Affecting Special Characters

var stringIn = 'My! name.is@rin';var rev = stringIn.replace(/[a-z]+/gi, function(s){return s.split('').reverse().join('')});document.write(rev); // yM! eman.si@nir

Reverse string without affecting specific characters that user can input

In your code, when you swap values at 2 positions, they both have to be valid characters, meaning, both alphabetic and not of the characters of ignore. Second issue is you are equating a character of ignore directly with left pointer of the rev string in ign[i] == str[l]. They need not coincide index-wise this way.

Algorithm:

• Create a set of all the characters in ignore.
• Create a result array of type char with length same as rev.
• Create another reserved boolean array with length same as rev.
• Now, loop on rev char by char. If it is non-alphabetic or one of the chars of ignore, fix that position with that char. In reserved, mark this index as true as we can't mess with this index now.
• Once done, move again on the string rev from left to right and this time only consider alphabetic chars and the ones which aren't a part of ignore. Now, add them in a reverse way inside result to actually store in the reversed state. Note that the next non-reserved location won't always be sequential in nature with a simple ptr--. We would need a while loop inside to get the next non reserved seat and insert them there.

Snippet:

public static String reverseString(String rev, String ignore) {
  Set<Character> set = new HashSet<>();
  for(int i = 0; i < ignore.length(); ++i){
    set.add(ignore.charAt(i));
  }
  
  char[] result = new char[rev.length()];
  boolean[] reserved = new boolean[rev.length()];
  
  
  for(int i = 0; i < rev.length(); ++i){
    if(!Character.isAlphabetic(rev.charAt(i)) || set.contains(rev.charAt(i))){
      result[i] = rev.charAt(i);
      reserved[i] = true;
    }
  }
  
  int ptr = rev.length() - 1;
  for(int i = 0; i < rev.length(); ++i){
    if(Character.isAlphabetic(rev.charAt(i)) && !set.contains(rev.charAt(i))){
      while(ptr >= 0 && reserved[ptr]) ptr--;
      result[ptr--] = rev.charAt(i);
    }
  }
  
  return new String(result);
}

Online Demo

How to reverse an array of strings without changing the position of special characters in C#

A basic solution with regex and LINQ. Try it online.

public static void Main()
{
    Console.WriteLine("Marshall! Hello.");
    Console.WriteLine(Reverse("Marshall! Hello."));
}

public static string Reverse(string source)
{
    // we split by groups to keep delimiters
    var parts = Regex.Split(source, @"([^a-zA-Z0-9])");
    // if we got a group of valid characters
    var results = parts.Select(x => x.All(char.IsLetterOrDigit)
            // we reverse it
            ? new string(x.Reverse().ToArray())
            // or we keep the delimiters as it
            : x);
    // then we concat all of them
    return string.Concat(results);
}

The same solution without LINQ. Try it online.

public static void Main()
{
    Console.WriteLine("Marshall! Hello.");
    Console.WriteLine(Reverse("Marshall! Hello."));

}

public static bool IsLettersOrDigits(string s)
{
    foreach (var c in s)
    {
        if (!char.IsLetterOrDigit(c))
        {
            return false;
        }
    }
    return true;
}

public static string Reverse(char[] s)
{
    Array.Reverse(s);
    return new string(s);
}


public static string Reverse(string source)
{
    var parts = Regex.Split(source, @"([^a-zA-Z0-9])");

    var results = new List<string>();
    foreach(var x in parts)
    {
        results.Add(IsLettersOrDigits(x)
                   ? Reverse(x.ToCharArray())
                   : x);
    }
    return string.Concat(results);
}

Related Topics