Кстате с рандомными строками у меня код будет проабгрейжин вот так

!x='a'..'z'
!m=0..5
y+='+x'+m.R
^y

А не будет полностью переписан как в Немерле.
Правда здесь есть один ньюанс. У меня нет рандом библиотеки, вотето R я подразумеваю целое число которое при каждом обращении разное

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

PC_>Кстате с рандомными строками у меня код будет проабгрейжин вот так

PC_>

PC_>!x='a'..'z'
PC_>!m=0..5
PC_>y+='+x'+m.R
PC_>^y
PC_>

Попробую разгадать этот ультрапонятный ребус
первые две строчки — переборщики.
третья: к y прибавляется строка '+x' а к ней видимо прибавляется случайное число.
Непонятно, когда этот процесс остановится, результатом будет что-то вроде
'+x3+x0+x4+x...'

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

S>

S>[|for i in 1..10 -> i*i|]
S>

!m=1..10
x.m=i*i

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

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

PC_>>Кстате с рандомными строками у меня код будет проабгрейжин вот так

PC_>>

PC_>>!x='a'..'z'
PC_>>!m=0..5
PC_>>y+='+x'+m.R
PC_>>^y
PC_>>

S>Попробую разгадать этот ультрапонятный ребус
S>первые две строчки — переборщики.
S>третья: к y прибавляется строка '+x' а к ней видимо прибавляется случайное число.
S>Непонятно, когда этот процесс остановится, результатом будет что-то вроде
S>'+x3+x0+x4+x...'

ребус остановится на 5, смотрите переборщик.
а для кода '+x3+x0+x4+x...' вызывается евал.
Кстате я решил что переборщик х с числовым индексом это будет тотже переборщик.
Должно быть очень удобно в комбинаторике.

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

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

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

S>>

S>>[|for i in 1..10 -> i*i|]
S>>

PC_>

PC_>!m=1..10
PC_>x.m=i*i
PC_>

фыгню спорол

конечно же так
!m=1..10
x.m=m*m

Если принять во внимание предложения по новому синтаксису, указание размерности через **
то
!m=**10
x.m=m*m

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

AV>Мужики, вы меня в конец запутали. То, вроде, ТС и PC_2 два разных человека, то один. Как бы не вышло как со Славой КПСС.

Ну ты это, сам посмотри и не выйдет

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

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

AV>>Мужики, вы меня в конец запутали. То, вроде, ТС и PC_2 два разных человека, то один. Как бы не вышло как со Славой КПСС.

E>Ну ты это, сам посмотри и не выйдет

Точно не выйдет.
Глянул в топ активности, сегодня делим с тобой первые два места.
По 112 сообщений за сегодня, одному не справится

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

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

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

PC_>>>Кстате с рандомными строками у меня код будет проабгрейжин вот так

PC_>>>

PC_>>>!x='a'..'z'
PC_>>>!m=0..5
PC_>>>y+='+x'+m.R
PC_>>>^y
PC_>>>

S>>Попробую разгадать этот ультрапонятный ребус
S>>первые две строчки — переборщики.
S>>третья: к y прибавляется строка '+x' а к ней видимо прибавляется случайное число.
S>>Непонятно, когда этот процесс остановится, результатом будет что-то вроде
S>>'+x3+x0+x4+x...'

PC_>ребус остановится на 5, смотрите переборщик.
PC_>а для кода '+x3+x0+x4+x...' вызывается евал.
И обламывается привычным образом, потому как что такое +x3 для Eval?
Даже бы если это сработало, то в пароле были бы лишь случайные из первых 5и букв. Или у тебя m.R каким-то образом догадывается что границей RND будет размерность x?

PC_>Кстате я решил что переборщик х с числовым индексом это будет тотже переборщик.
PC_>Должно быть очень удобно в комбинаторике.


PC_>Кстате мне действительно приятно, что не смотря на ультракороткость кода мои программы
PC_>уже читаются с первого взгляда без единого комментария
Читаются, но решения то не видно

PC_>

PC_>

PC_>!x='a'..'z'
PC_>!m=0..5
PC_>y+='+x'+m.R
PC_>^y
PC_>

