Здравствуйте, Erop, Вы писали:

E>>>Я так тебя понял, что ты просишь описать переборщик каких-то частичных сумм в двумерном массиве. Только я не понял, каких именно...
E>>>Если список сумм по первой/второй координате, то это вообще не проблема, однако. Что-то типа

E>>>x.I.J\J\+

E>>>Но ты хочешь какую-то другую сумму. Только я не понял, зачем ты хочешь её от ТС. Сам, что ли не можешь записать?

AV>>Вот условие Re[60]: Ультракороткий язык программирования RS

Автор: ambel-vlad
Дата: 24.12.10

AV>>Вот решение — Re[78]: Ультракороткий язык программирования RS

Автор: ambel-vlad
Дата: 27.12.10

E>Ты можешь понятно объяснить, что ты хочешь вот в этой фразе:

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

Как я уже писал, что наличие кортежа в условии задачи не делает невозможным ее решение на RS. И массив кортежей может спокойно заменить на двумерный массив. Каждая строка которого представляет собой элемент второго массива (кортеж кортежей). В строке первый и второй элементы предствляют первый внутренний кортеж, третий и четвертый — второй внутренний кортеж и т.д. То есть вот это [((2,5)), ((1,2), (1,7), (10, 10)), ((1,9))] превращается в
[2 5 -1 -1 -1 -1
1 2 1 7 10 10
1 9 -1 -1 -1 -1]
Это один из вариантов замены.

E>Ну нет в RS кортежей. Если вдруг бы были, то код бы был какой-то такой.
E>x -- первый массив (массив значений)
E>y -- второй массив (массив индексов к ним)

E>Для начала выразим концепцию "сумма отрезка x с позиции p по позицию q"
E>В зависимости от ума интерпретатора это будет либо (x.(I>p&I<q?I))\I\+

E>Либо (x.(p..q))\+ Я буду вторым вариантом пользоваться, так как он компактнее.

E>Дальше, если z -- это пара (p, q), то наше выражение будет таким:
E>(x.(z.1..z.2))\+

E>Если у нас в языке таки есть кортежи, то у нас бывает строчка таких пар. Пусть w обозначает такую строчку.
E>Тогда сумма для всей строчки пар будет выглядеть так:
E>(x.(w.I.1..w.I.2))\+

E>Осталось добавить итерацию по всем строкам кортежа. Сейчас в RS это сделать неудобно. Но я давно уже предлагаю придумать способ ссылаться на конкретные куски выражения. На конкретные позиции переборщика, на переборщики и т. д.

E>Хороший синтаксис для этой штуки пока не нашёлся, в том числе и потому, что нет до конца понятной семантики.
E>Но, если предположить, например, что после любого куска в скобках можно написать : и потом в скобках какое-то выражение, ЗНАЧЕНИЕ которого позволит сослаться на тот кусок, например заключив его в (:тут ID

E>То можно будет написать так:
E>(x.(y.J.I.1..y.J.I.2)::'k')\(:'k' I\+

E>Это, собственно, всё...

Да, все. Но есть три маленьких пункта, которые на данный момент портят все картину.
1. Как ты верно заметил, это запись решения с использованием мифического РС, а не реального. И я совсем не уверен, что этот или очень похожий код когда-либо заработает на РС. А я как раз просил решение на РС. Опять же, ты забыл еще кучку строчек для инициализации данных. А учитывая как сейчас обстоят дела с РС, то это будет совсем не одна-две строки.

2. Ты считаешь этот write-only код очень понятным? По сравнению с этой строкой тот же Перл можно считать вершиной понятности кода. А ТС так упирается в понятность кода. Я ради интереса дал посмотреть питоновский код и твое решение коллеге. Он не знает ни Питона на РС. В результате на питоноский код он потратил минуту-полторы, задал один вопрос и сказал, что ему все понятно. Твое решение у него вызвало тоже одну лишь фразу — "что за хреновина?"

3. ТС еще упирается на гибкость кода. Что мне делать, если мне вместно "+" понадобится что-то другое? Ладно если это другое будет бинарным, а если надо будет за один раз использовать три или более значения? Питоноское решение достаточно подвергнуть маленькому изменению:
а) в функцию process передавать третим параметров функцию для обработки (def process(data, control, fun) )
б) вместо вызова заранее предопределенной функции использовать третий параметр ( worker(worker_args) )

