Тест "Счастливые билеты"

Я не про пилу, а про f(x), где x=0...27.
Такая постановка вопроса не будет пилой.
Последний код что я цитировал считает эту штуку.

 

Вариант с 6 циклами самый простой, легко делается на самых простых ЯП, и он очень банальный. Я просто не понимаю как такое можно лепить, преобразовать в строку, выделить каждый символ, который преобразуем в число, при этом не применить функцию форматирования строки, чтобы не мучиться с добавлением нулей. В той теме на хабре, можно ещё его варианты просмотреть, они чуть более оптимальные. Думаете он в шутку, нет, он так по жизни погромирует, ну я так думаю. И всё из-за самого питухона, там можно умножать строки, а если бы это было делать нельзя, то это его бы просто заставила написать более оптимальный код. Такие ЯП как питухон и С++ с фреймворками, просто заставляют писать крайне неоптимальный код, он сам так получается. По мне оптимальный код даже проще делать, чем мучить все эти шаблонные фреймворки, их выучить надо много чего запомнить, в результате место на оптимизатор в мозгу просто не хватает, проще просто забить, и сказать, а я не умею, я не понимаю все эти ваши шаблонные шаблоны, с многократно перегруженными шаблонами фреймворками. И всё, чистый С++ с классами, может надо немного помучиться, но не факт что получиться быстрей, пока выучишь эти шибко высокоуровневые очень жирные фреймворки.

Чего? Боже, по мне это просто бред, я лучше сразу буду мучить С++, мне так проще, чем трахатся с питухоном, а потом ещё и переписывать на С++. Реально не вижу никаких преимуществ.
Может имеете ввиду Lua? Да, как раз Lua для этого и нужен, с LuaBinding в игровых движках объект можно сначала реализовать на Луне, а потом когда заработает, экспортировать в сам движок. Я так делал в модинге сталкера. Можно конечно сразу ковырять исходники(а бывает что они не доступны, либо проблемы с настройкой проекта), но больно долго ждать компиляции, а тут сразу можно проверять и тестировать.
Наверное я просто ленивый, и мне сильно лениво учить слишком много информации.

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

 

То, что так программирует именно он - допускаю.

Во-первых, не строки, а символы.
Во-вторых, разве на ассемблере или на си нельзя умножать буквы?
Смотри, что могу:

Code (ASM):

1.  
2. mov eax, 'a'
3. mov edx, 123  ; Multiplier
4. mul edx       ; EDX:EAX = 'a' * 123
5.  

Code (C):

1.  
2. int main()
3. {
4.     const char youAreCrazy = 'a' + 'b' - 'c' - 3;
5.     return 0x1ee7c0de;
6. }
7.  

"...а Сэмюэль Кольт уравнял их в правах".

А уверен, что дело в языке, а не в программисте? Похоже, ты никогда не писал на C++ и не очень представляешь, что собой представляют шаблоны, классы, STL, и как это работает внутри.
Например, о каких жирных фреймворках ты говоришь и что подразумется под скоростью в отношении этих фреймворков? Скорость... чего именно?

Нет, я имею в виду игры, целиком написанные на питоне - например, на Pygame, который под капотом использует нативный SDL.

Ключевое слово "мне". Для твоих задач вполне может хватать ассемблера и си. Но когда тебе надо сконвертировать один текстовый файл в другой, ты просто берёшь питон и в три строчки решаешь задачу.
Да, он выполнится не за наносекунду, а за 100 миллисекунд. Но на его написание ты потратишь минуту, а не три часа.
Простой пример: у тебя есть строка - раздели её на слова по пробелам. И посчитаем, сколько получится строк кода. К сведению, на питоне это займёт ровно одну: str.split().
По этой же причине питон используют для анализа данных, для реверсинга, для математики, многие популярные фреймворки для нейросетей - тоже на питоне.
Пока ты в сотый раз ищешь, где забыл free в своей сишной программе, дата-саентист уже крутит модели в своём тензорфлоу.
Как говорится, вам шашечки или ехать?

 

===========================================================================================================
Попробуем ещё раз, я что-то за два года реально подзабыл как точно тогда делал оптимизацию.
И так, базовый код, простой как лапоть.
OPTIMIZATION = 0

Code (C):

