Htykuut

First I'd like to say that im pretty new in regards to coding, so don't kill me if the code looks horrible.

Alright, so the problem is that im trying to make a generic function which purpose is to take two sorted arrays and merge them into a new sorted array.
The problem im facing is trying to use if's in the function, and it doesn't let me use the < operand.

public object mergeTwoSorted<Tone, Ttwo>(Tone array, Ttwo array2)

{

    object mergedArray = new object[array.Length + array2.Length];

    for (int i = 0; i < mergedArray.Length; i++)

    {

        if (array is ValueType && array2 is ValueType)

        {

            if (array[i] > array2[i])



        }

    }

}

Any idea on how to tackle this problem?

First I'd like to say that im pretty new in regards to coding, so don't kill me if the code looks horrible.

It looks pretty reasonable so far. It looks like what you're trying to do is to take two sorted arrays of two different types, but there is an ordering relationship between the two types. You're then merging the two arrays into an array of objects, such that the objects from the two arrays are still in the same order, but they are interleaved with each other to match the inter-type ordering relation, yes?

That is an unusual thing to do, but it is possible.

If that is not what you are doing, then you need to stop and re-design the code. In particular, if your intention is to take two arrays of the same type, then you must have one type parameter, not two, and you must make an array of T as the output, not object.

The problem is that there is in general no way to express "I have an ordering relationship between these two types" in C#. You'll have to provide a function that does that. Traditionally we provide a function that takes the two types and returns an integer: -1 if the first is the smaller, 1 if the second is the smaller, and 0 if they are equal.

If we have that then your method becomes:

public static object MergeTwoSorted<TOne, TTwo> (

  TOne items1, 

  TTwo items2,

  Func<TOne, TTwo, int> comparer) 

{

Note that we are using standard C# conventions here. Methods begin with a capital, type parameters are TSomething, and so on. A Func<A, B, C> is a function that takes an A, a B, and returns a C. Methods that do not manipulate an instance of their class are static.

Note that there is no need to re-state in the name of a thing what its type is. Say what the thing is logically, not how it is stored:

    object merged = new object[items1.Length + items2.Length];

Now your loop needs some work:

    for (int i = 0; i < mergedArray.Length; i++)

    {

        if (array is ValueType && array2 is ValueType)

        {

            if (array[i] > array2[i])

Arrays are never value types. I think you do not understand the difference between values and references, and that is really important to understand, so do some research on that.

Also, you have a counter i which counts the big merged array, but you use that as an index into the small arrays. That is very wrong; do you see why?

Think about it this way: you are going to count through both arrays at the same time filling in the merged array. So that would be:

int current1 = 0;

int current2 = 0;

while (current1 + current2 < merged.Length)

{

  if (comparer(items1[current1], items2[current2]) < 0)

  {

    // items1[current1] is the smaller

    merged[current1+current2] = items1[current1];

    current1 += 1;

  }

  else

  {

There is a bug in the code above; can you find it? Hint: indices for all array accesses must be >= 0 and < Length of the array. Is there a way in the code I've written so far that this gets violated?

• Can you fix the bug and finish it off?


• Can you now make a call site that takes an array of strings, an array of numbers, and an ordering relationship between strings and numbers, and merges the arrays?

public static object mergeTwoSorted<Tone, Ttwo>(Tone array, Ttwo array2)  

    where Tone : IComparable<Ttwo> 

{

    var mergedArray = new object[array.Length + array2.Length];

    for (int i = 0; i < mergedArray.Length; i++)

    {

        if (array is ValueType && array2 is ValueType)

        {

            if (array[i].CompareTo( array2[i] )>0)



        }

    }

    return mergedArray;

}

If you want to use specific operations on Generics, you have to limit them with a where clause accordingly. As when working with Fractural Numebrs, you need a common denominator.

Something like a "IMergable" interface that you have to write yourself.

public IMergeable mergeTwoSorted<Tone, Ttwo> (Tone array, Ttwo array2)

    where Tone : IMergeable, Ttwo : IMergeable

    {

        IMergeable mergedArray = new IMergeable[array.Length + array2.Length];

        for (int i = 0; i < mergedArray.Length; i++)

        {

            if (array is ValueType && array2 is ValueType)

            {

                if (array[i] > array2[i])



            }

        }

    }

Alternatively, you could jsut use one type:

public Tone mergeTwoSorted<Tone> (Tone array, Tone array2)

        {

            IMergeable mergedArray = new IMergeable[array.Length + array2.Length];

            for (int i = 0; i < mergedArray.Length; i++)

            {

                if (array is ValueType && array2 is ValueType)

                {

                    if (array[i] > array2[i])



                }

            }

        }