Здравствуйте, Mamut, Вы писали:
M>>>>> DoubleApply, //:=: что?
A>>>>Вообще, это у него Swap — переменные меняются значениями
M>>>да, но нам-то это неизвестно и если джля этого надо копаться в коде, то тут явно ультрапонятностью не пахнет
PC_>>Если ты знаешь паскалевское :=, и понимаешь что это присвоить.
PC_>>До видимо :=: это обмен значениями между переменными. Нелогично и непонятно ?
M>Нет, неочевидно. Потому что это подряд два оператора — Apply (который на самом деле assign) и NotNull. Если для того, чтобы понять язык, надо лезть в код, его реализующий, это явно не понятный язык.
M>По поводу других вопросов по операторам ответы будут?
Чтото я тебя не понял.
Ану давай еще раз.
A:=B Присвоили значение В переменной А
A:=:B Взаимное присваивание
Не понимаю, но уверен однажды увидивший это человек запомнит это навсегда. Как вот тот парень который вспомнил что я вчера этот оператор упоминал. Оператор очень просто и ультраклассно запоминается.
На счет других операторов они по семантике на 90% соответствуют Сишным. Остальные операторы я обьяснял уже, другие позже обьясню.
"Вся страна играть в футбол умеет, лишь мы 11 человек играть не умеем"(с)КВН
Здравствуйте, kochetkov.vladimir, Вы писали:
KV>Здравствуйте, Lloyd, Вы писали:
L>>Здравствуйте, kochetkov.vladimir, Вы писали:
KV>>>И правильно ли я понимаю, что выражение "1..5" означает "создать массив из пяти элементов, в котором X[i] = i"? Но ведь тогда, для того, чтобы посчитать факториал 1048576, ваша программа отожрет 1 мегабайт памяти только для формирования индексов, в то время, как в том же немерле можно обойтись по старинке:
KV>>>def factorial(n){ | 0 | 1 = > 1 | _ => factorial(n — 1)}
L>>Если приведенный код — правильный, то функцию можно упростить до L>>def factorial(n){ 1 }
L>>)
KV>n * factorial(n — 1) конечно же
Здравствуйте, Mamut, Вы писали:
M>>>Ты лучше на выделенное ответь
PC_>>Я на глупые вопросы не отвечаю, путем не сложных арифметических прикидов можно понять, что результат факториала от числа 1048576 не вместит в зазипованном архиве никакой компьютер, ну или может вместит но будет оооооооочень длинным
M>Ответь на неглупый. Вернее перепиши его так, чтобы он стал эквивалентен приведенному коду — без дикого жора памяти
Приведенный код ничем не лучше в плане потребления памяти (хвостовой рекурсии-то нету). Пожалуй даже хуже, т.к. стек по размеру мягко говоря обычно меньше размера доступной оперативки.
PC_>>Тогда у 1С мегапонятный говнокод, там все пишется на русском языке, даж не на английском
A>а 1С не ультраприближен к естественнному. При этом я тебя уверяю, что 1с-овский "говнокод" читается на порядок легче твоего
Не стоит настаивать.
Просто опять идет жесткая подмена понятий, давайте брейнфак комманды снабдим алиасами:
M>>>>>> DoubleApply, //:=: что?
A>>>>>Вообще, это у него Swap — переменные меняются значениями
M>>>>да, но нам-то это неизвестно и если джля этого надо копаться в коде, то тут явно ультрапонятностью не пахнет
PC_>>>Если ты знаешь паскалевское :=, и понимаешь что это присвоить.
PC_>>>До видимо :=: это обмен значениями между переменными. Нелогично и непонятно ?
M>>Нет, неочевидно. Потому что это подряд два оператора — Apply (который на самом деле assign) и NotNull. Если для того, чтобы понять язык, надо лезть в код, его реализующий, это явно не понятный язык.
M>>По поводу других вопросов по операторам ответы будут?
PC_>Чтото я тебя не понял. PC_>Ану давай еще раз.
PC_>A:=B Присвоили значение В переменной А PC_>A:=:B Взаимное присваивание
PC_>Не понимаю, но уверен однажды увидивший это человек запомнит это навсегда. Как вот тот парень который вспомнил что я вчера этот оператор упоминал. Оператор очень просто и ультраклассно запоминается.
но он не является "ультрапонятным", иначе он был бы понятен сразу. Более того, как рядом описано, имея на руках операторы ":", "=", ":=" оператор ":=:" не выводится никак
PC_>На счет других операторов они по семантике на 90% соответствуют Сишным.
В С нет операторов, которые я перечислил:
public enum OperationType
{
Agregate, //\ аггрегирование чего?
Generate, //.. генерация чего?
Apply, //:= может все таки assign?
DoubleApply, //:=: что?
AddApply, //,= что?
Dimension, //D что за размерность?
Add, //, добавление чего?
Compare, //? сравнение чего?
CompareInNot, //?: что?
NotNull, //: что notnull?
Next, //; next что?
Point, //. что?
Rational //./ что?
}
PC_>Остальные операторы я обьяснял уже, другие позже обьясню.
Ты объяснял, по сути, только присваивание, запятую и fold left. Более того, тупа из перечисления этих операций не следует, что понятно, что они делают, как они используются, и какой у них приоритет
M>>>>Ты лучше на выделенное ответь
PC_>>>Я на глупые вопросы не отвечаю, путем не сложных арифметических прикидов можно понять, что результат факториала от числа 1048576 не вместит в зазипованном архиве никакой компьютер, ну или может вместит но будет оооооооочень длинным
M>>Ответь на неглупый. Вернее перепиши его так, чтобы он стал эквивалентен приведенному коду — без дикого жора памяти
L>Приведенный код ничем не лучше в плане потребления памяти (хвостовой рекурсии-то нету). Пожалуй даже хуже, т.к. стек по размеру мягко говоря обычно меньше размера доступной оперативки.
Да, что-то я промахнулся
Правда, если туда добавить хвостовую рекурсию...
factorial( N ) ->
factorial( N, 1 ).
% tail-recursive:
factorial( 0, Product ) ->
Product;
factorial( N, Product ) ->
factorial( N - 1, N * Product ).
Память будет тратиться только на собственно результат Миллион я не высичлял, но 100 000 вполне спокойно обрабатывает.
M>public enum OperationType
M>{
M> Agregate, //\ аггрегирование чего? -> Курили пример с факториалом array\*
M> Generate, //.. генерация чего? -> Массивов ясен перец, 1..5 не забыл ?
M> Apply, //:= может все таки assign? -> присваивание
M> DoubleApply, //:=: что? -> взаимное присваивание или свап, как тут уже говорили
M> AddApply, //,= что? -> было, тоже что += только добавляет элемент в конец массива
M> Dimension, //D что за размерность? -> 5D5 двумерный массив 5 на 5
M> Add, //, добавление чего? -> опять было 1,2,3 вернет массив из трех элементов
M> Compare, //? сравнение чего? -> Оператор сравнения 1<2?True:False
M> CompareInNot, //?: что? -> Тоже самое 1<2 ?: False
M> NotNull, //: что notnull? -> Operand1:Operand2 из двух возвращает ненулевой операнд
M> Next, //; next что? -> просто конец строки
M> Point, //. что? -> флоаты 1.5
M> Rational //./ что? -> рациональные 1./3
M>}
M>
"Вся страна играть в футбол умеет, лишь мы 11 человек играть не умеем"(с)КВН
Здравствуйте, PC_2, Вы писали:
PC_>>>Как это сделал с рациональными числами, архитектура у меня позволяет еще не такое делать,
Здесь фозратимся к контексту
Перепиши пример с факториалом так, чтобы он не требовал жора памяти для составления индексов массива. Ты же сам пишешь:
Я то напишу, не вопрос и смогу работать с числами которые имеют, например, миллиард разрядов.
Как это сделал с рациональными числами, архитектура у меня позволяет еще не такое делать
M>>рабочие примеры в студию
PC_>Чо, яж приводил рабочие примеры, помойму во втором посте этой темы.
PC_>Рациональные одна треть две трети пишутся очень просто !
PC_>Рациональные PC_>
PC_>1./3
PC_>2./3
PC_>
PC_>Флоаты PC_>
PC_>1.3
PC_>2.3
PC_>
PC_>Целые PC_>
PC_>1
PC_>2
PC_>
PC_>Ну и операции всяки разные там, ну как обычно +,-. Рассказывать чо они делают ?
Для этого есть отдельная подветка. В той подветке объясни следующее:
— Есть оператор точка . (что он делает?)
— Есть оператор деление /
— Естьоператор rational ./
Здравствуйте, Mamut, Вы писали:
M>>>>>Ты лучше на выделенное ответь
PC_>>>>Я на глупые вопросы не отвечаю, путем не сложных арифметических прикидов можно понять, что результат факториала от числа 1048576 не вместит в зазипованном архиве никакой компьютер, ну или может вместит но будет оооооооочень длинным
M>>>Ответь на неглупый. Вернее перепиши его так, чтобы он стал эквивалентен приведенному коду — без дикого жора памяти
L>>Приведенный код ничем не лучше в плане потребления памяти (хвостовой рекурсии-то нету). Пожалуй даже хуже, т.к. стек по размеру мягко говоря обычно меньше размера доступной оперативки.
M>Да, что-то я промахнулся
M>Правда, если туда добавить хвостовую рекурсию...
M>
M>factorial( N ) ->
M> factorial( N, 1 ).
M>% tail-recursive:
M>factorial( 0, Product ) ->
M> Product;
M>factorial( N, Product ) ->
M> factorial( N - 1, N * Product ).
M>
M>Память будет тратиться только на собственно результат Миллион я не высичлял, но 100 000 вполне спокойно обрабатывает.
M>Думаю, на PC_2 фиг сделаешь.
Чо-чо, на РС не сделаешь ?
А так
Sum:=1
Sum*=(I<1048576?I)
?
"Вся страна играть в футбол умеет, лишь мы 11 человек играть не умеем"(с)КВН
PC_>>>Тогда у 1С мегапонятный говнокод, там все пишется на русском языке, даж не на английском
A>>а 1С не ультраприближен к естественнному. При этом я тебя уверяю, что 1с-овский "говнокод" читается на порядок легче твоего
PC_>Не стоит настаивать. PC_>Просто опять идет жесткая подмена понятий, давайте брейнфак комманды снабдим алиасами:
PC_>"Переместить каретку вправо" PC_>"Переместить каретку влево" PC_>"Прибавить один"
PC_>Чудные естественные программы получатся, хорошо читаемые и всетакое !
Здравствуйте, Mamut, Вы писали:
PC_>>>>Тогда у 1С мегапонятный говнокод, там все пишется на русском языке, даж не на английском
A>>>а 1С не ультраприближен к естественнному. При этом я тебя уверяю, что 1с-овский "говнокод" читается на порядок легче твоего
PC_>>Не стоит настаивать. PC_>>Просто опять идет жесткая подмена понятий, давайте брейнфак комманды снабдим алиасами:
PC_>>"Переместить каретку вправо" PC_>>"Переместить каретку влево" PC_>>"Прибавить один"
PC_>>Чудные естественные программы получатся, хорошо читаемые и всетакое !
M>понимаешь ли.
M>
M>[1..2].foldLeft(любая_функция)
M>
да не. Слишком много букв
M>горазддо понятнее, чем
M>
M>1..2\*
M>
M>особенно если кода больше, чем одна строчка
Обратный слеш напоминает блок который развернут в другую сторону и пытается "схлопнуть" то что слева.
Так что ультрапонятно и ультракоротко. Кстате раньше этот оператор назывался по другому, но теперь все пучком
"Вся страна играть в футбол умеет, лишь мы 11 человек играть не умеем"(с)КВН
Обычно это то, с чего начинается объяснение языка, вообще-то.
M>>
M>>public enum OperationType
M>>{
M>> Agregate, //\ аггрегирование чего? -> Курили пример с факториалом array\*
M>> Generate, //.. генерация чего? -> Массивов ясен перец, 1..5 не забыл ?
M>> Apply, //:= может все таки assign? -> присваивание
M>> DoubleApply, //:=: что? -> взаимное присваивание или свап, как тут уже говорили
M>> AddApply, //,= что? -> было, тоже что += только добавляет элемент в конец массива
M>> Dimension, //D что за размерность? -> 5D5 двумерный массив 5 на 5
M>> Add, //, добавление чего? -> опять было 1,2,3 вернет массив из трех элементов
M>> Compare, //? сравнение чего? -> Оператор сравнения 1<2?True:False
M>> CompareInNot, //?: что? -> Тоже самое 1<2 ?: False
M>> NotNull, //: что notnull? -> Operand1:Operand2 из двух возвращает ненулевой операнд
M>> Next, //; next что? -> просто конец строки
M>> Point, //. что? -> флоаты 1.5
M>> Rational //./ что? -> рациональные 1./3
M>>}
M>>
мде.
— next не является оператором
— point и rational не являются операторами
— .. будет генерировать строки?
помимо этого:
apply срочно менять на assign
addapply на append
doubleapply на swap
M>>Правда, если туда добавить хвостовую рекурсию...
M>>
M>>factorial( N ) ->
M>> factorial( N, 1 ).
M>>% tail-recursive:
M>>factorial( 0, Product ) ->
M>> Product;
M>>factorial( N, Product ) ->
M>> factorial( N - 1, N * Product ).
M>>
M>>Память будет тратиться только на собственно результат Миллион я не высичлял, но 100 000 вполне спокойно обрабатывает.
M>>Думаю, на PC_2 фиг сделаешь.
PC_>Чо-чо, на РС не сделаешь ?
PC_>А так
PC_>
Здравствуйте, PC_2, Вы писали:
M>>Память будет тратиться только на собственно результат Миллион я не высичлял, но 100 000 вполне спокойно обрабатывает.
M>>Думаю, на PC_2 фиг сделаешь.
PC_>Чо-чо, на РС не сделаешь ?
PC_>А так
PC_>
PC_>Sum:=1
PC_>Sum*=(I<1048576?I)
PC_>
Operators: S1
Object reference not set to an instance of an object.
================
Sum:=1
Sum:=1
...um:=1
......1
S1
S:=1
S*=(I<1048576?I)
Operators: 1Expression
Object reference not set to an instance of an object.
================
S:=1
Здравствуйте, PC_2, Вы писали:
PC_>Здравствуйте, Mamut, Вы писали:
PC_>>>>>Тогда у 1С мегапонятный говнокод, там все пишется на русском языке, даж не на английском
A>>>>а 1С не ультраприближен к естественнному. При этом я тебя уверяю, что 1с-овский "говнокод" читается на порядок легче твоего
PC_>>>Не стоит настаивать. PC_>>>Просто опять идет жесткая подмена понятий, давайте брейнфак комманды снабдим алиасами:
PC_>>>"Переместить каретку вправо" PC_>>>"Переместить каретку влево" PC_>>>"Прибавить один"
PC_>>>Чудные естественные программы получатся, хорошо читаемые и всетакое !
M>>понимаешь ли.
M>>
M>>[1..2].foldLeft(любая_функция)
M>>
PC_>да не. Слишком много букв
от того, что там больше букв, он не стал непонятнее, а наоборт только стал понятнее, так как четко указывает, что происходит.
M>>горазддо понятнее, чем
M>>
M>>1..2\*
M>>
M>>особенно если кода больше, чем одна строчка
PC_>Обратный слеш напоминает блок который развернут в другую сторону и пытается "схлопнуть" то что слева.
Что за бредятина? Никакие блоки он не напоминает
PC_>Так что ультрапонятно и ультракоротко. Кстате раньше этот оператор назывался по другому, но теперь все пучком
Пофиг, как он назывался и называется. Мы же не название его пишем.
PC_>да не. Слишком много букв
M>>горазддо понятнее, чем
M>>
M>>1..2\*
M>>
M>>особенно если кода больше, чем одна строчка
PC_>Обратный слеш напоминает блок который развернут в другую сторону и пытается "схлопнуть" то что слева. PC_>Так что ультрапонятно и ультракоротко. Кстате раньше этот оператор назывался по другому, но теперь все пучком
