1. C++ / Говнокод #12853

    +13

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    #include <iostream>
    #include <vector>
    #include <stdlib.h>
    #include <time.h>
    
    using std::vector;
    
    void print_vec(const vector<int> v)
    {   /* Print Vector */
        for(vector<int>::size_type i(0); i!=v.size(); ++i)
            std::cout << v[i] << (i!=v.size()-1 ? "|":"\n");
    }
    
    bool sort_vec(const vector<int> v)
    {   /* Return True if vector sorted */
        bool b(true);
        for(vector<int>::size_type i(v.size()-1);i!=0;--i)
            if (v[i]<v[i-1]) {b=false;}
        return b;
    }
    
    int main()
    {
        vector<int> VectorForNumber;
        const unsigned int ConstMaxElement(10);
        srand(time(NULL));
        for(vector<int>::size_type i(0);i!=ConstMaxElement;++i)
            VectorForNumber.push_back(rand() % 50); // Max Number. Unsigned int && 0<N!
        while (not sort_vec(VectorForNumber))
        {
            print_vec(VectorForNumber);
            std::swap(VectorForNumber[rand() % ConstMaxElement],VectorForNumber[rand() % ConstMaxElement]);
        }
        print_vec(VectorForNumber);
        return 0;
    }

    Менять местами два элемента вектора до тех пор, пока он не станет отсортированным по возрастанию.
    С выводом сортирует примерно за 30 секунд вектор из 10 элементов, без вывода - от 0.5-1 секунды.

    Запостил: eli, 06 Апреля 2013

    Комментарии (58) RSS

    • хорошая оптимизация пузырька с приближением по трудоемкости к случайной сортировке
      Ответить
    • Вау, более или менее красиво оформленная лаба. Не думал, что доживу до этого дня. +
      Ответить
      • Всё равно найду, к чему придраться: собственно сама сортировка не оформлена функцией. Как будет выглядеть код, если нужно отсортировать два вектора?
        Ответить
        • Придраться всегда есть к чему, а этот код просто демонстрирует мало эффективную сортировку.
          Почему "мало"? Потому что в итоге все ровно рано или поздно вектор отсортирован.
          Ответить
          • Доказательств конечности алгоритма я не увидел. А вдруг будет бесконечный цикл?
            Ответить
            • Почему же? Условие выхода из цикла - есть, перемещение конкретных значений внутри вектора для сортировки - есть. Следовательно, когда-то но он закончится. А вот на сколько быстро это произойдет, это уже другой вопрос.
              Ответить
              • Не факт. Можете убедиться, например, на алгоритме решения нелинейных уравнений методом простых итераций. Условие выхода из цикла есть, а на некоторых уравнениях цикл оказывается бесконечным.

                Кстати, у всех алгоритмов генерации псевдослучайных чисел есть цикл: число на шаге (n+m) может совпасть с числом на шаге n, тогда цепочка чисел от n-ного до (n+m)-ного будет повторяться вечно.
                Ответить
                • Поэтому я ненавижу алгоритмы с выходом по рандому, стараясь находить вменяемую альтернативу.
                  Ответить
              • Можно посчитать число итераций, за которые массив отсортируется с вероятностью 1–ε — алгоритм сходится по вероятности. Правда, псевдорандом действительно несколько портит анализ, но если взять какой-нибудь вихрь Мерсенна, «псевдо-» можно смело пренебречь.
                Ответить
    • > вектор из 10 элементов
      Там всего 3628800 вариантов. А вот вектора из 20 элементов уже не дождешься ;)
      Ответить
      • Всё намного хуже. Можно и вектора из 10 элементов не дождаться: программа перемешивает даже частично упорядоченный вектор. Перед свопом никакой проверки не делается.
        Ответить
        • Если вектор отсортирован, то она и трогать его не будет, иначе перемешивает.
          Ответить
          • Пример частично упорядоченного вектора: 1, 2, 3, 4, 5, 6, 7, 8, 10, 9.

            Человеку очевидно, что для сортировки достаточно переставить два последних элемента. Продемонстрированному алгоритму — нет. Он сначала размешает все предыдущие элементы, а потом, когда-нибудь в далёком будущем, отсортирует вектор, если звёзды будут благосклонны.
            Ответить
            • Я и говорю, что если вектор отсортирован, тогда и только тогда он его не трогает, во всех остальных случаях он его мешает. И ему не важно как именно он перемешан.
              Ответить
            • Да ты гений, братишка!
              Ответить
    • Согласен, похоже на пузырьковую сортировку, но основная идея взята с баша.
      Перемешивать массив до тех пор, пока он не будет отсортирован. Немного упрощаем до перемешивания двух случайных элементов и смотрим как от будет сортировать.
      Эм... Это не лаба, а просто шуточные код.
      Почему же, подождать можно, просто будет долго считать, особенно если не убирать вывод.
      :)
      Ответить
      • Это не просто шуточный код. Это жесть. Вызов Его Величеству Случаю.
        Ответить
    • http://ru.wikipedia.org/wiki/Bogosort
      Ответить
    • Ёжик упал в колодец. Лезет-лезет, вылезти не может: колодец глубокий, а стенки скользкие. Думает: если сейчас не вылезу, пойду домой за лестницей. А что, колодец открыт, возможность вылезти имеется. А вот насколько быстро это произойдёт, это уже другой вопрос.
      Ответить
    • > vector<int>::size_type
      ну не лень, а
      я б все векторы на int переточил, ибо int писать быстрее, чем size_t
      А те, кому надо больше 2 млрд элементов - да ну их нахуй!
      Ответить
      • >я б все векторы на int переточил
        64-bit addressing mode
        Ответить
      • > я б все векторы на int переточил
        Юзай жабу. Там так и есть.
        Ответить
      • >А те, кому надо больше 2 млрд элементов - да ну их нахуй!
        Ну как тебе сказать. С первой частью поста (про лень) я согласен, со второй не совсем.

        Вот запили свой TVector. И напиши в документации:
        >кому надо больше 2 млрд элементов - да ну их нахуй!
        Ответить
        • Почему? Предлагаешь не нахуй? А куда же ещё?
          Ответить
          • Нахуй.
            А все кому надо больше - пусть пилят косвенную адресацию.
            И в это время думают - надо ли им одним куском памяти такие вещи. Или всё-таки надо делать страничную адресацию.

            Вернее даже так. Я полностью с тобой согласен в вопросе размера цельного массива, но не согласен в вопросах интерфейса для доступа к вектору - тут нельзя ничего ограничивать.
            Ответить
            • И обязательно сделать страницы с пересекающимися адресами, чтобы поиск страницы по индексу не был однозначным. И по умолчанию последнюю страницу закольцевать на первую, а выключать закольцовку по сигналу от внешнего оборудования.
              Ответить
            • А я не предлагал ограничивать доступ, я предлагал сделать int по умолчанию, чтобы не писать лишнее и компилятор не ругался.
              Ответить
              • это сказал человек, которому не западло писать Integer, но которому западло написать size_t
                Ответить
                • Нет, на крестах мне было бы западло писать Integer
                  Ответить
                • Типы надо назвать l, q, i, d, s, w, c, b, чтобы их не западло было писать Тарасу.

                  P.S. l - 64 бита знаковое, q - 64 беззнаковое (quad word) и так далее по уменьшению.
                  Ответить
                  • Зачем вообще явно писать типы? Как в первых фортранах, по первой букве имени переменной тип выводить.
                    Ответить
                    • Типы выводить по правой часты выражения.
                      Вообще я что хочу сказать.
                      В одном сишкоблядском языке явно экономили на названиях типов и функций, в ущерб остальному, поэтому чтоб на нём ещё и типы писать длинными словами - ну нахуй.
                      А в другом (нормальном) языке тупой экономией не занимались, и на нём, кстати, длинные названия смотрятся нормально.
                      Ответить
                      • > экономили на названиях типов и функций
                        unsigned long long. Неплохо так наэкономили...
                        Ответить
                        • Всё правильно, сначала экономили (не включая голову), а потом (т.е. голову-то не включали) экономия по пизде пошла.
                          Ответить
                    • >Как в первых фортранах, по первой букве имени переменной
                      А в бейсиках по последней!
                      Ответить
                      • Там же не только буквы могли быть.
                        Ответить
    • > while (not sort_vec(VectorForNumber))
      > not
      Ответить
      • > gcc

        http://ideone.com/SWN5rB
        Ответить
        • почему гцц
          стандарт
          2.6 Alternative tokens [lex.digraph]
          Ответить
          • А в стандарте нет где-нибудь приписки / флажка компилятора, чтобы сделать нечуствительным к регистру и begin / end считать эквивалентными скобкам? Ну и желательно, чтоб тогда уже и значения из функций возвращать через присваивание имени функции.
            Ответить
            • надо знать меру мракобѣсию
              begin/end можно запилить через #define
              нечувствительно к регистру - не сталкивался с такими опциями ни в одном компиляторе, и думаю, их не существует
              имя функции без скобок имеет семантику адреса этой функции
              Ответить
              • > не сталкивался с такими опциями ни в одном компиляторе

                и правильно, такое надо делать через препроцессор
                Ответить
            • -Wpascal
              Ответить
    • предлагаю перемешивать массив, пока его элементы не упорядочатся в нужном порядке.
      алгоритм универсален, т.к. позволяет задать не только требование упорядоченности, но и самый сумасшедший.
      вот на закуску бонусный псевдокод:
      Array makeMeHappy(Array in, Array rule) {
        if(in.size!=rule.size) throw new Error("impossible");
        while(in!=rule) in=in.shuffle();
        return in;
      }

      сложность алгоритма O(NaN)
      Ответить
      • Я вижу одну оптимизацию, которая позволит снизить сложность до O(0).
        Ответить
        • Рискуете нарваться на холивар: http://avva.livejournal.com/2323823.html
          Ответить
          • Не вижу аналогии, поясните.
            Ответить
            • Ну как же, массив придётся копировать, а может оказаться, что скопировали не тем способом. А в алгоритме Lure Of Chaos перемешали массив in и думать не надо, каким способом его заполнять.
              Ответить
        • о, сработала моя ловушка для благородных донов кихотов )
          и, кстати, O(1), а не O(0)
          Ответить
          • Это была шутка же. Про единицу верно, хотя в принципе любая константа годиться.
            Ответить
      • а раз тут мы про холивары, вот еще дровишки:
        1. найдите еще один изъян в этом коде (как функции, а не как алгоритма)
        2. ответьте, нужно ли его исправлять
        Ответить
        • > while (in!=rule)
          Если это жаба, и функции не передали один и тот же массив в оба аргумента, то цикл будет вечным.

          Если это кресты, то при достаточно хорошем ГСЧ и терпении все норм, особыъ изъянов не вижу.
          Ответить
          • Это может быть PHP, тогда быстро свалимся
            http://php.net/manual/ru/function.shuffle.php
            Ответить

    Добавить комментарий