1. Куча / Говнокод #26800

    0

    1. 1
    Продолжаем форс Перла

    Нечто запредельно пиздатое в перле — это книга Ларри, написанная с охуенным чувством юмора и предельно чистым и умным языком, как будто сам стиль книги и то, с каким Ларри мы через этот текст знакомимся — является одним из образцов применения философии перла на практике. Роман Кашицин, царствие ему небесное, ценил; есть ещё среди нас ценители?

    Запостил: vistefan, 10 Июля 2020

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

    • MAKAKA, перелогинься.
      Ответить
    • Это которая с верблюдом? Да, она вроде самая важная про перл.
      Еще нужно читать книжку с собачкой: PBP. По ней работает Perl::critic.
      Есть еще кукбук и эвенсд, но это опциональнее.

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

        Так вплетать юмор в технически точное и полезное повествование — это надо быть Ларри.
        Ответить
    • Перл — говно.
      Ответить
    • Особенно красив и логичен в перле ООП
      package Mammal {
          sub milk {
              'yes'
          }
          sub new {
              bless { name => $_[1] }, $_[0];
          }
          sub talk {
              die 'unimplemented'
          }
      }
      1;
      
      package Wombat {
          our @ISA = 'Mammal';
      
          sub talk {
              my $name = $_[0]->{name};
              "I am $name";
          }
      }
      1;
      
      package main;
      my $wombat = Wombat->new('BatjanaWombat');
      print $wombat->talk;
      Ответить
    • Страшно подумать, что заставило человека взять такой ник
      https://metacpan.org/author/CHOCOLATE
      Ответить
      • А ник Кгози норм?
        Ответить
        • Доктор Кгози Летлейп является офтальмологом и здравоохранения лидера из Южной Африки
          Ответить
    • Суппортера попросили написать скрипт, который сохранял бы переменные окружения пользователя, но вырезал бы при этом его личные данные (например, его ник).

      Получившаяся на перле кросс-платформенная программа генерирует файл при вызове без аргументов, и считывает и распечатывает его при вызове с аргументами.

      Без учета бойлерплейта программа занимает 10 строк. Какой перл!
      #!/usr/bin/perl
      use strict;
      use warnings FATAL => 'all';
      
      use Fcntl;
      use SDBM_File;
      tie my %db, 'SDBM_File', 'file.db', O_RDWR | O_CREAT, 0666 or die "Can't open file";
      my $nick = getlogin;
      if (@ARGV) {
          printf "%s: %s\n", $_, $db{$_} for keys %db;
      }
      else {
          $db{$_} = $ENV{$_} for grep {$ENV{$_} !~ /$nick/i} keys %ENV;
      }
      Ответить
      • Суппортер пишет код? Или я не правильно понял кто это?
        Ответить
        • Это же тред для форсинга перла. В нем все пишут
          Ответить
      • в конце untie %db; конечно

        ну правда тоже самое на шеле пишется в одну строчку, а питоне в тоже немного совсем
        Ответить
    • Христоматийного говна вам. Из такого потом вырос пых. Это год так 1998-й
      #!/usr/bin/perl
      
      #full path for the guestbook file
      $file="/home/httpd/html/guestbook.html";
      
      require "cgi-lib.pl";
      &ReadParse;
      
      #translate all the linefeeds into <BR>s for nice formatting
      $in{'comments'} =~ s/\n/<BR>\n/g;
      
      #open the guestbook file and append data to the end of it
      open(GUESTBOOK,">>$file");
      
      #print the information
      print GUESTBOOK "\n<UL>\n";
      print GUESTBOOK $in{'comments'};
      print GUESTBOOK "\n<B>$in{'name'}<BR>\n";
      print GUESTBOOK "$in{'location'}</B><BR>\n";
      close GUESTBOOK;
      Ответить
      • Да чот поздновато для такого говна, не?
        Ответить
        • Так это копролит времен царя гороха. Разумеется, за такой код бьют с вертушки по ебалу вот уже лет двадцать как
          Ответить
          • Так ты ж сказал что 98-й примерно. Поздновато говорю.
            Ответить
            • А, думаешь в 98 уже так не писали?
              Писали. Я все эти "guestbook.cgi" как раз в 99-м где-то и наблюдал.

              CGI появился-то в apache году так в 1996-м
              Ответить
              • А. Ну просто самописная гостевая книга в виде простыни, вся хуйня. Если учесть что в 2000-м уже Яндекс.Народ появился.
                Ответить
                • Наличие народру (кажется к я он не имел тогда отношения) никак не мешало крутым вебмастерам делать свои сайты web 1.0. Хостинг агава поддерживал запуск cgi.
                  Ответить
              • Понятно, что на пыхе и щас так пишут
                Ответить
                • В пхп была бы mysql.
                  Тут говно везде: начиная с неиспользования модуля CGI, и заканчивая тем, что результат вместе с версткой срут в .html (чтоб верстку было никак не поменять) да еще и без flock: чтобы одновременный заход на сайт двух петухов мог сделать интересные гонки.
                  К счастью, количество пользователей такого сайта обычно лежит в отрезке [0,1]
                  Ответить
                  • > количество пользователей такого сайта обычно лежит в отрезке [0,1]

                    Этот код идеален для своих задач.
                    Ответить
                • Опровергаю. Пыхомакаки слишком ленивые для того, чтобы генерировать и сохранять HTML-файл.
                  Ответить
                  • Пыхомакаки уже не те, я джва года не видел ни одной свежей самописной цмс-ки
                    Ответить
                    • Сейчас у них даже фреймоврки есть.
                      А в начале нулевых не было: надо было или все с ноля писать на голом PHP, или брать готовый CMS, где у тебя прямо в ядре было понятие "верхнее меню".
                      Очень гибко.
                      Ответить
              • но чтобы ещё и не рендерить из какого-нибудь массива строк в оформление для комментов в цикле, а блять тупо аппендить в html-файл — это прям мамонт.
                Ответить
                • В перле из коробки привязывание хеша к dbm: key-value базе данных. Обычно перловики все таки ее использовали в то время.
                  Ответить
              • Где взял? html-файл небось потом в iframe вставлялся?
                Ответить
                • Наверное.

                  Ввел в гугл "guestbook.cgi", и нашел. Такого много
                  Ответить
                • Кстати, на фреймах тогда работали чаты. Там было два фрейма: главный обновлялся переодически, и там была комната. В нижем была форма для посылки сообщения. Хранилось все в базе данных. Много было таких чатов.
                  Ответить
                  • А я тут когда-то показывал свой пруф-оф-концепт литературного чата.
                    Ответить
                    • Тоже на фреймах, или уже SPA с вебсокетом?
                      Ответить
                    • тащемто, чат web 1.0
                      https://web.archive.org/web/19991009015038/http://www.mtrros.msk.ru/chats/011/

                      Цветовое решение -- ок

                      Экшен формы -- thankschat.cgi?job=login

                      Качать тут
                      http://www.atbcode.com/code/t5pm36h2-136017-down

                      ($secn,$minn,$hourn,$dayn,$monn,$yearn,$weekn,$yeardayn,$isdst) = localtime(time+(3600*$time_miss));
                      $monn=$monn+1;
                      if ($monn<10)  {$monn="0$monn";}
                      if ($dayn<10)  {$dayn="0$dayn";}
                      if ($hourn<10) {$hourn="0$hourn";}
                      if ($minn<10)  {$minn="0$minn";}
                      if ($secn<10)  {$secn="0$secn";}
                      $daten="$yearn/$monn/$dayn";
                      $timen="$hourn\:$minn\:$secn";
                      $secn=$hourn*60*60+$minn*60+$secn;
                      $reloadtimes=4;
                      $reloadxx=$reloadx*$reloadtimes;
                      $reloadxxx=$reloadxx*$reloadtimes;
                      $userinfo="&username=$username";
                      $userinfo="$userinfo&usersex=$usersex" if ($usersex ne ""); 
                      $userinfo="$userinfo&userid=$userid&userpassword=$userpassword" if (($userid) && ($userid ne "") && ($userpassword) && ($userpassword ne "")); 
                      }

                      какой перл)) а printf какой!
                      Ответить
                      • Писала Юлия?
                        Ответить
                        • Да, вероятно это её дипломная работа на тему эпилепсии
                          Ответить
                        • print "Content-type: text/html;CHARSET=gb2312\n";


                          Судя по кодировке, писа́л Сунь Хуй Вчай.
                          Ответить
                          • видимо да) вообще пиздец конечно срать такие заголовки напрясую
                            https://metacpan.org/pod/CGI#Creating-a-standard-http-header
                            Ответить
                      • >> http://www.atbcode.com/code/t5pm36h2-136017-down

                        Капча на скачивание, всплывающее окно по дефолту блокируется браузером. Нужно добавлять исключение и снова вводить капчу. Какой багор )))
                        Ответить
                      • Все переменные уже с баксами. Это хорошо. Легче будет переводить на «PHP».
                        Ответить
                        • ну-ну
                          foreach (@pairs) {
                            ($name, $value) = split(/=/, $_);
                            $value =~ tr/+/ /;
                            $value =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;
                            $value = &filterhtml($value);
                            &setvaluetoform($name, $value); 
                            if ($name eq "userpassword") {&check_password;}
                          }
                          Ответить
                          • foreach ($pairs as $_) {
                              list($name, $value) = explode('=', $_);
                              $value = strtr($value,'+',' ');
                              $value = preg_replace_callback('/%([a-fA-F0-9][a-fA-F0-9])/eg', function($x){return pack("C", hex($x[1]));}, $value);
                              $value = filterhtml($value);
                              setvaluetoform($name, $value); 
                              if ($name === "userpassword") {check_password();}
                            }
                            Ответить
                            • вербозненько, но по сути верно, да
                              Ответить
                              • Если бы не вызов функции pack, можно было бы использовать preg_replace и шаблон подстановки типа '$1'. А из-за того, что шаблон подстановки неконстантный, пришлось использовать preg_replace_callback и лямбду, которая в «PHP» пишется довольно длинно.
                                Ответить
                      • https://web.archive.org/web/20001007075022/http://cards.ru/
                        (это по рекламе если перейти)
                        Такой домен проебали (((
                        Ответить
                        • В ту пору можно было задешево взять охуенный домен. У них еще chat.ru был, например
                          Ответить
                          • Почему был.

                            Правда там капча называется "ключ активации", и передают погоду по москве +4..+6
                            Ответить
                            • На вид типичный сайт из 90-х. И вдруг... аутентификация по OAuth2 через «mail.ru».
                              Ответить
                            • Каталог зато есть. Когда мне нужно найти интересный сайт в Интернете, я всегда использую каталоги.
                              Ответить
                              • ну если интересный, то точно через каталог.
                                Ответить
                      • А как путешествовать в прошлое, когда браузеры не будут корректно отображать сайты 2000 годов?
                        Ответить
                        • А с чего это они вдруг перестанут?
                          Ответить
                        • Ну будет на waybackmachine рендерилка, допустим, если внезапно html, css и js запретят по конституции без возможности обжаловать обратную совместимость.
                          Ответить
                        • Анлайкли. Всё таки там HTML был очень тупой, кажется что рендерилку HTML 3.2 может написать студент
                          Ответить
                          • В HTML 3.2 было много элементов, которые не вошли в новые версии HTML. Например, векторная графика и математические формулы. Эти элементы дали начало новым языкам: SVG и MathML.

                            Всё-таки с реализацией HTML 3.2 придётся попердолиться. Вот HTML 4 без CSS и без JS реализовать проще.
                            Ответить
                            • > без CSS

                              Лол, это как?
                              Ответить
                              • Не поверишь, в 90-х были такие сайты. С тегами <font>, с кучей атрибутов типа width, height, bgcolor.
                                Ответить
                                • с депрекейтнутым атрибутом align у блочных элементов, с кучей ныне умерших атрибутов у ячеек таблицы, с тегами <center>, <right>, <color>
                                  Ответить
                                  • Я верстал таблицам в то время.
                                    Весь сайт именно и состоял из таблиц с align=right, align=left..

                                    css правда тоже был, но мало
                                    Ответить
                                  • Там ещё с кроссбраузерностью всё плохо. Например, «Хром» игнорирует какой-то из атрибутов цвета то ли для рядов в таблице, то ли для ячеек. Типа, используйте CSS, нам некогда в новом браузере реализовывать устаревшее говно.
                                    Ответить
                                    • Да, в ту пору я верстал под два одельных браузера: netscape и explorer.

                                      помнишь таг layer?
                                      Ответить
                              • Погугли «CSS Naked Day». Это флешмоб: 1 апреля владельцы сайтов отключают CSS, возвращая голый HTML, чтобы посетители почувствовали атмосферу 90-х. Если вёрстка реально семантическая, всё по делу, сайт не должно распидорасить. Если же элементы используются не по назначению, а «для красоты», будет какой багор.
                                Ответить
                                • Семантических сайтов не бывает со времен бутстрапа
                                  Ответить
                                  • да реально, тру осталось только на редких сайтах с документацией по софту, где сематника сама собой ясна.
                                    Ответить
                                    • именно по этому я за
                                      https://www.rfc-editor.org/rfc-index-100a.html
                                      Ответить
                                  • В бутстрапе всё плохо. Внешне он выглядит нормально, дизайн неплохой. Но вот реализация страшная, как будто целью было нарушить как можно больше правил.
                                    Ответить
                                    • У нас у вебщиков свой фреймворк, и он точно такой же.

                                      Сплошное
                                      <div class="__red_message"></div>
                                      Ответить
                                      • Вот, да, никаких «редмесседж» быть не должно. Класс должен указывать на назначение сообщения, а не на его цвет. Цвет должен заботить дизайнера, а не разработчика фреймворка.

                                        А то потом после смены темы оформления появится зелёное сообщение с классом "__red_message".
                                        Ответить
                                        • Это в идеальном мире, где единороги какают принцессами, верстальщик получает на вход семантический XML от бекендера и преобразовывает его в семантический HTML посредством XSLT, а затем натягивает на него css.

                                          В реально же мире веба царит треш, говно, кал, и вот такое

                                          <div class="container">
                                            <div class="row">
                                              <div class="col-sm-4">
                                                <h3>Column 1</h3>
                                                <p>Lorem ipsum dolor..</p>
                                              </div>
                                              <div class="col-sm-4">
                                                <h3>Column 2</h3>
                                                <p>Lorem ipsum dolor..</p>
                                              </div>
                                              <div class="col-sm-4">
                                                <h3>Column 3</h3>
                                                <p>Lorem ipsum dolor..</p>
                                              </div>
                                            </div>
                                          </div>


                                          В место XSLT -- такое
                                          https://github.com/django/django/blob/master/django/contrib/admin/templates/admin/change_form.html
                                          Ответить
                                          • Какое говно )))
                                            Ответить
                                            • еще немного семантики с сайта одной фирмы
                                              <div class="wt-row wt-row_size_m wt-offset-top-24 product-card_description">
                                                                      <div class="wt-col-11 wt-col-lg-12 wt-subtitle-2 wt-subtitle-2_theme_dark">
                                                                          The integrated team environment
                                                                      </div>
                                                                  </div>


                                              offset-24 и theme-dark
                                              ясно-понятнго
                                              Ответить
                                              • А теперь представь, как выглядит CSS-файл, если где-то нужны смещения 23, 22, 21, 20, 25, 26, 27, 28 и т. д.
                                                Ответить
                                                • Так скомпилированный LESS или SCSS же

                                                  руками не пишут же, циклом небось генерирувается
                                                  Ответить
                                                  • Я где-то даже приводил реальные примеры, как писать LESS или SCSS с циклом.

                                                    Меня смущает результат. Это типа как кэш маленьких целочисленных значений в «Йаже». Свалка ненужных объектов про запас.
                                                    Ответить
                                                    • Так и есть. Но всем похуй. Ну будет весить твой css 100 килобайт. Ну сожмет его gzip, будет он еще меньше весить.
                                                      Всем похуй же
                                                      Ответить
                                          • XSLT -- это младший брат лиспа, который носит деловой костюм, но при этом злоупотребляет героином. Как же всё-таки хорошо, что он помер.
                                            Ответить
                                            • Если бы вместо него пришел бы кто-то типа JSPX: xml-based шаблонизатор, генерирующий велформенный xhtml (но без привязки к вебу) то было бы еще не плохо.

                                              Но я же показал, что вместо младшегол брата лиспа пришел младший брат говна
                                              https://github.com/django/django/blob/master/django/contrib/admin/templates/admin/edit_inline/tabular.html
                                              Ответить
                                • Да без жс будет белый экран.
                                  Ответить
                                • Коллеги, не кажется ли вам, что в какой-то момент веб тотально свернул не туда?

                                  Такое ощущение, что раньше, грубо сказать, сайт был как книга: он что-то сообщал нам в виде гипертекста.

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

                                  Да, это прикольно. Но не более чем!

                                  Как же могла такая свистоперделка внезапно стать главным, и уже почти единственным (sic) форматом в вебе?

                                  Что за хуйня, какие в пизду веб-приложения, порталы? Где сайты-то блять? Где гипертекст нахуй? На википедии одной остался.

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

                                  Товарищи, обращаюсь ко всем людям доброй воли. Что будем делать? Может какие-то декреты издадим? Борманд был прав, надо запрещать нахуй PHP по конституции. Давайте попробуем подсидеть начальство, займём управленческие позиции в госкорпорациях и под видом импортозамещения и защиты от иностранных агентов протолкнём трушные принципи свободного софта и адекватного веба на нашей Родине?

                                  Например запретить электрон как принадлежащий microsoft'у неоднократно пиздившему данные наших соотечественников и не соблюдающему какие-нибудь ебанутые требования министерства обороны. Более того, в конституции написано, что главное — это дети. Линукс учит детей и делает их умными, а потом они становятся славными русскими хакерами, и прославляют отчизну. А чему учит майкрософт? Играть в игры, в половине из которых надо убивать русских!
                                  Ответить
                                  • >надо запрещать нахуй PHP по конституции
                                    >запретить электрон как принадлежащий microsoft'у

                                    Русне бы только всё запрещать.
                                    Именно поэтому я за легалайз вообще всего. И ПХП, и «электрона», и легких наркотиков, и гей-копрофилии, и тормозных бесполезных «говносайтов», и детского порно, и продукции Яббл наконец.

                                    >Играть в игры, в половине из которых надо убивать русских!

                                    Смерть ванючей русьне!
                                    Ответить
                                    • >И ПХП, и «электрона», и легких наркотиков, и гей-копрофилии,

                                      Зачем дублировать?
                                      Ответить
                                      • > гей-копрофилии, и продукции Яббл наконец

                                        Это плеоназм.
                                        Ответить
                                        • Яблу многое можно простить за отсутствие ГЦ в свифте и обжси.

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

                                            Спасибо надо говорить не за отсутствие ГЦ, а за ARC. Распиханные руками retain'ы и release'ы в обжективсишных портянках это минное поле почище крестов.

                                            А вообще на макоси был ГЦ и от него отказались примерно после внедрения ARC.

                                            Is GC (Garbage Collection) deprecated on the Mac?

                                            Garbage collection is deprecated in OS X Mountain Lion v10.8, and will be removed in a future version of OS X. Automatic Reference Counting is the recommended replacement technology. To aid in migrating existing applications, the ARC migration tool in Xcode 4.3 and later supports migration of garbage collected OS X applications to ARC.
                                            Ответить
                                            • >Сегодня внутри телефона столько мозгов, что можно вкорячить и ГЦ и никто и разницы не заметит

                                              «Андроид» тому подтверждение.
                                              Ответить
                                            • > Garbage collection is deprecated

                                              Какой багор )))
                                              Ответить
                                              • Пэхапэшники об этом не думают и текут. «FPM» («FastCGI process manager») перезагружает интерпретатор через каждые 500 запросов, чтобы точно освободилось то, что забыли освободить.
                                                Ответить
                                                • А зачем тогда в новой пыхе гц завезли?
                                                  Ответить
                                                  • для соснольной пишутни?
                                                    Ответить
                                                  • В насколько новой? Он появился в 5.3, которая вышла больше 10 лет назад:
                                                    https://www.php.net/manual/ru/function.gc-enable.php

                                                    А тут некоторые детали реализации:
                                                    https://www.php.net/manual/ru/features.gc.refcounting-basics.php
                                                    Ответить
                                            • GC это не только память: это еще и ненужные действия, и что самое мерзкое -- недетерминированное уничтожение объекта: отсюда у нас все эти клозаблы диспозаблы.

                                              С RC их нет, а с ARC нет еще и бойлерплейта
                                              Ответить
                                    • >Смерть ванюч
                                      bogoeb.txt ?
                                      Ответить
                                      • >bogoeb.txt
                                        Да.

                                        Читать далее >>>
                                        https://pastebin.com/5Tz79QvK
                                        Ответить
                                        • Как там Дадыкин?
                                          Ответить
                                          • а все праильна
                                            русня это ж не люди, а пидарасы, хуесосы и говно государства райпсейскага
                                            их при рождении высирают, а когда русьячьокь подыхает, то его, как говно, прикапывают
                                            все правильно
                                            будь Моя воля, Я б на месте каклов живую русню в сортирах топил бы спецом, и в навозные ямы, где-нть там возле ферм, скотобоен всяких, где говнища побольше, вот очистные крупных городов еще тоже очень хорошее место, вот туда вот дохлую мразоту сбрасывал бы
                                            говно к говну так сказать ггг
                                            Ответить
    • Некто имеет файл с телефонами пользователей в таком форматеЖ
      User1
      122-16-96
      User2
      17-66-29
      .

      С помощью какого языка его можно легко считать?
      Разумеется, с помощью
      #!/usr/bin/perl
      use strict;
      use warnings FATAL => 'all';
      
      open my $file, '<', '1.txt';
      my %users = map {chomp && $_} <$file>;
      print $users{User1}; # Выведет телефон
      close $file;

      Где еще так можно?
      Ответить
    • rss fixed
      Ответить
    • ssr xifed
      Ответить
    • wss fixie-wixed ^_^
      Ответить
    • Друзья, пользуйтесь на здоровье!
      Добавление поддержки utf и парсинг JSONа с ответом оставляю вам в качестве домашнего задания.

      Гомосексуализм Вордпресс, отдающий 200 в случае ошибки, я обсуждать не хочу
      #!/usr/bin/perl
      use strict;
      use warnings FATAL => 'all';
      
      use LWP::UserAgent;
      use HTTP::Request::Common qw{POST GET};
      
      use constant COMMENT => 26799;
      use constant BASE_URL => 'https://govnokod.xyz/';
      
      my $ua = LWP::UserAgent->new((agent => 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Mobile Safari/537.36'));
      my ($nonce) = $ua->request(GET(BASE_URL . '_' . COMMENT . '/'))->as_string =~ /ajax_nonce=([a-z0-9]+)"/;
      my $request = POST(BASE_URL . "wp-admin/admin-ajax.php?action=add-comment&_ajax_nonce=$nonce", {
          'comment'         => ':))',
          'comment_post_ID' => COMMENT,
          '_ajax_nonce'     => $nonce
      });
      print $ua->request($request)->as_string();
      Ответить
      • Я считаю, что запрет отдавать 200 в случае ошибки, а также запрет отдавать многомегабайтную страницу в случае ошибки (с любым кодом) нужно внести в Конституцию.
        Ответить
        • Он отдает JSON c error, но с 200. Проверь, у тебя же есть перл.
          Ответить
          • А это вроде обычное дело для «AJAX».

            Код 404 отдаётся, если у тебя «API endpoint URL» написано с ашипкой.
            Код 301/302 отдаётся, если endpoint куда-то переехал.
            Код 500 отдаётся, если сервер упал.

            Если же endpoint указан верно, сервер не лежит, то возвращается 200. Если ошибка заключается в том, что ты указал неправильный номер поста, то расшифровка ошибки будет внутри JSON, а не в коде ответа HTTP. Протокол HTTP не обязан ничего знать о твоём API.

            Какой код ты хотел получать в случае ошибки?
            Ответить
      • кто знает, почему важно писать ($nonce) именно в скобках -- тот знает основы перл:)
        Ответить
        • Попробую угадать. Регулярка возвращает массив/список найденных значений, а нам нужен не массив, нам нужно одно значение.
          Ответить
          • Почти:) Регулярка (на самом деле это оператор "m", который можно не писать ~=m// есть ~=//) смотрит на контекст. Если от нее ожидают список -- она возвращает список находок. Если скаляр -- она возвращает 1 (то-есть true) если что-то нашла, иначе ничего (то-есть false).

            Если слева от приравнивания массив (@foo) или хеш (%foo) это списковый контекст.
            Если скаляр ($foo) то скалярный.

            Скобочки организуют списковый (листовой) контекст, раскладывая каждое значение в переменную:

            ($a, $b) = (1,2);

            В нашем случае я организовал списковый контекст, и положил значение в первую переменную.
            Ответить
          • еще примеров
            my %users = "user is petuz" =~ m/(.+) is (.+)/; # список (user, petuz) превратится в хеш (user => petuz)
            print $users{'user'};                           # petuz
            
            my @findings = "a,b,c" =~ /(.),(.),(.)/; # список (a,b,c)
            print join '-', @findings;               #a-b-c
            
            my ($job, $title) = "joe programmer" =~ /([^ ]+) ([^ ]+)/;
            print $title; # programmer
            
            my $found = "joe programmer" =~ /([^ ]+) ([^ ]+)/;
            print $found; #1
            
            print "joe programmer" =~ /([^ ]+) ([^ ]+)/;        #joeprogrammer -- print организовал листовой контекст, и схлопнул список
            print scalar "joe programmer" =~ /([^ ]+) ([^ ]+)/; #1 -- зафоршен скалярный контекст


            В функции определить конекст можно через ``wantarray``
            sub foo {
                wantarray ? qw/Foo bar buz/ : 42;
            }
            
            print join ',', foo; #Foo, bar, buz
            print scalar foo;    #42
            Ответить
          • Массив в скалярном контексте возвращает количество элементов.
            Известный тебе оператор организует справа от себя списковый контекст, а слева -- скалярный
            my $num_of_a = () = "a bad day" =~ /(a)/g; # организуем справа списковый контекст, а слева скалярный (получим кол-во элементов)
            print $num_of_a;                           # 3
            Ответить
        • Перевожу на «PHP»:
          <?php
          
          $mosiv = array(0 => 'Kukareku');
          
          list($scalar) = $mosiv;
          
          var_export($scalar);


          https://ideone.com/lIF222

          В этом реальном примере list() в левой части раздирает массив на элементы.
          Ответить
          • Но это же только для массивов. А можно сделать свою функцию как в примере с wantarray ?
            Ответить
            • В «Перле» полная противоположность той перегрузке, которая бывает в «крестах» и во многих популярных языках программирования.

              В «PHP» нельзя узнать контекст, в котором будет вызвана функция. Однако, можно объявить класс с магическими методами. Во-первых, можно реализовать интерфейс ArrayAccess, чтобы экземпляр класса вёл себя как массив, если к нему прилепить квадратные скобки:
              https://www.php.net/manual/ru/class.arrayaccess.php

              Ну то есть если $pituhi — экземпляр класса, который implements ArrayAccess, то можно писать $pituhi[42].

              Во-вторых, можно реализовать интерфейс ArrayIterator, чтобы бегать по нему форичем:
              https://www.php.net/manual/ru/class.arrayiterator.php

              То есть если $pituhi — экземпляр класса, который implements ArrayIterator, то можно foreach($pituhi as $pituh) {}.

              В-третьих, можно реализовать магический метод __toString(), чтобы класс возвращал строку в «скалярном контексте»:
              https://www.php.net/manual/ru/language.oop5.magic.php

              То есть если $pituhi — экземпляр класса с методом __toString(), то можно echo $pituhi.

              Увы, только строку. Магических методов __toInt() и подобных в «PHP» нет. То ли дело «кресты», в которых можно перегрузить операторы приведения типа.

              Можно реализовать интерфейс Countable, чтобы count($pituhi) возвращала количество питухов.

              А ещё можно реализовать магический метод __invoke(), чтобы использовать экземпляр в «функциональном контексте».

              Например, если $pituhi — экземпляр класса с методом __invoke(), то можно сделать вызов $pituhi('кококо'). Это типа перегрузки оператора () в «крестах».
              Ответить
              • Итого: в «PHP» функция может вернуть хитрый объект, который реализует метод __toString, чтобы его можно было использовать в «строковом контексте», интерфейсы ArrayAccess и ArrayIterator, чтобы его можно было использовать в «списковом контексте», интерфейс Countable для функции count и метод __invoke для «процедурного контекста».
                Ответить
                • Ну, у многих языков есть волшебные методы для преобразования в другой тип (преобразование в строку у всех есть практичеки), а у крестов можно и обратно преобразоыватся (как там этот конструктор называется? Конвертинг?)

                  Но только у перла от контекста зависит не сам объект, а возвращающая его функция или оператор.

                  В perldoc perldata написано, что английские слова тоже меняются от контекста (например, слово fish) и потому так сделано в перле. Кстати, сигилы (%,$,@ итд) тоже похожи на английский: $ это "the", а @ и % это "those", а & это "do". и как do" он опционален.

                  Сразу видно, что перл для умных, а Ларри лингвист
                  Ответить
    • Ну вот доработанная версия Говноклиента. Теперь с объетно-оринтеированным подходом
      #!/usr/bin/perl
      use strict;
      use Encode::Locale;
      use warnings FATAL => 'all';
      use utf8;
      use LWP::UserAgent;
      binmode($_, ":encoding(console_out)") for qw/STDOUT STDERR/;
      
      package Govnoclient {
          use JSON;
          use constant AGENT => 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Mobile Safari/537.36';
          use HTTP::Request::Common qw{POST};
          sub new {
              my ($class, $url, $comment) = @_;
              my $ua = LWP::UserAgent->new(agent => AGENT);
              my ($nonce) = $ua->get("$url/_$comment")->as_string =~ /ajax_nonce=([a-z0-9]+)"/;
              bless {
                  url     => $url,
                  ua      => $ua,
                  nonce   => $nonce,
                  comment => $comment
              }, $class;
          }
          sub say {
              my ($this, $phrase) = @_;
              my $url = $this->{url} . '/wp-admin/admin-ajax.php?action=add-comment&_ajax_nonce=' . $this->{nonce};
              my $params = {
                  'comment'         => $phrase,
                  'comment_post_ID' => $this->{comment},
                  '_ajax_nonce'     => $this->{nonce}
              };
              my $response = $this->{ua}->post($url, $params);
              $response->is_success or die $response->status_line;
              my $content = $response->decoded_content;
              return if ($content !~ /error/);
              my $result = decode_json $content;
              die $result->{'message'};
          }
      };
      1;
      
      package main;
      # Your code starts here
      my $client = Govnoclient->new('https://govnokod.xyz', 26237);
      
      foreach my $what (qw/сослик услик паукан/) {
          $client->say("$what. Отправлено с Perl.");
      }


      Кто поймет про binmode -- тот значит понимает про кодировки в перд)
      Ответить
    • лядь, это слишком хорошо, чтоб быть правдой
      #!/usr/bin/perl
      use strict;
      use warnings FATAL => 'all';
      use Smart::Comments;
      
      for(my $i = 0; $i < 5; $i++) { ### Initialzing....
              sleep 1;
      }
      
      for(my $i = 0; $i < 5; $i++) { ### Preparing...
              sleep 1;
      }


      https://metacpan.org/pod/Smart::Comments
      Ответить
      • Can't locate Smart/Comments.pm in @INC (you may need to install the Smart::Comments module) (@INC contains: /etc/perl /usr/local/lib/x86_64-linux-gnu/perl/5.28.1 /usr/local/share/perl/5.28.1

        Так это ж не из коробки.

        Но выглядит оче пиздато.
        Особенно ### Progress: 0... 100


        In each case, the module animates the comment, causing the dots to extend from the left text, reaching the right text on the last iteration. For "open ended" loops (like while and C-style for loops), the dots will never reach the right text and their progress slows down as the number of iterations increases.
        Ответить
    • perl -wle 'print "Prime" if (1 x shift) !~ /^1?$|^(11+?)\1+$/' [number]


      трудно поверить, но эта штука проверяет число на простоту.
      1 x shift повторяет единицу число раз
      затем, результат проверяется на несовпадение с релурякой
      ахаха
      Ответить
      • Лет 15 назад я читал, что перловые регулярки тьюринг-полны благодаря бектрекингу и рекурсивности. Но это не точно.
        Ответить
      • Как и всё гениальное просто.

        > /^1?$|^(11+?)\1+$/
        Здесь у нас склеено 2 регэкса.

        Первый отсекает единицу ^1?$ т.к. она не является простым.

        А второй матчит на простое число
        ^(11+?)\1+$
        Мы берём строку с двумя и более единицами и lazy-матчингом проверяем может ли она повториться целое число раз — \1+

        \1 — выражение в первых скобках.
        Ответить
      • Продолжу капитанство:
        !~ в пёрле означает инверсию совпадения с регэксом, которая в свою очередь записывается как =~

        Сама регулярка, как отмечено выше, проверяет является ли строка единицей ИЛИ состоит из целого числа подстрок вида 11+.

        Забавно что ^(11+?)\1+$ прекрасно работает и в жадном режиме, то есть без ?

        А lazy является всего-лишь оптимизацией.
        Ответить
        • Забавно так же что ? то ускоряет тест в разы, то замедляет его.
          165001 - Разница около 10%
          
          $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 165001
          Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
          Prime
          
          real	0m1.283s
          user	0m1.261s
          sys	0m0.014s
          
          $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 165001
          Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
          Prime
          
          real	0m1.365s
          user	0m1.356s
          sys	0m0.003s
          
          165003 - lazy в 3 раза медленее
          
          $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 165003
          Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
          
          real	0m1.034s
          user	0m1.017s
          sys	0m0.018s
          
          $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 165003
          real	0m0.301s
          user	0m0.290s
          sys	0m0.010s
          
          165005 - lazy в 4 раза быстрее
          
          $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 165005
          Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
          
          real	0m0.122s
          user	0m0.113s
          sys	0m0.009s
          
          $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 165005
          
          real	0m0.518s
          user	0m0.509s
          sys	0m0.009s
          Ответить
          • На числах больше 65536 пёрл выдаёт ворнинг, но считает почти всегда правильно.
            Только изредка промахиваясь.

            165073 — простое. Но регэкс так не считает.
            $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 165073
            Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
            
            real	0m0.036s
            user	0m0.032s
            sys	0m0.004s

            Заметно так же что время выполнения очень небольшое.
            При этом код ответа всегда 0.
            Ответить
            • >165073 — простое. Но регэкс так не считает.
              Отэта я лоханулся.

              Я сделал кривой тест, который перебирал числа до 300. Для диапазона [2;65537] этого было достаточно. Для 165073 нет, т.к. делитель 383.
              Ответить
          • Странно, что на 165003 вопросик так долго работает. Там же тройка в делителях, должно почти сразу заматчить на 111. Видимо какая-то особенность перебора в перловых регулярках, о которой я не знаю.

            З.Ы. Походу тройка сорвалась из-за subexpression recursion limit, поэтому пришлось перебирать до второго множителя, а он аж 55001.

            На 165005 пятёрка точно так же отлетела по лимиту, но быстро нашлось 61. А жадному перебору пришлось копать с конца аж до 541. Поэтому здесь жадный перебор проиграл.
            Ответить
            • Удивительный код:
              0% branch misprediction. 0% cache miss
              Performance counter stats for 'perl -wle print "Prime" if (1 x shift) !~ /^(11+?)\1+$/ 1165139':
              
                    17015,696277      cpu-clock (msec)          #    1,000 CPUs utilized          
                  14 815 266 939      branches                  #  870,682 M/sec                    (36,81%)
                      13 169 260      branch-misses             #    0,09% of all branches          (42,08%)
                         189 341      cache-misses              #    0,003 % of all cache refs      (42,08%)
                   6 739 590 559      cache-references          #  396,081 M/sec                    (42,08%)
                  62 826 558 696      cpu-cycles                #    3,692 GHz                      (42,08%)
                 141 850 740 540      instructions              #    2,26  insn per cycle           (47,34%)
                  59 435 188 197      ref-cycles                # 3492,962 M/sec                    (52,61%)
                               0      alignment-faults          #    0,000 K/sec                  
                           1 697      page-faults               #    0,100 K/sec                  
                  27 179 282 229      uops_issued.stall_cycles  # 1597,306 M/sec                    (52,61%)
                  26 990 197 686      resource_stalls.any       # 1586,194 M/sec                    (52,63%)
                  13 575 040 916      L1-dcache-load-misses     #   19,59% of all L1-dcache hits    (52,65%)
                  69 287 657 652      L1-dcache-loads           # 4071,985 M/sec                    (52,66%)
                         120 891      LLC-load-misses           #    0,00% of all LL-cache hits     (52,66%)
                   6 739 283 765      LLC-loads                 #  396,063 M/sec                    (52,66%)
                          76 562      LLC-store-misses          #    0,004 M/sec                    (10,53%)
                       1 711 272      LLC-stores                #    0,101 M/sec                    (10,53%)

              Тест на тупую, грубую силу.
              Ответить
              • То есть оно ждёт пока из L2/L3 кеша подтянется ещё больше единичек.
                _
                    28 609 758 607      cycle_activity.cycles_l1d_pending # 1702,178 M/sec                    (21,61%)
                    55 467 959 473      cycle_activity.cycles_l2_pending # 3300,145 M/sec                    (21,59%)
                    62 032 007 742      cycle_activity.cycles_ldm_pending # 3690,683 M/sec                    (21,57%)
                     3 598 789 774      cycle_activity.cycles_no_execute #  214,115 M/sec                    (21,54%)
                     2 729 009 407      cycle_activity.stalls_l1d_pending #  162,366 M/sec                    (10,76%)
                    13 824 770 304      cycle_activity.stalls_l2_pending #  822,524 M/sec                    (13,45%)
                    23 044 685 962      cycle_activity.stalls_ldm_pending # 1371,076 M/sec                    (16,14%)
                        21 719 141      ild_stall.iq_full         #    1,292 M/sec                    (18,82%)
                            12 634      ild_stall.lcp             #    0,752 K/sec                    (21,51%)
                    26 250 234 675      resource_stalls.any       # 1561,795 M/sec                    (21,51%)
                        36 824 152      resource_stalls.rob       #    2,191 M/sec                    (21,51%)
                    26 439 449 946      uops_issued.core_stall_cycles # 1573,053 M/sec                    (21,51%)
                Ответить
            • > Походу тройка сорвалась из-за subexpression recursion limit
              Кстати, а разве после вылета в лимит «Перл» не перестаёт считать оставшееся? Как-то странно получается.
              Пи, проверь большое простое число — оно вообще простоту-то проверяет, когда вываливается в «Complex regular subexpression recursion limit»?
              Ответить
              • >Пи, проверь большое простое число — оно вообще простоту-то проверяет
                1165139 достаточно большое?
                Просто дальше идёт квадратичная питушня на полчаса.

                [0] $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 1165139
                Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
                Prime


                https://govnokod.ru/26800#comment559582
                Ответить
                • Странно.
                  https://govnokod.ru/26800#comment559663
                  Ответить
                  • >Пи, проверь большое простое число — оно вообще простоту-то проверяет, когда вываливается в «Complex regular subexpression recursion limit»?

                    Досчитало 5165191
                    $ time perf stat -e $EVENTS perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 5165191
                    Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
                    Prime
                    
                     Performance counter stats for 'perl -wle print "Prime" if (1 x shift) !~ /^(11+?)\1+$/ 5165191':
                    
                        2079517,176142      cpu-clock (msec)          #    0,840 CPUs utilized          
                       274 267 611 244      branches                  #  131,890 M/sec                    (21,63%)
                            93 974 602      branch-misses             #    0,03% of all branches          (21,63%)
                        61 736 335 661      cache-misses              #   27,163 % of all cache refs      (21,63%)
                       227 283 416 540      cache-references          #  109,296 M/sec                    (21,63%)
                     7 638 165 967 233      cpu-cycles                #    3,673 GHz                      (21,62%)
                     2 711 109 980 628      instructions              #    0,35  insn per cycle           (24,32%)
                    
                        2474,145686595 seconds time elapsed
                    
                    
                    real	41m14.605s
                    user	34m39.382s
                    sys	0m0.920s
                    Ответить
      • Йажа работает в десятки раз медленее пёрла
        jshell> "1".repeat(1165139).matches("^(11+)\\1+$")

        Какой компилируемый язык )))
        Ответить
        • есть мнение, что \1 это не совсем \1
          Ответить
        • Нода раз в 10 медленее пёрла
          [0]$ time node -e '"1".repeat(165139).match("^(11+)\\1+$")'
          
          real	0m2.503s
          user	0m2.499s
          sys	0m0.004s
          
           [0] $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 165139
          
          real	0m0.255s
          user	0m0.255s
          sys	0m0.000s
          1165139
          [0] $ time node -e '"1".repeat(1165139).match("^(11+)\\1+$")'
          real	2m47.556s
          user	2m47.542s
          sys	0m0.008s
          
           [0] $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 1165139
          Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
          Prime
          
          real	0m22.741s
          user	0m22.728s
          sys	0m0.012s
          Ответить
          • PHP отрабатывает на больших числах на порядки быстрее чем все остальные *

            $ time /usr/bin/php7.3 -r "echo(preg_match('/^(11+?)\1+$/', str_repeat("1",1165139), $matches));"
            
            real	0m0.057s
            user	0m0.032s
            sys	0m0.023s
            
            $ time /usr/bin/php7.3 -r "echo(preg_match('/^(11+?)\1+$/', str_repeat("1",49139), $matches));"
            0
            real	0m1.357s
            user	0m1.331s
            sys	0m0.025s

            * после 49 тысяч оно просто перестаёт выводить результат
            но всё-равно раза 2 в быстрее чем «йажа» и «йажасцрипт»
            Ответить
            • Проверь 167281.
              Ответить
              • Какой язык?

                $ time /usr/bin/php7.3 -r "echo(preg_match('/^(11+?)\1+$/', str_repeat("1",167281), $matches));"
                
                real	0m0.055s
                user	0m0.030s
                sys	0m0.025s
                
                $ time node -e '"1".repeat(167281).match("^(11+)\\1+$")'
                
                real	0m14.929s
                user	0m14.767s
                sys	0m0.109s
                
                $ time node -e '"1".repeat(167281).match("^(11+?)\\1+$")'
                
                real	0m1.663s
                user	0m1.594s
                sys	0m0.074s
                
                $ time  perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 167281
                Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
                
                real	0m0.180s
                user	0m0.156s
                sys	0m0.025s
                
                $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 167281
                
                real	0m1.127s
                user	0m1.122s
                sys	0m0.005s

                *Все результаты для «PHP» было получены на слабой арм-машине.
                Для консистентности в этом посте я запускал всё на ней.
                Ответить
                • > арм машине

                  Пи?
                  Ответить
                  • Чуть мощнее. Там Cortex-A73.

                    А перф я на штеуде запускал.
                    Ответить
                • Любопытно. Можно ещё поэкспериментировать с разными видами чисел. 167281 — это было 409*409.
                  Ответить
                  • Реквестирую код на питухе.

                    Кстати там из-за квадратичной питушни числа сильно выше 10 миллионов не проверишь.
                    Пёрлотест на (11 165 139) у меня на штеуде работал больше часа.
                    Ответить
                    • python -c "import re;re.match(r'^(11+?)\1+$', '1' * 167281) is None"

                      У меня на машине в ~3 раза медленнее «Перла» (55 миллисекунд против 155). Но тут ещё проблема в том, что «import re» читает мудуль с диска, что плохо сказывается на производительности.

                      Без «?» тормозит совсем неадекватно.
                      Ответить
                      • >Но тут ещё проблема в том, что «import re» читает мудуль с диска
                        На greedy c 35 секундами это не заметно

                        Питух слился как лалка, но с ? он ноду делает.
                        Правда мы не знаем сколько в жсухе занимает прогрев интепретатора и его конпеляция.
                        $ time python -c "import re;re.match(r'^(11+?)\1+$', '1' * 167281) is None"
                        
                        real	0m0.387s
                        user	0m0.324s
                        sys	0m0.036s
                        
                        $ time python -c "import re;re.match(r'^(11+)\1+$', '1' * 167281) is None"
                        
                        real	0m35.876s
                        user	0m35.834s
                        sys	0m0.022s


                        Машина та же что и здесь:
                        https://govnokod.ru/26800#comment559599
                        Ответить
                        • Проверил: импорт не тормозит (прогретый, во всяком случае), «Питон» просто сливается как лалка.
                          PS C:\Users\gost> Measure-Command {python -c "import re"}
                          
                          
                          Days              : 0
                          Hours             : 0
                          Minutes           : 0
                          Seconds           : 0
                          Milliseconds      : 47
                          Ticks             : 476564
                          TotalDays         : 5,51578703703704E-07
                          TotalHours        : 1,32378888888889E-05
                          TotalMinutes      : 0,000794273333333333
                          TotalSeconds      : 0,0476564
                          TotalMilliseconds : 47,6564
                          
                          
                          
                          PS C:\Users\gost> Measure-Command {python -c "# nop"}
                          
                          
                          Days              : 0
                          Hours             : 0
                          Minutes           : 0
                          Seconds           : 0
                          Milliseconds      : 48
                          Ticks             : 482257
                          TotalDays         : 5,58167824074074E-07
                          TotalHours        : 1,33960277777778E-05
                          TotalMinutes      : 0,000803761666666667
                          TotalSeconds      : 0,0482257
                          TotalMilliseconds : 48,2257
                          Ответить
                          • Чем ваще вызваны такие разницы от языка к языку? У них настолько разные реализации регулярок?
                            Ответить
                            • Пёрл всегда считался стандартом де-факто для регулярок. Тут ничего удивительного.

                              Интересно и в пёрле, и в пхп, и в питухе используются сишные биндинги. В принципе нода с пхп идут нос-в-нос.

                              Только в Йажа реализация не нативная, а йажевская через java.util.Pattern.

                              Емнип в крестах регэксы как-то хуёво сделаны. Потому их я даже не стал бенчить. А буст влом ставить.
                              Ответить
                              • > Причём удивительно что и в пёрле, и в пхп, и в питухе используются сишные биндинги

                                И я про то же, чо за дела?

                                Каждый забиндил к себе разные сишные реализации перлового де-факто?
                                Ответить
                            • Ну да, каждый своё пилит. Плюс тут весьма специфическая задача с очень «тяжёлым» паттерном («квадратичный» бэктрекинг).

                              Ну а рагулярный движок «Перла» совершенствовали десятилетиями, у него это основной инструмент. Неудивительно, что он даёт пососать остальной скриптушне.
                              Ответить
                              • Интересно что когда строка больше 10 метров (не влазит в L3), то перл тупит даже на простеньких делителях.
                                4091*4099

                                $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 16769009
                                Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
                                
                                real	0m8.783s
                                user	0m8.775s
                                sys	0m0.008s


                                Питух тупит клювом
                                $ time python -c "import re;print(re.match(r'^(11+?)\1+$', '1' * 16769009) is None)"
                                False
                                
                                real	1m55.101s
                                user	1m54.856s
                                sys	0m0.244s

                                Нода наконец-то разваливается

                                $ time node -e 'console.log("1".repeat(16769009).match("^(11+?)\\1+$")!=null)'
                                [eval]:1
                                console.log("1".repeat(16769009).match("^(11+?)\\1+$")!=null)
                                                                 ^
                                
                                RangeError: Maximum call stack size exceeded
                                    at String.match (native)
                                    at [eval]:1:34
                                    at Object.exports.runInThisContext (vm.js:54:17)
                                    at Object.<anonymous> ([eval]-wrapper:6:22)
                                    at Module._compile (module.js:410:26)
                                    at node.js:578:27
                                    at nextTickCallbackWith0Args (node.js:419:9)
                                    at process._tickCallback (node.js:348:13)
                                
                                real	0m0.133s
                                user	0m0.109s
                                sys	0m0.024s
                                Ответить
                                • > даже на простеньких делителях. 4091*4099
                                  Это, КМК, наоборот worst-case для непростых чисел. Интерпретатору же нужно будет последовательно заматчить все последовательности единиц длиной от 2 до 4091. Например, 16769008 матчится на порядок быстрее.

                                  UPD: А полный worst-case — это, по идее, простые числа: 16769017 ты, скорее всего, не дождёшься.

                                  Кстати, я за «WolframAlpha»:
                                  https://www.wolframalpha.com/input/?i=first+prime+number+greater+than+16769009
                                  Ответить
                                  • >наоборот worst-case для непростых чисел
                                    Да. Там выше 10 миллионов уже пиздец.

                                    > Кстати там из-за квадратичной питушни числа сильно выше 10 миллионов не проверишь.
                                    > Пёрлотест на (11 165 139) у меня на штеуде работал больше часа.

                                    >А полный worst-case — это, по идее, простые числа: 16769017 ты, скорее всего, не дождёшься.
                                    Да.
                                    Ответить
                                  • $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 50041451
                                    Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
                                    
                                    real	0m51.365s
                                    user	0m51.296s
                                    sys	0m0.068s


                                    Там ещё кеш-промахи сильно вредят.

                                    https://govnokod.ru/26800#comment559641
                                    Ответить
                                  • >Это, КМК, наоборот worst-case для непростых чисел.
                                    Оказывается нет.

                                    Это неплохой кейс.

                                    Чётное 100160062 тупит гораздо больше чем 100160063=10007*10009

                                    Думаю здесь валидно объяснение борманда.

                                    >тройка сорвалась из-за subexpression recursion limit, поэтому пришлось перебирать до второго множителя, а он аж 55001.
                                    Ответить
                                    • 100160062 оказалось очень «удачным».
                                      Это простое 50080031 умноженное на 2.

                                      Сейчас пробую там где много мелких делителей
                                      4*5*7*11*13*5003 = 100160060

                                      $ time perf stat -e $EVENTS perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 100160060
                                      Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
                                      
                                       Performance counter stats for 'perl -wle print "Prime" if (1 x shift) !~ /^(11+?)\1+$/ 100160060':
                                      
                                            43081,010456      cpu-clock (msec)          #    1,000 CPUs utilized          
                                          18 959 550 242      branches                  #  440,091 M/sec                    (21,62%)
                                             143 147 111      branch-misses             #    0,76% of all branches          (21,63%)
                                           1 893 880 046      cache-misses              #   57,505 % of all cache refs      (21,64%)
                                           3 293 399 449      cache-references          #   76,447 M/sec                    (21,65%)
                                         158 688 007 127      cpu-cycles                #    3,683 GHz                      (21,65%)
                                         129 521 338 377      instructions              #    0,82  insn per cycle           (24,35%)
                                      
                                            43,081747676 seconds time elapsed
                                      
                                      real	0m43.108s
                                      user	0m43.034s
                                      sys	0m0.073s
                                      Ответить
                                      • 2**27= 134217728
                                        Жадный алгоритм быстр
                                        $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 134217728
                                        
                                        real	0m2.636s
                                        user	0m2.596s
                                        sys	0m0.040s


                                        Ленивый тупит
                                        $ time perf stat -e $EVENTS perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 134217728
                                        real	0m46.975s
                                        user	0m46.913s
                                        sys	0m0.061s
                                        Ответить
                              • Пыха даже в жадном режиме не хочет матчить больше 2х миллионов. Ошибок ЧСХ нет.
                                $ time /usr/bin/php7.3 -r "echo(preg_match('/^(11+)\1+$/', str_repeat("1",2001223), $matches));"
                                
                                real	0m0.065s
                                user	0m0.037s
                                sys	0m0.029s


                                От миллиона до двух она тупит, но ничего не выдает
                                $ time /usr/bin/php7.3 -r "echo(preg_match('/^(11+)\1+$/', str_repeat("1",1981223), $matches));"
                                
                                real	0m8.490s
                                user	0m8.405s
                                sys	0m0.057s

                                А до миллиона работает

                                $ time /usr/bin/php7.3 -r "echo(preg_match('/^(11+)\1+$/', str_repeat("1",981225), $matches));"
                                1
                                real	1m57.572s
                                user	1m56.635s
                                sys	0m0.141s
                                Ответить
                          • >Measure-Command
                            Качется, что это говёная команда: она измеряет много лишнего, не?
                            Сравни с ptime
                            Ответить
                            • Не знаю, я просто загуглил и потёк. Вроде выдаёт адекватные результаты.
                              Ответить
                  • Штеуд
                    1018081=1009²

                    [0] $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 1018081
                    Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
                    
                    real	0m0.201s
                    user	0m0.193s
                    sys	0m0.008s
                     [0] $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 1018081
                    
                    real	0m12.590s
                    user	0m12.590s
                    sys	0m0.000s


                    1111261 = 1013 *1093
                    [0] $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 1111261
                    Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
                    
                    real	0m0.216s
                    user	0m0.212s
                    sys	0m0.004s
                     [0] $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 1111261
                    
                    real	0m15.051s
                    user	0m15.047s
                    sys	0m0.004s
                    Ответить
                    • Штеуд

                      На больших числах Питух сливается даже ноде.
                      $ time python -c "import re;print(re.match(r'^(11+?)\1+$', '1' * 1111261) is None)"
                      False
                      
                      real	0m2.026s
                      user	0m1.993s
                      sys	0m0.008s
                      
                      $ time node -e 'console.log("1".repeat(1111261).match("^(11+?)\\1+$")!=null)'
                      true
                      
                      real	0m0.518s
                      user	0m0.502s
                      sys	0m0.016s
                      Ответить
              • Ага, PHP всё-таки выдаёт корректные результаты для больших чисел, если не использовать ?
                По скорости получается почти как жадная нода.
                И в 13 раз медленее чем pёrl

                $ time /usr/bin/php7.3 -r "echo(preg_match('/^(11+)\1+$/', str_repeat("1",167281), $matches));"
                1
                
                real	0m15.063s
                user	0m15.024s
                sys	0m0.035s
                Ответить
    • стейт хранится привязанным к скаляру, лол
      #!/usr/bin/perl
      use v5.10;
      use strict;
      use warnings FATAL => 'all';
      
      my $CODE = 'here we go again';
      
      
      while ($CODE =~ m/\G(\p{Word}+)\s+/gc) {
      	say "Word found at:".(pos $CODE);
      }
      Ответить
    • Мало кто знает, но в перле всё передается по ссылке.
      #!/usr/bin/perl
      use strict;
      use warnings FATAL => 'all';
      use v5.10;
      
      sub capituz {
          tr/uz/UZ/ foreach @_;
      }
      
      
      my $name = 'petuz';
      say $name; #petuz
      capituz $name;
      say $name; #petUZ


      Кстати, зацените божественный оператор tr, известный каждому униксоиду
      Ответить
      • А с точки зрения стиля тоже так принято писать, или ты просто показываешь, что так можно? Так-то говно процедурное сайдэффектное.
        Ответить
        • А что такого?

          Ты просто не привык, что "изменяют" строку. А если бы я отдал туда массив, и его поменяли, было бы лучше?
          Ответить
          • Я привык ко всему, я на поцкале долго писал чисто процедурно, передавая данные по ссылке если надо, и знаю цимес в мутабл данных. Но чисто стилистически, у тебя везде будут такие процедуры, и так будет написан весь скрипт/проект? Если да - заебись, если же ты начнёшь комбинировать подход, когда процедуры с сайд эффектами замешаны с чистыми функциями с возвращаемым значением, или, того хуже, функциями у которых есть и значение и сайд эффекты, стилистически получится говнокод.
            Ответить
          • Код будет хуево говорить сам за себя, без повышенного внимания или документации в нем не будет охуенно комфортно плавать.
            Ответить
        • вот такой же код тебе нормаелн?
          use strict;
          use warnings FATAL => 'all';
          
          my @nums = (1 .. 200000);
          
          sub multiply_evens_zachem_zachem {
              for (my $i = 0; $i < @_; $i++) {
                  $_[$i] *= 2 unless $_[$i] % 2;
              }
          }
          
          multiply_evens_zachem_zachem @nums;
          print join ',', @nums[0 .. 30];
          Ответить
    • На числах выше 8М с полного кеш хита, начинается тотальный кеш-мисс.

      IPC резко падает с 2.2 до 0.9, больше чем в 2 раза.

      10007 * 10009 = 100160063
      $ time perf stat -e $EVENTS perl -wle 'print "Prime" if (1 x shift) !~ /^(11+?)\1+$/' 100160063
      Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
      
       Performance counter stats for 'perl -wle print "Prime" if (1 x shift) !~ /^(11+?)\1+$/ 100160063':
      
           101989,511547      cpu-clock (msec)          #    1,000 CPUs utilized          
          45 673 821 713      branches                  #  447,829 M/sec                    (21,62%)
             313 208 108      branch-misses             #    0,69% of all branches          (21,62%)
           5 227 242 279      cache-misses              #   49,080 % of all cache refs      (21,63%)
          10 650 526 377      cache-references          #  104,428 M/sec                    (21,63%)
         375 496 611 323      cpu-cycles                #    3,682 GHz                      (21,63%)
         341 922 618 724      instructions              #    0,91  insn per cycle           (24,33%)
         355 232 658 048      ref-cycles                # 3483,031 M/sec                    (27,04%)
                  25 865      page-faults               #    0,254 K/sec                  
         287 479 711 819      uops_issued.stall_cycles  # 2818,718 M/sec                    (27,04%)
         280 966 049 622      resource_stalls.any       # 2754,852 M/sec                    (27,04%)
          14 806 209 992      L1-dcache-load-misses     #   10,88% of all L1-dcache hits    (27,04%)
         136 092 303 505      L1-dcache-loads           # 1334,375 M/sec                    (27,03%)
          5 188 921 503      LLC-load-misses           #   49,15% of all LL-cache hits     (27,03%)
          10 557 576 315      LLC-loads                 #  103,516 M/sec                    (27,03%)
      
      
           101,990844967 seconds time elapsed
      
      
      real	1m42.028s
      user	1m41.969s
      sys	0m0.046s
      Ответить
      • Вывод такой. Жадный алгоритм хорошо работает на числах где есть мелкий множитель двойка.

        100160060 = 4*5*7*11*13*5003
        
        $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 100160060
        real	0m2.005s
        
        134217728 = 2**27
        $ time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 134217728
        real	0m2.636s
        
        2*50080031 (простое)
        time perl -wle 'print "Prime" if (1 x shift) !~ /^(11+)\1+$/' 100160062
        real	0m2.046s


        Но очень тупит на нечетных, на простых, или на больших произведениях двух примерно равных простых. 10007 * 10009 = 100160063

        Ленивый наоборот для простых и множителей >=3 работает лучше.
        Ответить
        • > множителей >= 3

          Множителей, больших чем N / 32k. Т.е. чем больше число, тем хуже он ищет мелкие множители. Если бы не это ограничение на 32k раскрытий \1, то он бы всегда выигрывал.
          Ответить
          • >Множителей, больших чем N / 32k
            Ленивый сливается на 4*5*7*11*13*5003.
            Тут же есть делители меньше 32k: 2*5003, 3*5003 итд.

            Жадный благодаря какой-то оптимизации на чётных работает крайне быстро (2 секунды для 100М).

            А как оставлю одни нечётные, то полчаса не могу дождаться пока жадный доработает.
            3*5*7*11*13*5003 = 75120045
            Ответить
            • > Жадный благодаря какой-то оптимизации на чётных работает крайне быстро
              Не потому ли, что он сразу пытается сматчить в первую группу N/2 единиц (больше матчить не имеет смысла из-за \1+)? А для 3*... ему придётся поочерёдно матчить N/2, N/2 - 1 и так далее до N/3.
              Ответить
            • Ну вот смотри. 4*5*7*11*13*5003 это 100160060. Т.е. все множители ниже 3057 ленивая версия не сможет проверить из-за ограничения на подстановку. Но видимо будет пытаться и тратить на них время. Первый множитель, который она сможет найти и прервать цикл - это 5003 4004.

              А жадная версия тупо промотает всё от конца до середины и, о чудо, найдёт множитель 50080030. Строки больше половины скорее всего очень быстро отбиваются на проверке длины.

              На нечётных же числах, как правильно пишет гост, у жадной версии начинается реальный перебор от N/2 как минимум до N/3. Что как бы дохуя.
              Ответить
          • Оба сливаются на 100160079 = 3 * 33386693 (простое).

            Похоже на worst-case для составных.
            Ответить
            • А между тем Питух заклёвывает Пёрл на чётных 100160062 со «?»
              $ time python -c "import re;print(re.match(r'^(11+?)\1+$', '1' * 100160060) is None)"
              False
              
              real	0m7.061s
              user	0m3.341s
              sys	0m1.984s
              
              $ time python -c "import re;print(re.match(r'^(11+?)\1+$', '1' * 100160062) is None)"
              False
              
              real	0m6.944s
              user	0m3.257s
              sys	0m2.087s


              И вообще Питух зверски быстр на куче маленьких множителей.
              $ time python -c "import re;print(re.match(r'^(11+?)\1+$', '1' * 75120045) is None)"
              False
              
              real	0m8.261s
              user	0m4.975s
              sys	0m1.503s

              Для Питуха ? однозначно улучает пирформанс.
              Ответить
              • Ну потому что нет сраного лимита на 32к. А с мелких чисел начинать проверку всё-таки выгоднее.
                Ответить
                • >сраного лимита на 32к
                  Питух рекурсию превращает в цикл? Гвидо вроде был против tail-call.

                  Пёрл сливается на 100160079 = 3 * 33386693 (простое).

                  А Питух шустро так крыльями, хлоп-хлоп.
                  $ time python -c "import re;print(re.match(r'^(11+?)\1+$', '1' * 100160079) is None)"
                  False
                  
                  user	0m6.645s
                  sys	0m1.938s

                  Там время будет чуть ниже, просто на всех ядрах тесты пёрла уже больше часа ебошат.
                  Ответить
                  • > Питух рекурсию превращает в цикл?
                    У питуха, скорее всего, просто в реализации рекурсии нет — или конпелятор её в tail-call и оптимизировал.

                    > Гвидо вроде был против tail-call.
                    Вряд ли ради этого мейнтейнеры «CPython» добавляют флаг «-fno-optimize-sibling-calls» :-).
                    Ответить
                  • Потому что в питоне нет сраного лимита на 32к подстановок. Пёрл физически не может заматчить тройку для таких больших чисел, он даже ворнинг про это высирает. Поэтому он будет мотать аж до 33386693 и само собой соснёт.
                    Ответить
                    • > Пёрл физически не может заматчить тройку
                      А как это вообще обрабатывается? «Пёрл» может возвратить некорректный результат, если упрётся в лимит?
                      Ответить
                      • В душе не ебу, я ж не настоящий сварщик. Но судя по тому что он не сдох и просто не заматчил - да. Алгоритм в целом корректно работает только из-за того, что всегда есть второй парный делитель.

                        Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
                        Ответить
                      • Он походу обламывается, ставит отсутствие матча и идёт дальше.
                        Я ещё полтора часа назад запустил на перле тест на два множителя >32K
                        33013*33023 = 1090188299
                        Пока жду.
                        Ответить
                        • Боюсь, что ты не дождёшься. Это ж миллиард. И на каждой итерации там почти вся строка сверяется кроме, возможно, хвостика.

                          Ну ок, последние 500 миллионов наверное скипнутся по-быстрому т.к. \1 длиннее хвоста. Но это всё равно дофига.
                          Ответить
                          • >Это ж миллиард
                            10007 * 10009 = 100160063
                            За 100 секунд отработало.

                            А тут число в 10 раз больше. 100*10²=10000 секунд.

                            Походу тепловая смерть Вселенной часа через три будет.

                            Хреново что я их без nohup запустил. Надо почитать как их детачнуть, если вдруг сеть сбойнёт.
                            Ответить
                            • Дык 10007 * 10009 прервалось на 10007! А 1090188299 будет проверять всё до победного 1090188299.

                              В стотыщраз разница. 760 тыщ лет будешь ждать если предположить, что там квадратичный алгоритм.
                              Ответить
                              • > Дык 10007 * 10009 прервалось на 10007!
                                Я тоже хочу себе компьютер, который сможет досчитать до 10007!.
                                Ответить
                                • 70! — это уже стозначное число. Сколько же знаков в 10007! ?
                                  Ответить
                                  • 35688.
                                    Ответить
                                  • Я за «Python».
                                    https://pastebin.com/ez09A4BC
                                    Ответить
                                    • Учитесь, анскильные лалки: https://ideone.com/jL0ZGB

                                      <?php
                                      
                                      $n = 10007;
                                      echo ceil(log10(sqrt(2 * M_PI * $n)) + log10($n / M_E) * $n);
                                      Ответить
                                      • >sqrt(2 * M_PI * $n)
                                        Похоже на формулу Стирлинга.

                                        Так она же приблизительная. Плюс плавающий питух.
                                        Ответить
                                      • https://ideone.com/Fh4ywu
                                        $n = 0;
                                        echo ceil(log10(sqrt(2 * M_PI * $n)) + log10($n / M_E) * $n);
                                        Какой NaN )))
                                        Ответить
                                        • > кроме n < 2
                                          Ответить
                                          • Для [2; 15000) работает правильно. Надо подключать аналитику.
                                            Ответить
                                            • Версию на питухе можно чуток питумизировать.

                                              math.log10(math.factorial(21))

                                              Или просто циклом for сложить все логарифмы натуральных.

                                              >Надо подключать аналитику
                                              Я думаю формула хорошая. Она может лажануть только если будет ситуация близости переноса.

                                              >>> math.log10(math.factorial(29))
                                              30.946538820206058

                                              Только .9999.
                                              Ответить
                                              • А как работает math.factorial?
                                                Он учитывает, что можно балансированно считать делением пополам (чтобы умножать равные по длине числа), и использует ли быстрое преобразование Фурье для умножения (оно, кстати, тоже на правпитухе)?


                                                Кажется, хуйню написал. Ведь умножение длинного на короткое наверное лучше.
                                                Ответить
                                            • ЕМНИП, я сам на ГК в каком-то сраче писал Стирлинга.

                                              И он работал.

                                              Т.к. на маленьких не случалось переносов из-за погрешности, а на больших решала асимптотика.

                                              >Для [2; 15000) работает правильно
                                              Дальше смысла проверять особо нет, т.к. формула асимптотическая.
                                              Ответить
                                            • 15000!

                                              >>>Стирлинг:
                                              56129.438792851

                                              >>> math.log10(math.factorial(15000))
                                              56129.4387952629

                                              15!
                                              >>>Стирлинг:
                                              12.114087220993

                                              >>> math.log10(math.factorial(15))
                                              12.1164996111234

                                              И чем дальше, тем оно точнее после запятой. Разве что будет случай когда в логарифме появится .99999999 и случится перенос.
                                              Ответить
                                            • Написал простенький говновалидатор, которые выдает гипотетические разногласия, где логарифм факториала около целого числа.

                                              s=0; for (var i=1;i<=12345678;++i) {
                                                  var stirling = Math.log10(Math.sqrt(2 * Math.PI * i)) + Math.log10(i / Math.E) * i;
                                                  s+=Math.log10(i);
                                                  if (Math.ceil(s)!=Math.ceil(stirling)) console.log(i);
                                              }
                                              3121515
                                              4187665
                                              4423458


                                              Имеет смысл перепроверить только такие случаи.
                                              Ответить
                                            • Имеет смысл проверить только числа, которые выдаст эта питушня.
                                              s=0; for (var i=1;i<=1123456789;++i) {
                                                  var stirling = Math.log10(Math.sqrt(2 * Math.PI * i)) + Math.log10(i / Math.E) * i;
                                              //    s+=Math.log10(i); // плавающий питух с ростом числа итераций накапливает ошибку
                                                  if (Math.ceil(stirling+1/i)!=Math.ceil(stirling)) console.log(i,stirling);
                                              }
                                              Ответить
                                              • Проверил всё из списка, вплоть до 12861320! (включительно)
                                                12861320! = 10^85849199.99999996  [ math.log10(math.factorial( 12861320 )) =85849199.99999997
                                                ]
                                                16641157! = 10^112941689.99999996
                                                28563732! = 10^200560832.9999999
                                                Ответить
                                          • Не обновил страницу.

                                            Похоже что точности формулы всегда хватает для подсчёта порядка. На больших числах уже начинает помогать асимптотика.

                                            А чтобы поймать багры от плав. питуха нужны числа такого порядка, для которых прямой подсчёт закончится после того как потухнет Солнце.
                                            Ответить
                            • З.Ы. Блин, т.е. перл может выдать неправильный ответ. Но воспроизвести за разумное время это нельзя. Т.е. алгоритм работает правильно для любых разумных применений.
                              Ответить
                              • Ага, я тоже хотел подметить что Ларри всё просчитал.

                                Можно слить Пёрл как лалку, но к тому моменту всем уже будет похуй.
                                Ответить
                            • На самом деле можно проще тест сделать. Сгенери строку в 1090188299 единичек и заматчи её с фиксированными паттернами из 33013 и 33023 единичек питоном и пёрлом.
                              Ответить
                              • Странно. Заматчил и не упал.
                                $ perl -wle "$barop = \"1\" x 33013; print \"MATCH\" if (1 x shift) =~ /^($barop)+$/" 1090188298
                                
                                $ perl -wle "$barop = \"1\" x 33013; print \"MATCH\" if (1 x shift) =~ /^($barop)+$/" 1090188299
                                MATCH

                                UPD: Заматчил правильное число, результаты те же.
                                Ответить
                                • А. Я понял. Это же жадина-говядина.
                                  Тут бектрекинга «?» нет.

                                  Ленивый куда дольше считает
                                  time perl -wle '$barop = "1" x 33023; print "MATCH" if (1 x shift) =~ /^($barop?)+$/' 1090188299
                                  Ответить
                                  • А, точно же.
                                    Ответить
                                    • Доработало наконец. Пёрл слился в хламину.

                                      $ time perl -wle '$barop = "1" x 33023; print "MATCH" if (1 x shift) =~ /^($barop?)+$/' 1090188299
                                      Complex regular subexpression recursion limit (32766) exceeded at -e line 1.
                                      
                                      
                                      real	25m35.657s
                                      user	23m12.344s
                                      sys	0m0.912s
                                      Ответить
                                      • Для сравнения 32693*33023 отрабатывает почти моментально
                                        $ time perl -wle '$barop = "1" x 33023; print "MATCH" if (1 x shift) =~ /^($barop?)+$/' 1079620939
                                        MATCH
                                        
                                        real	0m1.807s
                                        user	0m0.396s
                                        sys	0m0.495s

                                        А если подставить 32693, тогда нет.
                                        Ответить
                  • Кстати, я придумал тебе число, на котором пёрл сольётся как лалка и выдаст неправильный ответ.

                    1416242689 = 37633 * 37633

                    Оба делителя больше 32к. Пёрл их ни так ни сяк не заматчит. И скажет, что число простое.
                    Ответить
                    • Я уже больше часа жду
                      https://govnokod.ru/26800#comment559666

                      У меня такое чувство, что результат утром будет.
                      Ответить
                      • Боюсь, что результат будет после тепловой смерти вселенной.
                        Ответить
                      • Какой язык в итоге слил лалок в хламину?
                        Ответить
                        • Си. Потому что там со строками неудобно работать и проще нормальный алгоритм написать.
                          Ответить
                          • То ли лыжи не едут, то ли я спать хочу.

                            https://ideone.com/2MelzP

                            Posix рагулярки начинают сливаться и дико тупить на 41, 43, 45.

                            int main (int argc, char *argv[])
                            {
                            	/*
                                if (argc < 2) {
                                    fprintf(stderr, "Usage: %s number\n", argv[0]);
                                    return(1);
                                }
                            
                                int num = atoi(argv[1]);
                                */
                                int num=41;
                                printf("%d\n",num);
                            
                                regex_t regex;
                                char    buf[255];
                                char    str[num];
                            
                                memset(str,'1',num);
                                str[num] = 0;
                                puts(str);
                            
                                regcomp(&regex, "^(11+)\\1+$", REG_EXTENDED);
                            
                                int r = regexec(&regex, str, 0, NULL, 0);
                            
                                //If a match is found, the regexec() function returns 0. 
                                if (0 == r) {
                                    puts("Not Prime");
                                }
                                //If no match is found, the regexec() function returns REG_NOMATCH. 	
                                else if (REG_NOMATCH == r) {
                                    puts("Prime");
                                }
                                //Otherwise, it returns a nonzero value indicating an error. 		
                                else {
                                    regerror(r, &regex, buf, sizeof(buf));
                                    fprintf(stderr, "Error:%d %s\n",r , buf);
                                    return(1);
                                }

                            Я знал что оно хуеватое.
                            Не может же оно быть НАСТОЛЬКО хуёвым.
                            Ответить
    • Йажа на небольших множителях сливает всех за секунду как лалок.

      jshell> long ns=nanoTime(); "1".repeat(100160060).matches("^(11+?)\\1+$") ; out.println( TimeUnit.NANOSECONDS.toMillis(nanoTime()-ns));
      $6 ==> true
      1188
      
      jshell> long ns=nanoTime(); "1".repeat( 100160079 ).matches("^(11+?)\\1+$") ; out.println( TimeUnit.NANOSECONDS.toMillis(nanoTime()-ns));
      $9 ==> true
      1775
      
      jshell> long ns=nanoTime(); "1".repeat(100160060).matches("^(11+)\\1+$") ; out.println( TimeUnit.NANOSECONDS.toMillis(nanoTime()-ns));
      $12 ==> true
      1019
      
      jshell> long ns=nanoTime(); "1".repeat(3*5*7*11*13*5003).matches("^(11+?)\\1+$") ; out.println( TimeUnit.NANOSECONDS.toMillis(nanoTime()-ns));
      $18 ==> true
      1415
      
      
      jshell> long ns=nanoTime(); "1".repeat(3*5*7*11*13*5003).matches("^(11+)\\1+$") ; out.println( TimeUnit.NANOSECONDS.toMillis(nanoTime()-ns));
      35984
      Ответить
    • Отныни говнокод объявлен клубом фанатов tcl
      #!/usr/bin/tclsh
      set f [open "/etc/passwd"]
      foreach line [split [read $f] "\n"] {
      	set user [lindex [split $line ":"] 0]
      	if {$user ne ""} then {
      		puts [exec id $user]
      	}	
      }
      close $f
      Ответить
      • Минусы — упоротые скобочки, завоз зловонного ООП.

        Плюсы — понятный синтаксис, простота, минимум ёбаных значков.

        Лучше бы баш издох в какой-то момент и мы писали на этом.

        Подозреваю что на самом деле он Tsar Command Language. Но это не точно.
        Ответить
        • Синтаксис настолько простой, что парсер для него кажется что за пол дня пишется.
          ООП опционален.

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

            А для индексации массивов, наоборот нужны квадратные.
            Ответить
            • Квадратные не совсем для условий:)
              Квадратные скобки это запуск "подкоманды" и получение ее аутпута, как `` `` или $().
              Ответить
    • Уже полтора дня ебошит. Результата нет.
      TIME+                            Command
        41h03:45 perl -wle print "Prime" if (1 x shift) !~ /^(11+)\1+$/ 75120045
        41h03:40 perl -wle print "Prime" if (1 x shift) !~ /^(11+?)\1+$/ 100160079
        41h03:46 perl -wle print "Prime" if (1 x shift) !~ /^(11+)\1+$/ 100160063
        41h03:38 perl -wle print "Prime" if (1 x shift) !~ /^(11+?)\1+$/ 1090188299

      Блядский пёрл.
      Ответить
      • Поехавший!
        Ответить
        • >perl -wle print "Prime" if (1 x shift) !~ /^(11+)\1+$/ 75120045

          Эта доработала, но т.к. команда time печатает вывод после отсылки процессу сигнала STOP, то точное время сказать не могу.

          Но явно больше 40+ часов.

          В то время как «Ruby» делает это же за 2 секунды. А «Йажа» за одну.
          $ time ruby -e 'puts !(("1" * 75120045).match /^(11+?)\1+$/);'
          false
          
          real	0m2.736s
          user	0m2.128s
          sys	0m0.608s


          Edit: сорян. Я Обманул. Пёрл ведь жадный.
          Жадная Йажа за 36 секунд раскладывает 3*5*7*11*13*5003
          Ответить
          • Какой врост кейс )))
            Ответить
            • Врост это 100_160_079 = 3 * 33386693
              Жадина-говядина явно будет считать его дольше чем 75_120_045.

              А ленивое до сих пор его матчит.

              Интересно что жадная Йажа работает на удивление быстро. В отличие от остальной скриптухи.
              Ответить
              • > Интересно что жадная Йажа работает на удивление быстро. В отличие от остальной скриптухи.
                Значит, надо найти вореант, при котором ЙАЖА соснёт.
                Ответить
                • >надо найти вореант, при котором ЙАЖА соснёт.

                  Ещё позавчера нашёл. Но не замерял.
                  Это в особенности простые числа.
                  А также квадраты простых или произведения примерно одинаковых простых.
                  Ответить
                • Кстати ruby — питушня.
                  Сначала он мне понравился. Но я заметил, что в отличие от питуха и пёрла почему-то жрёт дохуя памяти.
                  VIRT   RES     TIME+               Command
                   3316M 2945M  16:57.20  ruby -e puts !(("1" * 75120045).match /^(11+)\1+$/);
                   121M  104M   48h16:08  perl -wle print "Prime" if (1 x shift) !~ /^(11+?)\1+$/ 100160079
                   116M  100M   48h15:45  perl -wle print "Prime" if (1 x shift) !~ /^(11+)\1+$/ 100160063
                   1065M 1049M  48h15:52  perl -wle print "Prime" if (1 x shift) !~ /^(11+?)\1+$/ 1090188299

                  30х отличие не объяснить даже уникодными строками.
                  Ответить
        • 10. Security Considerations
          
          JSON Schema validation defines a vocabulary for JSON Schema core and concerns all the security considerations listed there.
          
          JSON Schema validation allows the use of Regular Expressions, which have numerous different (often incompatible) implementations. 
          Some implementations allow the embedding of arbitrary code, which is outside the scope of JSON Schema and MUST NOT be permitted.
           Regular expressions can often also be crafted to be extremely expensive to compute (with so-called "catastrophic backtracking"), resulting in a denial-of-service attack. 


          Я кстати стопнул эти процессы и забыл про них. А они так и висят.
          309h perl -wle print "Prime" if (1 x shift) !~ /^(11+?)\1+$/ 100160079
           319h perl -wle print "Prime" if (1 x shift) !~ /^(11+)\1+$/ 100160063
          Ответить
          • > 319h
            Какой багор )))

            Уже бы лекарство от рака рассчитал, с такими-то мощностями.
            Ответить

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