1. Python / Говнокод #19819

    −47

    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
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    def making_field(size):
    	field = []
    	for i in range(size):
    		field.append([0] * size)
    	return field
    size = 1001
    quad = making_field(size)
    
    def print_quad(quad):
    	for i in range(0,len(quad)):
    		print '\n'
    		for y in range(0,len(quad[i])):
    			c = str(quad[i][y])
    			if len(c) == 1: c = '00' + c
    			elif len(c) == 2: c = '0' + c
    			print c,
    			
    def get_new_direction(direction):
    	if direction == 'right': return 'down'
    	elif direction == 'down': return 'left'
    	elif direction == 'left': return 'up'
    	elif direction == 'up': return 'right'
    
    def making_step_rules(size):
    	steps = [1]
    	for i in range(1,size*size):
    		steps.append(i)
    		steps.append(i)
    	return steps
    
    steps = making_step_rules(size)
    
    def making_step(steps):
    	steps.pop(0)
    	return steps[0]
    	
    def step_by_step(quad, y, x, direction, steps, fill):
    	if fill-1 == size*size-steps: steps -= 1
    	if direction == 'right':
    		for i in range(0,steps):
    			fill += 1
    			quad[y][x+i] = fill
    			x = x + steps - 1
    		y = y + 1
    	elif direction == 'left':
    		for i in range(0,steps):
    			fill += 1
    			quad[y][x-i] = fill
    		x = x - steps + 1
    		y = y - 1
    	elif direction == 'up':
    		for i in range(0,steps):
    			fill += 1
    			quad[y-i][x] = fill
    		y = y - steps + 1
    		x = x + 1
    	elif direction == 'down':
    		for i in range(0,steps):
    			fill += 1
    			quad[y+i][x] = fill
    		y = y + steps - 1
    		x = x - 1
    	return fill, y, x
    	
    def fill_quad(quad):
    	fill = 1
    	x, y = size/2, size/2
    	direction = 'up'
    	quad[y][x] = fill
    	x += 1
    	while fill < size*size-1:
    		step = making_step(steps)
    		direction = get_new_direction(direction)
    		fill, y, x = step_by_step(quad, y, x, direction,  step, fill)
    
    fill_quad(quad)
    
    print 'Sum :' , sum(quad[i][i]+quad[i][(len(quad)-1)-i] for i in range(0,len(quad)))-1

    Пытался изобрести велосипед по 28 задачке Euler
    https://projecteuler.net/problem=28

    Запостил: hootie, 14 Апреля 2016

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

    • Что сподвигло на такое решение? Ибо первое, что должно прийти в голову человеку - данные числа в задаче определенная последовательность, и нам нужно найти ее сумму.
      Ответить
      • Хм, задачу не осилил сходу, частично поленился думать.
        Ответить
    • как то так?

      https://ideone.com/QbAoIS
      Ответить
      • самый чоткий код по задачке
        Ответить
        • >самый чоткий код по задачке
          Ахахаха.
          Особенно учитывая что он не выдаёт правильных ответов, только какие-то вореции.
          Ответить
        • А. Стоп. Код действительно чёткий.
          Просто в мою и wvxvw формулы надо подставлять половину n

          n=500; //669171001
          12*n+(4*n*(n-1)*(4*n+7))/3 +6*(n+1)*n+1

          n=2; //101
          12*n+(4*n*(n-1)*(4*n+7))/3 +6*(n+1)*n+1
          Ответить
    • 1, 3, 5, 7, 9, 13, 17, 21, 25
      2, 2, 2, 2, 2, 4,  4,  4,  4
      0, 0, 0, 0, 2, 0,  0,  0,  0


      Т.е. на каждом витке спирали разность увеличивается на 2. Т.о. чтобы получить искомую суму нужно вычислить рекурсию T(n) = T(n - 1) + 4 * (n - 1) * 2, где T(1) = 1.
      Ответить
      • Итого:
        def euler_28(n):
            if n == 1: return 1
            else: return euler_28(n - 1) + ((2 * n) - 1)**2 * 4 - 12 * (n - 1)
        Ответить
      • Да, и не забыть:
        sys.setrecursionlimit(1002)
        Ответить
        • Или просто переписать в виде цикла.

          З.Ы. Можно вообще в формулу преобразовать и считать за O(1), но я так и не научился ;(
          Ответить
          • T(n) = T(n - 1) + ((2 * n) - 1)**2 * 4 - 12 * (n - 1)
            T(n) = T(n - 2) + ((2 * (n - 1)) - 1)**2 * 4 - 12 * ((n - 1) - 1) + ((2 * n) - 1)**2 * 4 - 12 * (n - 1)
            T(n) = T(n - 2) + 4 * (((2 * (n - 1)) - 1)**2 + ((2 * n) - 1)**2)
                            - 12 * (((n - 1) - 1) + (n - 1))
            T(n) = 1 + 4 * sum((3..n:2)**2) - 12 * (n**2 - n * (n + 2) / 2)
            T(n) = 1 + 4 * n * (2 * n - 1) * (2 * n + 1) / 3 - 12 * (n**2 - n * (n + 2) / 2)

            Но проверять влом.
            Ответить
            • Как-то сложно у вас.

              Сумма состоит из сумм арифметических прогрессий 4х членов.
              b - основание b0 = 1, b1 = 3, b2 = 13, b3 = 31

              Сумма каждой мини-прогресии
              sum=b+(b+k)+(b+2*k)+(b+3*k)=4*b+6*k

              Следующий шаг (k) на 2 больше предыдущего
              kn+1=kn+2
              bn+1=bn+3*k+(k+2)=bn+4*k+2
              Ответить
              • bn=4*n*n+6*n+3
                b(0)=3
                b(1)=4+6+3=13
                b(2)=4*2*2+6*2+3=16+12+3=28+3=31
                Ответить
              • Задумка была в том, что можно суммировать каждые четыре элемента последовательности, а потом отнять от каждой такой сумы n * 12. Но я тут промахнулся.
                Ответить
          • bormand в http://govnokod.ru/19819#comment322039 написал:
            >> Или просто переписать в виде цикла.

            http://govnokod.ru/19819#comment321693
            Ответить
            • Ну и собственно:
              def euler_28_direct(n):
                  return 1 + 4 * (n * (2 * n - 1) * (2 * n + 1) / 3 - 1) - \
                      6 * n * (n - 1)
              Ответить
              • for ( var i=0, k=0, b=1, sum=0 ; i<N ; ++i,k+=2 ){
                    sum += 4*b+6*k;
                    b    = b+4*k+2; 
                }
                return sum-3;
                Ответить
                • т.к. k=2*i
                  for ( var i=0, b=1, sum=0 ; i<N ; ++i){
                      sum += 4*b+12*i;
                      b    = b+8*i+2; 
                  }
                  return sum-3;
                  Ответить
              • В итоге получил формулу похожую формулу
                12*n+(4*n*(n-1)*(4*n+7))/3    //сумма b
                +6*(n+1)*n+1                  //сумма арифметических прогрессий k
                Ответить
            • >> Или просто переписать в виде цикла.
              O(N)
              Ответить
      • Очень ловко подмечено. Дальше - дело техники.
        Ответить
    • do =: >:@(+/@(*&4@*: - *&6@<:)@(+&2)@(] #~ ] - +:@<.@-:)&i.) 
         do 5
      101
         do 1001
      669171001
      Ответить
      • Как ты на этом пишешь?
        Ответить
        • Ты привыкаешь к этому. Скоро твой мозг сам делает перевод. Я уже даже не вижу код. Я вижу блондинку, брюнетку и рыжую.
          Ответить
        • Присоединяюсь к вопросу. И аналогично - для пользователей брейнфака.
          Я, конечно, писал мелкие куски кода на обфусцированных C, Haskell и JavaScript, но это сначала были нормальные, понятные программы, которые я последовательными эквивалентными преобразованиями доводил до убожеского состояния.
          Ответить
          • >:@+/@(*&4@*: - *&6@<:)@(+&2)@(] #~ ] - +:@<.@-:)@i.

            несколько последовательных глаголов
            @ - это связка

            в порядке выполнения

            1 i. - создать список от ноля до n-1

            i. 10
            0 1 2 3 4 5 6 7 8 9


            2 ] #~ ] - +:@<.@-:

            это сложно. тут глагол двойная вилка, состоящий из 5 глаголов

            (a b c d f) x = (a x) b ((c x) d (f x))

            2.1 +:@<.@-:

            последовательность трех глаголов
            -: - разделить на два
            <. округлить
            +: удвоить

            2.2 -

            простая разность

            2.3 ]

            тождественная функция

            2.1 -2.3 по сути - обычный mod 2
            Может в J есть mod из коробки, но я его не нашел, подскажите кто знает

            (] - +:@<.@-:) 10
            0
               (] - +:@<.@-:) 3
            1


            2.4 #~- выбрать

            работает так

            0 1 2 1 0 # 1 2 3 4 5
            2 3 3 4


            то есть 1 взята 0 раз, двойка - один раз и т.д

            ~ меняет аргументы местами

            0 1 2 1 0 #~ 1 2 3 4 5
            0 1 1 2 2 2 1 1 1 1 0 0 0 0 0


            2.5 ]

            тождественная функция

            3. +&2

            "плюс и два" сложить с двойкой

            (+&2)@(] #~ ] - +:@<.@-:)@i. 11
            3 5 7 9 11


            4 *&4@*: - *&6@<:

            тут у нас снова вилка, но уже простая

            4.1 *&6@<:

            <: - уменьшить на 1
            *&6 - умножить на 6

            *&6@<: 10
            54



            4.2 - простая советская разность

            4.3 *&4@*:

            *: - в квадрат
            *&4 - умножить на 4

            (*&4@*: - *&6@<:) 3
            24


            5. +/
            сумма элементов вектора

            +/ 1 2 3 4 5
            15


            6. >:
            ну и прибавить 1

            вот и все, ребята
            Ответить
            • Спасибо, дяденька.
              Просто въебал плюс, и пролистал дальше.

              Ты когда большие комменты пишешь, сразу предупреждай что это не вореции.
              Ответить
            • Ну это уже обратный разбор. Впечатляет, конечно, весьма впечатляет. Но так можно многие вореции раскрыть и показать фокус.
              А как протекает процесс написания? Похоже на работу с регулярными выражениями? (Написал, пока пишешь, помнишь; отлаживаешь - уже проще переписать)
              Или же после какого-то момента начинаешь мыслить в этих букашках, и код легко читается?
              Ответить
              • Ну расписываешь подзадачи и пишешь с конца
                потом сливаешь кусочки вместе и удивляешь как это оно не наебнулось)

                На регулярки не похоже, скорее на хаскель в точечной нотации
                Ответить
              • если интересно, попробуй разобрать вот это

                http://euler.jakumo.org/problems/view/1.html

                do =: +/@(#~=&0@(5&|<.3&|))@i.
                   do 10
                23
                   do 1000
                233168


                вот тебе словарь

                http://www.jsoftware.com/help/dictionary/vocabul.htm
                Ответить
                • Ох, да я же потом никогда не приду в себя. Впрочем, свои плюсы в этом есть: на говнокодике менее шумно будет.
                  Ответить
                  • От тебя то шума почти нет. это всякие пидоры тут цирк устраивают

                    В J еще есть крюк

                    (a b) x = (x) a (b x)
                    Ответить
                    • Какой крюк )))

                      Вилки, крюки... А электрическую схему на J можно написать? Скажем, генератор -> фильтр из индуктивности и ёмкости -> динамик. Вместо генератора - какое-то число, которое пускают по двум линиям, кобенируют, пропускают через функцию-конденсатор, пускают как-то число и сконденсированное число в функцию-индуктивность (только куда деть результат?), потом число и сконденсированное число подают на динамик (скажем, сложение и вывод).
                      Ответить
                      • динамик (функция-индуктивность функция-конденсатор)

                        пример

                        f =: * (+ %&2)
                        f 4
                        24
                        f 2
                        6

                        типа число делим пополам, потом прибавляем исходное число, а потом умножаем на исходное число

                        если ты об этом

                        Ответить
                        • Я интересовался, можно ли написать программу, где данные будут течь по функциям, образуя граф с циклами (который, например, может соответствовать электрической схеме), причём хорошо бы сделать это стандартным способом (создание своего var f = (f,g,h,x) => h(f(x), g(x)) - ближе к читерству, а вот Array.prototype.map - естественная вилка в ES5)
                          // псевдонимы, которые чуть меняют синтаксис, но не создают искусственные вилки
                          var apply = (f, xs) => f.apply(null, xs); // квадратный вызов: f[x,y,...]
                          var sq = f => xs => apply(f, xs); // создание квадратной функции: f(x, y) -> f[x, y]
                          var map = (f, xs) => xs.map(f);
                          var fork = (f,g,x) => map(f => f(x), [f, g]);
                          // сомнительная функция закрывания вилки, над ней надо подумать
                          var close = (f, xs) => xs.reduce(f);
                          
                          // схема (над сутью функций можно подумать:
                          // можно за счёт побочных эффектов реализовать что-то более правдоподобное, чем произвольные математические функции)
                          var generator = u => fork(x => -x, x => +x, u);
                          var C = sq((a, b) => [a - b, b - a]); // параллельно источнику питания
                          var L0 = a => a - 3; // последовательно с источником питания
                          var L = sq((a, b) => [L0(a), b]); // четырёхполюсник из последовательной индуктивности
                          var speaker = sq((a, b) => a * b);
                          
                          var scheme = u => close(speaker, fork(C, L, generator(u)));
                          
                          console.log(scheme(5));
                          Ответить
                          • >> создание своего var f = (f,g,h,x) => h(f(x), g(x))

                            apply =:  4 : '([email protected] [email protected] [email protected]) y'
                               (*:`+:`-) apply 1 2 3 4
                            _1 0 3 8


                            только так
                            Слева список глаголов, справа данные. в J глагол не может принимать больше 2 параметров
                            Ответить
                          • >Я интересовался, можно ли написать программу, где данные будут течь по функциям, образуя граф с циклами (который, например, может соответствовать электрической схеме),

                            В юниксе эти идеи с 70х витают, stdin, stdout, piping, кобенации простых вореционных фильтров.

                            cat x.txt | awk ... | grep vorecii | sed | wc - l

                            https://en.wikipedia.org/wiki/Unix_philosophy
                            Ответить
                            • алоиз черч смеется над таким ответом
                              Ответить
                              • только он Алонзо

                                Алоиз это папа Адика
                                Ответить
                              • Напиши/нагугли факториал в нумералах чёрча, посмёмся вместе.

                                >The Unix philosophy emphasizes building simple, short, clear, modular, and extensible code that can be easily maintained and repurposed by developers other than its creators.

                                >алоиз
                                гость ниже сказал
                                Ответить
                                • Ну конечно, а у Windows филосифия complex, long, unclear, monolythic, and unextensible code that can't be easily maintained
                                  да?
                                  Ответить
                                  • вообще говоря да

                                    точнее не так:

                                    Unix: мы делаем много маленьких тулзов, каждая из которых отвечает за одну тех. деталь. Одна умеет SMTP, другая умеет файлы парсить, третья еще чего-то.
                                    Windows: мы делаем программу которая решает бизнес-задачу. Exchange помогает обмениваться документами и письмами, Project планировать проекты итд

                                    ps:да, я знаю что sendmail делал много чего, и про systemd тоже в курсе
                                    Но философия такова
                                    Ответить
                                    • Всё верно.
                                      Потому грубо говоря

                                      ms-подход: поставил софтину и ищещь в интерфейсе кнопку которая сделает всё хорошо. Приспособить абстрактный ворд, фотошоп или там просмотрщик pdf для других целей, совместить с чем-то непредусмотренным -- варьируется от "трудно" до "невозможно".

                                      unix-подход: миллиона кнопок которые сделают всё как надо нет. если надо сделать, то придётся поебаться/найти чужое.
                                      но зато у тебя есть конструктор. можешь собрать что хочешь.

                                      Опять же не аксиома. Но таков общий тренд.
                                      Ответить
                                • Если бы еще структуры по пайпам гонять (тот самый помершелл)
                                  Ответить
                      • чет меня пенесло

                        найти числа фибоначи, меньшие заданного

                        do =: 3 : '}:@([`(,{:@}:+{:)@.(<&y@{:)^:_)1 1'
                           do 100
                        1 1 2 3 5 8 13 21 34 55 89
                           do 4000000
                        1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578
                        Ответить
          • таки есть mod из коробки - |

            и того

            >:@+/@(*&4@*:-*&6@<:)@(+&2)@(]#~2&|)@i.
            Ответить
        • Эта шняга на регулярки похожа.
          В принципе для поехавших математиков, работающих с массивами, если руку набить - вполне удобно.
          Реально как регулярки, то что делается 100 строками лапши substringов / indexofов [в случае J это унылые for (i=0)], превращается в быстрые, но нечитабельные пару строк.

          Удивляет что крестолюбители и просто хацкелисты не текуют слюной от J.
          Ответить
    • Он забеспокоился, когда на экране смартфона высветился вызов с фоткой парнишки и подписью "Питомец". Случилось что-то?
      Ответить
    • А х ты гнида
      мой любимый ник...
      Ответить

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