В результате я смогу затребованные данные обсчитавыть как заблагорассудится. После этих изменений функция в моем коде, приведенном ранее будет вообще просто вызываться — process(data, control, worker) ну или если лень заводить функцию, то так process(data, control, lambda x: reduce(lambda a, b: a+b, x))

Все хорошо, но вот где решение задачки от автора языка.

Здравствуйте, samius, Вы писали:

S>У него в алгоритме фильтрации нет. Она навесная, а алгоритм универсальный. В РС нет такой возможности комбинировать алгоритмы.
Почему? Те же фильтры, только в профиль.

S>>>Есть еще один ответ на твой вопрос. Все пароли фильтровать можно эффективнее. Но это все равно хуже, чем не получать ненужные.
E>>Это я тоже не понимаю.
S>Что именно из этого?
Смысл фразы ускользает. Попробуй выразить ту же мысль как-то ещё.

E>>Вот научиться писать что-то вроде "перебирай пароли о сих до сих" -- это прикольно. Это тоже сейчас в RS не особо хорошо получается. И тоже, опять, хочется сказать, что-то типа того, что столько-то пропускаем, а потом столько-то крутим. При этом это "сколько" определяется одним переборщиком, а пропускают в другом, перебирающим, как бы параллельно.
S>Ты о Paging?

Ну это какой-то простой частный и не очень нужный случай. По идее, если научиться накладывать такие параллельные ограничения на итерацию множеств, то постраничная печать множеств должна получаться одной левой пяткой...

Здравствуйте, samius, Вы писали:

S>Я предлагал написать тебе такое на РС, но ты видимо о чем-то другом, раз про объекты и конструкторы
Дык речь шла о том, что это якобы трудно будет на С++ написать


E>>Давай я напишу, но оставлю там две ошибки, а ты отладишь потом?
S>Напиши на РС

Ну там сейчас нет нужных конструкций, чтобы это УДОБНО написать.

По дурацки если писать, то
!X = <выражение для переборщика всех нужных строк>
X.1000000

Но занафиг это надо --

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, samius, Вы писали:

S>>У него в алгоритме фильтрации нет. Она навесная, а алгоритм универсальный. В РС нет такой возможности комбинировать алгоритмы.
E>Почему? Те же фильтры, только в профиль.
Почему в РС нет возможности комбинировать? За этим ответом не ко мне.

S>>>>Есть еще один ответ на твой вопрос. Все пароли фильтровать можно эффективнее. Но это все равно хуже, чем не получать ненужные.
E>>>Это я тоже не понимаю.
S>>Что именно из этого?
E>Смысл фразы ускользает. Попробуй выразить ту же мысль как-то ещё.
Хорошо. Когда есть полный списко всех перестановок, то фильтровать его можно гораздо эффективнее за счет того, что наткнувшись на строку с дубликатом можно точно сказать, сколько строк можно заодно выкинуть не просматривая сами строки. Это так сказать проблемно-ориентированный частный фильтр. Если фильтровать строки по мене получения — то этой информацией в фильтре воспользоваться не удастся просто потому что фильтр не будет знать, что строки идут в некотором порядке.

E>>>Вот научиться писать что-то вроде "перебирай пароли о сих до сих" -- это прикольно. Это тоже сейчас в RS не особо хорошо получается. И тоже, опять, хочется сказать, что-то типа того, что столько-то пропускаем, а потом столько-то крутим. При этом это "сколько" определяется одним переборщиком, а пропускают в другом, перебирающим, как бы параллельно.
S>>Ты о Paging?

E>Ну это какой-то простой частный и не очень нужный случай. По идее, если научиться накладывать такие параллельные ограничения на итерацию множеств, то постраничная печать множеств должна получаться одной левой пяткой...
Не согласен полностью. То что он простой — ладно. То что он частный — это не так. paging нужен чуть ли не везде где информация представляется человеку и ее много.
А еще, легкий paging доступен только для таких предсказуемых последовательностей как размещения, где в каждой ветке (n,k) точно известно количество элементов. И любые две ветки (n,k) имеют один и тот же размер. Очевидно, что если множество не бьется так красиво на равные доли, то тот же алгоритм легкого входа использовать не получится. Т.е. итерации по множествам общего характера не может быть выполнена столь эффективно, и в общем случае придется заглядывать в каждую подветку, как это делается сейчас при пропуске последовательности результатов в F#/C#/Nemerle.
Пример — выбрать [r1..r2] теги из HTML.

