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

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

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

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

S>>>Комбинатор Where.
S>>>MyStrings.Where(s=>RegExp.Match(s, "pattern"));
E>>Но, это же то же самое, что (match(x, "pattern")?x) не?
S>да, если ввелись функции

S>>>да, там декартово произведение убирается из двойного цикла в один явный. А он спрятал и один явный. Вот и все отличие.

E>>Ну, можно, кроме декартова произведения описать и другие переборщики.
E>>Например переборщик "нижней" части произведения: (I;(I > J?J))
S>Ты записал полное декартово произведение + фильтр
S>на C# можно сделать именно часть произведения так:
S>

S>from i in Enumerable.Range(0, 10)
S>from j in Enumerable.Range(i+1, j-i)
S>select new {i,j}
S>

E>>Или размещение по два без повторов: (I;(I!=J?J))
S>

S>from i in Enumerable.Range(0, 10)
S>from j in Enumerable.Range(0, 10)
S>where i != j
S>select new {i,j}
S>

E>>Правда не все такие записи позволяют эффективную интерпретацию на всех платформах. Но именно вот ЗАПИСАТЬ можно много какие переборщики...
S>Вышеприведенные записи предполагают эффективные переборы. Но я не имею в виду куду.

Так о чем спор то,
это что решение с фиалками ?
По сути будет тот же самый цикл там отфильтрованый по условию

where i != j

РС поступает также...

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

E>>Ну тонкости реализации -- это отдельная тема. Хорошо бы научиться тонкости оставлять транслятору.
S>Хочешь научить транслятор самостоятельно вставлять эвристики и доказывать что они что-то улучшают в общем виде?
Ну да. Или, хотя бы, в среднем угадывать.

S>Да, хорошо бы сформулировать транслятору задачу коммивояжёра в терминах полного перебора и что бы он сам допер до эвристической имитации отжига. Но это уже не задача проектирования языка/транслятора. Это замах на ИИ.
Ну это было бы совсем круто. Только я думаю, что так нереально продвинуться можно будет только RS++
Но сейчас наступает эра параллельных вычислений. И хорошего инструмента на эту тему нет. Тензоры -- это как бы прямое исследование на эту тему.
Я вот пример простой приведу. Положим надо нам просуммировать элементы массива. Понятно, что на нескольких головах, на кластере и на КУДЕ это надо делать по разному. Ну и для массивов разного размера тоже по-разному. И как именно это делать выбрать может интерпретатор.
Та же ерунда с сортировками, с поиском элемента в упорядоченном списке и т. д.
Но, если есть способы как-то относительно дёшево залудить такого рода эвристики которые ты назвал "замах на ИИ", то можно залудить. Просто язык не должен этому мешать. То есть хорошо бы декларировать что мы хотим перебрать или что и среди чего найти, например, или что и по какому критерию разделить. А как это сделать лучше бы решал транслятор языка. Так же как в прологе, например. У него, конечно же, есть процедурный аспект, но во многих задачах мы можем о нём не думать.

S>(Щас набежит ТС и заявит что всех порвет, чем опять меня насмешит).
Ну посмотрим. Он, в принципе, человек неординарный, насколько я успел заметить, что он скажет или сделает лично мне предсказать трудно.

S>Мне было интересно, вдруг мне причудилось что там без повторений.

Ну я решал "без повторений". И решение ТС, то которое с eval -- тоже без. Хотя там много условиями жонглировали, может и не без

Но я хочу обратить твоё внимание, что оказалось легко довольно записать перебор переборщиков.
То есть на С++, например, чтобы написать такой переборщик, надо писать то, что обычно называют "счётчик". А на RS можно просто попросить RS сконкатенировать отклики N переборщиков букв.
То есть, пока мы смогли БЕЗ макросов и прочего записать в виде свёртки следующий код:
!С = 'a'..'z'
!D = C
!E = C
!F = C
!G = C
C+D+E+F+G

Теперь надо понять, как записать так же код такого вида:
!С = 'a'..'z'
!D = C
!E = C
!F = C
!G = C
C+(D!=C?D)+(E!=C&&E!=D?E)+(F!=C&&F!=D&&F!=E?F)+(G!=C&&G!=D&&G!=E&&G!=F?G)

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

