нечетные/четные числа - сортировка массива

Question

Может ли кто-нибудь помочь. Мне нужно написать программу, которая позволяет пользователю вводить 10 номеров. И сортировать эти числа в нечетном (по возрастанию) и даже (порядке убывания).

, например: вход: 2, 8, 7, 13, 23, 9, 34, 11, 1, 16 выход: 1, 7, 9, 11, 13, 23, 34, 16, 8, 2

И я должен сделать это без каких-либо методов, таких как Array.Sort.

Это мой код до сих пор:

Console.WriteLine("Input 10 numbers: "); 
     int[] number = new int[10]; 
     for (int i = 0; i < number.Length; i++) { 
      number[i] = int.Parse(Console.ReadLine()); 

      if (number[i] == 0) { 
       Console.WriteLine("input of 0 is not alllowed!"); 
       break; 
      } 
     } 

     //EVEN NUMBERS 
     for (int i = 0; i < number.Length; i++) { 
      if (number[i] % 2 == 0) { 
       Console.Write("{0} ", number[i]); 
      } 
     } 

     //ODD NUMBERS 
     for (int i = 0; i < number.Length; i++) { 
      if (number[i] % 2 != 0) { 
       Console.Write("{0} ", number[i]); 
      } 
     } 

мне просто нужно общее представление о том, как это сделать.

Answer 1