1.     for(l3=0; l3<10; l3++)
2.         for(l2=0; l2<10; l2++)
3.             for(l1=0; l1<10; l1++)
4.                 for(r3=0; r3<10; r3++)
5.                     for(r2=0; r2<10; r2++)
6.                         for(r1=0; r1<10; r1++)
7.                             if (l1+l2+l3==r1+r2+r3)
8.                                 count++;

Эта оптимизация важны для дальнейшей оптимизации, мы тут добавляем sum_l и sum_r это сумма левой комбинации и правой.
OPTIMIZATION = 1

Code (C):

1.     for(l3=0, sum_l=0; l3<10; l3++, sum_l-=9)
2.         for(l2=0; l2<10; l2++, sum_l-=9)
3.             for(l1=0; l1<10; l1++, sum_l++)
4.                 for(r3=0, sum_r=0; r3<10; r3++, sum_r-=9)
5.                     for(r2=0; r2<10; r2++, sum_r-=9)
6.                         for(r1=0; r1<10; r1++, sum_r++)
7.                             if (sum_l==sum_r)
8.                                 count++;

Тут мы определили условие sum_l==sum_r срабатывает в определённом диапазоне, которое можно выразить как sum_l>=sum_r && sum_l<sum_r+10
OPTIMIZATION = 2

Code (C):

1.     for(l3=0, sum_l=0; l3<10; l3++, sum_l-=9)
2.         for(l2=0; l2<10; l2++, sum_l-=9)
3.             for(l1=0; l1<10; l1++, sum_l++)
4.                 for(r3=0, sum_r=0; r3<10; r3++, sum_r-=9)
5.                     for(r2=0; r2<10; r2++, sum_r++)
6.                         if (sum_l>=sum_r && sum_l<sum_r+10)
7.                             count++;

Здесь мы нарисуем такую таблицу, надеюсь форматирования не сломает таблицу.

Code (Text):

1. ------------------------------------
2.         0000000000111111111122222222
3. sum_r   0123456789012345678901234567
4. ------------------------------------
5.         0000000001000000000000000000
6. sum     1234567890987654321000000000
7. ------------------------------------
8. r2
9. 9       0000000001111111111000000000
10. 8       0000000011111111110000000000
11. 7       0000000111111111100000000000
12. 6       0000001111111111000000000000
13. 5       0000011111111110000000000000
14. 4       0000111111111100000000000000
15. 3       0001111111111000000000000000
16. 2       0011111111110000000000000000
17. 1       0111111111100000000000000000
18. 0       1111111111000000000000000000
19. ------------------------------------
20.         0000000000111111111122222222
21. sum_l   0123456789012345678901234567
22. ------------------------------------

Единички это количество срабатывания count в диапазоне итерации r2 0..9
OPTIMIZATION = 3

Code (C):

1.     for(l3=0, sum_l=0; l3<10; l3++, sum_l-=9)
2.         for(l2=0; l2<10; l2++, sum_l-=9)
3.             for(l1=0; l1<10; l1++, sum_l++)
4.                 for(r3=0, sum_r=0; r3<10; r3++, sum_r++){
5.                     int sum = sum_l - sum_r + 1;
6.                     if (sum>0 && sum<20){
7.                         count += sum;
8.                         sum -= 10;
9.                         if (sum>0)
10.                             count -= 2*sum;
11.                     }
12.                 }

Code (Text):

1. 9   0000000001
2. 8   00000000111
3. 7   000000011111
4. 6   0000001111111
5. 5   00000111111111
6. 4   000011111111111
7. 3   0001111111111111
8. 2   00111111111111111
9. 1   011111111111111111
10. 0   1111111111111111111

Формула пирамиды 2д: (sum*sum+sum)/2
далее удаляем ещё одну итерацию, это 3д пирамида, и вот её вид сверху.

Code (Text):

1. ------------------------------------
2.         0000000000111111111122222222
3. sum_r   0123456789012345678901234567
4. ------------------------------------
5.         000112234566777
6. sum     136051865539355
7. ------------------------------------
8. r1
9. 9       000000000123456789a876543210
10. 8       00000000123456789a8765432100
11. 7       0000000123456789a87654321000
12. 6       000000123456789a876543210000
13. 5       00000123456789a8765432100000
14. 4       0000123456789a87654321000000
15. 3       000123456789a876543210000000
16. 2       00123456789a8765432100000000
17. 1       0123456789a87654321000000000
18. 0       123456789a876543210000000000
19. ------------------------------------
20.         0000000000111111111122222222
21. sum_l   0123456789012345678901234567
22. ------------------------------------

