We Keep Coding

Convert a sentence to Integer

Assuming i have a string that says
string version = "Version 1.0.2.3"
I want to convert this to an integer or number like "1232454982394".
This should change based on the text i input.
While one option is to convert to ascii value or unicode, i have to iterate through each character. Wondering if there is an easier way - like a one line method that can accomplish this.
The below one works. but i am looking for something better
string version = "Version 1.0.2.3";
string finalOutput = "";
foreach (char c in version)
{
finalOutput = finalOutput + ((int)c).ToString();
}
Console.WriteLine(finalOutput);
// Output is 861011141151051111103249464846504651

One way is to use the GetHashCode method.
string version = "Version 1.0.2.3";
var hashedValue = version.GetHashCode();
From MSDN
A hash code is a numeric value that is used to insert and identify an
object in a hash-based collection such as the
Dictionary(Of TKey, TValue) class, the Hashtable class, or a type
derived from the DictionaryBase class. The GetHashCode method provides
this hash code for algorithms that need quick checks of object
equality.

I don't really like the GetHashCode option for this as the Version intervals are going to be different than the Hash intervals
string Version1023 = "Version 1.0.2.3";
string Version1024 = "Version 1.0.2.4";
string Version1033 = "Version 1.0.3.3";
string Version1034 = "Version 1.0.3.4";
Console.WriteLine(Version1023 + " => " + Version1023.GetHashCode());
Console.WriteLine(Version1024 + " => " + Version1024.GetHashCode());
Console.WriteLine(Version1033 + " => " + Version1033.GetHashCode());
Console.WriteLine(Version1034 + " => " + Version1034.GetHashCode());
/* =====[ Results ]=====
Version 1.0.2.3 => -674112888
Version 1.0.2.4 => -1433627775
Version 1.0.3.3 => -674112889
Version 1.0.3.4 => -1433627776
*/
What I would recommend, and only if the string is going to remain in the same format, would be to split the string and concentrate on the version numerics portion. For a four element version number we can use common scripting which is used for converting IP4 Addresses to long addresses.
Here is a slighty tweaked version to do this split and conversion
public static long GetLongFromVersion(string VersionString) {
string[] VersionSplit = VersionString.Split(` `);
string VersionNumber = VersionSplit[1];
string[] VersionBytes;
double num = 0;
if (!string.IsNullOrEmpty(VersionNumber)) {
VersionBytes = VersionNumber.Split(`.`);
for (int i = VersionBytes.Length - 1; i >= 0; i--) {
num += ((int.Parse(VersionBytes[i]) % 256) * Math.Pow(256, (3 - i)));
}
}
return (long)num;
}
And when we use this method to convert the version numbers, the version and result will have intervals that are parallel.
string Version1023 = "Version 1.0.2.3";
string Version1024 = "Version 1.0.2.4";
string Version1033 = "Version 1.0.3.3";
string Version1034 = "Version 1.0.3.4";
Console.WriteLine(Version1023 + " => " + GetLongFromVersion(Version1023));
Console.WriteLine(Version1024 + " => " + GetLongFromVersion(Version1024));
Console.WriteLine(Version1033 + " => " + GetLongFromVersion(Version1033));
Console.WriteLine(Version1034 + " => " + GetLongFromVersion(Version1034));
/* =====[ Results ]=====
Version 1.0.2.3 => 16777731
Version 1.0.2.4 => 16777732
Version 1.0.3.3 => 16777987
Version 1.0.3.4 => 16777988
*/

Fast multi-string replacement

I need to perform multi string replacement. I have a string where several parts need to be changed according to substitution map.
All replacement must be done in one action - it means if "a" should be replaced with "b" and also "b" must be replaced with "c" and input string is "abc", the result will be "bcc"
I have a sollution based on building regex and then replacing all matches. I wrote it some time ago, now I'm refactoring the code and not so satisfied with it. Is there better (faster, simplier) sollution?
This is what I have:
public static string Replace(string s, Dictionary<string, string> substitutions)
{
string pattern = "";
int i = 0;
foreach (string ch in substitutions.Keys)
{
if (i == 0)
pattern += "(" + Regex.Escape(ch) + ")";
else
pattern += "|(" + Regex.Escape(ch) + ")";
i++;
}
var r = new Regex(pattern);
var parts = r.Split(s);
string ret = "";
foreach (string part in parts)
{
if (part.Length == 1 && substitutions.ContainsKey(part[0].ToString()))
{
ret += substitutions[part[0].ToString()];
}
else
{
ret += part;
}
}
return ret;
}
And test case:
var test = "test aabbcc";
var output = Replace(test, new Dictionary<string, string>{{"a","b"},{"b","y"}});
Assert.That(output=="test bbyycc");