Это должно работать: (имейте в виду, что «число» представляет собой массив со всеми номерами внутри

List<int> oddnumbers = new List<int>(); 
List<int> evennumbers = new List<int>(); 
foreach(int number in numbers) 
{ 
    if(numer % 2 == 0)//If number is divisible by 2(is even) 
    { 
     evennumbers.Add(number); 
    } 
    else//If number is not divisible by 2(is odd) 
    { 
     oddnumbers.Add(number); 
    } 
} 
evennumbers = evennumbers.Sort(); 
oddnumbers = oddnumbers.Sort();//Sort both lists so that they values are in ascending order. 
evennumbers = evennumbers.Reverse();//Reverse the items in "evennumbers" into descending order. 
List<int> newnumbersequence = new List<int>(); 
foreach(int number in oddnumbers) 
{ 
    newnumbersequence.Add(number); 
} 
foreach(int number in evennumbers) 
{ 
    newnumbersequence.Add(number); 
} 

А затем поместить их в статическом классе

public static List<int> Sort(this List<int> numbers) 
{ 
    int[] temp = numbers.ToArray(); 
    for(int i = 0; i < temp.Length-1; i++) 
    { 
     int index = i; 
     while(index > -1) 
     { 
      if (temp[index] > temp[index+1]) 
      { 
       int num1 = temp[index]; 
       int num2 = temp[index+1]; 
       temp[index] = num2; 
       temp[index+1] = num1; 
      } 
     } 
    } 
    return temp.ToList(); 
} 

public static List<int> Reverse(this List<int> numbers) 
{ 
    List<int> returner = new List<int>(); 
    for(int i = numbers.Count-1; i > -1; i++) 
    { 
     returner.Add(numbers[i]); 
    } 
    return returner; 
} 

Answer 2

Вы должны следовать. эти шаги, когда вы думаете о том, как реализовать этот код:

• Разделите массив на два массива, один из которых содержит нечетные числа и один содержащие четные числа
• Создайте один метод, который сортирует массив в порядке возрастания
• Сортируйте оба массива с помощью этой функции, но измените порядок четного массива.

В псевдокоде это будет выглядеть примерно так:

//Array you get from the user 
arr = get_user_inputs() 
def split(array) : 
    even = [] 
    odd = [] 
    for item in array: 
    if(item %2 == 0): 
     even.append(item) 
    else: 
     odd.append(item) 
    return (even,odd) 

(even,odd) = split(arr) 
(even,odd) = (sort(even) , sort(odd)) 
print(odd.toString + even.toString.reverse) 

Для реализации самого алгоритма сортировки я хотел бы предложить отрываясь некоторые простые алгоритмы сортировки, такие как выбор рода.

Существует видео с CS50 на YouTube объясняя этот алгоритм, который делает очень хорошую работу:

https://www.youtube.com/watch?v=f8hXR_Hvybo

Answer 3

Убедитесь, что ваш вход не врезаться, если ввести букву ...

номер [i] = int.Parse (Console.ReadLine());

Вы успешно обнаруживаете номера ODD/EVEN, но перед их печатью вам необходимо сохранить их в промежуточном массиве.

У вас есть два подхода,

1. Возьмите низкое нечетное число, удалить из списка ввода и добавить в новый список.
2. Повторите, пока не осталось нечетных чисел
3. Примите самое высокое четное число, удалите из списка ввода и добавьте в новый список.
4. Повторять до не четных номеров осталось
5. Распечатайте новый список

2 (работаю с тем, что у вас есть)

1. Создание списка для хранения нечетных чисел и один для четных чисел ,
2. Добавьте свои номера в соответствующий список (нечетный/четный), как вы их найдете (вместо того, чтобы печатать на консоль, как вы сейчас делаете). Также добавьте требуемый заказ. Например. для длины списка, если число больше элемента в i, тогда вставьте в i.
3. Распечатайте обоих списках

Answer 4

Я бы первым положить разделить число на два списка (да, я хотел бы использовать списки вместо массивов), а затем создать BubbleSort функцию, которая принимает направление.

https://en.wikipedia.org/wiki/Bubble_sort

Если эта ссылка недостаточно, вы должны быть в состоянии найти много ссылок реализации, чтобы помочь вам.

Answer 5

Существует множество хороших алгоритмов сортировки, которые вы можете реализовать, и я не буду вдаваться, поскольку это немного не соответствует теме вашего вопроса, но here's a link на странице, которая описывает многие из них.

Ключ к решению проблемы с любым алгоритмом сортировки будет иметь хорошую функцию сравнения, которая может рассказать вам, в каком порядке должны отображаться значения. Важными правилами для этого сравнения в вашем случае являются: 1. Нечетный должен всегда прихожу, прежде чем даже 2. Нижняя числа нечетной должен прийти до чисел высшего нечетных 3. высшего даже цифры должны прийти до Lower даже номер

Таким образом, ваша функция сравнения может выглядеть следующее (примечание: я бы не называйте функцию или параметры таким образом, как правило, но это делает ее более понятной для этого примера)

public bool AComesBeforeB(int a, int b) 
{ 
    if(IsOdd(a)) 
    { 
     if(IsOdd(b)) 
     { 
      return a < b; 
     } 
     else 
     { 
      return true; 
     } 
    } 
    else 
    { 
     if(isOdd(b)) 
     { 
      return false; 
     } 
     else 
     { 
      return a > b; 
     } 
    } 
} 

Альтернативно вы можете сделать это, как рекомендовал yyttr3, и разделить четные и нечетные числа на разные массивы, а затем отсортировать их оттуда. Я предпочитаю не делать этого таким образом, потому что он требует больше кода и больше памяти, но он работает в основном так же хорошо.

Несколько дополнительных примечаний непосредственно не относящиеся к данному вопросу:

1. Посмотрите на то, что произойдет, если кто-то введите 0 (намек, он не работает правильно)

2. Основываясь на ваших код и ваш пример ввода, вы предполагаете, что вход всегда будет целым числом, что произойдет, если пользователь поставит число с десятичной точкой? Или алфавитная строка?(подсказка: исключение приведет к сбою вашей программы)

3. Убедитесь, что ваша программа обрабатывает отрицательные числа, поскольку она стоит прямо сейчас. Я не понимаю, почему это не так, но это всегда хороший тест при работе с номером входы

4. Это похоже на задание на домашнюю работу, и, хотя это хорошо, чтобы попросить совета и помочь в решении конкретных проблем, не пытайтесь использовать СО, чтобы сделать домашнее задание для вас, чтобы быть ясным. Думаю, что вы это делаете, но ответ Rariolu в основном дает вам код оптовой торговли, который можно рассматривать как плейер, если он представлен как ваша собственная работа.

5. Когда вы говорите, что вы wan t сделать это «без каких-либо методов», что предает непонимание того, что такое метод. Этот код по своей сути будет выполняться внутри метода, и для того, чтобы писать этот код ясным и понятным способом, вы захотите написать свои собственные методы, которые вы можете вызвать из основного метода. Я думаю, что вы действительно хотите сказать: «Я должен делать это без использования методов библиотеки C#, которые обычно используются для сортировки».

Answer 6

В основном псевдокод, показывающий, как можно разбить работу.

// initial conditions 
evens = new List // standard C# List<T> interface 
odds = new List 
i = 0; 

// read numbers 
while (i++ < 10) { 
    filter(input); 
} 

print(odds, evens) 

А вот «рабочие» функция:

// decide if it goes to the even or odd: 
filter(input) { 
    if(input % 2 == 0) { 
    // sort descending 
    sort(evens, input, "desc"); 
    } else { 
    sort(odds, input, "asc"); 
    } 
} 

// given a list, a new input to add, and direction, 
// the function mutates the list accordingly 
sort(list, input, direction) { 
    for(j = 0; j < list.length; j++) { 
    item = list[j]; 
    if((direction == "desc" && item < input) 
     || (direction == "asc" && item > input)) 
    { 
     list.insert(j, input); 
     return 
    } 
    } 
    list.add(input); // lastly, if nothing else was triggered 

Я полагаю, что наиболее важный недостающий элемент является алгоритмом сортировки. Выше я внедрил вариант insertion sort, который использует метод List.insert в качестве ярлыка для переключения уже отсортированной части «массива».