P.S. мне не нравится некоторый момент в твоем последнем утвреждении про левую пятку. Форма другая, но смысл напоминает шапкозакидательские настроения ТС-а.

Здравствуйте, samius, Вы писали:

S>Это набор операций, с помощью которых можно решать разные задачи. В том числе можно и расширять диапаон перебора, в отличии от решения с только лишь заданием фильтра, как ты предлагаешь. Неоднократно в топике мелькали задачи, где взять диапазон счетчика из контекста просто неоткуда.
Ну, как бы, если найти, как или когда можно эффективно, находить ответы на запросы вида "перебрать все состояния переборщика 1, которые не соответствуют никаким состояниям переборщика 2", то всё сразу станет хорошо.
Но мне так кажется, что оптимизировать множества заданные предикатами, проще и прямее, чем разгребать хитрые операции над перебощиками.

Вот попробуй написать, например, переборщик всех строчек где ЕСТЬ повторы...

E>>Кроме того, такие простые модификации не сложно и из формул вытащить...
S>А со сложными как быть? Отложить до РС-4?

Ну для совсем сложных всегда есть вариант "тупо фильтровать в конце". Но если у тебя размерность задачи открытая, то у тебя и фильтр в предикате, скорее всего имеет открытую какую-то структуру, так что отсечение по измерениям всё равно будет доступно.

Просто кроме совсем тупо в лоб переборных задач, которые обычно простые очень и их не много, есть очень много задач, где перебор ведётся по очень сложным множествам. И возможность просто записать сложное для таких задач намного важнее, IMHO.

Здравствуйте, ambel-vlad, Вы писали:


E>>То можно будет написать так:
E>>(x.(y.J.I.1..y.J.I.2)'k'))\(:'k') I\+

E>>Это, собственно, всё...

AV>Да, все. Но есть три маленьких пункта, которые на данный момент портят все картину.
AV>1. Как ты верно заметил, это запись решения с использованием мифического РС, а не реального. И я совсем не уверен, что этот или очень похожий код когда-либо заработает на РС. А я как раз просил решение на РС. Опять же, ты забыл еще кучку строчек для инициализации данных. А учитывая как сейчас обстоят дела с РС, то это будет совсем не одна-две строки.

Про "мифический" и "реальный" RS я не понял мысли. Ты хочешь сказать, что имеющийся интерпретатор так не умеет? Ну и что? Это же просто прототипирование. Тут нет ничего такого уж сложного для реализации, кстати.
Единственная проблема -- нет хорошей и интуитивно понятной нотации для того, чтобы записать утверждение "по этому итератору сверни, а по тому не надо". Это вот и есть настоящая проблема.
Ещё, наверное, чтобы не было конфликта с интуицией программистов, надо вернуться к квадратным скобкам в массивах.
Хотя, если честно, вторая обычно лишняя

AV>2. Ты считаешь этот write-only код очень понятным?
Я считаю, что плохо понятно место "свернуть по всему, кроме J"
AV>По сравнению с этой строкой тот же Перл можно считать вершиной понятности кода. А ТС так упирается в понятность кода. Я ради интереса дал посмотреть питоновский код и твое решение коллеге. Он не знает ни Питона на РС. В результате на питоноский код он потратил минуту-полторы, задал один вопрос и сказал, что ему все понятно. Твое решение у него вызвало тоже одну лишь фразу — "что за хреновина?"
Ну просто он знает, что-то похожее на питон, и не знает ничего похожего на RS. Это, как раз, пофиг.

AV>3. ТС еще упирается на гибкость кода. Что мне делать, если мне вместно "+" понадобится что-то другое? Ладно если это другое будет бинарным, а если надо будет за один раз использовать три или более значения?
Не совсем понимаю, что такое свёртка, для триарного аператора? Вот у меня есть массив чисел (1, 4, 6, 2, 6, 7) и тернарная операция foo(_1, _2, _3)
И как вычислим свёртку? Что имеется в виду?