S>Писать генератор размещений без повторов. При его написании могут быть использованы эти функции. Но одними только ими вряд ли обойдется.
Ну покажи, как ты себе это представляешь? Типа просто цикл, которые клонирует переборщик и фильтрует его?

Ну там что-то вроде

переборщик перебратьРазмещенияБезПовторов( переборщик X, int count )
{
   Что тут пишем? 
}

C+(D!=C?D)+(E!=C && E!=D?E)

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

PC_>Так о чем спор то,
PC_>это что решение с фиалками ?
PC_>По сути будет тот же самый цикл там отфильтрованый по условию

PC_>where i != j

PC_>РС поступает также...
C# может пробежать только часть квадрата и в любой момент покинуть цикл, а RS может наложить разве что фильтр на весь квадрат.

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

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

S>>Писать генератор размещений без повторов. При его написании могут быть использованы эти функции. Но одними только ими вряд ли обойдется.
E>Ну покажи, как ты себе это представляешь? Типа просто цикл, которые клонирует переборщик и фильтрует его?

E>Ну там что-то вроде

E>переборщик перебратьРазмещенияБезПовторов( переборщик X, int count )
E>{
E>   Что тут пишем? 
E>}

E>C+(D!=C?D)+(E!=C && E!=D?E)
Убежал, отвечу позже

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


S>Сейчас они перебираются в порядке объявления. И по этому поводу должна быть четкая спецификация. Если порядок будет неопределен, то пользоваться ими не будут.

Почему? Должна быть возможность задать порядок, но в общем случае порядок итерации должен выбирать транслятор, конечно же.
Даже в С операции компилятор переупорядочивает. Зачем ограничивать транслятор RS искусственными ограничениями?

Ладно, пропустим этот момент.
Вообщем что я уже закодил

x='a'..'z' //генерит строку по алфавиту
x.rnd      //встроеный метод, возвращает случайный элемент из массива. В игрушках точно пригодится

щас еще чуть чуть и генерация пассворда произвольной длины будет работать ...

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

S>Тебя никто не просил разжовывать мне полиморфизм

А зря. Он это слово, похоже, употребляет совсем в другом значении, чем ты, например

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

Пришла вчера интересная, на мой взгляд, идея.
Суть в том что вот есть алгоритм генератора паролей, который вы рассматриваете.
И ставится новое условие, что символы не должни повторяться.
Так вот новое условие, это по сути аспект над генератором.

В чем суть — решение на шарпе или Ф Шарпе, подозреваю и в Немерле, разбивается о скалистые берега реальности при внесении
этого малого изменения в задачу лишь потому, что сам по себе аспект как бы находится в другом слое.
Он находится над кодом и имеет к нему отношение поскольку постольку. А обычный язык всегда пытается как бы "смержить"
эти два слоя, потому что он довольно плотненько лежит на самой архитектуре процессора.

На самом деле аспект это вовсе не экзотическое понятние для экзотических задач.

В шахматах аспектом будут правила игры, которые накладываются на некоторый генератор ходов
В базах данных аспекты это констреинты на данных
В коде аспект это обработка ошибок, которая как бы тоже лежит паралельно плоскости кода
И евал тоже может быть эдаким аспектом. Он тоже как бы над кодом

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

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

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

S>Не, ты попал. Теперь у тебя есть комитет, почти как у Бьёрна Пока не согласуешь — не выпустишь стандарт.
S>Шутка. Но не без доли.

Дык коллективный ум лучше индивидуального. Но только если коллективный не является усреднённым в энной степени

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

PC_>та собственно уже почти оценено. На sql модератор хотел квадрат от прямоугольника пронаследовать и тогда я понял
PC_>идеальное христоматийное применение. Например фигура могла бы мигрировать от класса Квадрат к классу Прямоугольник
PC_>на основе свойства "все стороны равны". А ООП эту простейшую проблему решает реально криво, хоть и тоже пытается
PC_>взять ее за христоматийный пример ООП.

IMHO, наследовать в любом порядке ромб, квадрат и прямоугольник неправильно. От задач, конечно же зависит, но обычно глупо. Так же глупо, как выводить треугольник из угла, например.

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

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

