Question

I am trying to solve my task using a List and I know I am very close to solving it but I am stuck now. Something is not ok in the code and I can not figure out what it is. Could you please take a look and help:

        /*
Write a program that reads an array of integers and removes from it a minimal number of elements in such way that the
remaining array is sorted in increasing order. Print the remaining sorted array.
Example: {6, 1, 4, 3, 0, 3, 6, 4, 5}  {1, 3, 3, 4, 5}
 */
using System;
using System.Collections.Generic;

class RemoveMinimalElements
{

    static void Main()
    {
        int n;
        n = int.Parse(Console.ReadLine());
        List<int> arr = new List<int>();
        List<int> sorted = new List<int>();
        int maxSubsetLenght = 0;

        for (int i = 0; i < n; i++)
        {
            arr.Add(int.Parse(Console.ReadLine()));
        }


        for (int i = 1; i <= (int)Math.Pow(2, n) - 1; i++)
        {
            int tempSubsetLenght = 0;
            string tempString = "";
            List<int> temp = new List<int>();


            for (int j = 1; j <= n; j++)
            {
                int andMask = i & (1 << j);
                int bit = andMask >> j;

                if (bit == 1)
                {
                    temp.Add(arr[n - 1 - j]);
                    tempSubsetLenght++;
                }
                if (tempSubsetLenght > maxSubsetLenght)
                {
                    maxSubsetLenght = tempSubsetLenght;

                    for(int k =1; k < temp.Count; k ++)
                    {
                        if (temp[k] >= temp[k - 1])
                        {
                            sorted = temp;
                        }
                    }
                }
            }
        }

        for (int i = sorted.Count - 1; i > 0; i--)
        {
            Console.WriteLine(sorted[i]);
        }
    }
}

Answer 1

I don’t know if an exhaustive search is suitable for your case, but will this work for you?

static void Main(string[] args)
        {
            int[] input = new[] { 6, 1, 4, 3, 0, 3, 6, 4, 5 };
            int[] expectedOutput = new[] { 1, 3, 3, 4, 5 };

            int[] solution = TryGetSolution(input);

            Console.WriteLine("Input: " + FormatNumbers(input));
            Console.WriteLine("Expected Output: " + FormatNumbers(expectedOutput));
            Console.WriteLine("Output: " + FormatNumbers(solution));
            Console.ReadLine();
        }

        private static string FormatNumbers(int[] numbers)
        {
            return string.Join(", ", numbers);
        }

        private static int[] TryGetSolution(int[] input)
        {
            return TryWithoutAnyItem(input);
        }

        private static int[] TryWithoutAnyItem(int[] items)
        {
            return Enumerable.Range(0, items.Length)
                             .Select(i => TryWithoutItem(items, i))
                             .Where(solution => solution != null)
                             .OrderByDescending(solution => solution.Length)
                             .FirstOrDefault();
        }

        private static int[] TryWithoutItem(int[] items, int withoutIndex)
        {
            if (IsSorted(items)) return items;
            var removed = items.Take(withoutIndex).Concat(items.Skip(withoutIndex + 1));
            return TryWithoutAnyItem(removed.ToArray());
        }

        private static bool IsSorted(IEnumerable<int> items)
        {
            return items.Zip(items.Skip(1), (a, b) => a.CompareTo(b)).All(c => c <= 0);
        }
    }