AV>Питоноское решение достаточно подвергнуть маленькому изменению:
AV>а) в функцию process передавать третим параметров функцию для обработки (def process(data, control, fun) )
AV>б) вместо вызова заранее предопределенной функции использовать третий параметр ( worker(worker_args) )
Это я не понял. Но никакой принципиальной разницы в RS нет. Кроме того, что нет самих функций. Если ты можешь записать какое-то выражение, то его можно и в RS записать. Так что я тут чего-то не понял.
А главное, чего я не понимаю, так это то, чего ты хочешь доказать или показать?
Что RS недоделан? Так это и так известно. И то, что нет хорошей нотации для того, чтобы ссылаться на переборщики, позиции переборщиков и для указания в операторе свёртки по чём мы сворачиваем, а по чём нет -- так это известная проблема. Может что посоветуешь?
AV>В результате я смогу затребованные данные обсчитавыть как заблагорассудится. После этих изменений функция в моем коде, приведенном ранее будет вообще просто вызываться — process(data, control, worker) ну или если лень заводить функцию, то так process(data, control, lambda x: reduce(lambda a, b: a+b, x))

Что именно тут просто?

AV>Все хорошо, но вот где решение задачки от автора языка.
А это тебе зачем? Он же тебе сказал, что задачка не интересная и вообще простая и глупая. Я согласен с ним...
Зачем ты гонишь негатив килобайтами я не понимаю.
Опять же, не интересно тебе -- ну отпишись от темы и не страдай...

Здравствуйте, samius, Вы писали:

S>Хорошо. Когда есть полный списко всех перестановок, то фильтровать его можно гораздо эффективнее за счет того, что наткнувшись на строку с дубликатом можно точно сказать, сколько строк можно заодно выкинуть не просматривая сами строки. Это так сказать проблемно-ориентированный частный фильтр. Если фильтровать строки по мене получения — то этой информацией в фильтре воспользоваться не удастся просто потому что фильтр не будет знать, что строки идут в некотором порядке.

Можно выбрасывать строки целыми подмножествами перебираемого множества...
Порядок для этого совсем не нужен.

S>Не согласен полностью. То что он простой — ладно. То что он частный — это не так. paging нужен чуть ли не везде где информация представляется человеку и ее много.
Ну есть такая мега-утилита more называется...
В общем с т. з. разработки языка описания перебираемых множеств это мелкая частная проблема.

S>P.S. мне не нравится некоторый момент в твоем последнем утвреждении про левую пятку. Форма другая, но смысл напоминает шапкозакидательские настроения ТС-а.

Да нет. Ну правда задачка должна быть не сложной.
Сложную задачку я сформулировал.

Мы хотим перебрать строки, отвечающие некоторому регэкспу и при этом отвечающие требованию баланса скобок.
Положим, что переборщик по регэкспу у нас уже есть. Что делаем дальше?

Здравствуйте, samius, Вы писали:

E>>Я так думаю, что 30^5 от 30*29*28*27*26 отличается процентов на 20...
S>На 42
Не верю.

Здравствуйте, Mamut, Вы писали:

M>>>Вы явно клоны.
M>Вы явно клоны.

Заело? Ты в объективную реальность веришь?

Здравствуйте, samius, Вы писали:

S>Да, вот еще что. Алфавит может быть задан не последовательно, и не только из одних букв.
S>['1'..'4'] + ['z'..'a'] + '-#%&*$@!~_+'
S>Так что с номером будет попроще.

А какая разница какую строчку хранить?

Здравствуйте, samius, Вы писали:

AV>>Да?
S>Это на той версии интерпретатора, с которой начинали. Уже по зубам.

Главное, что вопрос просто конкретно по сути темы...

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, samius, Вы писали:

S>>Это набор операций, с помощью которых можно решать разные задачи. В том числе можно и расширять диапаон перебора, в отличии от решения с только лишь заданием фильтра, как ты предлагаешь. Неоднократно в топике мелькали задачи, где взять диапазон счетчика из контекста просто неоткуда.
E>Ну, как бы, если найти, как или когда можно эффективно, находить ответы на запросы вида "перебрать все состояния переборщика 1, которые не соответствуют никаким состояниям переборщика 2", то всё сразу станет хорошо.
E>Но мне так кажется, что оптимизировать множества заданные предикатами, проще и прямее, чем разгребать хитрые операции над перебощиками.
Мне кажется ровно наоборот. Явные комбинации генераторов не нуждаются в оптимизации. Тем более что они не исключают оперирование предикатами.

