На главную Наши проекты:
Журнал   ·   Discuz!ML   ·   Wiki   ·   DRKB   ·   Помощь проекту
ПРАВИЛА FAQ Помощь Участники Календарь Избранное RSS
msm.ru
Модераторы: Qraizer, Hsilgos
  
> Срочно нужна помощь. , Задачка на c++
    Очень срочно нужна помощь. Помогите плз. Необходимо написать программку, которая генерирует массив и преобразует его так, чтобы сначала шли нулевые элементы, а затем все остальные.
      Вот еще в копилку:
      ExpandedWrap disabled
        #include <iostream>
        #include <iterator>
        #include <vector>
        #include <algorithm>
         
        int main()
        {
            int item = 5;
            std::vector<int> iArray;
            std::generate_n(std::back_inserter(iArray), 10, [&item]() { return (item == 0) ? item : item--; });
            std::cout << "Array is: " << std::endl;
            std::copy(iArray.begin(), iArray.end(), std::ostream_iterator<int>(std::cout, " "));
            std::sort(iArray.begin(), iArray.end());
            std::cout << "\nSorted array is: " << std::endl;
            std::copy(iArray.begin(), iArray.end(), std::ostream_iterator<int>(std::cout, " "));
         
            return 0;
        }
        ExpandedWrap disabled
          #include <algorithm>
          #include <vector>
          #include <cstdlib>
           
          int main()
          {
              std::vector<int> v(30);
              std::generate(v.begin(), v.end(), [](){return (std::rand() % 10);});
              size_t idx = v.size();
              for(auto it = v.rbegin(); it != v.rend(); it++)
                  if(*it != 0)
                      v[--idx] = *it;
              std::fill(v.begin(), v.begin() + idx, 0);
              return 0;
          }


        Добавлено
        Цитата KILLER @
        Вот еще в копилку:

        У тебя перемешивается порядок ненулевых элементов.
        Сообщение отредактировано: shm -
          Цитата shm @
          У тебя перемешивается порядок ненулевых элементов.

          Ну да, в условии сказано было, чтоб сначало шли нулевые, потом все остальные. Я подумал, что раз в условии не сказано, что порядок остальных элементов должен сохранится, то можно натравить обычную сортировку на массив. Возможно я не так условие понял :-?
            Цитата KILLER @
            Ну да, в условии сказано было, чтоб сначало шли нулевые, потом все остальные.

            Тебе бы добавить в сортировку - лямбду, которая будет сравнивать отрицательные элементы с нулем.
            Иначе, в случае наличия отрицательных элементов - нули не будут впереди.
              Цитата JoeUser @
              Тебе бы добавить в сортировку - лямбду, которая будет сравнивать отрицательные элементы с нулем.
              Иначе, в случае наличия отрицательных элементов - нули не будут впереди.

              Да там просто лень было писать цикл, а хотелось чтоб массив был сразу сгенерирован с разными числами, среди которых есть нули. Поэтому написал там такую проверку. Ессно автор может под себя переделать как ему нужно, и проверки повставлять. Я то выкладывал с целью показать саму идею. :-?
                Цитата KILLER @
                Да там просто лень было писать цикл, а хотелось чтоб массив был сразу сгенерирован с разными числами, среди которых есть нули. Поэтому написал там такую проверку. Ессно автор может под себя переделать как ему нужно, и проверки повставлять. Я то выкладывал с целью показать саму идею.

                Идея хорошая - циклы не нужны.
                Вот на основе твоего кода:

                ExpandedWrap disabled
                  #include <iostream>
                  #include <iterator>
                  #include <vector>
                  #include <algorithm>
                   
                  int main() {
                    int item = 10;
                    std::vector<int> iArray;
                    std::generate_n(std::back_inserter(iArray), item , [] () -> int {
                      int tmp = std::rand() % 10;
                      return (std::rand() % 10 > 5) ? tmp : -tmp;
                    });
                    std::cout << "Array is: " << std::endl;
                    std::copy(iArray.begin(), iArray.end(), std::ostream_iterator<int>(std::cout, " "));
                    std::sort(iArray.begin(), iArray.end(), [](const auto &a, const auto &b) -> bool {
                      if (a == 0) return true;
                      return a < b;
                    });
                    std::cout << "\nSorted array is: " << std::endl;
                    std::copy(iArray.begin(), iArray.end(), std::ostream_iterator<int>(std::cout, " "));
                    return 0;
                  }
                  Преподы ваш код не оценят :lool: + коллекции вряд ли можно называть "массивами"
                  + в задании не было сказано что элементы массива не являются комплексным числом. Можно тогда уже, заюзать список классов, внутри которых будут мультикомплексные гиперкомплексные числа, и уже если их действительные части равны 0 (но, не факт что имелось ввиду это), то выталкивать такие числа в начало списка
                  Сообщение отредактировано: VisualProg -
                    Цитата VisualProg @
                    Преподы ваш код не оценят :lool:

                    Да ладно, сразу автомат поставят 8-)

                    Добавлено
                    Цитата VisualProg @
                    + коллекции вряд ли можно называть "массивами"

                    Ну можно вместо вектора взять std::array, хотя std::vector - самый что ни на есть массив, по стандарту. Правда динамический. Но в задании ничего не было сказано о том, каким он должен быть. :-?
                    Сообщение отредактировано: KILLER -
                      Цитата KILLER @
                      сразу автомат поставят 8-)

                      Мне бы таких преподавателей) Я бы сказал что большинство из преподавателей такой код не осилят...

                      Кстати, почему именно так?
                      Цитата JoeUser @
                      std::generate_n(std::back_inserter(iArray), item , [] () -> int {
                      int tmp = std::rand() % 10;
                      return (std::rand() % 10 > 5) ? tmp : -tmp;
                      });


                      Разве не проще в одно действие сделать?
                      ExpandedWrap disabled
                          std::generate_n(std::back_inserter(iArray), item , [] () -> int {
                            return (std::rand() % 21) - 10;
                          });
                      Сообщение отредактировано: VisualProg -
                        Цитата VisualProg @
                        Разве не проще в одно действие сделать?

                        Да, так лучше.
                          Цитата JoeUser @
                          [](const auto &a, const auto &b) -> bool {
                          if (a == 0) return true;
                          return a < b;
                          }

                          По-моему тут будет фигня если будут сравниваться два нуля - получится, что одновременно a < b и b < a.
                            Кстати что-то я тупанул, можно сделать проще:
                            ExpandedWrap disabled
                              #include <algorithm>
                              #include <vector>
                              #include <cstdlib>
                               
                              int main() {
                                  std::vector<int> v(30);
                                  std::generate(v.begin(), v.end(), [](){return (std::rand() % 10);});
                                  std::fill(std::remove(v.rbegin(), v.rend(), 0), v.rend(), 0);
                                  return 0;
                              }
                              Цитата OpenGL @
                              По-моему тут будет

                              Одновременно не будут. Сработает либо первый, либо второй ретурн.
                                Цитата JoeUser @
                                Одновременно не будут. Сработает либо первый, либо второй ретурн.

                                Причём тут первый либо второй?
                                ExpandedWrap disabled
                                  int a = 0;
                                  int b = 0;
                                  auto cmp = [](const auto &a, const auto &b) -> bool {
                                  if (a == 0) return true;
                                  return a < b;
                                  };
                                  std::cout << cmp(a, b) << " " << cmp(b, a); // Выводит два раза true

                                что для сортировки, очевидно, плохо.
                                  Ну раз уж пошли флудить, дайте и я добавлю :rolleyes:
                                  ExpandedWrap disabled
                                    #include <algorithm>
                                    #include <iostream>
                                    #include <vector>
                                    #include <cstdlib>
                                     
                                    int main()
                                    {
                                        std::vector<int> v(30);
                                        std::generate(v.begin(), v.end(), [](){ return (std::rand() % 10); });
                                        std::stable_partition(v.begin(), v.end(), [](int i){return i == 0;});
                                        std::copy(std::begin(v), std::end(v), std::ostream_iterator<int>(std::cout, " "));
                                        return 0;
                                    }
                                    ExpandedWrap disabled
                                      [](const auto &a, const auto &b) -> bool {
                                      if (!a && b) return true;
                                      return false;
                                      }

                                    Смысл весь массив сортировать если надо только нули вперёд вытянуть?
                                    Или как вариант:
                                    ExpandedWrap disabled
                                      [](const auto &a, const auto &b) -> bool {
                                      return abs(a)<abs(b);
                                      }
                                      Цитата OpenGL @
                                      очевидно

                                      Не очевидно.
                                      Вот пример сортировки всех нулей:
                                      ExpandedWrap disabled
                                            #include <algorithm>
                                            #include <iostream>
                                            #include <iterator>
                                            #include <vector>
                                            #include <cstdlib>
                                            
                                            int main() {
                                                int c = 0;
                                                std::vector<int> v(10,0);
                                                std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
                                                std::sort(v.begin(), v.end(), [&](const auto &a, const auto &b) -> bool {
                                                  c = c + ((a == 0 || a < b) ? 1:0);
                                                  if (a == 0) return true;
                                                  return a < b;
                                                });
                                                std::cout << std::endl;
                                                std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
                                                std::cout << std::endl;
                                                std::cout << "c:" << c << std::endl;
                                                return 0;
                                            }

                                      Лямбда со значением true отработала ровно 9 раз. В чем проблема?

                                      Добавлено
                                      При векторе std::vector<int> v = {0,1,0,1,0,1,0,1,0,1} лямбда со значением true отработала 4 раза.

                                      Добавлено
                                      Можно конечно городить портянку сравнений на всевозможные варианты a и б - а смысл?

                                      Добавлено
                                      Цитата negram @
                                      Ну раз уж пошли флудить, дайте и я добавлю

                                      Согласно "Т3" - твое решение лучшее :)
                                        Точно, забыл я про stable_partition :(
                                          Цитата JoeUser @
                                          Не очевидно.

                                          Цитата из стандарта:
                                          Цитата
                                          Compare is a function object type (20.8). The return value of the function call operation applied to an object of type Compare, when contextually converted to bool (4), yields true if the first argument of the call is less than the second, and false otherwise.

                                          В частности, из этого следует, что cmp(x, x) должно равняться false для любого x.
                                            Цитата OpenGL @
                                            В частности, из этого следует, что cmp(x, x) должно равняться false для любого x.

                                            Задавая лямбду сортировки - мы задаем свое (любое!) условие сравнения. Почему мы не можем задать, что "левый" нуль всегда меньше "правого"? Возможно это как-то повлияет на количество излишних свопов, но логику не нарушит. Что и демонстрируют примеры.
                                              Цитата JoeUser @
                                              Задавая лямбду сортировки - мы задаем свое (любое!) условие сравнения. Почему мы не можем задать, что "левый" нуль всегда меньше "правого"?

                                              Не можем. То, что у тебя работает в конкретном компиляторе, говорит только о том, что это работает в нём и на твоих примерах, а не о том, что сортировка обязана работать и при таком компараторе.
                                                Цитата OpenGL @
                                                Не можем. То, что у тебя работает в конкретном компиляторе, говорит только о том, что это работает в нём и на твоих примерах, а не о том, что сортировка обязана работать и при таком компараторе.

                                                Да ешкин кот! Я могу в компораторе при сравнении указать что меньшее число является большим большего? Могу! И получится обратная сортировка. В документации "а" и "b" - это не целочисленные типы, это просто типы, которые я как хочу так и сравниваю. Повторюсь - максимум я потеряю на излишних свопах, когда одно значение в одном вызове будет меньше (в равных условиях), а во втором вызове оно больше.
                                                  JoeUser, OpenGL говорит о том, что в компараторе если comp(a,b)==false, то comp(b,a)==true
                                                  У тебя это нарушается и появляется случай когда comp(a,b)==comp(b,a) что может привести к UB, и получится "ой" когда в твоей STL поменяют алгоритм сортировки :)
                                                    Ты ссылку вообще читал? Если у тебя компаратор не обеспечивает strict weak ordering, то алгоритмы летят к чертям - их работоспособность не гарантируется. Например:
                                                    ExpandedWrap disabled
                                                      #include <iostream>
                                                      #include <vector>
                                                      #include <algorithm>
                                                       
                                                      int main ()
                                                      {
                                                          std::vector<std::pair<int, int>> v;
                                                          for(int i = 0; i < 10; ++i)
                                                          {
                                                              v.push_back(std::make_pair(0, i));
                                                          }
                                                          std::stable_sort(v.begin(), v.end(), [](const auto &a, const auto &b) -> bool {
                                                              if (a.first == 0) return true;
                                                              return a.first < b.first;
                                                          });
                                                          for(auto &x: v)
                                                          {
                                                              std::cout << x.first << " " << x.second << std::endl;
                                                          }
                                                      }

                                                    Вывод:
                                                    ExpandedWrap disabled
                                                      0 9
                                                      0 8
                                                      0 7
                                                      0 6
                                                      0 5
                                                      0 4
                                                      0 3
                                                      0 2
                                                      0 1
                                                      0 0

                                                    На wandbox.
                                                    Офигенно stable она работает, не так ли? :D
                                                      Цитата negram @
                                                      что может привести к UB

                                                      Не будет UB. Для чего нужен компаратор? Чтобы понять когда обменять значения. Что если обменять равные значения? Будет лишний своп. Но это не UB - это оверхед.

                                                      Добавлено
                                                      Цитата OpenGL @
                                                      Офигенно stable она работает, не так ли?

                                                      Работает так как ты "заказал", закидывать в начало - пары, у которых первое значение "нуль". Это все. Другой порядок ты не определил. Как заказал - так и получил.
                                                        Цитата JoeUser @
                                                        Работает так как ты "заказал", закидывать в начало - пары, у которых первое значение "нуль". Это все. Другой порядок ты не определил. Как заказал - так и получил.

                                                        "Закидывать в начало нули" это означает, что сначала должны идти нули в том же порядке, в котором шли, а потом остальные - с аналогичным условием. Ты здесь это видишь?
                                                        Ну и для кучи можешь ещё std::is_sorted вызвать на только что отсортированном векторе из примера выше - тоже весело будет.

                                                        Добавлено
                                                        О, а вот и пример того, как ломается уже просто std::sort:
                                                        ExpandedWrap disabled
                                                          #include <iostream>
                                                          #include <vector>
                                                          #include <algorithm>
                                                           
                                                          int main ()
                                                          {
                                                              std::vector<std::pair<int, int>> v;
                                                              for(int i = 0; i < 10; ++i)
                                                              {
                                                                  v.push_back(std::make_pair(rand() % 3 - 1, i));
                                                              }
                                                              auto cmp = [](const auto &a, const auto &b) -> bool {
                                                                
                                                                  if (a.first == 0) return true;
                                                                  return a.first < b.first;
                                                              };
                                                              std::sort(v.begin(), v.end(), cmp);
                                                              for(auto &x: v)
                                                              {
                                                                  std::cout << x.first << " " << x.second << std::endl;
                                                              }
                                                          }

                                                        Вывод на wandbox:
                                                        ExpandedWrap disabled
                                                          0 9
                                                          -1 7
                                                          0 6
                                                          0 5
                                                          0 3
                                                          -1 2
                                                          -1 8
                                                          0 1
                                                          0 0
                                                          1 4


                                                        Добавлено
                                                        Цитата negram @
                                                        OpenGL говорит о том, что в компараторе если comp(a,b)==false, то comp(b,a)==true

                                                        Только наоборот - если (a, b) == true, то (b, a) обязано быть false :)
                                                          Цитата negram @
                                                          Ну раз уж пошли флудить

                                                          Ты как творчество называешь?! :)

                                                          Цитата OpenGL @
                                                          if (a.first == 0) return true;
                                                          return a.first < b.first;


                                                          В общем, я решу ваш спор:

                                                          ExpandedWrap disabled
                                                                std::stable_sort(v.begin(), v.end(), [](const auto &a, const auto &b) -> bool {
                                                                    if (a.first == b.first) return false;
                                                                    if (a.first == 0) return true;
                                                                    return a.first < b.first;
                                                                });


                                                          Всё, и никто не уйдёт обиженным.

                                                          Бесплатно вставлю любой if в ваш код, без регистрации и смс :D
                                                            Цитата OpenGL @
                                                            "Закидывать в начало нули" это означает, что сначала должны идти нули в том же порядке, в котором шли

                                                            С какого это фига?
                                                            Ты по первым элементам сравниваешь - по первым тебе и отсортировало.
                                                              Цитата cppasm @
                                                              Ты по первым элементам сравниваешь - по первым тебе и отсортировало.

                                                              Суть в том, что если элементы равны, сортировка считается - избыточным действием. Лично я согласен с этим утверждениям)
                                                                Цитата OpenGL @
                                                                "Закидывать в начало нули" это означает, что сначала должны идти нули в том же порядке, в котором шли, а потом остальные - с аналогичным условием.

                                                                С чего бы это? Этого в компараторе ничем не определялось - а определяется существующим алгоритмом сортировки. Он вообще был вправе все перемешать. Главное условие, которое он не должен нарушить - "ноль меньше нуля".
                                                                  Цитата VisualProg @
                                                                  В общем, я решу ваш спор:

                                                                  Нет. В твоём компараторе cmp(0, -1) == cmp(-1, 0) == true :)
                                                                  Вот так будет правильно:
                                                                  ExpandedWrap disabled
                                                                    if (a.first == 0) return b.first != 0;
                                                                    if (b.first == 0) return false;
                                                                    return a.first < b.first;


                                                                  Добавлено
                                                                  Цитата cppasm @
                                                                  С какого это фига?
                                                                  Ты по первым элементам сравниваешь - по первым тебе и отсортировало.

                                                                  Там stable_sort, поэтому нули должны идти ровно в том же порядке, в каком шли изначально.

                                                                  Добавлено
                                                                  Цитата JoeUser @
                                                                  Главное условие, которое он не должен нарушить - "ноль меньше нуля".

                                                                  И именно это он в твоей версии компаратора и нарушил.
                                                                  Сообщение отредактировано: OpenGL -
                                                                    Цитата OpenGL @
                                                                    О, а вот и пример того, как ломается уже просто std::sort:

                                                                    Да, тут это не работает ... и тем не менее:

                                                                    ExpandedWrap disabled
                                                                      std::sort(v.begin(), v.end(), [] (const auto &a, const auto &b) -> bool {
                                                                        return (a.first == 0);
                                                                      });

                                                                    Работает просто прекрасно.
                                                                      Цитата OpenGL @
                                                                      Там stable_sort

                                                                      А, сорри. Не заметил, думал там std::sort()
                                                                        Цитата JoeUser @
                                                                        и тем не менее:

                                                                        И тем не менее всё вышесказанное про требование алгоритмами strict weak ordering остаётся в силе - с таким компаратором ты рискуешь в самые неожиданные моменты нарваться на грабли.
                                                                          Цитата JoeUser @
                                                                          Работает просто прекрасно.
                                                                          То, что что-то компилируется и работает никогда не было доказательством корректности, если речь идёт о плюсах :D
                                                                            Цитата OpenGL @
                                                                            И тем не менее всё вышесказанное про требование алгоритмами strict weak ordering остаётся в силе - с таким компаратором ты рискуешь в самые неожиданные моменты нарваться на грабли.

                                                                            Про отсутствие UB и вероятное наличие оверхеда я уже повторял трижды. Ты не услышал. Да, первый мой вариант некорректен - надо было смотреть только "левый" нуль. Пусть он всегда меньше "правого". Это лишь лишняя перестановка. И по ТЗ топикстартера все будет ровно!

                                                                            Цитата negram @
                                                                            То, что что-то компилируется и работает никогда не было доказательством корректности, если речь идёт о плюсах

                                                                            Тут слов нет - согласен и посыпаю голову пепломЪ :) Постарайся развидеть этот мой аргумент :lol:
                                                                              Цитата JoeUser @
                                                                              Про отсутствие UB и вероятное наличие оверхеда я уже повторял трижды.

                                                                              А толку-то от этих повторений, если изначальный мой посыл - что оба твоих компаратора не удовлетворяет контрактам, на которые полагаются функции стандартной библиотеки - это никак не опровергает? Допускаю, что std::sort написать так, чтобы она не работала с антирефлексивным компаратором не так-то просто, но тем не менее твой код от этого говнокодом быть не перестаёт - практически все остальные функции с твоими компараторами тупо не заработают.
                                                                                Цитата OpenGL @
                                                                                практически все остальные функции с твоими компараторами тупо не заработают.

                                                                                А ниче што я это не "презентовал" для фсего? А только для данной темы?
                                                                                  Ну начинается :lool:
                                                                                  Ладно, раз хочешь флудить, то ок. Твой код не работает в студии в дебаге, ибо она проверяет компараторы на антирефлексивность, и если условие не выполняется - валится с ассертом. Т.е. твой код уже не работает. Что дальше ? Что-то вроде "я не презентовал для работы во всех компиляторах"? :D
                                                                                    Цитата OpenGL @
                                                                                    Ну начинается :lool:
                                                                                    Ладно, раз хочешь флудить, то ок. Твой код не работает в студии в дебаге, ибо она проверяет компараторы на антирефлексивность, и если условие не выполняется - валится с ассертом. Т.е. твой код уже не работает. Что дальше ? Что-то вроде "я не презентовал для работы во всех компиляторах"? :D

                                                                                    Да, студии у меня нет, проверить не могу.
                                                                                    Но и у меня вопрос!!! Если GCC/Clang во всех ипостасях это кушают, то СТУДИЯ В ДЕБАГЕ - это аргумент? Это окончательная инстанция?

                                                                                    Добавлено
                                                                                    Скрытый текст
                                                                                    Студия - с пальмы слезла пол-часа назад, по сведениям от британских ученых. Есличо.


                                                                                    Добавлено
                                                                                    Цитата JoeUser @
                                                                                    не "презентовал" для фсего? А только для данной темы?

                                                                                    а если более точно, то для std::sort
                                                                                      Цитата JoeUser @
                                                                                      Но и у меня вопрос!!! Если GCC/Clang во всех ипостасях это кушают, то СТУДИЯ В ДЕБАГЕ - это аргумент? Это окончательная инстанция?

                                                                                      Нет конечно - окончательная инстанция это стандарт. Но, видимо, для тебя он не авторитет :D
                                                                                        Цитата OpenGL @
                                                                                        Но, видимо, для тебя он не авторитет

                                                                                        05 25. Я стандарт не нарушаю! У меня четкое условие - "если левый аргумент компаратора равен нулю, то результат == true".
                                                                                        ЭТО МОЕ УСЛОВИЕ СРАВНЕНИЯ!!!

                                                                                        В Стандарте указано что я ОБЯЗАН учитывать ОБА ПАРАМЕТРА компоратора? Что не запрещено, то разрешено.
                                                                                        Сообщение отредактировано: JoeUser -
                                                                                          Цитата JoeUser @
                                                                                          В Стандарте указано что я ОБЯЗАН учитывать ОБА ПАРАМЕТРА компоратора?

                                                                                          В Стандарте сказано, что предикат должен обладать свойством транзитивности, а у тебя ее не наблюдается.
                                                                                            Цитата shm @
                                                                                            В Стандарте сказано, что предикат должен обладать свойством транзитивности

                                                                                            Цитата
                                                                                            Транзитивность — свойство бинарного отношения. Бинарное отношение R {\displaystyle R} R на множестве X {\displaystyle X} X называется транзитивным, если для любых трёх элементов множества a , b , c {\displaystyle a,b,c} a,b,c выполнение отношений a R b {\displaystyle aRb} aRb и b R c {\displaystyle bRc} bRc влечёт выполнение отношения a R c {\displaystyle aRc} aRc.

                                                                                            WTF??? В компораторе два аргумента. Давай-ка цитату из Стандарта. Давай разбираться. Я не то, чтобы чтобы ... ))) Но на слово не верю.
                                                                                              Цитата JoeUser @
                                                                                              В компораторе два аргумента

                                                                                              Ты просто не так понял процитированное. Смотри там написано:
                                                                                              Цитата JoeUser @
                                                                                              Транзитивность — свойство бинарного отношения.

                                                                                              Вот это бинарное отношение - компаратор.

                                                                                              Дальше пишут:
                                                                                              Цитата JoeUser @
                                                                                              Бинарное отношение R {\displaystyle R} R на множестве X {\displaystyle X} X называется транзитивным, если для любых трёх элементов множества a , b , c {\displaystyle a,b,c} a,b,c выполнение отношений a R b {\displaystyle aRb} aRb и b R c {\displaystyle bRc} bRc влечёт выполнение отношения a R c {\displaystyle aRc} aRc.

                                                                                              1) то что выделено зеленым имеется ввиду для любых трех взятых элементов из множества, т.е. это не компаратор, это предложение как раз говорит, что твой компаратор будет удовлетворять транзитивности, если для любых трех взятых элементов массива выполняется отношение a R b и b R c ылечет a R c
                                                                                              Другими словами R - это твой компаратор, а a,b,c - 'это любых три числа, взятых из массива.
                                                                                              Т.е. по сути если из массива взяли три элемента, "a b c", то для того, что бы твой оператор удовлетворял транзитивности, должно выполнятся вот такое отношение для него:

                                                                                              Если
                                                                                              a < b
                                                                                              и
                                                                                              b < c
                                                                                              Тогда
                                                                                              a < c

                                                                                              Вот именно так я понял то, что ты привел про транзитивность.
                                                                                              Сообщение отредактировано: KILLER -
                                                                                                    KILLER, сенкс - понял. Ну ладно, пусть будет так. Я был неправ.

                                                                                                    Тогда пусть будет исправленный вариант от VisualProg:

                                                                                                    ExpandedWrap disabled
                                                                                                      std::stable_sort(v.begin(), v.end(), [](const auto &a, const auto &b) -> bool {
                                                                                                        if (a.first == b.first) return false;
                                                                                                        if (a.first == 0) return true;
                                                                                                        return a.first < b.first;
                                                                                                      });

                                                                                                    ... ну или в этом духе для решения вопроса топика. Хотя negram решил получче :whistle:
                                                                                                    Сообщение отредактировано: JoeUser -
                                                                                                        Некоторые алгоритмы сортировки не заканчивают свою работу или неправильно работают, если им вместо оператора < подсунуть оператор <=. К таковым относятся шейкерная сортировка и (ВНИМАНИЕ) быстрая сортировка Хоара. Естественно, в последовательности должны быть повторяющиеся элементы. Шейкерная сортировка при этом зацикливается, а быстрая сортировка может в некоторых случаях не обработать часть последовательности. Пузырьковая сортировка, сортировка вставками, слиянием и многие другие выполняют лишнюю работу, но выдают в результате отсортированную последовательность.
                                                                                                          Цитата JoeUser @
                                                                                                          Давай-ка цитату из Стандарта.

                                                                                                          Было выше.
                                                                                                            а студент то где? :punish: :D
                                                                                                              Цитата Cfon @
                                                                                                              а студент то где?

                                                                                                              Думаю, что не появится тут до пересдачи осенью.
                                                                                                                Цитата shm @
                                                                                                                Точно, забыл я про stable_partition :(

                                                                                                                Можно было обойтись обычным partition :)
                                                                                                                  Цитата Flex Ferrum @
                                                                                                                  Цитата shm @
                                                                                                                  Точно, забыл я про stable_partition :(

                                                                                                                  Можно было обойтись обычным partition :)

                                                                                                                  Эт я специально stable_ заюзал, а то перед этим были обвинения в изменении порядка равных элементов :)
                                                                                                                  В задаче про это, конечно, ничего нет, но так все обвинения на корню зарезаны
                                                                                                                    Цитата Flex Ferrum @
                                                                                                                    Можно было обойтись обычным partition

                                                                                                                    Я вот не уверен. Впрочем, мы это вряд ли уже узнаем :)
                                                                                                                    Сообщение отредактировано: shm -
                                                                                                                      Цитата shm @
                                                                                                                      Впрочем, мы это вряд ли уже узнаем

                                                                                                                      Не удивлюсь если автор темы уже вторую неделю листает справочники и методички "по с++" и не может понять, на каком языке вы тут ему задачу решили :lool:
                                                                                                                        А вот я удивлюсь в этом случае.
                                                                                                                          Цитата Qraizer @
                                                                                                                          А вот я удивлюсь в этом случае.

                                                                                                                          +1
                                                                                                                            Скрытый текст
                                                                                                                            Цитата Qraizer @
                                                                                                                            А вот я удивлюсь в этом случае.

                                                                                                                            Скорее всего. Задача и без STL тривиальная, и ее разобрать самостоятелно - не хватило желания/терпения.
                                                                                                                              Добрый день! Жаль, что автор пропал) Интересно помогло ему или нет)
                                                                                                                              0 пользователей читают эту тему (0 гостей и 0 скрытых пользователей)
                                                                                                                              0 пользователей:


                                                                                                                              Рейтинг@Mail.ru
                                                                                                                              [ Script execution time: 0,1310 ]   [ 17 queries used ]   [ Generated: 29.03.24, 00:06 GMT ]