PC_>А не будет полностью переписан как в Немерле.
PC_>Правда здесь есть один ньюанс. У меня нет рандом библиотеки, вотето R я подразумеваю целое число которое при каждом обращении разное

незапно появилась новая зарезервированная буква R, которая исполняет фунцию генератора случайных чисел. Ну-ну. Скоро алфавита не хватит

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

PC_>Кстате с рандомными строками у меня код будет проабгрейжин вот так

PC_>

PC_>!x='a'..'z'
PC_>!m=0..5
PC_>y+='+x'+m.R
PC_>^y
PC_>

PC_>А не будет полностью переписан как в Немерле.
PC_>Правда здесь есть один ньюанс. У меня нет рандом библиотеки, вотето R я подразумеваю целое число которое при каждом обращении разное

Логичнее было бы, чтобы .R обозначало "случайная позиция переборщика"

Так же, как всякие .F .L .T и т. д.


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

Ну, типа X.I + X.J обозначает "перебрать все возможные суммы пар элементов X".
То есть, это можно воспринимать и как переборщик двумерного многообразия.

С другой стороны, если я верно помню,
конструкция вида <массив/переборщик>\<оператор>
обозначает коммулятивное применение оператора ко всем перебираемым значениям.
Ну и выражение вида <предикат от переборщика>?<выражение от переборщика> — это частный случай выражения содержащего переборщики.
Только результирующий переборщик будет профильтрован по предикату.

Так?
Тогда, если написать выражение от переборщика 1..5 и от рандомной буквы, то получим переборщик из пяти рандомных букв, которые останется только проконкатенировать при помощи \+
К сожалению в RS пока что нет прямого способа употребить переборщик только для целей итерации, поэтому предлагаю хак.
Напишем фильтр по переборщику, который всегда true, и профильтруем им скалярное значение "случайная буква" -- получим что хотели..

Итого, для выражения "случайный набор из 5 латинских букв" получаем

!x = 'a'..'z'
!m = 1..5
(m>0?x.R)\+

Или без ненужных переменных, (если интерпретатор так тоже может)
((1..5)>0?('a'..'z').R)\+

А если завести какой-то оператор, который позволяет упомянуть подвыражение в выражении, но не использовать его значения (аналог Сишной запятой, например), например палку, или двоеточие, или точку с запятой можно, кстати, то будет ещё проще:
(1..5;('a'..'z').R)\+

Теперь у нас может возникнуть задача "перебрать все пятибуквенные строчки". Типа надо описать такой переборщик.
Надо подумать, как это сделать.
Пусть у нас есть два переборщика
!C = 'a'..'z'
и
!m = 1..5

Очевидно, что C -- это переборщик однобуквенных строк. Для того, чтобы пербрать двухбуквенные, надо сделать как-то так:
!D = C;
C+D

Хотелось бы иметь какой-то способ записать это не используя доп переменную. Типа "такой же переборщик, но независимый.
Насколько я понял PC_2 он предложил дописывать числа к имени переборщика. Мне этот способ не нравится, потому, что нельзя тогда записать переборщик копий другого переборщика. Лучше всё-таки иметь какой-то наглядный оператор для этого. Только я не знаю какой выбрать. Ну там двоеточие, например, или решётка. Обычно решётка используется как "номер", так что запись типа m#5 -- может читаться, как "пятый клон переборщика номер 5", а, например, m#(1..5) будет переборщиком пяти клонов m
То есть переборщиком пятимерного гиперкуба m.

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

abcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz

будет выглядеть так: C#m

Осталось придумать, как это свернуть не по всем переборщикам, а только по одному.
Я думаю, что самый прямой путь -- указывать у оператора свртки явно по каким переборщикам надо или не надо сворачивать. Я думаю, что логичнее писать по кому сворачивать, а если не пишем, то сворачивает по всем.
Только тоже надо с синтаксисом определиться. Я бы после \ писал список переборщиков, а потом ещё раз \
То есть переборщик всех пятибуквенных цепочек будет выглядеть как-то так:
C#m/m/+
А если вспомнить, что на C нам ссылаться не надо, то можно ещё и его определение выкинуть.
Тогда ПОЛНОЕ описание будет таким:
!m=1..5
('a'..'z')#m/m/+