You can replace all this with
var r = new Regex(string.Join("|", substitutions.Keys.Select(k => "(" + k + ")")));
return r.Replace(s, m => substitutions[m.Value]);
The key things are making use of the string.Join method rather than implementing it yourself, and making use of this Regex.Replace overload and delegates to do the replacement.

get values from array and add into one string

Object Book has Author which has property Name of type string.
I want to iterate trough all Authors and add it's Name string to the one string (not array) separated by comma, so this string should be at the as
string authorNames = "Author One, Author two, Author three";
string authorNames = string.Empty;
foreach(string item in book.Authors)
{
string fetch = item.Name;
??
}

You can use the string.Join function with LINQ
string authorNames = string.Join(", ", book.Authors.Select(a => a.Name));

You can use
string authors = String.Join(", ", book.Authors.Select(a => a.Name));

LINQ is the way to go in C#, but for explanatory purposes here is how you could code it explicitly:
string authorNames = string.Empty;
for(int i = 0; i < book.Authors.Count(); i++)
{
if(i > 0)
authorNames += ", ";
authorNames += book.Authors[i].Name;
}

You could also loop through them all, and append them to authorNames and add a comma in the end, and when it's done simply trim of the last comma.
string authorNames = string.Empty;
foreach(string author in book.Authors)
{
string authorNames += author.Name + ", ";
}
authorNames.TrimEnd(',');

Using LinQ, there are plenty of ways to merge multiple string into one string.
book.Authors.Select(x => x.Name).Aggregate((x, y) => x + ", " + y);
To anwsers James' comment
[TestMethod]
public void JoinStringsViaAggregate()
{
var mystrings = new[] {"Alpha", "Beta", "Gamma"};
var result = mystrings.Aggregate((x, y) => x + ", " + y);
Assert.AreEqual("Alpha, Beta, Gamma", result);
}

How can I split and prepend text?

I have a string like this in C#:
string a = "A|B|C|D"
I want to split this string on the pipe character and prepend some text to each entry. Currently, I am doing a split like this:
string[] result = a.Split('|')
But because the string array is of a fixed size, I need to create a new array and copy the prepended result using a for loop. Is there a Linq way or a one-liner to achieve this instead of writing a for loop? In Python, I would have done a one-liner for loop:
newresult = ["Prepend string " + x for x in result]
Any suggestions?

var newResult = a.Split('|').Select(x => "Prepend string " + x).ToArray();

I found this to be easy enough, if you say want to join it back too:
string.Join(" , ", devices.Select(s => "PREFIX = " + s).ToArray());

Not sure why you need to create a new array, but first the Linq method is to use the .Select operator:
stirng[] result = a.Split('|').Select(x => "Prepend string " + x).ToArray();
That said, you could also just edit the array inline (i.e. no need for a new array):
for (var i = 0; i < result.Length; i++)
result[i] = "Prepend string " + result[i];

How do I iterate "between" items in an array / collection / list?

This problem has bugged me for years, and I always feel like I'm coming up with a hack when there's a much better solution. The issue at hand occurs when you want to do something to all items in a list and then add something inbetween those items. In short, I want to:
Do something to every item in the list.
Do something else to all but the last item in the list (in effect, do something "inbetween" the items in the list).
For example, let's say I have a class called Equation:
public class Equation
{
public string LeftSide { get; set; }
public string Operator { get; set; }
public string RightSide { get; set; }
}
I want to iterate over a list of Equations and return a string that formats these items together; something like the following:
public string FormatEquationList(List<Equation> listEquations)
{
string output = string.Empty;
foreach (Equation e in listEquations)
{
//format the Equation
string equation = "(" + e.LeftSide + e.Operator + e.RightSide + ")";
//format the "inbetween" part
string inbetween = " and ";
//concatenate the Equation and "inbetween" part to the output
output += equation + inbetween;
}
return ouput;
}
The problem with the above code is that it is going to include and at the end of the returned string. I know that I could hack some code together, replace the foreach with a for loop, and add the inbetween element only if it's not the last item; but this seems like a hack.
Is there a standard methodology for how to deal with this type of problem?

