What is the fastest way to replace extra white spaces to one white space?
e.g.
from
foo bar
to
foo bar
c# Fastest way to remove extra white spaces
Viewed 81882
29 Answers
I've tried with an array and with no if.
Results
PS C:\dev\Spaces> dotnet run -c release
// .NETCoreApp,Version=v3.0
Seed=7, n=20, s.Length=2828670
Regex by SLaks 1407ms, len=996757
StringBuilder by Blindy 154ms, len=996757
Array 130ms, len=996757
NoIf 91ms, len=996757
All match!
Methods
private static string WithNoIf(string s)
{
var dst = new char[s.Length];
uint end = 0;
char prev = char.MinValue;
for (int k = 0; k < s.Length; ++k)
{
var c = s[k];
dst[end] = c;
// We'll move forward if the current character is not ' ' or if prev char is not ' '
// To avoid 'if' let's get diffs for c and prev and then use bitwise operatios to get
// 0 if n is 0 or 1 if n is non-zero
uint x = (uint)(' ' - c) + (uint)(' ' - prev); // non zero if any non-zero
end += ((x | (~x + 1)) >> 31) & 1; // https://stackoverflow.com/questions/3912112/check-if-a-number-is-non-zero-using-bitwise-operators-in-c by ruslik
prev = c;
}
return new string(dst, 0, (int)end);
}
private static string WithArray(string s)
{
var dst = new char[s.Length];
int end = 0;
char prev = char.MinValue;
for (int k = 0; k < s.Length; ++k)
{
char c = s[k];
if (c != ' ' || prev != ' ') dst[end++] = c;
prev = c;
}
return new string(dst, 0, end);
}
Test code
public static void Main()
{
const int n = 20;
const int seed = 7;
string s = GetTestString(seed);
var fs = new (string Name, Func<string, string> Func)[]{
("Regex by SLaks", WithRegex),
("StringBuilder by Blindy", WithSb),
("Array", WithArray),
("NoIf", WithNoIf),
};
Console.WriteLine($"Seed={seed}, n={n}, s.Length={s.Length}");
var d = new Dictionary<string, string>(); // method, result
var sw = new Stopwatch();
foreach (var f in fs)
{
sw.Restart();
var r = "";
for( int i = 0; i < n; i++) r = f.Func(s);
sw.Stop();
d[f.Name] = r;
Console.WriteLine($"{f.Name,-25} {sw.ElapsedMilliseconds,4}ms, len={r.Length}");
}
Console.WriteLine(d.Values.All( v => v == d.Values.First()) ? "All match!" : "Not all match! BAD");
}
private static string GetTestString(int seed)
{
// by blindy from https://stackoverflow.com/questions/6442421/c-sharp-fastest-way-to-remove-extra-white-spaces
var rng = new Random(seed);
// random 1mb+ string (it's slow enough...)
StringBuilder ssb = new StringBuilder(1 * 1024 * 1024);
for (int i = 0; i < 1 * 1024 * 1024; ++i)
if (rng.Next(5) == 0)
ssb.Append(new string(' ', rng.Next(20)));
else
ssb.Append((char)(rng.Next(128 - 32) + 32));
string s = ssb.ToString();
return s;
}
I don't know if it's the fastest way but i use this and this is worked for me:
/// <summary>
/// Remove all extra spaces and tabs between words in the specified string!
/// </summary>
/// <param name="str">The specified string.</param>
public static string RemoveExtraSpaces(string str)
{
str = str.Trim();
StringBuilder sb = new StringBuilder();
bool space = false;
foreach (char c in str)
{
if (char.IsWhiteSpace(c) || c == (char)9) { space = true; }
else { if (space) { sb.Append(' '); }; sb.Append(c); space = false; };
}
return sb.ToString();
}
I just whipped this up, haven't tested it yet though. But I felt this was elegant, and avoids regex:
/// <summary>
/// Removes extra white space.
/// </summary>
/// <param name="s">
/// The string
/// </param>
/// <returns>
/// The string, with only single white-space groupings.
/// </returns>
public static string RemoveExtraWhiteSpace(this string s)
{
if (s.Length == 0)
{
return string.Empty;
}
var stringBuilder = new StringBuilder();
var whiteSpaceCount = 0;
foreach (var character in s)
{
if (char.IsWhiteSpace(character))
{
whiteSpaceCount++;
}
else
{
whiteSpaceCount = 0;
}
if (whiteSpaceCount > 1)
{
continue;
}
stringBuilder.Append(character);
}
return stringBuilder.ToString();
}
I know this is really old, but the easiest way to compact whitespace (replace any recurring whitespace character with a single "space" character) is as follows:
public static string CompactWhitespace(string astring)
{
if (!string.IsNullOrEmpty(astring))
{
bool found = false;
StringBuilder buff = new StringBuilder();
foreach (char chr in astring.Trim())
{
if (char.IsWhiteSpace(chr))
{
if (found)
{
continue;
}
found = true;
buff.Append(' ');
}
else
{
if (found)
{
found = false;
}
buff.Append(chr);
}
}
return buff.ToString();
}
return string.Empty;
}
I'm not very familiar with C#, hence my code is not an elegant/most efficient one. I came here to find an answer that fits my use case, but I couldn't find one (or I couldn't figure out one).
For my use case, I needed to normalize all the White Spaces (WS:{space, tab, cr lf}) with the following conditions:
- WS can come in any combination
- Replace a sequence of WS with the most significant WS
tabneed to be retained in some cases (a tab separated file, for eg. and in that case repeated tabs also need to be preserved). But in most cases they have to be converted into spaces.
So here's a sample input and an expected output (Disclaimer: my code is test only for this example)
Every night in my dreams I see you, I feel you
That's how I know you go on
Far across the distance and places between us
You have come to show you go on
to be converted into
Every night in my dreams I see you, I feel you
That's how I know you go on
Far across the distance and places between us
You have come to show you go on
Here's my code
using System;
using System.Text.RegularExpressions;
public class Program
{
public static void Main(string text)
{
bool preserveTabs = false;
//[Step 1]: Clean up white spaces around the text
text = text.Trim();
//Console.Write("\nTrim\n======\n" + text);
//[Step 2]: Reduce repeated spaces to single space.
text = Regex.Replace(text, @" +", " ");
// Console.Write("\nNo repeated spaces\n======\n" + text);
//[Step 3]: Hande Tab spaces. Tabs needs to treated with care because
//in some files tabs have special meaning (for eg Tab seperated files)
if(preserveTabs)
{
text = Regex.Replace(text, @" *\t *", "\t");
}
else
{
text = Regex.Replace(text, @"[ \t]+", " ");
}
//Console.Write("\nTabs preserved\n======\n" + text);
//[Step 4]: Reduce repeated new lines (and other white spaces around them)
//into a single new line.
text = Regex.Replace(text, @"([\t ]*(\n)+[\t ]*)+", "\n");
Console.Write("\nClean New Lines\n======\n" + text);
}
}
See this code in action here: https://dotnetfiddle.net/eupjIU
What if you adjust famos algo - in this case to compare "similar" strings - case in-sensitive & do not care about multi spaces and can stand NULLs too. Do not trust benchmarks - this one was put into a data compare intensive task, aprox. 1/4GB data and speed-up is arround 100% (commented part vs this algo 5/10min) on whole action. Some of these here had less arround 30% difference. Would tell building best algo will need go to disassembly and check what will compiler do with in both release or debug build. Here also half simpler a fulltrim as answer to similar (C question), case sensitive yet.
public static bool Differs(string srcA, string srcB)
{
//return string.Join(" ", (a?.ToString()??String.Empty).ToUpperInvariant().Split(new char[0], StringSplitOptions.RemoveEmptyEntries).ToList().Select(x => x.Trim()))
// != string.Join(" ", (b?.ToString()??String.Empty).ToUpperInvariant().Split(new char[0], StringSplitOptions.RemoveEmptyEntries).ToList().Select(x => x.Trim()));
if (srcA == null) { if (srcB == null) return false; else srcA = String.Empty; } // A == null + B == null same or change A to empty string
if (srcB == null) { if (srcA == null) return false; else srcB = String.Empty; }
int dstIdxA = srcA.Length, dstIdxB = srcB.Length; // are there any remaining (front) chars in a string ?
int planSpaceA = 0, planSpaceB = 0; // state automaton 1 after non-WS, 2 after WS
bool validA, validB; // are there any remaining (front) chars in a array ?
char chA = '\0', chB = '\0';
spaceLoopA:
if (validA = (dstIdxA > 0)) {
chA = srcA[--dstIdxA];
switch (chA) {
case '!': case '"': case '#': case '$': case '%': case '&': case '\'': case '(': case ')': case '*': case '+': case ',': case '-':
case '.': case '/': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case ':':
case ';': case '<': case '=': case '>': case '?': case '@': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T':
case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '[': case '\\': case ']': case '^': case '_': case '`': // a-z will be | 32 to Upper
case '{': case '|': case '}': case '~':
break; // ASCII except lowercase
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i':
case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
chA = (Char)(chA & ~0x20);
break;
case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001':
case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006':
case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F':
case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009':
case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085':
if (planSpaceA == 1) planSpaceA = 2; // cycle here to address multiple WS before non-WS part
goto spaceLoopA;
default:
chA = Char.ToUpper(chA);
break;
}}
spaceLoopB:
if (validB = (dstIdxB > 0)) { // 2nd string / same logic
chB = srcB[--dstIdxB];
switch (chB) {
case '!': case '"': case '#': case '$': case '%': case '&': case '\'': case '(': case ')': case '*': case '+': case ',': case '-':
case '.': case '/': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case ':':
case ';': case '<': case '=': case '>': case '?': case '@': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T':
case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '[': case '\\': case ']': case '^': case '_': case '`': // a-z will be | 32 to Upper
break;
case '{': case '|': case '}': case '~':
break; // ASCII except lowercase
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i':
case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
chB = (Char)(chB & ~0x20);
break;
case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001':
case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006':
case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F':
case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009':
case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085':
if (planSpaceB == 1) planSpaceB = 2;
goto spaceLoopB;
default:
chB = Char.ToUpper(chB);
break;
}}
if (planSpaceA != planSpaceB) return true; // both should/not have space now (0 init / 1 last non-WS / 2 last was WS)
if (validA) { // some (non-WS) in A still
if (validB) {
if (chA != chB) return true; // both have another char to compare, are they different ?
} else return true; // not in B not - they are different
} else { // A done, current last pair equal => continue 2 never ending loop till B end (by WS only to be same)
if (!validB) return false; // done and end-up here without leaving by difference => both are same except some WSs arround
else return true; // A done, but non-WS remains in B - different
} // A done, B had no non-WS or non + WS last follow - never ending loop continue
planSpaceA = 1; planSpaceB = 1;
goto spaceLoopA; // performs better
}
}
public static string RemoveExtraSpaces(string input)
{
input = input.Trim();
string output = "";
bool WasLastCharSpace = false;
for (int i = 0; i < input.Length; i++)
{
if (input[i] == ' ' && WasLastCharSpace)
continue;
WasLastCharSpace = input[i] == ' ';
output += input[i];
}
return output;
}
My version (improved from Stian's answer). Should be very fast.
public static string TrimAllExtraWhiteSpaces(this string input)
{
if (string.IsNullOrEmpty(input))
{
return input;
}
var current = 0;
char[] output = new char[input.Length];
var charArray = input.ToCharArray();
for (var i = 0; i < charArray.Length; i++)
{
if (!char.IsWhiteSpace(charArray[i]))
{
if (current > 0 && i > 0 && char.IsWhiteSpace(charArray[i - 1]))
{
output[current++] = ' ';
}
output[current++] = charArray[i];
}
}
return new string(output, 0, current);
}
Simplest way I can think of:
Text = Text.Replace("\<Space>\<Space>", "\<Space>").Replace("\<Space>\<Space>", "\<Space>");
// Replace 2 \<Space>s with 1 space, twice
Related