Вообще, похоже, что eval пока лишний.
Это слишком сложный способ прикрутить рекурсию.
Надо для простых случаев научиться писать какой-то простой код. А eval заюзать потом, чтобы уже по-взрослому сделать функциональные языки.

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

M>незапно появилась новая зарезервированная буква R, которая исполняет фунцию генератора случайных чисел. Ну-ну. Скоро алфавита не хватит

Без проблем можно сделать так, чтобы вместо R была RND, например.

Мало того, можно сделать ещё и так, что вообще запись вида <переборщик/массив>.<имя функции> приводило бы к тому, что вызывалась бы функция от переборщика, а в ответ возвращался бы переборщик или скаляр...

Тогда можно будет легко писать любые ID методов на самом RS.

Пока же способ записи функций не проработан...

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

E>Тогда ПОЛНОЕ описание будет таким:
E>!m=1..5
E>('a'..'z')#m/m/+

В смысле таким:
!m=1..5
('a'..'z')#m\m\+

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

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

PC_>>Кстате с рандомными строками у меня код будет проабгрейжин вот так

PC_>>

PC_>>!x='a'..'z'
PC_>>!m=0..5
PC_>>y+='+x'+m.R
PC_>>^y
PC_>>

PC_>>А не будет полностью переписан как в Немерле.
PC_>>Правда здесь есть один ньюанс. У меня нет рандом библиотеки, вотето R я подразумеваю целое число которое при каждом обращении разное

E>Логичнее было бы, чтобы .R обозначало "случайная позиция переборщика"

E>Теперь у нас может возникнуть задача "перебрать все пятибуквенные строчки". Типа надо описать такой переборщик.
E>Надо подумать, как это сделать.
E>Пусть у нас есть два переборщика
E>!C = 'a'..'z'
E>и
E>!m = 1..5

Извини, но для задачи "взять 5 случайных букв" тут слишком много рассуждений, все поскипал.
На C# задача записывается в лоб так:

Enumerable.Repeat(1, 5).Select(_ => (char)('a' + rnd.Next('z' - 'a')));

Если чуть покумекать и сделать генератор rnd, то так:

Rnd('z' - 'a' + 1).Select(r => (char)('a' + r)).Take(5);

E>Очевидно, что C -- это переборщик однобуквенных строк. Для того, чтобы пербрать двухбуквенные, надо сделать как-то так:
E>!D = C;
E>C+D
Это очень не очевидно

E>Насколько я понял PC_2 он предложил дописывать числа к имени переборщика. Мне этот способ не нравится, потому, что нельзя тогда записать переборщик копий другого переборщика. Лучше всё-таки иметь какой-то наглядный оператор для этого. Только я не знаю какой выбрать. Ну там двоеточие, например, или решётка. Обычно решётка используется как "номер", так что запись типа m#5 -- может читаться, как "пятый клон переборщика номер 5", а, например, m#(1..5) будет переборщиком пяти клонов m
E>То есть переборщиком пятимерного гиперкуба m.
Для того что бы взять 5 букв надо рассуждать о пятимерном гиперкубе?

E>Я нисколько не настаиваю на такой именно записи, но возможность прикольная. Как записать -- стоит обсудить. В любом случае получаем, что записать переборщик, который перебирает клетки таблицы

abcdefghijklmnopqrstuvwxyz
E>abcdefghijklmnopqrstuvwxyz
E>abcdefghijklmnopqrstuvwxyz
E>abcdefghijklmnopqrstuvwxyz
E>abcdefghijklmnopqrstuvwxyz

будет выглядеть так: C#m

E>Тогда ПОЛНОЕ описание будет таким:
E>!m=1..5
E>('a'..'z')#m/m/+
А на C# я написал, что я хочу получить. Пусть там много букв, но решение очевидно и понятно джуниору.

E>Вообще, похоже, что eval пока лишний.
E>Это слишком сложный способ прикрутить рекурсию.
E>Надо для простых случаев научиться писать какой-то простой код. А eval заюзать потом, чтобы уже по-взрослому сделать функциональные языки.
сделать функциональные языки? И ты туда же? Может ты в совершенстве постиг парочку, что собрался сделать их eval-ом?

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