You basically have a few different strategies for dealing with this kind problem:
Process the first (or last) item outside of the loop.
Perform the work and then "undo" the extraneous step.
Detect that your're processing the first or last item inside the loop.
Use a higher-level abstraction that allows you to avoid the situation.
Any of these options can be a legitimate way to implement a "between the items" style of algorithm. Which one you choose depends on things like:
which style you like
how expensive "undoing work" is
how expensive each "join" step is
whether there are any side effects
Amongst other things. For the specific case of string, I personally prefer using string.Join(), as I find it illustrates the intent most clearly. Also, in the case of strings, if you aren't using string.Join(), you should try to use StringBuilder to avoid creating too many temporary strings (a consequence of strings being immutable in .Net).
Using string concatentation as the example, the different options break down into examples as follows. (For simplicity, assume Equation has ToString() as: "(" + LeftSide + Operator + RightSide + ")"
public string FormatEquation( IEnumerable<Equation> listEquations )
{
StringBuilder sb = new StringBuilder();
if( listEquations.Count > 0 )
sb.Append( listEquations[0].ToString() );
for( int i = 1; i < listEquations.Count; i++ )
sb.Append( " and " + listEquations[i].ToString() );
return sb.ToString();
}
The second option looks like:
public string FormatEquation( IEnumerable<Equation> listEquations )
{
StringBuilder sb = new StringBuilder();
const string separator = " and ";
foreach( var eq in listEquations )
sb.Append( eq.ToString() + separator );
if( listEquations.Count > 1 )
sb.Remove( sb.Length, separator.Length );
}
The third would look something like:
public string FormatEquation( IEnumerable<Equation> listEquations )
{
StringBuilder sb = new StringBuilder();
const string separator = " and ";
foreach( var eq in listEquations )
{
sb.Append( eq.ToString() );
if( index == list.Equations.Count-1 )
break;
sb.Append( separator );
}
}
The last option can take multiple forms in .NET, using either String.Join or Linq:
public string FormatEquation( IEnumerable<Equation> listEquations )
{
return string.Join( " and ", listEquations.Select( eq => eq.ToString() ).ToArray() );
}
or:
public string FormatEquation( IEnumerable<Equation> listEquations )
{
return listEquations.Aggregate((a, b) => a.ToString() + " and " + b.ToString() );
}
Personally, I avoid using Aggregate() for string concatenation because it results in many intermediate, discarded strings. It's also not the most obvious way to "join" a bunch of results together - it's primarily geared for computing a "scalar" results from a collection in some arbitrary, caller-defined fashion.

You can use String.Join().
String.Join(" and ",listEquations.Select(e=>String.Format("({0}{1}{2})",e.LeftSide,e.Operator,e.RightSide).ToArray());

You can do this with LINQ's Aggregate operator:
public string FormatEquationList(List<Equation> listEquations)
{
return listEquations.Aggregate((a, b) =>
"(" + a.LeftSide + a.Operator + a.RightSide + ") and (" +
b.LeftSide + b.Operator + b.RightSide + ")");
}

Using a for loop with counter is perfectly reasonable if you don't want a foreach loop. This is why there is more than one type of looping statement.
If you want to process items pairwise, loop at LINQ's Aggregate operator.

I usualy add it before the condition, and check if its the 1st item.
public string FormatEquationList(List<Equation> listEquations)
{
string output = string.Empty;
foreach (Equation e in listEquations)
{
//use conditional to insert your "between" data:
output += (output == String.Empty) ? string.Empty : " and ";
//format the Equation
output += "(" + e.LeftSide + e.Operator + e.RightSide + ")";
}
return ouput;
}
I have to say I would look at the string.Join() function as well, +1 for Linqiness on that. My example is a more of a traditional solution.

I generally try to prefix separators based on a condition rather than add them to the end.
string output = string.Empty;
for (int i = 0; i < 10; i++)
{
output += output == string.Empty ? i.ToString() : " and " + i.ToString();
}
0 and 1 and 2 and 3 and 4 and 5 and 6 and 7 and 8 and 9

I like the String.Join method already posted.
But when you're not using an Array this has normally been my solution to this problem:
public string FormatEquationList(List<Equation> listEquations)
{
string output = string.Empty;
foreach (Equation e in listEquations)
{
// only append " and " when there's something to append to
if (output != string.Empty)
output += " and ";
output += "(" + e.LeftSide + e.Operator + e.RightSide + ")";
}
return output;
}
Of course, it's usually faster to use a StringBuilder:
public string FormatEquationList(List<Equation> listEquations)
{
StringBuilder output = new StringBuilder();
foreach (Equation e in listEquations)
{
// only append " and " when there's something to append to
if (output.Length > 0)
output.Append(" and ");
output.Append("(");
output.Append(e.LeftSide);
output.Append(e.Operator);
output.Append(e.RightSide);
output.Append(")");
}
return output.ToString();
}