E>Вот попробуй написать, например, переборщик всех строчек где ЕСТЬ повторы...
Не проблема. Могу написать так, что для конечного алфавита любая конечная строка может быть достигнута за конечное время. И это будет эффективно, да и коду не сильно больше чем в размещениях. Просто я буду не фильтровать алфавит, а расширять его при переходе к вложенным генераторам. Если попросишь таки показать — займет какое-то время. Мгновенно не напишу, но ничего невозможного не вижу.

В свою очередь прикинь (писать не надо) как ты эффективно сделаешь переборщик (IsPrime(I)?I) где IsPrime — пользовательская функция
В свою очередь я могу написать более менее эффективный генератор простых чисел и использовать его при необходимости.
В то же время ничего не мешает использовать фильтрацию с оптимизацией:

Enumerable.Range(0, oo)      /// генератор чисел 0..оо где бесконечность условная
    .Select(x => x*2 + 1)    /// отображаем числа в нечетные
    .Where(x => IsPrime(x)); /// выбираем только простые из них.

Все стандартное для дотнета кроме IsPrime. Range можно переписать и для BigInt-ов, если что.
И эта штука на фильтрации работает как минимум в 2 раза быстрее чем (IsPrime(I)?I).

Хочешь я эту штуку продолжу до генерации пар простых с разницей в 2 — (3,5),(5,7),(11,13),...
либо только тех пар простых, сумма цифр которы четна?

А генератор праймов может быть куда эффективнее чем даже забег по нечетным с проверкой IsPrime.

S>>А со сложными как быть? Отложить до РС-4?

E>Ну для совсем сложных всегда есть вариант "тупо фильтровать в конце". Но если у тебя размерность задачи открытая, то у тебя и фильтр в предикате, скорее всего имеет открытую какую-то структуру, так что отсечение по измерениям всё равно будет доступно.

E>Просто кроме совсем тупо в лоб переборных задач, которые обычно простые очень и их не много, есть очень много задач, где перебор ведётся по очень сложным множествам. И возможность просто записать сложное для таких задач намного важнее, IMHO.
Комбинация генераторов не исключает фильтрацию, а значит ту оптимизацию о которой ты говоришь, можно применить и там. В то время как одной только фильтрацией не догнать явно заданные генерируемые последовательности.

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, samius, Вы писали:

E>Можно выбрасывать строки целыми подмножествами перебираемого множества...
E>Порядок для этого совсем не нужен.
Я говорил именно об эффективной спец-фильтрации для конкретной задачи. Без порядка она невозможна, следовательно нужно будет анализировать каждую строку.

S>>Не согласен полностью. То что он простой — ладно. То что он частный — это не так. paging нужен чуть ли не везде где информация представляется человеку и ее много.
E>Ну есть такая мега-утилита more называется...
?
E>В общем с т. з. разработки языка описания перебираемых множеств это мелкая частная проблема.
Если так ставить вопрос, то да...

E>Сложную задачку я сформулировал.

E>Мы хотим перебрать строки, отвечающие некоторому регэкспу и при этом отвечающие требованию баланса скобок.
E>Положим, что переборщик по регэкспу у нас уже есть. Что делаем дальше?
Что подразумевается под балансом скобок? Совпадение открытых и закрытых и их порядка?

Вручную я бы написал эффективный перебор таких строк. А писать оптимизатор, который бы сделал эффективно в частности и эту задачу — побоялся бы.

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, samius, Вы писали:

E>>>Я так думаю, что 30^5 от 30*29*28*27*26 отличается процентов на 20...
S>>На 42
E>Не верю.
а ему?

Здравствуйте, samius, Вы писали:

S>Мне кажется ровно наоборот. Явные комбинации генераторов не нуждаются в оптимизации. Тем более что они не исключают оперирование предикатами.
Ну как будет устроена программа, которая перебирает строки, соответсвующие регэкспу + требование баланса скобок?


S>Не проблема. Могу написать так, что для конечного алфавита любая конечная строка может быть достигнута за конечное время. И это будет эффективно, да и коду не сильно больше чем в размещениях. Просто я буду не фильтровать алфавит, а расширять его при переходе к вложенным генераторам. Если попросишь таки показать — займет какое-то время. Мгновенно не напишу, но ничего невозможного не вижу.
Про расширять алфавит не понял совсем. Очевидно что в таких строчках на первом месте может быть любая буква. Куда там дальше расширять-то?