Тут мне лень все суммы вычислять, но вот следующий код получается вот такой.
OPTIMIZATION = 4

Code (C):

1.     for(l3=0, sum_l=0; l3<10; l3++, sum_l-=9)
2.         for(l2=0; l2<10; l2++, sum_l-=9)
3.             for(l1=0; l1<10; l1++, sum_l++){
4.                 int sum = sum_l + 1;
5.                 count += (sum*sum+sum)/2;
6.                 if (sum>10){
7.                     sum -= 10;
8.                     count -= ((sum*sum+sum)/2)*3;
9.                     if (sum>10){
10.                         sum -= 10;
11.                         count += ((sum*sum+sum)/2)*3;
12.                     }
13.                 }
14.             }

И так мы половину решили. Тут надо подсчитать суммы квадратов результата.
OPTIMIZATION = 5

Code (C):

1.     for(sum_l=0; sum_l<=9*3; sum_l++){
2.         int             sum = sum_l + 1;
3.         unsigned int    count_l = (sum*sum+sum)/2;
4.         if (sum>10){
5.             sum -= 10;
6.             count_l -= ((sum*sum+sum)/2)*3;
7.             if (sum>10){
8.                 sum -= 10;
9.                 count_l += ((sum*sum+sum)/2)*3;
10.             }
11.         }
12.         count += count_l*count_l;
13.     }

Есть формулы и для 3д пирамид, я такую нашёл лет 25 назад, когда учился, вот только я её... не помню. Но у меня где-то записано... или выбросил ту тетрадку.
Ну ладно, пока отдохнём!!!

 

Умножать строку в твоём питухоне, это копировать Н-раз строку. Да, в ассме есть такая команда, просто некоторые используют возможности языка неправильно, и если бы их не было, то возможно это их заставила написать более простой код.

 

Так ты путаешь причину и следствие. Сам же написал, что некоторые используют возможности языка неправильно: язык-то в этом как виноват?
Имея много возможностей и используя их правильно, напишешь код проще и производительнее, чем на менее выразительном языке.
А если человек использует возможности неправильно, с переходом на менее фичастые языки он будет писать ещё хуже. Ведь если он не смог разобраться в высокоуровневой фиче, то что от него можно ожидать в языке, где нет даже её?

Для обучения - согласен, сначала правильнее разобраться в си. Затем спуститься до ассемблера, чтобы понять, что стоит за языковыми конструкциями. А после этого задерживаться в си и ассемблере смысла нет.

 

aa_dav, надо смотреть на эту таблицы и всё станет ясно.

Code (Text):

1. --------------------------------------
2.         0000000000|11111111|1122222222
3. sum_r   0123456789|01234567|8901234567
4. --------------------------------------
5.         0001122345|66777766|5432211000
6. sum     1360518655|39355393|5568150631
7. --------------------------------------
8. r1
9. 9       0000000001|23456789|a987654321
10. 8       0000000012|3456789a|9876543210
11. 7       0000000123|456789a9|8765432100
12. 6       0000001234|56789a98|7654321000
13. 5       0000012345|6789a987|6543210000
14. 4       0000123456|789a9876|5432100000
15. 3       0001234567|89a98765|4321000000
16. 2       0012345678|9a987654|3210000000
17. 1       0123456789|a9876543|2100000000
18. 0       123456789a|98765432|1000000000
19. --------------------------------------
20.         0000000000|11111111|1122222222
21. sum_l   0123456789|01234567|8901234567
22. --------------------------------------

После 10 у нас 2д пирамида вылезает за пределы 0..9 r1, и мы лишние вырезаем, там как раз три пирамидки:
sum -= 10;
count_l -= ((sum*sum+sum)/2)*3;
Короче, тут у нас получается целочисленная функция sinуса. Такой код у нас получается последовательной оптимизацией, по идеи умные оптимизаторы могут получить похожий код, но вроде таких нет, максимум они всё заранее подсчитают. А если чисел будет больше, то что, долго придётся компиляции ждать?

 