PC_>>та собственно уже почти оценено. На sql модератор хотел квадрат от прямоугольника пронаследовать и тогда я понял
PC_>>идеальное христоматийное применение. Например фигура могла бы мигрировать от класса Квадрат к классу Прямоугольник
PC_>>на основе свойства "все стороны равны". А ООП эту простейшую проблему решает реально криво, хоть и тоже пытается
PC_>>взять ее за христоматийный пример ООП.

E>IMHO, наследовать в любом порядке ромб, квадрат и прямоугольник неправильно. От задач, конечно же зависит, но обычно глупо. Так же глупо, как выводить треугольник из угла, например.

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

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

PC_>Тоесть вложены циклы есть, можно их строить любой причудливой формы.
PC_>Правда конструкция не ахти.


А зачем они вообще нужны?
Я постараюсь до конца года написать как я это всё понимаю.
IMHO, это всё с [] вообще излишнее.

Если кратко совсем, то сама по себе запись вида x.a + x.b -- это таки уже итерация и по a и по b.
То есть это тоже переборщик, сумм пар значений их x

Но переборщик -- это просто описание потенциальной итерации какого-то множества значений. То есть это проста такая сокращённая запись большого числа похожих выражений.

Теперь мы можем с этим переборщиком сделать что-то итеративное. Как-то перебрать какие-то выражения из этого семейства.
Ну что мы можем сделать?
1) Протабулировать (ну типа солить в массив или распечатать в виде таблицы)
2) Свернуть, например через + или через * или ещё через какую-то операцию
3) Что-нибудь поискать
4) Найти какое-то подмножество итерируемых сущностей.
5) Задать какой-то порядок перебора

Ok.

Короче говоря,
есть еще какой-то хитрый баг с Евал.
Всетаки перегонять переменные обьявленные в одном документе, другому документу оказалось не так то и просто.

Но!
Вот код

x='a'..'z'
i<4?a+='+x.rnd'
^a

Который четко решает задачу генерации пароля по случайному алгоритму и по заданому алфавиту указаной длины.
Это ульрапонятное и ультракороткое решение в 27 байт

В принципе уже мона думать о регекспах, потом сходить попинать Немерлистов и продолжить работу
(напомню что решение выше у короля метапрограммирования заняло чтото около 100 байт )

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

S>C# может пробежать только часть квадрата и в любой момент покинуть цикл, а RS может наложить разве что фильтр на весь квадрат.

Нет. Это не так. Можно написать переборщик, который будет, при прямой интерпретации, аналогичен такому коду:

for( int i = 1; i <= 10; i++ ) {
    if( i < 3 ) {
        continue;
    }
    for( int j = 1; j <= 10l j++ ) {
        if( j > 7 ) {
            continue;
        }
        итерируемое выражение....
    }
}

Все, отладил. Через 5 мин можно будет забрать на СВН.

Код рабочий!

x='a'..'z' //генерим алфавит от a до z, это наш массив строк
i<8?a+='+x.rnd' //теперь, пока переборщик меньше 8, прибавляем к строке строку. В итоге для восьми получится +х.rnd+x.rnd+x.rnd ... Первый плюс унарный оператор, он для массива не определен, поэтому просто возвращается "х" (+х = х)
'passwrod:' + ^a // а тут делаем евал этой строки и возвращаем строку в формате "passwrod:oxsdrehl"  :up:

Так, и еще одно решение которое просто перебирает строки заданой длины по алфавиту.
Тоже уже рабочее и отлаженое решение

!x='a'..'f'
i<3?a+='+x'+i
^('s,=' + a)
s

34 байта

выдает это

aa,ab,ac,ad,ae,af,ba,bb,bc,bd,be,bf,ca,cb,cc,cd,ce,cf,da,db,dc,dd,de,df,ea,eb,ec,ed,ee,ef,fa,fb,fc,fd,fe,ff

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

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

PC_>Ну ты даешь. Конечно это мегапонятно.

Эк вы его. "Ультра" упало до "мега", скоро глядишь просто "понятно" станет , а потом и до "непонятно" дойдем.

эх, стока спеси вчера было, даже ВикиЛикс нам бы позавидовал в разоблачениях неработающего кода

Я жду (но не надеюсь, потому как ты неоднократно продемонстрировал что ты балабол) что ты наконец-то предоставишь рабочее решение выборки 5и случайных букв и решение по всем размещениям букв, так что бы одно из другого можно было получить за 30 сек.

а сегодня чтото тишинааа ....