S>В свою очередь прикинь (писать не надо) как ты эффективно сделаешь переборщик (IsPrime(I)?I) где IsPrime — пользовательская функция
Ну если это просто функция от просто позиции переборщика, то это никак и никогда не оптимизируешь ни на каком языке. Если же речь идёт о каких-то комбинациях, ну, например, мы хотим написать переборщик возрастающих последовательностей простых чисел, то очень даже напишу...

S>

S>Enumerable.Range(0, oo)      /// генератор чисел 0..оо где бесконечность условная
S>    .Select(x => x*2 + 1)    /// отображаем числа в нечетные
S>    .Where(x => IsPrime(x)); /// выбираем только простые из них.
S>

S>Все стандартное для дотнета кроме IsPrime. Range можно переписать и для BigInt-ов, если что.
S>И эта штука на фильтрации работает как минимум в 2 раза быстрее чем (IsPrime(I)?I).

Ну это первый шаг решета Эратосфена. Никто не мешает так же профильтровать и на RS: (i%2==0&&i%3==0&&i%5==0&&i%%7==0&&IsPrime(I)?I)

S>Хочешь я эту штуку продолжу до генерации пар простых с разницей в 2 — (3,5),(5,7),(11,13),...
S>либо только тех пар простых, сумма цифр которы четна?

Так на RS это тоже легко сделать, и при том оно наверное и оптимизироваться будет хорошо...


E>>Ну для совсем сложных всегда есть вариант "тупо фильтровать в конце". Но если у тебя размерность задачи открытая, то у тебя и фильтр в предикате, скорее всего имеет открытую какую-то структуру, так что отсечение по измерениям всё равно будет доступно.

E>>Просто кроме совсем тупо в лоб переборных задач, которые обычно простые очень и их не много, есть очень много задач, где перебор ведётся по очень сложным множествам. И возможность просто записать сложное для таких задач намного важнее, IMHO.
S>Комбинация генераторов не исключает фильтрацию, а значит ту оптимизацию о которой ты говоришь, можно применить и там. В то время как одной только фильтрацией не догнать явно заданные генерируемые последовательности.

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

Здравствуйте, Erop, Вы писали:

E>>>То можно будет написать так:
E>>>(x.(y.J.I.1..y.J.I.2)'k'))\(:'k') I\+

E>>>Это, собственно, всё...

AV>>Да, все. Но есть три маленьких пункта, которые на данный момент портят все картину.
AV>>1. Как ты верно заметил, это запись решения с использованием мифического РС, а не реального. И я совсем не уверен, что этот или очень похожий код когда-либо заработает на РС. А я как раз просил решение на РС. Опять же, ты забыл еще кучку строчек для инициализации данных. А учитывая как сейчас обстоят дела с РС, то это будет совсем не одна-две строки.

E>Про "мифический" и "реальный" RS я не понял мысли. Ты хочешь сказать, что имеющийся интерпретатор так не умеет? Ну и что? Это же просто прототипирование. Тут нет ничего такого уж сложного для реализации, кстати.

Вот только автор заявляет несколько большее нежели прототипирование. А насчет "нет ничего сложного для реализации", то быть может, быть может. В теории. А вот в реальности РС, это совсем не факт.

AV>>По сравнению с этой строкой тот же Перл можно считать вершиной понятности кода. А ТС так упирается в понятность кода. Я ради интереса дал посмотреть питоновский код и твое решение коллеге. Он не знает ни Питона на РС. В результате на питоноский код он потратил минуту-полторы, задал один вопрос и сказал, что ему все понятно. Твое решение у него вызвало тоже одну лишь фразу — "что за хреновина?"
E>Ну просто он знает, что-то похожее на питон, и не знает ничего похожего на RS. Это, как раз, пофиг.

Он знает плюсы. А насчет пофиг, то как раз не пофиг. Если только это не язык заточенный под решение одной задачи. А в топике автор утверждал, что это язык общего назначения. Так что если он будет так же понятен и остальным (а пока что оно так и есть), то он будет brainfuck2. Потому что приведенные решение (как и многие другие на этом языке) — write-only. И через месяц вспомнить что вон та вот загогулина делает будет не совсем тривиальная задача.

