so I am trying to take all the numbers from a list that are less than 5 and I try to put them in another list and print that list. I have no idea how to do that in c#. I will be very grateful if you'd help me. Thank you and here is my code:
using System;
namespace exercices
{
class Hello
{
static void Main(string[] args)
{
int[] a = { 1, 2, 3, 4, 5, 6, };
int[] b = { };
for (int i = 0; i < a.Length; i++)
{
if (a[i] < 5)
{
b.Append(a[i]);
}
}
}
}
Method 1. Just check every element
You should use List<T> collection in this method. It's possible to convert it to array later, if you need.
List<int> b = new();
foreach (int element in a)
{
if (element < 5)
{
b.Add(element);
}
}
Method 2. Use Array.FindAll<T> method
int[] b = Array.FindAll(a, element => element < 5);
Method 3. Use LINQ
int[] b = a.Where(element => element < 5).ToArray();
You could do something like this:
using System;
namespace exercices
{
class Hello
{
static void Main(string[] args)
{
int[] a = { 1, 2, 3, 4, 5, 6, };
int[] b = { };
for (int i = 0; i < a.Length;i++)
{
Int number=a[i];
if (number < 5)
b.Insert(i, number);
}
}
}
}
You can avoid explicit for loops using LINQ: the Where() method returns an IEnumerable object; you can then create an array or a list from the IEnumerable with the corresponding ToArray()/ToList() method, as shown below:
int[] a = { 1, 2, 3, 4, 5, 6};
IEnumerable<int> lessThanFiveElements = a.Where(element => element < 5);
int[] lessThanFiveArray = lessThanFiveElements.ToArray();
List<int> lessThanFiveList = lessThanFiveElements.ToList();
In case you have a console application, you can then print the resulting array/list with a Console.WriteLine() command, as shown below
Console.WriteLine(string.Join(",", lessThanFiveElements));
where I used the string.Join() in order to have comma separated elements, which accepts the separator as a first parameter and any IEnumerable as the second one.
I have an algorithm with all possible permutations, can i get permutations with only odd transpositions. Or simplify the algorithm to find only such permutations. For example, array {1,2,3,4}. If I move one element I will get only one transposition, and it odd tansposition: {2,1,3,4}, {3,2,1,4}, {4,2,3,1}, {1,3,2,4}, {1,4,3,2}, {1,2,4,3}.
class Program
{
static void Main(string[] args)
{
int[] arr = new int[] { 1, 2, 3, 4 };
ShowAllCombinations(arr);
Console.Read();
}
public static void ShowAllCombinations<T>(IList<T> arr, string current = "")
{
if (arr.Count == 0)
{
Console.WriteLine(current);
return;
}
for (int i = 0; i < arr.Count; i++)
{
List<T> lst = new List<T>(arr);
lst.RemoveAt(i);
ShowAllCombinations(lst, current + arr[i].ToString());
}
}
}
This algorithm gives all permutations, but not only odd ones.
Your ShowAllCombinations method is inconvenient, the string should stay a list so you can process the elements.
Once you have a complete list of elements, you can "unpermute" back to the natural order and count the number of swaps. This assumes unique elements (no repetitions) and that the list is one-based. Note that this method permutes the list, will want to create a copy somewhere.
public void SwapCount(List<int> arr)
{
var swapCount = 0;
// double for loop, compare the value at the outer position
// to the value at the inner position.
for (var i=0; i<arr.Count; i++)
{
// Start at the index after the outer loop
for (var j=i+1; j<arr.Count; j++)
{
// If the inner value is what the outer value
// is supposed to be then swap it.
if (arr[j] == i+1)
{
var t = arr[i];
arr[i] = arr[j];
arr[j] = t;
swapCount++;
}
}
}
Console.WriteLine($"swap count: {swapCount}");
}
output
> SwapCount(new List<int>() { 1, 2, 3, 4 })
swap count: 0
> SwapCount(new List<int>() { 2, 1, 3, 4 })
swap count: 1
> SwapCount(new List<int>() { 1, 3, 2, 4 })
swap count: 1
> SwapCount(new List<int>() { 1, 3, 4, 2})
swap count: 2
>
This is ~ O(n^2), but I'm assuming performance is not so important here. You can find more efficient algorithms here: Parity of permutation with parallelism
This is my code, but everytime i try compiling it i keep getting this error:
System.IndexOutOfRangeException: Index was outside the bounds of the
array.
using System;
using System.Collections.Generic;
using System.IO;
namespace nrinfile
{
class Program
{
static void Main(string[] args)
{
List<int> numbers= new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
string[] folderLoc = File.ReadAllLines(#"E:\folder\numbers.txt");
for (int i = 0; i < 12; i++)
{
folderLoc[i] = Convert.ToString(numbers[i]);
}
}
}
}`
As you want to write from your list of numbers to a file, you will need to use a System.IO method which writes to a file.
Something like:
static void Main(string[] args)
{
string destFile = #"E:\folder\numbers.txt";
List<int> numbers = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
using (StreamWriter sw = new StreamWriter(destFile)) {
for (int i = 0; i < numbers.Count(); i++)
{
sw.WriteLine(numbers[i].ToString());
}
}
}
The using construct takes care of closing the file when the code has finished writing to it and disposing of any "unmanaged resources" that the StreamWriter used.
Instead of the using part and the code inside it, you could use a different method which takes an array of strings and writes that out as lines:
File.WriteAllLines(destFile, numbers.Select(n => n.ToString()).ToArray());
There's no guarantee that folderLoc has at least 12 items
for (int i = 0; i < 12; i++) {...}
You can put it like this (note folderLoc.Length instead of 12):
string[] folderLoc = File.ReadAllLines(#"E:\folder\numbers.txt");
// If you want at most 12 items to be changed put the condition as
// i < Math.Max(12, folderLoc.Length)
for (int i = 0; i < folderLoc.Length; i++)
{
folderLoc[i] = $"{i} {folderLoc[i]}"; //TODO: Apply the correct format here
}
Or even (no explicit loops, but Linq query)
using System.Linq;
...
string[] folderLoc = File
.ReadLines(#"E:\folder\numbers.txt")
.Select((value, index) => $"{index} {value}")
.ToArray();
If you want to change top 12 lines only, the Select should be
...
.Select((value, index) => index < 12 ? $"{index} {value}" : value)
...
Finally, if you want just to write 0..11 numbers into a file
File.WriteAllLines(#"E:\folder\numbers.txt", Enumerable.Range(0, 12));
Is there a built in function in .NET 2.0 that will take two arrays and merge them into one array?
The arrays are both of the same type. I'm getting these arrays from a widely used function within my code base and can't modify the function to return the data in a different format.
I'm looking to avoid writing my own function to accomplish this if possible.
In C# 3.0 you can use LINQ's Concat method to accomplish this easily:
int[] front = { 1, 2, 3, 4 };
int[] back = { 5, 6, 7, 8 };
int[] combined = front.Concat(back).ToArray();
In C# 2.0 you don't have such a direct way, but Array.Copy is probably the best solution:
int[] front = { 1, 2, 3, 4 };
int[] back = { 5, 6, 7, 8 };
int[] combined = new int[front.Length + back.Length];
Array.Copy(front, combined, front.Length);
Array.Copy(back, 0, combined, front.Length, back.Length);
This could easily be used to implement your own version of Concat.
If you can manipulate one of the arrays, you can resize it before performing the copy:
T[] array1 = getOneArray();
T[] array2 = getAnotherArray();
int array1OriginalLength = array1.Length;
Array.Resize<T>(ref array1, array1OriginalLength + array2.Length);
Array.Copy(array2, 0, array1, array1OriginalLength, array2.Length);
Otherwise, you can make a new array
T[] array1 = getOneArray();
T[] array2 = getAnotherArray();
T[] newArray = new T[array1.Length + array2.Length];
Array.Copy(array1, newArray, array1.Length);
Array.Copy(array2, 0, newArray, array1.Length, array2.Length);
More on available Array methods on MSDN.
Use LINQ:
var arr1 = new[] { 1, 2, 3, 4, 5 };
var arr2 = new[] { 6, 7, 8, 9, 0 };
var arr = arr1.Union(arr2).ToArray();
Keep in mind, this will remove duplicates. If you want to keep duplicates, use Concat.
If you don't want to remove duplicates, then try this
Use LINQ:
var arr1 = new[] { 1, 2, 3, 4, 5 };
var arr2 = new[] { 6, 7, 8, 9, 0 };
var arr = arr1.Concat(arr2).ToArray();
First, make sure you ask yourself the question "Should I really be using an Array here"?
Unless you're building something where speed is of the utmost importance, a typed List, like List<int> is probably the way to go. The only time I ever use arrays are for byte arrays when sending stuff over the network. Other than that, I never touch them.
Easier would just be using LINQ:
var array = new string[] { "test" }.ToList();
var array1 = new string[] { "test" }.ToList();
array.AddRange(array1);
var result = array.ToArray();
First convert the arrays to lists and merge them... After that just convert the list back to an array :)
I think you can use Array.Copy for this. It takes a source index and destination index so you should be able to append the one array to the other. If you need to go more complex than just appending one to the other, this may not be the right tool for you.
Everyone has already had their say but I think this more readable than the "use as Extension method" approach:
var arr1 = new[] { 1, 2, 3, 4, 5 };
var arr2 = new[] { 6, 7, 8, 9, 0 };
var arr = Queryable.Concat(arr1, arr2).ToArray();
However it can only be used when bringing together 2 arrays.
This is what I came up with. Works for a variable number of arrays.
public static T[] ConcatArrays<T>(params T[][] args)
{
if (args == null)
throw new ArgumentNullException();
var offset = 0;
var newLength = args.Sum(arr => arr.Length);
var newArray = new T[newLength];
foreach (var arr in args)
{
Buffer.BlockCopy(arr, 0, newArray, offset, arr.Length);
offset += arr.Length;
}
return newArray;
}
...
var header = new byte[] { 0, 1, 2};
var data = new byte[] { 3, 4, 5, 6 };
var checksum = new byte[] {7, 0};
var newArray = ConcatArrays(header, data, checksum);
//output byte[9] { 0, 1, 2, 3, 4, 5, 6, 7, 0 }
Assuming the destination array has enough space, Array.Copy() will work. You might also try using a List<T> and its .AddRange() method.
Personally, I prefer my own Language Extensions, which I add or remove at will for rapid prototyping.
Following is an example for strings.
//resides in IEnumerableStringExtensions.cs
public static class IEnumerableStringExtensions
{
public static IEnumerable<string> Append(this string[] arrayInitial, string[] arrayToAppend)
{
string[] ret = new string[arrayInitial.Length + arrayToAppend.Length];
arrayInitial.CopyTo(ret, 0);
arrayToAppend.CopyTo(ret, arrayInitial.Length);
return ret;
}
}
It is much faster than LINQ and Concat. Faster still, is using a custom IEnumerable Type-wrapper which stores references/pointers of passed arrays and allows looping over the entire collection as if it were a normal array. (Useful in HPC, Graphics Processing, Graphics render...)
Your Code:
var someStringArray = new[]{"a", "b", "c"};
var someStringArray2 = new[]{"d", "e", "f"};
someStringArray.Append(someStringArray2 ); //contains a,b,c,d,e,f
For the entire code and a generics version see: https://gist.github.com/lsauer/7919764
Note: This returns an unextended IEnumerable object. To return an extended object is a bit slower.
I compiled such extensions since 2002, with a lot of credits going to helpful people on CodeProject and 'Stackoverflow'. I will release these shortly and put the link up here.
Just to have it noted as an option: if the arrays you are working with are of a primitive type – Boolean (bool), Char, SByte, Byte, Int16 (short), UInt16, Int32 (int), UInt32, Int64 (long), UInt64, IntPtr, UIntPtr, Single, or Double – then you could (or should?) try using Buffer.BlockCopy. According to the MSDN page for the Buffer class:
This class provides better performance for manipulating primitive types than similar methods in the System.Array class.
Using the C# 2.0 example from #OwenP's answer as a starting point, it would work as follows:
int[] front = { 1, 2, 3, 4 };
int[] back = { 5, 6, 7, 8 };
int[] combined = new int[front.Length + back.Length];
Buffer.BlockCopy(front, 0, combined, 0, front.Length);
Buffer.BlockCopy(back, 0, combined, front.Length, back.Length);
There is barely any difference in syntax between Buffer.BlockCopy and the Array.Copy that #OwenP used, but this should be faster (even if only slightly).
I needed a solution to combine an unknown number of arrays.
Surprised nobody else provided a solution using SelectMany with params.
private static T[] Combine<T>(params IEnumerable<T>[] items) =>
items.SelectMany(i => i).Distinct().ToArray();
If you don't want distinct items just remove distinct.
public string[] Reds = new [] { "Red", "Crimson", "TrafficLightRed" };
public string[] Greens = new [] { "Green", "LimeGreen" };
public string[] Blues = new [] { "Blue", "SkyBlue", "Navy" };
public string[] Colors = Combine(Reds, Greens, Blues);
Note: There is definitely no guarantee of ordering when using distinct.
In case someone else is looking for how to merge two image byte arrays:
private void LoadImage()
{
string src = string.empty;
byte[] mergedImageData = new byte[0];
mergedImageData = MergeTwoImageByteArrays(watermarkByteArray, backgroundImageByteArray);
src = "data:image/png;base64," + Convert.ToBase64String(mergedImageData);
MyImage.ImageUrl = src;
}
private byte[] MergeTwoImageByteArrays(byte[] imageBytes, byte[] imageBaseBytes)
{
byte[] mergedImageData = new byte[0];
using (var msBase = new MemoryStream(imageBaseBytes))
{
System.Drawing.Image imgBase = System.Drawing.Image.FromStream(msBase);
Graphics gBase = Graphics.FromImage(imgBase);
using (var msInfo = new MemoryStream(imageBytes))
{
System.Drawing.Image imgInfo = System.Drawing.Image.FromStream(msInfo);
Graphics gInfo = Graphics.FromImage(imgInfo);
gBase.DrawImage(imgInfo, new Point(0, 0));
//imgBase.Save(Server.MapPath("_____testImg.png"), ImageFormat.Png);
MemoryStream mergedImageStream = new MemoryStream();
imgBase.Save(mergedImageStream, ImageFormat.Png);
mergedImageData = mergedImageStream.ToArray();
mergedImageStream.Close();
}
}
return mergedImageData;
}
If you have the source arrays in an array itself you can use SelectMany:
var arrays = new[]{new[]{1, 2, 3}, new[]{4, 5, 6}};
var combined = arrays.SelectMany(a => a).ToArray();
foreach (var v in combined) Console.WriteLine(v);
gives
1
2
3
4
5
6
Probably this is not the fastest method but might fit depending on usecase.
Here is a simple example using Array.CopyTo.
I think that it answers your question and gives an example of CopyTo usage - I am always puzzled when I need to use this function because the help is a bit unclear - the index is the position in the destination array where inserting occurs.
int[] xSrc1 = new int[3] { 0, 1, 2 };
int[] xSrc2 = new int[5] { 3, 4, 5, 6 , 7 };
int[] xAll = new int[xSrc1.Length + xSrc2.Length];
xSrc1.CopyTo(xAll, 0);
xSrc2.CopyTo(xAll, xSrc1.Length);
I guess you can't get it much simpler.
I'm assuming you're using your own array types as opposed to the built-in .NET arrays:
public string[] merge(input1, input2)
{
string[] output = new string[input1.length + input2.length];
for(int i = 0; i < output.length; i++)
{
if (i >= input1.length)
output[i] = input2[i-input1.length];
else
output[i] = input1[i];
}
return output;
}
Another way of doing this would be using the built in ArrayList class.
public ArrayList merge(input1, input2)
{
Arraylist output = new ArrayList();
foreach(string val in input1)
output.add(val);
foreach(string val in input2)
output.add(val);
return output;
}
Both examples are C#.
int [] SouceArray1 = new int[] {2,1,3};
int [] SourceArray2 = new int[] {4,5,6};
int [] targetArray = new int [SouceArray1.Length + SourceArray2.Length];
SouceArray1.CopyTo(targetArray,0);
SourceArray2.CopyTo(targetArray,SouceArray1.Length) ;
foreach (int i in targetArray) Console.WriteLine(i + " ");
Using the above code two Arrays can be easily merged.
Created and extension method to handle null
public static class IEnumerableExtenions
{
public static IEnumerable<T> UnionIfNotNull<T>(this IEnumerable<T> list1, IEnumerable<T> list2)
{
if (list1 != null && list2 != null)
return list1.Union(list2);
else if (list1 != null)
return list1;
else if (list2 != null)
return list2;
else return null;
}
}
string[] names1 = new string[] { "Ava", "Emma", "Olivia" };
string[] names2 = new string[] { "Olivia", "Sophia", "Emma" };
List<string> arr = new List<string>(names1.Length + names2.Length);
arr.AddRange(names1);
arr.AddRange(names2);
string[] result = arr.Distinct().ToArray();
foreach(string str in result)
{
Console.WriteLine(str.ToString());
}
Console.ReadLine();
I wanted to find an approach without using any libraries or functionality beyond arrays themselves.
The first two examples are mostly for reading the logic from scratch, but I also wonder if there could be performance variations depending on the sitaution.
The third example is the most practical choice.
// Two for-loops
private static int[] MergedArrays_1(int[] a, int[] b)
{
int[] result = new int[a.Length + b.Length];
for (int i = 0; i < a.Length; i++)
{
result[i] = a[i];
}
for (int i = a.Length; i < result.Length; i++)
{
result[i] = b[i - a.Length];
}
return result;
}
// One for-loop
private static int[] MergedArrays_2(int[] a, int[] b)
{
int[] results = new int[a.Length + b.Length];
for (int i = 0; i < results.Length; i++)
{
results[i] = (i < a.Length) ? a[i] : b[i - a.Length];
}
return results;
}
// Array Method
private static int[] MergedArrays_3(int[] a, int[] b)
{
int[] results = new int[a.Length + b.Length];
a.CopyTo(results, 0);
b.CopyTo(results, a.Length);
return results;
}
Lastly, I made a fourth example, that can merge multiple arrays, using the params keyword.
int[] result = MultipleMergedArrays(arrayOne, arrayTwo, arrayThree);
private static int[] MultipleMergedArrays(params int[][] a)
{
// Get Length
int resultsLength = 0;
for (int row = 0; row < a.GetLength(0); row++)
{
resultsLength += a.Length;
}
// Initialize
int[] results = new int[resultsLength];
// Add Items
int index = 0;
for (int row = 0; row < a.GetLength(0); row++)
{
a[row].CopyTo(results, index);
index += a[row].Length;
}
return results;
}
The way it works when using params, is that the single-dimension arrays are passed into a jagged array.
GetLength(0) returns the number of arrays contained within the jagged array.
The code first counts the Length of all the arrays, then it initializes a new array based on that size, and starts adding entire arrays into the new results array by using the CopyTo() method, while adding the Length of each added array to an index counter.
PS: Some times it is necessary to remove empty items, or certain items, from arrays when merging.
private static int[] RemoveEmpty(int[] array)
{
int count = 0;
for (int i = 0; i < array.Length; i++)
{
if (array[i] == 0) count++;
}
int[] result = new int[array.Length - count];
count = 0;
for (int i = 0; i < array.Length; i++)
{
if (array[i] == 0) continue;
result[count] = array[i];
count++;
}
return result;
}
This function can be combined with the ones above.
It takes an array, counts the number of items that match zero. And creates a new array of the proper size. Then the counter is recycled and used as an index, for where to put place the input array's values into the new and smaller result array.
When an item matches zero, it skips the rest of the code in that round of the loop, and continues with the next round, without incrementing the integer counter.
Since .NET 5, we now have AllocateUnitializedArray which can possibly add an additional (small) performance improvement for the suggested solutions:
public static T[] ConcatArrays<T>(IEnumerable<T[]> arrays)
{
var result = GC.AllocateUnitializedArray<T>(arrays.Sum(a => a.Length));
var offset = 0;
foreach (var a in arrays)
{
a.CopyTo(result, offset);
offset += a.Length;
}
return result;
}
This code will work for all cases:
int[] a1 ={3,4,5,6};
int[] a2 = {4,7,9};
int i = a1.Length-1;
int j = a2.Length-1;
int resultIndex= i+j+1;
Array.Resize(ref a2, a1.Length +a2.Length);
while(resultIndex >=0)
{
if(i != 0 && j !=0)
{
if(a1[i] > a2[j])
{
a2[resultIndex--] = a[i--];
}
else
{
a2[resultIndex--] = a[j--];
}
}
else if(i>=0 && j<=0)
{
a2[resultIndex--] = a[i--];
}
else if(j>=0 && i <=0)
{
a2[resultIndex--] = a[j--];
}
}
Simple code to join multiple arrays:
string[] arr1 = ...
string[] arr2 = ...
string[] arr3 = ...
List<string> arr = new List<string>(arr1.Length + arr2.Length + arr3.Length);
arr.AddRange(arr1);
arr.AddRange(arr2);
arr.AddRange(arr3);
string[] result = arr.ToArray();
This is another way to do this :)
public static void ArrayPush<T>(ref T[] table, object value)
{
Array.Resize(ref table, table.Length + 1); // Resizing the array for the cloned length (+-) (+1)
table.SetValue(value, table.Length - 1); // Setting the value for the new element
}
public static void MergeArrays<T>(ref T[] tableOne, T[] tableTwo) {
foreach(var element in tableTwo) {
ArrayPush(ref tableOne, element);
}
}
Here is the snippet/example
Try this:
ArrayLIst al = new ArrayList();
al.AddRange(array_1);
al.AddRange(array_2);
al.AddRange(array_3);
array_4 = al.ToArray();