|
identity = identity.Replace("-", "");
".45 ACP - because shooting twice is just silly" - JSOP, 2010 ----- You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010 ----- When you pry the gun from my cold dead hands, be careful - the barrel will be very hot. - JSOP, 2013
|
|
|
|
|
Where can i change your replace id?
|
|
|
|
|
Most major retail clothing outlets have changing rooms.
".45 ACP - because shooting twice is just silly" - JSOP, 2010 ----- You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010 ----- When you pry the gun from my cold dead hands, be careful - the barrel will be very hot. - JSOP, 2013
|
|
|
|
|
This is work. How how can i dow that for under Column name / row?
modified 23-Feb-15 8:52am.
|
|
|
|
|
Thanks, this string work with click. Replace string dont work for datagridview, how dow i that for datagridview?
|
|
|
|
|
Hi coders
I am looking to convert alphabet entries in a char array into their corresponding place in the alphabet. E.g. A=1, B=2, C=3, and onward.
I have done some searching online but can't find a way of doing this for an array, just for individual values. I imagine it will require a foreach loop, but I can't figure out the correct terminology
If someone could help I would hugely appreciate it
|
|
|
|
|
Well on the assumption that your string is ASCII encoded, and with the knowledge that 'A' = 65 its simply a case of casting the character to an integer and taking off 64.
You could try something like this using linq:
var input= "ABC";
var output = input.Select(x => ((int)x)-64).ToArray();
or, more clearly:
int[] output = new int[input.Length];
for (int i = 0; i < input.Length; i++) output[i] = ((int)input[i]) - 64;
Regards,
Rob Philpott.
|
|
|
|
|
That's done it, thanks for the help Rob
|
|
|
|
|
Rob Philpott wrote: var output = input.Select(x => ((int)x)-64).ToArray();
Or, more clearly:
int[] output = input.Select(x => (x - 'A') + 1).ToArray();
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
I'm being stalked! Well presuming subtraction of chars yields an int I guess that's a neater answer.
Personally, I'd probably stick with my answer though due to the explicit cast. And I should state I'd never do anything as filthy as using 'var' in my own code!
Regards,
Rob Philpott.
|
|
|
|
|
Rob Philpott wrote: I'd never do anything as filthy as using 'var' in my own code!
I thought I was the only one who hated that filthy habit
|
|
|
|
|
Tetra1044 wrote: a char array
An actual array of characters? Or a string? (Not that it matters much.)
Tetra1044 wrote: a foreach loop
for loops tend to be quicker than foreach loops, so use for whenever you can.
|
|
|
|
|
It was an array of characters, but I've changed it to a string for ease.
And thanks, I'll keep that in mind
|
|
|
|
|
At the risk of adding too much salt to the stew, let me, obsessively, add:
You don't mention if the char[] (now a string) is guaranteed to use only upper-case letters, and if the string might contain spaces. And, how about if the string contains numbers, or other white-space, or high-value Unicode characters. What about encoding ?
private IEnumerable<int> AlphaToInteger(string source)
{
source = source.ToUpper();
return source.Where(ch => Char.IsLetter(ch)).Select(chr => chr - 64);
}
«I'm asked why doesn't C# implement feature X all the time. The answer's always the same: because no one ever designed, specified, implemented, tested, documented, shipped that feature. All six of those things are necessary to make a feature happen. They all cost huge amounts of time, effort and money.» Eric Lippert, Microsoft, 2009
|
|
|
|
|
Well, now we're talking.
*Although* you could do away with that ToUpper, and the -64.
private IEnumerable<int> AlphaToInteger(string source)
{
return source.Where(ch => Char.IsLetter(ch)).Select(chr => chr & 0x9f));
}
But now we're getting silly.
Regards,
Rob Philpott.
|
|
|
|
|
Hi, I have tried to implement my own array sort for struct arrays. But I noticed that the performance was not what I expected. So I tried to find out the reason behind and made a very simple test code, using not a struct array but a normal one dimensional long array. The comparer class looks like this:
struct sortKeys : IComparer<long>
{
private static readonly Comparer<long> comparer
= Comparer<long>.Default;
public int Compare(long x, long y)
{
return x.CompareTo(y);
}
public static int GetHashCode(long value)
{
return comparer.GetHashCode();
}
}
and for comparing the Array.Sort without and with the comparer, I wrote the following:
private void compareSortsPerformance()
{
Stopwatch sw = new Stopwatch();
int Maximum = 10000000;
Random rand = new Random();
long[] la = new long[Maximum];
for (int i = 0; i < Maximum; i++)
la[i] = rand.Next();
sw.Start();
Array.Sort(la);
Console.WriteLine("Sort without icomparable" + sw.ElapsedMilliseconds);
for (int i = 0; i < Maximum; i++)
la[i] = rand.Next();
sortKeys sk = new sortKeys();
sw.Restart();
Array.Sort(la, sk);
Console.WriteLine("Sort with icomparable" + sw.ElapsedMilliseconds);
}
Array.Sort(la) is about 3 times faster than Array.Sort(la,sk). If I do the same comparison for a struct array with only one long variable inside, it takes even longer. Does anyone have an idea how to increase the speed for this first step?
Thx
|
|
|
|
|
Interesting question. I've taken your code and come to the same findings.
My suspicion is that because you are using a primitive type 'long' as the thing to sort, .NET has its own optimized method of sorting these effectively bypassing the whole IComparer/IComparable mechanism as a specific performance tuned operation.
What I mean by that is that it knows what a long is, so when sorting without a comparer specified it can use a dedicated long sort rather than something that repeatedly calls IComparer.Equals.
In your example, it gets called around about 300 million times...
Regards,
Rob Philpott.
|
|
|
|
|
Good to know or... bad to know that my code seems to be as efficient as possible... but still 3 times slower than the Array.Sort(la). I have implemented a quicksort as well and found the same performance as when I use the comparer Array.Sort(la,sk). But I read on several pages that C# uses quicksort in Array.Sort(). Using unsafe would increase the performance by about 20%, so something is strange. There must be a possibility to further increase the speed.
It would be interesting to know how they do it, because if I want to improve the speed of the struct array sort, which needs 8 times longer than the Array.Sort(la), I need to understand the mechanism behind the .NET implementation. Do you have an idea of how to get behind their mechanism?
Thx
|
|
|
|
|
|
|
Rob Philpott wrote: Well, you can use something like dotPeek to disassemble mscorlib ...
Or, go to http://sourceof.net/[^] and get the source straight from the horse's mouth.
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
|
... which is altogether a much better idea! Good thinking.
Regards,
Rob Philpott.
|
|
|
|
|
In the end I found the source code of the c++ quicksort implementation in clr and it's really very similar to the quicksort algorithm I used in c# (see node below).
So I guess one should switch to c++ if it comes to sorting big structs as well and the average performance difference between c# and c++ of a few percenant points does not hold for this kind of operations. For everybody who tries to find the answer to the same question, here is the code they use:
static void QuickSort(KIND keys[], KIND items[], int left, int right) {
WRAPPER_CONTRACT;
// Make sure left != right in your own code.
_ASSERTE(keys != NULL && left < right);
do {
int i = left;
int j = right;
KIND x = keys[i + ((j - i) >> 1)];
do {
while (keys[i] < x) i++;
while (x < keys[j]) j--;
_ASSERTE(i>=left && j<=right);
if (i > j) break;
if (i < j) {
KIND key = keys[i];
keys[i] = keys[j];
keys[j] = key;
if (items != NULL) {
KIND item = items[i];
items[i] = items[j];
items[j] = item;
}
}
i++;
j--;
} while (i <= j);
if (j - left <= right - i) {
if (left < j) QuickSort(keys, items, left, j);
left = i;
}
else {
if (i < right) QuickSort(keys, items, i, right);
right = j;
}
} while (left < right);
}
|
|
|
|
|
Part of the problem is your code is not in-lined with the code calling your comparer. Just the fact of supplying a comparer introduces the overhead of calling your function and popping the result off the stack.
The only way to solve this problem is to write your own sorting algorithm, specifically typed to sort longs. That way, all the code is completely in-lined and as compact as possible with no function call overhead.
|
|
|
|
|
I tried as well to build a quicksort, taken and adapted to long from Searching and Sorting Algorithms via C#[^]
But it needs longer than Array.Sort... sorry, I forgot to update the stopwatch before. But now quicksort is still slower than the others.
private void compareSortsPerformance()
{
Stopwatch sw = new Stopwatch();
int Maximum = 10000000;
Random rand = new Random();
long[] la = new long[Maximum];
for (int i = 0; i < Maximum; i++)
la[i] = rand.Next();
sw.Start();
Array.Sort(la);
Console.WriteLine("Sort without icomparable" + sw.ElapsedMilliseconds);
for (int i = 0; i < Maximum; i++)
la[i] = rand.Next();
sortKeys sk = new sortKeys();
sw.Restart();
Array.Sort(la, sk);
Console.WriteLine("Sort with icomparable" + sw.ElapsedMilliseconds);
for (int i = 0; i < Maximum; i++)
la[i] = rand.Next();
sw.Restart();
QuickSort(ref la);
Console.WriteLine("Sort with Quicksort" + sw.ElapsedMilliseconds);
}
public static void QuickSort(ref long[] x)
{
qs(x, 0, x.Length - 1);
}
public static void qs(long[] x, long left, long right)
{
long i, j;
long pivot, temp;
i = left;
j = right;
pivot = x[(left + right) / 2];
do
{
while ((x[i] < pivot) && (i < right)) i++;
while ((pivot < x[j]) && (j > left)) j--;
if (i <= j)
{
temp = x[i];
x[i] = x[j];
x[j] = temp;
i++; j--;
}
} while (i <= j);
if (left < j) qs(x, left, j);
if (i < right) qs(x, i, right);
}
|
|
|
|
|