Каким бы не был язык программирования, всегда найдется какой-нибудь HoShiMin который накодит на нем лютого говна,
после чего хомяки посмотрев на это, будут думать что этот язык программирования недостаточно хорош для них

 

Именно! Поэтому никогда нельзя оценивать языки по тем, кто на них пишет. Нет плохих языков, есть плохие программисты

 

Это очень хорошо, если это будет так. А если хомяки подумают это круто, и начнут сами так делать, а потом пилить ролики, типа "прекратите задрачивать код", то тут точно лучше "хватит задрачивать ЯП, нам хватить Си и Луа".

 

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

 

плохие яп-ы есть из того простого ФАКта, что есть плохие прогеры. более того, много }{@v№@ кода написано крайне толковыми прогерами... почему так??? всё просто..

1. Время и прочих ресурсов практически всегда не хватает..
1.1. физ ограниченность железок стоит отметить особо - зачастую любое тех решение является плохим.
1.2. в своём коде нужно использовать массу чужих либ/фреймворков/апи и на всём этом очень часто взрастают проблемы совместимости / ограниченность функционала / неустойчивость /.. / лицензионные дрязги / бедность документации.
2. бизнес - модель: даже в гениальных кодах всегда можно найти изъян и самый большой изъян гениального кода - это его плохая прибыльность.
3. зачастую элементарно нет мотивации писать хороший код. для кого??? в куче случаев юзвер даже доброго слова не скажет - этому оленю нужно, чтобы прога обладала развитыми функами телепатии )
========
Так что в итоге пишутся злоЁ..чие Костыли - они плохие, но работают здесь да сейчас, а не где-то там в прекрасном далЁко

 

Так да, опять всё сводится к программистам, а не к языкам. Какой язык человеку ни дай, в описанных тобой условиях он так же будет писать не самый лучший код.
Вот Intro топит за си, но для сложения строк, для работы с файлами или для организации деревьев ему придётся изобретать свои костыли или брать готовые либы. В чём смысл, если можно просто не писать на си?
Поднимемся лишь на одну ступеньку - до плюсов - и у нас уже богатая STL, которая покрывает все потребности в структурах данных и которая оптимизирована до последнего байтика.
Поднимемся ещё выше - например, в раст, - и у нас из коробки уже есть сеть, есть async/await, есть менеджер зависимостей.
Делаем ещё шаг - попадаем в Go/шарп/джаву, которые скомпилируются и запустятся на любом железе под любой операционкой.
И на вершине пирамиды уже питон и js - для тех, кому надо просто делать дело, не отвлекаясь на всякую низкоуровневую фигню.

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

 

В общем, блаблабла. Но к питухону у меня одна претензия, он ни разу не простой, это скриптовый С++, именно С++ со всей требухой. Простой это Lua, Луна, его делали в каком-то смысле святые люди. А хренов гвидошка грешник, и его надо на костёр !

 

Ты прав, но только начни юзать питоХУ и ты полюбишь сие безобразие, особенно рекомендую функу exec - она прелесть впрочем, есть более интересный вариант, нежели питоХА, - это юлька https://julialang.org/ однако, не знаю насколько хорошо её к выньке прикрутили.

вообще-то говоря, на сишке писать легче, чем на плюсах. извратность кодов на плюсах бьёт рекорды.

если не секрет, сколько структур данных пользуешь именно ты?

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

что-то уж очень разные вещи ты в одну кучу сложил..

го - компилируемый язык, портабильность там такая себе..

шарп и портабельность - это очень большая натяжка. у жабы - да, портабельность на высоте, но по всем остальным параметрам она средь наихудших яп-ов.

ну, как сказать - питоха весьма обманчив в своей "простоте" - даже сопряжение питохи с консолью несёт в себе массу кувырканей и там не многим легче получается костылять, чем на ди иль той же сишечке + по мере надобности питоху можно вызывать из-под нативного кода, то бишь получаем ХИмеру. жаба-скрипт, так это совсем ахтунг: сю злоЁ..честь ладить.. ну, если совсем по житухе заняться нечем

--- Сообщение объединено, Nov 6, 2023 ---

такой кери в той же питохе не получить