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>>)
PC_>Шутка которая повторена в 4й раз в этой теме кажется еще смешнее, не правда ли ?
Здравствуйте, Mamut, Вы писали:
PC_>>Когда же вы научитесь наконец читать первую строчку хотябы темы.
PC_>>А)Простота
M>Так как тебе постоянно приходится объяснять, что у тебя в коде происходит, простым твой язык не назовешь
Может быть идет речь не о той простоте.
В моем понимание, простота это скорость написания программ, лаконичность и краткость их кода.
Потому что у меня закрадывается впечетление что идет подмена понятий.
Товарищ тут один не даром заметил, что наиболее простым для "понимания" код явялется код Брейнфака,
всего лишь потому что там шесть операций ( насколько помню ). Тоесть всегда пальчиком можно тыкнуть в простыню говнокода
и воскликнуть "я понимаю что тут происходит, тут каретка вправо уходит !".
Но в моем понимании БрейнФак не простой а очень сложный язык, не смотря на то, что как ты говоришь в нем не нужно разбираться,
и так все понятно, 6 операций — нечего разбирать.
E ( S.I.J<S.I.(S.I.Len/2)? PC_> S.(I*2+1): PC_> S.(I*2+2) PC_> ),=S.I.J
Этот код не реализует нормальной сортировки и работает в стиле Немерле ( я так думаю ), также нещадно оджирает памяти.
Суть его в том, что идет работа с двумерным массивом. Сравниваются элементы с опорным элементом и следующие строчки этого двумерного массива заполняются поделенным на две части массивом. Так операция повторяется со всеми элементами массива, в итоге получается перевернутая пирамида, которую кстате говоря еще нужно "схлопнуть" что этот форматированный ультрапонятный код размером в 50 байт не делает.
Меня это решение не удовлитворило по двум причинам:
1. Первое это по памяти, такая же лажа как у любого функционального языка
2. Всеже код мог бы быть более очевидным и простым.
Поэтому этот код я перепишу, позже.
"Вся страна играть в футбол умеет, лишь мы 11 человек играть не умеем"(с)КВН
Здравствуйте, Mamut, Вы писали:
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>>>)
PC_>>Шутка которая повторена в 4й раз в этой теме кажется еще смешнее, не правда ли ?
M>Ты лучше на выделенное ответь
Я на глупые вопросы не отвечаю, путем не сложных арифметических прикидов можно понять, что результат факториала от числа 1048576 не вместит в зазипованном архиве никакой компьютер, ну или может вместит но будет оооооооочень длинным
"Вся страна играть в футбол умеет, лишь мы 11 человек играть не умеем"(с)КВН
M>да, но нам-то это неизвестно и если джля этого надо копаться в коде, то тут явно ультрапонятностью не пахнет
Ультра понятным может быть только язык ультра приближённый к естественному языку. Но у естественных языков проблемы с однозначностью. А вообще, как сегодня кто-то упомянул, это явно троллинг
Здравствуйте, PC_2, Вы писали:
PC_>Здравствуйте, Mamut, Вы писали:
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>>>>)
PC_>>>Шутка которая повторена в 4й раз в этой теме кажется еще смешнее, не правда ли ?
M>>Ты лучше на выделенное ответь
PC_>Я на глупые вопросы не отвечаю, путем не сложных арифметических прикидов можно понять, что результат факториала от числа 1048576 не вместит в зазипованном архиве никакой компьютер, ну или может вместит но будет оооооооочень длинным
А RS транслятор будет работать нормально, выделит гдето 5 мегабайт памяти на хранение развертки этого числа, но только вот при подсчете вылетит с аут оф мемори или с оферфлов как Немерла, уже в "начале пути"
1048576
"Вся страна играть в футбол умеет, лишь мы 11 человек играть не умеем"(с)КВН
PC_>>>А)Простота
M>>Так как тебе постоянно приходится объяснять, что у тебя в коде происходит, простым твой язык не назовешь
PC_>Может быть идет речь не о той простоте. PC_>В моем понимание, простота это скорость написания программ, лаконичность и краткость их кода.
Тогда чем тебе не нравится K?
PC_>>>Б)Ультракороткость
M>>Ультракороткость противоположна понятности (см тот же K)
M>>Кстати, все еще ждем объяснений тут: http://rsdn.ru/forum/philosophy/4087739.1.aspx
PC_>E ( S.I.J<S.I.(S.I.Len/2)? PC_>> S.(I*2+1): PC_>> S.(I*2+2) PC_>> ),=S.I.J
PC_>Этот код не реализует нормальной сортировки и работает в стиле Немерле ( я так думаю ), также нещадно оджирает памяти.
То есть, объяснений, что там происходит, мы так и не дождемся?
PC_>Суть его в том, что идет работа с двумерным массивом. Сравниваются элементы с опорным элементом и следующие строчки этого двумерного массива заполняются поделенным на две части массивом. Так операция повторяется со всеми элементами массива, в итоге получается перевернутая пирамида, которую кстате говоря еще нужно "схлопнуть" что этот форматированный ультрапонятный код размером в 50 байт не делает.
PC_>Меня это решение не удовлитворило по двум причинам: PC_>1. Первое это по памяти, такая же лажа как у любого функционального языка
ВНЕЗАПНО! Ага
PC_>2. Всеже код мог бы быть более очевидным и простым.
PC_>Поэтому этот код я перепишу, позже.
Давай сейчас. Потому что ты пичкаешь нас неправильными и неработающими примерами. Давай рабочие.
Здравствуйте, Mamut, Вы писали:
M>>> DoubleApply, //:=: что?
A>>Вообще, это у него Swap — переменные меняются значениями
M>да, но нам-то это неизвестно и если джля этого надо копаться в коде, то тут явно ультрапонятностью не пахнет
Если ты знаешь паскалевское :=, и понимаешь что это присвоить.
До видимо :=: это обмен значениями между переменными. Нелогично и непонятно ?
"Вся страна играть в футбол умеет, лишь мы 11 человек играть не умеем"(с)КВН
Здравствуйте, PC_2, Вы писали:
KV>>>def factorial(n){ | 0 | 1 = > 1 | _ => factorial(n — 1)}
L>>Если приведенный код — правильный, то функцию можно упростить до L>>def factorial(n){ 1 }
L>>)
PC_>Шутка которая повторена в 4й раз в этой теме кажется еще смешнее, не правда ли ?
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>>>>)
PC_>>>Шутка которая повторена в 4й раз в этой теме кажется еще смешнее, не правда ли ?
M>>Ты лучше на выделенное ответь
PC_>Я на глупые вопросы не отвечаю, путем не сложных арифметических прикидов можно понять, что результат факториала от числа 1048576 не вместит в зазипованном архиве никакой компьютер, ну или может вместит но будет оооооооочень длинным
Ответь на неглупый. Вернее перепиши его так, чтобы он стал эквивалентен приведенному коду — без дикого жора памяти
Здравствуйте, avpavlov, Вы писали:
M>>да, но нам-то это неизвестно и если джля этого надо копаться в коде, то тут явно ультрапонятностью не пахнет
A>Ультра понятным может быть только язык ультра приближённый к естественному языку. Но у естественных языков проблемы с однозначностью. А вообще, как сегодня кто-то упомянул, это явно троллинг
Тогда у 1С мегапонятный говнокод, там все пишется на русском языке, даж не на английском
"Вся страна играть в футбол умеет, лишь мы 11 человек играть не умеем"(с)КВН
M>>>> DoubleApply, //:=: что?
A>>>Вообще, это у него Swap — переменные меняются значениями
M>>да, но нам-то это неизвестно и если джля этого надо копаться в коде, то тут явно ультрапонятностью не пахнет
PC_>Если ты знаешь паскалевское :=, и понимаешь что это присвоить.
PC_>До видимо :=: это обмен значениями между переменными. Нелогично и непонятно ?
Нет, неочевидно. Потому что это подряд два оператора — Apply (который на самом деле assign) и NotNull. Если для того, чтобы понять язык, надо лезть в код, его реализующий, это явно не понятный язык.
По поводу других вопросов по операторам ответы будут?
Здравствуйте, 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>)
Здравствуйте, Mamut, Вы писали:
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>>>>>)
PC_>>>>Шутка которая повторена в 4й раз в этой теме кажется еще смешнее, не правда ли ?
M>>>Ты лучше на выделенное ответь
PC_>>Я на глупые вопросы не отвечаю, путем не сложных арифметических прикидов можно понять, что результат факториала от числа 1048576 не вместит в зазипованном архиве никакой компьютер, ну или может вместит но будет оооооооочень длинным
M>Ответь на неглупый. Вернее перепиши его так, чтобы он стал эквивалентен приведенному коду — без дикого жора памяти
Мамут не стоит настаивать на ерунде.
Я то напишу, не вопрос и смогу работать с числами которые имеют, например, миллиард разрядов.
Как это сделал с рациональными числами, архитектура у меня позволяет еще не такое делать,
но зачем, вот например Немерла не обуздает эту проблему никакими макросами, потому что пасется на типах Шарпа, ксате говоря довольно скудных
"Вся страна играть в футбол умеет, лишь мы 11 человек играть не умеем"(с)КВН
M>>>да, но нам-то это неизвестно и если джля этого надо копаться в коде, то тут явно ультрапонятностью не пахнет
A>>Ультра понятным может быть только язык ультра приближённый к естественному языку. Но у естественных языков проблемы с однозначностью. А вообще, как сегодня кто-то упомянул, это явно троллинг
PC_>Тогда у 1С мегапонятный говнокод, там все пишется на русском языке, даж не на английском
И он таки мегапонятный
&НаКлиенте
Процедура ПриложенияТекущиеДанныеПередУдалением(ТекущиеДанные, Отказ) Экспорт
Если Не ПустаяСтрока(ТекущиеДанные.Имя) Тогда
Отказ = Истина;
КонецЕсли;
КонецПроцедуры
&НаКлиенте
Процедура ПриложенияПередУдалением(Элемент, Отказ)
ПриложенияТекущиеДанныеПередУдалением(Элемент.ТекущиеДанные, Отказ);
КонецПроцедуры
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>>>>>>)
PC_>>>>>Шутка которая повторена в 4й раз в этой теме кажется еще смешнее, не правда ли ?
M>>>>Ты лучше на выделенное ответь
PC_>>>Я на глупые вопросы не отвечаю, путем не сложных арифметических прикидов можно понять, что результат факториала от числа 1048576 не вместит в зазипованном архиве никакой компьютер, ну или может вместит но будет оооооооочень длинным
M>>Ответь на неглупый. Вернее перепиши его так, чтобы он стал эквивалентен приведенному коду — без дикого жора памяти
PC_>Мамут не стоит настаивать на ерунде.
Это не ерунда
PC_>Я то напишу, не вопрос и смогу работать с числами которые имеют, например, миллиард разрядов.
Напиши. Пока что все, что от тебя слышно — это "не работает", "потом позже", "не хочу"
PC_>Как это сделал с рациональными числами, архитектура у меня позволяет еще не такое делать,
рабочие примеры в студию
PC_>но зачем, вот например Немерла не обуздает эту проблему никакими макросами, потому что пасется на типах Шарпа, ксате говоря довольно скудных
при чем тут Немерле? ты напиши, а мы посмотрим. сложно обсуждать несуществующий код