AV>>Не все так однозначно. Идея "плачу только за то, что запросил" далеко не всегда плоха.
E>Это хорошая идея для С... А PC-2 всё время хочет уйти от императивной стороны вопроса...

С какой стати "плачу только за то что запросил" привязано к императивным языкам? Да и насчет "уйти от императивной стороны вопроса" как-то плохо у автора получается.

E>>>А зачем тогда создавать массив?
AV>>Массив может заполняться в нескольких местах. Это первое что приходит в голову

E>Можно создавать переборщики, и только потом дампить их в массив, если надо...

Далеко не всегда удобно.

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

S>>>

S>>>[|for i in 1..10 -> i*i|]
S>>>

PC_>конечно же так
PC_>!m=1..10
PC_>x.m=m*m
Это тоже работает только в твоей голове?

Error: Name x doesn't resolved.

Хоть на твоем языке оно и короче, я вижу непростительные для гуру языкостроения косяки
1. твой код невозможно использовать в подвыражениях без того что бы засунуть его в скобки и растащить на разные линии. 3 строчки (+ объявление x) для генератора квадратов — как бы намекают...
2. Как тут все время намекает ambel-vlad, у выражения 1..10 тип массив. Как кстати его не используй, с префиксом ! или нет, списко всех значений будет создан сразу. Создавать лишние списки для генерации нужного списка — непозволительная роскошь для многих задач.
3. Переборщик не ленив. Из генератора F#/C# я могу брать значения пока они удовлетворяют условию без создания лишних значений. Твой заполняет список значений при инициализации выражения, что опять таки не дает использовать его в целом классе задачь. Например, генерировать сильный пароль по заданной функции силы...

Я показал как делается это в современных языках, единственное что ты мог противопоставить — вот такой смайл , красноречиво вопрошающий "что тебе не нравится в моем лаконичном коде???". Твой язык не тянет на продукт дизайнера языков. Это плод работы минимизатора буковок.

PC_>>>>

PC_>>>>!x='a'..'z'
PC_>>>>!m=0..5
PC_>>>>y+='+x'+m.R
PC_>>>>^y
PC_>>>>

S>И обламывается привычным образом, потому как что такое +x3 для Eval?
S>Даже бы если это сработало, то в пароле были бы лишь случайные из первых 5и букв. Или у тебя m.R каким-то образом догадывается что границей RND будет размерность x?

Короче там маленькая ошибка есть
!x='a'..'z'
!m=0..5
y+='+x'+m+'.R'
^y

вот так надо

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

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

S>>>>

S>>>>[|for i in 1..10 -> i*i|]
S>>>>

PC_>>конечно же так
PC_>>!m=1..10
PC_>>x.m=m*m
S>Это тоже работает только в твоей голове?
S>

S>Error: Name x doesn't resolved.

Там же нормальная ошибка.
Х — не распознан,
обьяви Х

Enumerable.Repeat(1, 5).Select(_ => (char)('a' + rnd.Next('z' - 'a')));

Довольно прикольное решение.
Во-первых оно опять надругалось над решением Немерле,
которое ниразу понятней и короче.

Во-вторых имеет теже проблемы что и перловки. Ибо это нагромождение
встроенных функций.

Следовательно если я изменю условия так,
"Перебрать все пароли от a-z с длиной 5 символов,
причем дважды одна и таже буква не может встречаться в пароле"

или

"Перебрать все пароли от a-z c длиной 5 символов,
а вот пароли начинающиеся на A не должни быть больше 3 символов"


То решение разобьется о острые камни реальности.
А мне расширить свой алгоритм на РС секунд 30 наверное и плюс десять пятнадцать символов
в микро программку

Егор, на счет обсуждения переборщиков,
пока нет времени все читать, уже нужно бежать.
Если прийдете к консенсусу попробую вникнуть
в решение и оценить возможность реализации.
Но попожже

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

PC_>Короче там маленькая ошибка есть
PC_>!x='a'..'z'
PC_>!m=0..5
PC_>y+='+x'+m+'.R'
PC_>^y

PC_>вот так надо
убеди в том что eval прожует строку вида
'+x0.R+x1.R+x2.R ...'