AV>>3. ТС еще упирается на гибкость кода. Что мне делать, если мне вместно "+" понадобится что-то другое? Ладно если это другое будет бинарным, а если надо будет за один раз использовать три или более значения?
E>Не совсем понимаю, что такое свёртка, для триарного аператора? Вот у меня есть массив чисел (1, 4, 6, 2, 6, 7) и тернарная операция foo(_1, _2, _3)
E>И как вычислим свёртку? Что имеется в виду?

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

AV>>Питоноское решение достаточно подвергнуть маленькому изменению:
AV>>а) в функцию process передавать третим параметров функцию для обработки (def process(data, control, fun) )
AV>>б) вместо вызова заранее предопределенной функции использовать третий параметр ( worker(worker_args) )
E>Это я не понял. Но никакой принципиальной разницы в RS нет. Кроме того, что нет самих функций. Если ты можешь записать какое-то выражение, то его можно и в RS записать. Так что я тут чего-то не понял.

Есть одна принципиальная разница. Автор. И это не переход на личности. Но подход, который был продемонстрирован до сих пор не дает никаких оснований считать, что из этого языка выйдет что-то. Готов поставить сотню баксов, что в язык будет долго и мучительно добавляться очередная "фича" и достаточно быстро эти фичи удавят друг друга.

AV>>В результате я смогу затребованные данные обсчитавыть как заблагорассудится. После этих изменений функция в моем коде, приведенном ранее будет вообще просто вызываться — process(data, control, worker) ну или если лень заводить функцию, то так process(data, control, lambda x: reduce(lambda a, b: a+b, x))

E>Что именно тут просто?

А что, есть что-то сложное? Так как каждая функция обрабатывает один набор данных независимо от другого набора, то нам достаточно написать эту функию один раз, а функция process вполне может распараллелить всю обработку. Да, все это можно реализовать в RS. Теоретически.

AV>>Все хорошо, но вот где решение задачки от автора языка.
E>А это тебе зачем? Он же тебе сказал, что задачка не интересная и вообще простая и глупая. Я согласен с ним...

Если она такая простая, то пару десятков секунд можно и потратить.

Здравствуйте, samius, Вы писали:

S>Мне кажется ровно наоборот. Явные комбинации генераторов не нуждаются в оптимизации.

Кстати, почему? По идее, на разных архитектурах надо по разному перебирать одни и те же множества...

У генераторов, если я правильно понимаю о чём речь, есть недостаток -- в них намертво вбит порядок итерации множества. А ведь это не обязательно надо...

Здравствуйте, Erop, Вы писали:

E>Здравствуйте, samius, Вы писали:

S>>Да, вот еще что. Алфавит может быть задан не последовательно, и не только из одних букв.
S>>['1'..'4'] + ['z'..'a'] + '-#%&*$@!~_+'
S>>Так что с номером будет попроще.

E>А какая разница какую строчку хранить?
наверно без разницы. А вот находить нужную комбинацию состояний итераторов будет сложнее. Особенно после изменения алфавита.
Ты решительно отвергаешь необходимость paging-а для такой задачи?

Здравствуйте, samius, Вы писали:

S>Я не пытаюсь продвинуть себя в качестве идеолога. Лишь предложил альтернативный путь развития, который потенциально ближе к использованию и исследованиям чем РС, потому что встраиваем и комбинируем с возможностями платформы. Только вот короткого синтаксиса на первых порах не предвидится.

Мне кажется, что с библиотекой будут трудности. Трудности будут вызваны тем, что в RS хитро перепутана декларация кода и итерации. Не понятно, как это передать в библиотеку. Тут хочется иметь транслятор, на самом деле.

Ну просто пример.

Вот у нас есть матрица M и вектор V мы записываем их произведение:

M.I.J*V.J\J\+

Что и как тут сделает библиотека?

Здравствуйте, samius, Вы писали:


S>Что подразумевается под балансом скобок? Совпадение открытых и закрытых и их порядка?

Ну скобки в нужном порядке и парами
Ну типа ()()([]) -- баланс есть
А ()()([)] -- баланса нет.

S>Вручную я бы написал эффективный перебор таких строк. А писать оптимизатор, который бы сделал эффективно в частности и эту задачу — побоялся бы.
Ну, на самом деле, всё сходится к тому, что надо как-то ещё автоматы поддержать. На самом деле описание многомерных множеств им автоматы, которые эти множества описывают -- это что-то очень близкое, вообще-то.