У цьому виклику користувачі будуть по черзі виконуючи три досить прості завдання кодування в мовах програмування, які дозволяють поступово старіти.

Перша відповідь повинна використовувати мову програмування, яку було зроблено у 2015 році. Після того, як є хоча б одна відповідь з мови 2015 року, у відповідях можуть використовуватися мови програмування, які були зроблені у 2014 році. Так само відповіді, які використовують мови з 2013 року, забороняються поки не знайдеться хоча б одна відповідь 2014 року.

Як правило, використання мови програмування з року Y не дозволяється, поки відповідь, що використовує мову з року Y + 1, не надіслана. Єдиний виняток - Y = 2015.

Пошук року вашої мови

Щоб відповісти на це запитання, ви повинні знати рік, коли ваша мова програмування була "виготовлена". Це, звичайно, суб'єктивний термін; деякі мови розроблялися протягом декількох років, і багато мов все ще вдосконалюються щороку. Нехай рік, коли "була зроблена мова", буде першим роком, коли впровадження цієї мови з'явилося в широкій громадськості.

Наприклад, Python був "зроблений" у 1991 році , хоча його розробка тривала з 1989 року, а версія 1.0 не вийшла до 1994 року.

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

Різні версії або стандарти мови програмування (наприклад, Python 1, 2, 3) зараховуються як однакова мова з тим самим початковим роком.

Отже, якщо рік вашої мови - 2015, ви можете надіслати свою відповідь лише після того, як буде надіслано відповідь, рік мови якого - рік, що передує вашому.

Якщо справжня відповідь того ж року, що і ваш уже існує, ви можете відповісти. Не має значення, чи була розроблена ваша мова раніше чи пізніше року.

Завдання

Ви повинні виконати Завдання з 1 по 3. Завдання 0 не є обов'язковим.

Ці завдання були більш-менш обрані так, щоб відповідати трьом важливим аспектам програмування: забезпечення результатів (Завдання 1), циклічне завдання (Завдання 2) та рекурсія (Завдання 3).

Завдання 0 - Історія мови (необов’язково)

Напишіть принаймні абзац, що пояснює історію обраної мови програмування: хто її розробив, чому, як і т. Д. Це особливо рекомендується, якщо ви особисто були поруч, коли мова з'явилася, і, можливо, навіть зіграли певну роль у її розвитку. Не соромтеся розповідати особисті анекдоти про вплив мови на вас чи вашу роботу, або щось подібне.

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

Завдання 1 - "Привіт, світ!" Варіант

Напишіть програму, яка друкує

[language name] was made in [year made]!

до стандартної області виводу вашої мови (stdout для більшості останніх мов).

Наприклад, якби мова була Python, вихід буде таким:

Python was made in 1991!

Завдання 2 - ASCII Art N

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

Якщо вхід 1, вихід:

N

Якщо вхід 3, вихід:

N N
NNN
N N

Якщо вхід 5, вихід:

N   N
NN  N
N N N
N  NN
N   N

Якщо вхід 7, вихід:

N     N
NN    N
N N   N
N  N  N
N   N N
N    NN
N     N

Шаблон продовжується так. Вихід може містити пробіли.

Завдання 3 - GCD

Напишіть програму, яка дозволяє користувачеві ввести два натуральних числа (ви можете вважати, що введення завжди дійсне), і виводить їх найбільший спільний дільник . Це визначається як найбільше додатне ціле число, яке розділяє обидва числа, не залишаючи залишку. Його можна легко обчислити, використовуючи алгоритм Евкліда .

Приклади:

8, 12→ 4
12, 8→ 4
3, 30→ 3
5689, 2→ 1
234, 876→6

Ви можете використовувати вбудовану функцію, але спробуйте дізнатися, чи була вона там у першій версії вашої мови. Якщо ні, спробуйте не використовувати його.

Правила

• Ви можете відповісти кілька разів, але кожна нова відповідь повинна використовувати мову, зроблену щонайменше за 5 років до мови у вашій останній відповіді. Тож якщо ви відповіли мовою 2015 року, ви не зможете відповісти знову, поки не будуть дозволені мови 2010 року. Якщо ви почнете з відповіді 2010 року, ви не можете зробити відповідь у 2015 році своєю другою відповіддю, оскільки 2015 рік не до 2010 року.
• Якщо можливо, напишіть свій код так, щоб він працював у першій версії вашої мови (або якомога старшій версії). (Це не є вимогою, оскільки знайти старі компілятори / перекладачі для деяких мов може бути складно.)
• Утримуйтесь від публікації мови, яка вже була опублікована, якщо опублікована відповідь не має суттєвих помилок або у вас зовсім інший спосіб виконання завдань.
• Гольф ваш код добре, але не обов'язково.
• Новий рядок у вихідній програмі будь-якої програми чудово.
• У задачах 2 і 3 всі вхідні значення нижче деякого розумного максимуму, як 2 ^16, повинні працювати (як мінімум, 256).
• Можливо, ваша мова існувала до того, як це питання було розміщено.
• Дуже старі мови програмування можуть мати різні форми введення та виведення, ніж те, про що ми думаємо сьогодні. Це добре. Виконайте завдання, як можна краще, в контексті вашої мови.

Оцінка балів

Оцінка вашої заявки:

upvotes - downvotes + (2015 - languageYear) / 2 

Таким чином, 0,5 додається до підрахунку голосів за кожен рік до 2015 року, надаючи перевагу старішим мовам. Виграє подання з найвищим балом.

Список відповідей

У фрагменті стека нижче перелічені всі дійсні відповіді відповідно до їх мовного року.

Потрібно почати свою публікацію з цього рядка відмітки, щоб переконатися, що вона вказана правильно:

#[year] - [language name]

Наприклад:

#1991 - Python

Назва мови може містити посилання (це буде те саме посилання у списку відповідей):

#1991 - [Python](https://www.python.org/)

Відповіді, які не відповідають цьому формату, або рік, який ще не дозволений, або надходять від користувача, який уже відповів за останні 5 років, позначаються як недійсні.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script>$(function(){function e(e,r){var a="https://api.stackexchange.com/2.2/questions/48476/answers?page="+e.toString()+"&pagesize=100&order=asc&sort=creation&site=codegolf&filter=!YOKGPOBC5Yad160RQxGLP0r4rL";$.get(a,r)}function r(e){if(e.items.forEach(function(e){var r=e.link,a=e.owner.display_name,i=e.body.match(/<h1\b[^>]*>(\d{4}) - (.*?)<\/h1>/);if(i&&i.length>=3)var h=parseInt(i[1]),u=i[2];h&&u&&n>=h&&h>=t&&(!d.hasOwnProperty(e.owner.user_id)||d[e.owner.user_id]-h>=p)?(d[e.owner.user_id]=h,h==t&&--t,o.hasOwnProperty(h)||(o[h]=[]),o[h].push({language:u,user:a,link:r,score:e.score+(n-h)/2})):s.push(' <a href="'+r+'">'+a+"</a>")}),e.has_more)runQuery(++a,r);else{for(var i=n,h=[];o.hasOwnProperty(i);){for(var u=$("<tr>").append($("<td>").text(i.toString())),l=$("<td>"),c=$("<td>"),g=$("<td>"),f=0;f<o[i].length;f++){var v=o[i][f];l.append(v.language),c.append($("<a>").html(v.user).attr("href",v.link)),g.append(v.score),f+1<o[i].length&&(l.append("<br><br>"),c.append("<br><br>"),g.append("<br><br>"))}u.append(l).append(c).append(g),h.push(u),--i}$("#answers").find("tbody").append(h),s.length>0?$("#invalid").append(s):$("#invalid").remove()}}var a=1,n=2015,t=n-1,p=5,o={},s=[],d={};e(1,r)})</script><style>html *{font-family: Helvetica, Arial, sans-serif;}table{border: 4px solid #a4a; border-collapse: collapse;}th{background-color: #a4a; color: white; padding: 8px;}td{border: 1px solid #a4a; padding: 8px;}div{font-size: 75%;}</style><table id='answers'> <tr> <th>Year</th> <th>Language</th> <th>User (answer link)</th> <th>Score</th> </tr></table><div id='invalid'><br>Invalid Answers:</div>

2013 р. - Догескрипт

Dogescript - мова, створена в 2013 році Захом Брюггеменом . Це не що інше, як заміна синтаксису для Javascript, щоб він читав як внутрішні монологи меметичного Шиба Інуса.

Привіт доже

console dose loge with "Dogescript was made in 2013!"

ASCII ст

such N much N
          much i as 0 next i smaller N next i more 1
              very doge is ("N" + " ".repeat(N-2) + "N").split('')
              s[i] is "N";
              console dose loge with doge.join('')
                              wow
                                      wow

GCD

such gcd_doge much doge, dooge
    rly dooge
              gcd_doge(dooge, doge % dooge)
  but
    rly doge smaller 0
           -doge
    but
          doge
  wow
        wow

2015 - Сітківка

Retina - це мова програмування на основі регулярних виразів, яку я написав, щоб мати можливість змагатися в завданнях PPCG з відповідями, призначеними лише для регулярних виразів, не маючи зайвих накладних витрат на виклик регулярного виразу деякою мовою хоста. Сітківка Тюрінга. Щоб довести це, я реалізував 2-тег системного рішення, а також правило 110 . Він написаний на C #, отже, він підтримує як аромат .NET (за замовчуванням), так і аромат ECMAScript (через прапор).

Сітківка може працювати в декількох режимах, але найбільш релевантним для обчислень (і повного Тюрінга) є режим Замінити. У режимі заміни ви надаєте Retina парну кількість вихідних файлів. Потім вони спарюються, перша з кожної пари - це регулярний вираз, а друга - заміна. Потім вони виконуються в порядку, маніпулюючи введенням крок за кроком. Регексу також може передувати конфігурація (з обмеженням `). Найважливіший варіант (який робить Retina Turing-завершеним) - це те +, що змушує Retina застосовувати заміну в циклі, поки результат не перестане змінюватися. У наступних прикладах я також використовую ;, що пригнічує вихід на проміжних етапах.

У кожному з поданих подань кожен рядок складається в окремому вихідному файлі. (Крім того, ви можете скористатися новою -sопцією і ввести всі рядки в один файл.) Порожні файли / рядки представлені як <empty>. Файли / рядки, що містять єдиний пробіл, представлені як <space>.

Пояснення досить довгі, тому я перемістив їх до кінця посади.

Програми

"Привіт Світ!" Варіант

<empty>
Retina was made in 2015!

ASCII Art N

Це передбачає, що STDIN припиняється новим рядком.

;`^
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
N
;`.(?<=(?=(.*\n)).*)|\n
$1
;`N(?=N\n.*\n.*\n`$)
<space>
;+`N(?=.?(.)+\n.* (?<-1>.)+(?(1)!)\n)
<space>
;`(?<=^.*\n.*\nN)N
S
;+`(?<=\n(?(1)!)(?<-1>.)+S.*\n(.)+N?)N
S
S
<space>

GCD

Це вимагає, щоб STDIN не було припинено новим рядком.

;`\b(?=\d)
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
1
;`^(.+)\1* \1+$
$1
;`$
#:0123456789
;+`^(?=1)(1*)\1{9}(#(?=.*(0))|1#(?=.*(?<3>1))|11#(?=.*(?<3>2))|111#(?=.*(?<3>3))|1111#(?=.*(?<3>4))|11111#(?=.*(?<3>5))|111111#(?=.*(?<3>6))|1111111#(?=.*(?<3>7))|11111111#(?=.*(?<3>8))|111111111#(?=.*(?<3>9)))
$1#$3
#|:.*
<empty>

Пояснення

"Привіт Світ!" Варіант

Це досить банально. Він не бере жодного вводу (тобто порожній рядок), нічого не відповідає і замінює його Retina was made in 2015!. Можна також змусити його працювати для довільного введення, замінивши шаблон, [\s\S]*наприклад. Це призведе до того, що STDIN замінить все на вихід.

ASCII Art N

Це досить багато етапів. Ідея полягає в перетворенні вхідного сигналу в одинарне, створення блоку N x N N, а потім "вирізання" двох трикутників. Перейдемо до окремих етапів. Пам'ятайте, що це ;просто пригнічує проміжні виходи, але +призводить до того, що заміна застосовується в циклі.

;`^
#

Просте: додайте #до введення. Це буде використано як маркер при перетворенні в одинарне.

;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#

Це перетворює одну цифру в одинакову. Він бере вже перетворені цифри (\d*)і повторює їх 10 разів. А потім бере наступну цифру і додає відповідну кількість цифр. Фактичне значення цифр на цьому етапі не має значення. Коли #досягне кінець числа, регулярний вираз більше не збігається, і перетворення виконується. Як приклад, число 127буде оброблятися як

#127
1#27
111111111122#7
1111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111227777777#

де останній рядок містить точно 127 знаків.

;`#
<empty>
;`\d
N

Два прості етапи, які позбавляються від цього, #а потім перетворюють усі цифри N. Далі я буду використовувати 7приклад як приклад. Отже, тепер у нас є

NNNNNNN

Наступний етап

;`.(?<=(?=(.*\n)).*)|\n
$1

замінює кожну Nна весь рядок (пам’ятайте, що він містить кінцевий новий рядок), а також видаляє сам останній рядок. Отже, це перетворює один ряд у квадратну сітку:

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN

Тепер верхній трикутник. Спочатку ми починаємо все, перетворивши N у правому нижньому куті в пробіл:

;`N(?=N\n.*\n.*\n`$)
<space>

Lookahead гарантує, що ми змінюємо правильне N. Це дає

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNN N
NNNNNNN
NNNNNNN

І зараз

;+`N(?=.?(.)+\n.* (?<-1>.)+(?(1)!)\n)
<space>

- це регулярний вираз, який відповідає значенню, Nрозташованому вище або у верхньому лівому куті символу пробілу, і замінює його пробілом. Оскільки заміна повторюється, це по суті є заливкою, яка перетворює 3-й октант з початкового простору на більше просторів:

N     N
NN    N   
NNN   N
NNNN  N
NNNNN N
NNNNNNN
NNNNNNN

І, нарешті, ми повторюємо те ж саме з нижнім трикутником, але використовуємо інший символ, тому вже наявні пробіли не спричиняють неправильну заливку:

;`(?<=^.*\n.*\nN)N
S

встановлює насіння:

N     N
NN    N   
NSN   N
NNNN  N
NNNNN N
NNNNNNN
NNNNNNN

Тоді

;+`(?<=\n(?(1)!)(?<-1>.)+S.*\n(.)+N?)N
S

чи затоплює.

N     N
NN    N   
NSN   N
NSSN  N
NSSSN N
NSSSSNN
NSSSSSN

І, нарешті

S
<space>

Перетворює їх Sу пробіли, і ми закінчили:

N     N
NN    N   
N N   N
N  N  N
N   N N
N    NN
N     N

GCD

ГХД в одинаковому насправді дуже тривіальний при регулярному вираженні. Більшість із них складається з десяткового до одинарного та одинарного до десяткового перетворення. Це можна зробити більш компактно, але це не гольф з кодом, тому ...

;`\b(?=\d)
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
1

Ці етапи по суті такі ж, як і вище, за винятком того, що обидва вхідні числа перетворені, і в результаті використовується 1s замість Ns (не те, що це має значення). Тож якби вхід був 18 24, то це дало б результат

111111111111111111 111111111111111111111111

Тепер

;`^(.+)\1* \1+$
$1

- це все обчислення GCD. Ми узгоджуємо спільний дільник, захоплюючи кількість 1s, а потім використовуючи зворотні посилання, щоб переконатися, що обидва числа можна записати, повторивши цей рядок (і більше нічого). Завдяки тому, як працює зворотний трекінг в двигуні регулярних виразів (тобто .+жадібний), це завжди дає автоматично найбільшого спільного дільника. Оскільки збіг охоплює весь рядок, ми просто записуємо назад першу групу захоплення, щоб отримати наш GCD.

Нарешті, перетворення унарного до десяткового ...

;`$
#:0123456789

Додайте до рядка маркер #, роздільник :і всі цифри. Це необхідно, тому що ви не можете умовно створювати нових символів заміною регулярного вираження. Якщо ви хочете умовної заміни, вам потрібно витягнути символи з самої рядки, тому ми їх помістимо туди.

;+`^(?=1)(1*)\1{9}(#(?=.*(0))|1#(?=.*(?<3>1))|11#(?=.*(?<3>2))|111#(?=.*(?<3>3))|1111#(?=.*(?<3>4))|11111#(?=.*(?<3>5))|111111#(?=.*(?<3>6))|1111111#(?=.*(?<3>7))|11111111#(?=.*(?<3>8))|111111111#(?=.*(?<3>9)))
$1#$3

Це зворотна раніше одинарна експансія. Ми знаходимо найбільший кратний 10, який вписується в поточний рядок. Потім вибираємо наступну цифру на основі решти і ділимо кратну на 10, переміщаючи маркер через цифри.

#|:.*
<empty>

І, нарешті, лише крок очищення, щоб позбутися маркера, роздільника та цифр помічника.

2013 рік - оснащення !

Оснастка ! це мова на основі Scratch , створена в університеті Берклі. Це оновлення до Scratch, що містить першокласні дані та спеціальні блоки (функції). Як і Scratch, це не текст, а скоріше зроблений візуальними "блоками", які з'єднуються разом.

Оснастка ! , написаний на JavaScript, є спадкоємцем BYOB, який був написаний на Squeak Smalltalk. Оснастка ! бета-версія була випущена для громадського споживання в березні 2013 року .

Оснастка ! насправді не є езотеричною мовою. Він використовується як мова програмування для курсу « Краси та радість обчислень» (BJC) AP CS курсу в Берклі та інших.

Я допомагав у тестуванні та ін.

Варіант "Hello World"

ASCII Art "N"

При цьому використовується stdlib для деяких блоків.

Тут досить базового циклу. Бере вхід. Потім ми просто додаємо все це разом і говоримо це (результат для n = 5):

Я взяв на себе сміливість просто використовувати 2 пробіли замість 1, тому що Snap! не говорить про речі в монопросторі.

GCD

Алгоритм Евкліда не дуже швидкий, але він працює і досить простий. (Вибачте, я зробив друк у назві блоку. Тепер я закрив вкладку, не зберігаючи. Це просто доведеться залишитися.)

Після цього визначення функції вироблятиме цей блок:

2007 - LOLCODE

Історія мови

LOLCODE був створений у 2007 році Адам Ліндсей, науковий співробітник університету Ланкастер. Його синтаксис ґрунтується на мемах локатів, популяризованих Cheezburger, Inc.

"Привіт Світ!" Варіант

HAI
VISIBLE "LOLCODE wuz maed in 2007!"
KTHXBYE

ASCII Art N

HAI

BTW, read n from stdin
GIMMEH n

BTW, convert n from YARN to NUMBR
n R PRODUKT OF n AN 1

BOTH SAEM n AN 1, O RLY?
    YA RLY
        VISIBLE "N"
    NO WAI
        VISIBLE "N"!

        I HAS A butt ITZ 1
        IM IN YR toilet UPPIN YR butt TIL BOTH SAEM butt AN DIFF OF n AN 1
            VISIBLE " "!
        IM OUTTA YR toilet

        VISIBLE "N"

        I HAS A kat ITZ 2
        IM IN YR closet UPPIN YR kat TIL BOTH SAEM kat AN n
            VISIBLE "N"!
            BOTH SAEM kat AN 2, O RLY?
                YA RLY
                    VISIBLE "N"!
                NO WAI
                    I HAS A doge ITZ 1
                    IM IN YR l00p UPPIN YR doge TIL BOTH SAEM doge AN DIFF OF kat AN 1
                        VISIBLE " "!
                    IM OUTTA YR l00p
                    VISIBLE "N"!
            OIC

            I HAS A brd ITZ 1
            IM IN YR haus UPPIN YR brd TIL BOTH SAEM brd AN DIFF OF n AN kat
                VISIBLE " "!
            IM OUTTA YR haus

            VISIBLE "N"
        IM OUTTA YR closet

        VISIBLE "N"!

        I HAS A d00d ITZ 1
        IM IN YR lap UPPIN YR d00d TIL BOTH SAEM d00d AN DIFF OF n AN 1
            VISIBLE " "!
        IM OUTTA YR lap

        VISIBLE "N"
OIC

KTHXBYE

Значення читаються у вигляді рядків (YARN) із stdin із використанням GIMMEH. Вони можуть бути перетворені в числові (NUMBR) шляхом множення на 1.

Значення друкуються для stdout за допомогою VISIBLE. За замовчуванням додається новий рядок, але його можна придушити, додавши знак оклику.

GCD

HAI

GIMMEH a
a R PRODUKT OF a AN 1

GIMMEH b
b R PRODUKT OF b AN 1

I HAS A d00d ITZ 1
IM IN YR food UPPIN YR d00d TIL BOTH SAEM b AN 0
    I HAS A kitty ITZ a
    I HAS A doge ITZ b
    a R doge
    b R MOD OF kitty AN doge
IM OUTTA YR food

VISIBLE SMOOSH "gcd is " a

KTHXBYE

SMOOSH виконує конкатенацію рядків.

1982 - PostScript

PostScript - мова для створення векторної графіки та друку.

Adobe була заснована в 1982 році, а їх першим продуктом був PostScript. Мова використовувалася в принтерах: команди інтерпретуються принтером для створення растрового зображення, яке потім друкується на сторінку. Це був дуже поширений компонент лазерних принтерів в 90-х роках. Але це, очевидно, досить багато процесора на принтері, і оскільки комп'ютерні процесори ставали більш потужними, було важливіше робити растеризацію на комп'ютері, ніж принтер. PostScript значною мірою відійшов на споживчі принтери, хоча він все ще існує на багатьох більш висококласних принтерах.

Стандарт, який замінив PostScript - це маловідомий формат під назвою PDF.

PostScript вийшов з моди до того часу, як я почав програмувати, але я трохи навчився, будучи в університеті, як інший спосіб створення документів для TeX. Це було зовсім інакше від інших мов програмування, які я використовував (зворотне позначення інфіксації, стек, друк на сторінці замість консолі), але було приємно відпилити цю стару мову заради веселощів.

Оскільки PostScript є мовою друку, здається, більш доцільно використовувати її для друку чогось, а потім надсилати вихід на консоль.

Завдання 1

/Courier findfont
12 scalefont
setfont
newpath

100 370 moveto
(PostScript was made in 1982!\n) show

Перші кілька ліній створювали полотно для малювання. Потім movetoкоманда повідомляє PS малювати на певній позиції та showдрукує рядок на сторінці. Зауважте, що круглі дужки позначають рядок у PostScript, а не лапки.

Завдання 2

/asciiartN {% stack: N row col
            % output: draws an "ASCII art" N

  % PostScript doesn't allow you to pass variables directly into a function;
  % instead, you have to pass variables via the global stack. Pop the variables
  % off the stack and define them locally.
  6 dict begin
  /row exch def
  /col exch def
  /N exch def

  % Define how much space will be between each individual "N"
  /spacing 15 def

  % Get the width of the "N". We need this to know where to draw the right-hand
  % vertical
  /endcol col spacing N 1 sub mul add def

  % One row is drawn at a time, with the bottom row drawn first, and working
  % upwards. This stack variable tracks which column the diagonal is in, and so
  % we start on the right and work leftward
  /diagcol endcol def

  % Repeat N times: draw one row at a time
  N {
    % Left-hand vertical of the "N"
    col row moveto
    (N) show

    % Right-hand vertical of the "N"
    endcol row moveto
    (N) show

    % Diagonal bar of the "N"
    diagcol row moveto
    (N) show

    % Advance to the next row. This means moving the row one space up, and the
    % diagonal position one place to the left.
    /row row spacing add def
    /diagcol diagcol spacing sub def

  } repeat

  end
} def

1 100 200 asciiartN
3 150 200 asciiartN
5 230 200 asciiartN

Я написав функцію для малювання "ASCII art" N, але функції PostScript не можуть взяти аргумент. Натомість ви висуваєте свої аргументи до стеку, а потім повертаєте їх назад. Це /x exch defлінія.

Приклад: припустимо, стек є 8 9 2. Спочатку натискаємо ім'я /xна стек, значить, стек є 8 9 2 /x. exchОператор міняє місцями два значення стека, так що тепер стек 8 9 /x 2. Потім defз'являється два найпопулярніших значення стека та визначається /xзначення 2. Стек зараз 8 9.

Коли я почав використовувати PostScript, я вважав це трохи заплутаним. Я читав про стек як про теоретичну концепцію, але це був перший раз, коли я його використовував на практиці.

Решта функції - деякий код малювання: почніть з нижнього правого кута, заповнюючи рядки за один раз з діагоналі зліва направо на право.

Завдання 3

/modulo {% stack: x y
         % output: returns (x mod y)
  3 dict begin
  /y exch def
  /x exch def

  % If x = y then (x mod y) == 0
  x y eq {0} {

    % If x < y then (x mod y) == x
    x y lt {x} {

      % If x > y then subtract floor(x/y) * y from x
      /ycount x y div truncate def
      /x x ycount y mul sub def

      /x x cvi def
      x

    } ifelse
  } ifelse
} def

/gcd {% stack: a b
      % returns the gcd of a and b
  2 dict begin
  /b exch def
  /a exch def

  % I'm using the recursive version of the Euclidean algorithm

  % If b = 0 then return a
  b 0 eq {a} {

    % Otherwise return gcd(b, a mod b)
    /a a b modulo def
    b a gcd
  } ifelse

} def

/displaygcd {% stack: a b xcoord ycoord
             % displays gcd(a,b) at position (xcoord, ycoord)
  5 dict begin
  /ycoord exch def
  /xcoord exch def
  /b exch def
  /a exch def
  /result a b gcd def

  xcoord ycoord moveto
  result 20 string cvs show

  % end
} def

8 12 100 80 displaygcd
12 8 150 80 displaygcd
3 30 200 80 displaygcd
5689 2 250 80 displaygcd
234 876 300 80 displaygcd

Знову я використав форму алгоритму Евкліда, але я забув, що PostScript має вбудований оператор модуля, тому мені довелося написати свій власний. Це виявилося корисним нагадуванням про обмеження програмування на основі стека. Моя перша реалізація moduloбула заснована на рекурсії:

modulo(x, y)
    if (x = y) return 0
    elif (x < y) return x
    else return module(x - y, y)

що добре, поки ви не спробуєте запустити це, коли xвін великий і yмалий (наприклад, 5689 та 2). У вас може бути лише до 250 елементів на стеку, і тому я задув добре за межу стека. На жаль Мені довелося повернутися до креслярської дошки на цій.

Сам код GCD досить простий. Але так само, як функції не можуть приймати аргументи, тому вони не мають значення повернення. Натомість ви повинні натиснути результат на стек, де хтось інший зможе пізніше випустити його. Так роблять aі b a gcdрядки: коли вони закінчили оцінювати, вони висувають значення до стеку.

Якщо ви помістите весь код у документ і роздрукуєте його, ось такий вигляд виглядає:

2009 - > <>

Натхненний Befunge,> <> (Fish) - це езотерична 2D мова на основі стека, тобто потік програми може бути вгору, вниз, вліво або вправо. Початкова версія> <> ознаки многопоточности , де [і ]створила і закінчила теми, але для простоти причини цих інструкції були змінені , щоб створювати і видаляти нові стеки відповідно.

Поточного офіційного перекладача для <<> можна знайти тут . На жаль, посилання на старий перекладач на вікі Esolang порушена.

"Привіт Світ!" Варіант

"!9002 ni edam saw ><>"l?!;obb+0.

Зверніть увагу, як рядок записується назад -> <> технічно не має рядків, єдиним типом даних є дивна суміш char, int та float. "перемикає розбір рядків, натискаючи кожен символ на стек, поки не буде досягнуто закриття ".

Друга половина коду потім виштовхує довжину стека l, перевіряє, чи немає нуля, ?!і якщо так, програма припиняється ;. В іншому випадку покажчик інструкції продовжується, виводячи верхню частину стека з oперед виконанням bb+0., який телепортує вказівник на положення (22, 0)безпосередньо перед l, створюючи цикл.

ASCII Art N

&0 > :&:&:*=?;  :&:&%  :0=?v  :&:&1-=?v  :{:{-&:&,{=?v   " " o   \

                           > ~"N"o                           v    
   +                                  > ~"N"oao              v    
   1                                                 >"N"o   v    

   \                                                         <   /

З інтервалом для наочності. Ви можете спробувати це у новому онлайн-перекладачі тут, і побачити вказівник інструкцій навколо та навколо - просто не забудьте ввести число в текстове поле "Початковий стек". Якщо ви працюєте через інтерпретатора Python, використовуйте -vпрапор для ініціалізації стека, наприклад

py -3 fish.py ascii.fish -v 5

Для цієї програми ми вводимо вхід nв реєстр з &і натискаємо 0, який ми будемо називати i"ітераціями". Решта програми - це гігантський цикл, який іде так:

:&:&:*=?;          If i == n*n, halt. Otherwise ...
:&:&%              Push i%n
:0=?v              If i%n == 0 ...
>~"N"o               Print "N"
:&:&1-=?v          Else if i%n == n-1 ...
>~"N"oao             Print "N" and a newline
:{:{-&:&,{=?v      Else if i%n == i//n, where // is integer division...
>~"N"o               Print "N"
" "o               Otherwise, print a space
1+                 Increment i

Потім повторюємо петлю з початку.

Стрілки ^>v<змінюють напрямок програмного потоку, а дзеркала /\відображають напрямок потоку програми.

GCD

>:{:}%\
;n{v?:/
v~@/

Ось приклад того, як може виглядати програма для гольфу> <>. Ще раз, ви можете спробувати це в онлайн-інтерпретаторі (введіть два значення, розділених комами, у поле "Початковий стек", наприклад 111, 87) або використовуючи -vпрапор інтерпретатора Python, наприклад

py -3 fish.py gcd.fish -v 111 87

Ця програма використовує алгоритм Евкліда. Ось GIF, який я підготував раніше:

Зауважте, що> <> є тороїдальним, тому, коли vвиконується нижня ліва інструкція, вказівник інструкції йде вниз, загортається і знову з’являється вгорі.

Редагувати: змусивши код працювати повністю справа наліво , @randomra вдалося поголити три байти

<~@v!?:%}:{:
;n{/

Здогадуюсь, я не грав його досить :)

2012 - Елемент

Це мова, яку я винайшов на початку 2012 року як просту мову для гольфу. Маючи на увазі, я маю на увазі, що операторів з перевантаженням дуже мало. Оператори також більш прості та менші за кількістю сучасних мов для гольфу.

Найцікавішими рисами цієї мови є її структури даних. Є два стеки та хеш, які використовуються для зберігання інформації.

M-стек - це основний стек, де відбуваються арифметичні та більшість інших операцій. Коли дані вводяться або друкуються, це місце, звідки вони надходять або витягуються.

С-стек - це стек управління. Тут відбувається булева арифметика. Найвищі значення c-стеку використовуються циклом If і while як умовою.

Хеш - це місце, де зберігаються змінні. Збереження ;та ~отримання даних відповідно з хешу.

Елемент - це дуже слабо набрана мова. Він використовує здатність Perl вільно інтерпретувати числа як рядки і навпаки.

Хоча я в цьому, я можу також включити всю документацію на мову. Ви можете знайти оригінальний перекладач 2012 року, написаний на Perl, прямо тут . Оновлення: Я створив більш зручну версію, яку ви можете знайти тут .

OP    the operator.  Each operator is a single character
STACK tells what stacks are affected and how many are popped or pushed
      "o" stands for "other effect"
HASH  tells if it involves the hash
x & y represent two values that are already on the stack, so the effect of
      the operator can be more easily described

OP     STACK  HASH   DESCRIPTION
text     ->m         --whenever a bare word appears, it pushes that string onto 
                       the main stack
_       o->m         --inputs a word and pushes onto main stack
`       m->o         --output.  pops from main stack and prints
xy;    mm->    yes   --variable assignment.  the top stack element y is assigned 
                       the value x
~       m->m   yes   --variable retrieval.  pops from main stack, pushes contents 
                       of the element with that name
x?      m->c         --test. pops x and pushes 0 onto control stack if x is '0' or 
                       an empty string, else pushes 1
><=     m->c         --comparison. pops two numbers off of stack and performs 
                       test, pushes 1 onto control stack if true and 0 if false
'       m->c         --pops from main stack and pushes onto control stack
"       c->m         --pops from control stack and pushes onto main stack
&|     cc->c         --AND/OR. pops two items from control stack, performs and/or 
                       respectively, and pushes result back onto control stack
!       c->c         --NOT. pops a number off of control stack, pushes 1 if 0 or 
                       empty string, 0 otherwise
[]       c           --FOR statement (view the top number number from control stack 
                       and eval those many times)
{}       c           --WHILE (loop until top number on control stack is 0, also 
                       does not pop)
#       m->          --discard. pops from main stack and destroys
(       m->mm        --pops from main stack, removes first character, pushes the 
                       remaining string onto stack, and pushes the removed character 
                       onto stack
)       m->mm        --pops from main stack, removes last character, pushes the 
                       remaining string onto stack, and pushes the removed character 
                       onto stack
+-*/%^ mm->m         --arithmetic. pops two most recent items, adds/negates
                       /multiplies/divides/modulates/exponentiates them, and places 
                       the result on the stack 
xy@    mm->o         --move. pops x and y and moves xth thing in stack to move to 
                       place y in stack
x$      m->m         --length. pops x and pushs length of x onto the stack
xy:    mm->o         --duplication. pops x and y and pushes x onto the stack y times
xy.    mm->m         --concatination. pops x and y and pushes x concatonated with y
\        o           --escapes out of next character, so it isn't an operator and can
                       be pushed onto the stack
,      m->mm         --character conversion. pops from main stack, coverts it to char
                       and pushes, and converts to num and pushes
Newlines and spaces separate different elements to be pushed 
onto the stack individually, but can pushed onto the stack using \

Завдання 1 - Друкувати текст

Element\ was\ made\ in\ 2012\!`

Однією з більш незграбних частин мови є відсутність розділових рядків рядків, через що в цьому рядку потрібні символи втечі. У `кінці друкується рядок.

Завдання 2 - ASCII Art N

_+'[y~1+y;0[1+4:"2:'=1=|y~=|\ [#N]`"#]\
`]

Тут ви будете свідками деяких маніпуляцій стеком. Щоб пояснення було трохи простіше форматувати, я заміню новий рядок на an, Lа пробіл на an S.

_+'[y~1+y;0[1+4:"2:'=1=|y~=|\S[#N]`"#]\L`]
_+'      input line, convert to #, move to c-stack
[        FOR loop
 y~1+y;  increment the y-pos
 0       set the x-pos (the top # on the stack) to zero
 [       FOR loop
  1+4:   increment x-pos and make 3 additional copies (4 is total #)
  "2:'   make a copy of the N size on the main stack
  =      if x-pos == size
  1=     or if x-pos == 1
  y~=|   of if x-pos == y-pos
  \S     (always) push a space
  [      the IF body (technically a FOR loop)
   #N    if true, remove the space and push an N
  ]      end IF
  `      output the pushed character
  "#     remove the result of the conditional
 ]       end x-pos FOR
 \L`     output a newline
]        end y-pos FOR

Зробивши цю екстремальну гольфну відповідь, я знайшов рішення на 39 байт, хоча це набагато складніше.

_'1[y~+y;[#1+3:"2:'%2<y~=|\ [#N]`"]\
`]

Завдання 3 - GCD

__'{"3:~2@%'}`

Це метод на основі стека.

__                 input the two numbers
  '                use one of the number as a condition so the WHILE loop starts
   {        }      a WHILE loop. Repeats while the c-stack has a true value on top
    "              get the number back from the c-stack to do operations on it
     3:            make it so that there are threes copies on the stack
       ~           takes one of the copies from earlier and converts it to a zero
        2@         take the top item on the stack and move it behind the other two #s
          %        modulo operation
           '       use this number as the condition
             `     since one number is zero (and on the c-stack) print the 
                   other number, which is on m-stack

2012 - Юлія

Історія мови

Джулія була розроблена в 2012 році Джеффом Безансоном, Стефаном Карпінським та Вірусом Шахом, тоді як Джефф був студентом Массачусетського технологічного інституту (MIT), який консультував професор Алан Едельман. Їх мотивувало прагнення до мови програмування, яка була відкритим, швидким та динамічним (серед багатьох інших), зберігаючи зручність використання у різних програмах. Продуктом була Юлія, свіжий підхід до високопродуктивних наукових обчислень.

"Привіт Світ!" Варіант

println("Julia was made in 2012!")

Друк до STDOUT у Джулії досить простий!

ASCII Art N

function asciin(n)
    # Create an nxn matrix of spaces
    m = fill(" ", (n, n))

    # Fill the first and last columns with "N"
    m[:,1] = m[:,n] = "N"

    # Fill the diagonal elements with "N"
    setindex!(m, "N", diagind(m))

    # Print each row of the matrix as a joined string
    for i = 1:n
        println(join(m[i,:]))
    end
end

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

GCD

function g(a, b)
    b == 0 ? a : g(b, a % b)
end

Останнє, що перераховано у функції, повертається неявно.

1988 - Математика

Або я повинен називати це Вольфрам Мовою ?

Завдання 0

Творець Mathematica - Стівен Вольфрам, Засновник та генеральний директор Wolfram Research. До розвитку Математики він був фізиком. Була величезна кількість алгебраїчних обчислень у фізиці, тому він став користувачем Macsyma .

Вольфрам отримав докторську ступінь в 1979 році, коли йому було 20 років. Він вважав, що для занять фізикою йому потрібен кращий КАС, ніж Макіма, тому він почав писати SMP ("Програма символічного маніпуляції"). Перша версія SMP була випущена в 1981 році. SMP був попередником Mathematica. Хоча це мало глибокий вплив на Mathematica, жоден його код ніколи не використовувався для Mathematica.

У 1986 році Вольфрам вирішив написати "кінцеву систему обчислень". Він почав писати код у 1986 році, а заснований Wolfram Research у 1987 році. Нарешті, Mathematica 1.0 була випущена 23 червня 1988 року.

Я не знайшов Mathematica 1.0. Насправді, Mathematica 1.0 не мала ані версії Windows, ані Linux. Але я знайшов Mathematica 2.0 на китайському веб-сайті. Він все ще може працювати в Windows XP.

Завдання 1

Print["Mathematica was made in 1988!"]

Або просто:

"Mathematica was made in 1988!"

Завдання 2

У сучасній Mathematica ми можемо написати:

asciiArtN[n_] := Print @@@ SparseArray[{i_, 1 | i_ | n} -> "N", {n, n}, " "]

Так само, як і Юлія та R , це матричне рішення. У Mathematica можна визначити розріджену матрицю, використовуючи відповідність шаблонів.

Однак він SparseArrayбув введений в Mathematica 5.0, тому ми не можемо використовувати його в Mathematica 1.0.

Ось рішення, яке працює в Mathematica 1.0:

asciiArtN[n_] := Block[{f},
  f[i_, 1]  = "N";
  f[i_, i_] = "N";
  f[i_, n]  = "N";
  f[__]     = " ";
  Apply[Print, Array[f, {n, n}], 1];
]

Ми не можемо писати, f[i_, 1 | i_ | n] = "N"тому що Alternativesбуло введено в Mathematica 2.0.

Завдання 3

Ми можемо просто використовувати вбудовану функцію:

gcd = GCD

Або ми можемо використовувати визначення GCD:

gcd = Max[Intersection @@ Divisors[{##}]] &;

Або ми можемо використовувати LCM , хоча частіше LCM обчислюється з GCD:

gcd = Times[##]/LCM[##] &;

Або ми можемо використовувати алгоритм Евкліда з узгодженням зразків:

gcd[a_, 0] := a
gcd[a_, b_] := gcd[b, Mod[a, b]]

Або як анонімна функція:

gcd = If[#2 == 0, #1, #0[#2, Mod[##]]] &;

Усі вищевказані функції були введені в Mathematica 1.0.

1999 - XSLT

World Wide Web Consortium (W3C) створив XSLT для перетворення XML в HTML, текст і т.д. Наступні приклади припускають введення укладений в <input>..</input>тегах.

Завдання 1

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">XSLT was made in 1999!</xsl:template>
</xsl:stylesheet>

Цей простий. Він відповідає inputтегу на верхньому рівні і замінює його потрібним результатом.

Завдання 2

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">
    <xsl:call-template name="loop">
      <xsl:with-param name="i">1</xsl:with-param>
      <xsl:with-param name="n">
        <xsl:value-of select="."/>
      </xsl:with-param>
    </xsl:call-template>
  </xsl:template>
  <xsl:template name="loop">
    <xsl:param name="i"/>
    <xsl:param name="n"/>
    <xsl:choose>
      <xsl:when test="$i = 1 or $i = $n">
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$n - 2"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N&#13;&#10;</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$i - 2"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$n - $i - 1"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N&#13;&#10;</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:if test="$i &lt; $n">
      <xsl:call-template name="loop">
        <xsl:with-param name="i">
          <xsl:value-of select="$i + 1"/>
        </xsl:with-param>
        <xsl:with-param name="n">
          <xsl:value-of select="$n"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:template>
      <xsl:template name="spaces">
    <xsl:param name="n"/>
    <xsl:if test="$n &gt; 0">
      <xsl:text> </xsl:text>
      <xsl:call-template name="spaces">
        <xsl:with-param name="n">
          <xsl:value-of select="$n - 1"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:template>
</xsl:stylesheet>

Цей визначає 2 рекурсивні шаблони loopта spaces. loopз параметрами iі nбуде генерувати бажаний вихід для n, починаючи з позиції i. spacesз параметром nбуде генерувати nпробіли.

Завдання 3

Введення для цього має бути в <input><num>..</num><num>..</num></input>тегах.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">
    <xsl:call-template name="gcd">
      <xsl:with-param name="a"><xsl:value-of select="num[1]"/></xsl:with-param>
      <xsl:with-param name="b"><xsl:value-of select="num[2]"/></xsl:with-param>
    </xsl:call-template>
  </xsl:template>
  <xsl:template name="gcd">
    <xsl:param name="a"/>
    <xsl:param name="b"/>
    <xsl:choose>
      <xsl:when test="$b = 0"><xsl:value-of select="$a"/></xsl:when>
      <xsl:otherwise>
        <xsl:call-template name="gcd">
          <xsl:with-param name="a"><xsl:value-of select="$b"/></xsl:with-param>
          <xsl:with-param name="b"><xsl:value-of select="$a mod $b"/></xsl:with-param>
        </xsl:call-template>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
</xsl:stylesheet>

Цей лише рекурсивний шаблон, gcdякий використовує алгоритм Евкліда.

2014 - CJam

CJam був створений користувачем PPCG aditsu і був випущений близько квітня 2014 року .

"Привіт Світ!" Варіант

"CJam was made in 2014!"

CJam автоматично друкує вміст стеку в кінці програми

ASCII Art N

ri:R'#*a_R2-,{_)S*'#+\R((-zS*+}%+\+R<zN*

Пояснення коду:

ri:R                                       "Read the input as integer in R";
    '#*a                                   "Get a string of R # and wrap it in an array";
        _R2-,{                }%           "Copy that string and then run this loop R-2";
                                           "times for the diagonal";
              _)S*                         "Get iteration index + 1 spaces";
                  '#+                      "Append the hash";
                     \R((-zS*+             "Append remaining spaces";
                                +\+        "Append and prepend the initial # string";
                                   R<      "Take only R columns/rows. This is for";
                                           "tackling input 1";
                                     zN*   "Transpose and join with new lines";

Приймає висоту / ширину N як вхід через STDIN. Спробуйте його онлайн тут

GCD

l~{_@\%}h;

Приймає два числа як вхідні дані через STDIN. Спробуйте його онлайн тут

1990 - Хаскелл

Haskell - це популярна (чи варто сказати: найпопулярніша ?) Чиста функціональна мова. Це випливає з мейнстріму своєю незвичайною моделлю оцінювання (за замовчуванням все ліниво або, технічно, не суворо) та системою типу «Хіндлі-Мілнер», яка навіть зараз є однією з найпотужніших.

Завдання 1

main = putStrLn "Haskell was made in 1990!"

Завдання 2

-- Infinite list of growing letters 'N'
bigNs :: [[[Char]]]
bigNs = ["N"]
      : ["NN","NN"]
      : [ ins (ins 'N' t) $ map (ins ' ') n | n@(t:_) <- tail bigNs ]

-- Insert a new element after the head (i.e. at the second position).
ins :: a -> [a] -> [a]
ins x (l:ls) = l:x:ls

Демо, надрукуйте весь нескінченний список (поки користувач не перерве або не закінчиться світ ...)

GHCi> mapM_ (putStrLn . unlines) bigNs
N

NN
NN

N N
NNN
N N

N  N
NN N
N NN
N  N

N   N
NN  N
N N N
N  NN
N   N

N    N
NN   N
N N  N
N  N N
N   NN
N    N

...

Звичайно, ви можете легко дістатися до одного з них, відкривши лише один елемент нескінченного списку:

main :: IO ()
main = do
   i <- readLn
   putStrLn . unlines $ bigNs!!i

Завдання 3

gcd' :: Integer -> Integer -> Integer
gcd' a 0 = a
gcd' a b = gcd' b $ a`mod`b

1972 р. - ІНТЕРКАЛ

І ти думав, що Фортран і Кобол дивні. Це божевільно!

Завдання 1

DO ,1 <- #27
DO ,1SUB#1 <- #110
DO ,1SUB#2 <- #32
DO ,1SUB#3 <- #72
PLEASE DO ,1SUB#4 <- #136
DO ,1SUB#5 <- #88
DO ,1SUB#6 <- #136
PLEASE DO ,1SUB#7 <- #64
DO ,1SUB#8 <- #80
DO ,1SUB#9 <- #46
PLEASE DO ,1SUB#10 <- #22
DO ,1SUB#11 <- #104
DO ,1SUB#12 <- #184
PLEASE DO ,1SUB#13 <- #202
DO ,1SUB#14 <- #78
DO ,1SUB#15 <- #48
PLEASE DO ,1SUB#16 <- #96
DO ,1SUB#17 <- #128
DO ,1SUB#18 <- #162
PLEASE DO ,1SUB#19 <- #110
DO ,1SUB#20 <- #32
DO ,1SUB#21 <- #114
PLEASE DO ,1SUB#22 <- #120
DO ,1SUB#23 <- #240
DO ,1SUB#24 <- #128
PLEASE DO ,1SUB#25 <- #208
DO ,1SUB#26 <- #200
DO ,1SUB#27 <- #52
DO READ OUT ,1
DO GIVE UP

Я не збираюся намагатися пояснювати систему введення та виведення INTERCAL; просто прочитайте це і сподівайтеся, що ви не помрете.

Завдання 2

DO WRITE IN 7
DO .1 <- .7
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .8 <- .3
DO .5 <- .7
DO .6 <- .8
DO ,9 <- #2

DO (100) NEXT
DO (1) NEXT

(100) DO (99) NEXT
DO ,9SUB#1 <- #142
DO ,9SUB#2 <- #114
PLEASE DO READ OUT ,9
DO ,9SUB#1 <- #176
DO ,9SUB#2 <- #80
PLEASE DO READ OUT ,9
PLEASE GIVE UP

(99) DO .1 <- .7
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(1) PLEASE DO (3) NEXT
PLEASE DO FORGET #1
DO (1) NEXT

(3) DO (4) NEXT
PLEASE GIVE UP

(4) DO (8) NEXT
DO ,9SUB#1 <- #176
DO ,9SUB#2 <- #80
PLEASE DO READ OUT ,9
DO .6 <- .8
DO .1 <- .5
DO .2 <- #1
DO (1010) NEXT
DO .5 <- .3
DO .1 <- '.5~.5'~#1
PLEASE DO FORGET .1
DO RESUME #1

(8) DO (5) NEXT

(5) PLEASE DO (6) NEXT
PLEASE DO FORGET #1
DO (5) NEXT

(6) PLEASE DO (7) NEXT
DO RESUME #2

(7) DO (10) NEXT
DO .1 <- .6
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .6 <- .3
DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

(10) DO (11) NEXT
DO (13) NEXT
DO (14) NEXT
DO (15) NEXT

(11) DO (111) NEXT
DO (112) NEXT

(13) DO (113) NEXT
DO (112) NEXT

(14) DO (114) NEXT
DO (112) NEXT

(111) DO .1 <- .6
DO .2 <- .8
DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(112) DO ,9SUB#1 <- #142
DO ,9SUB#2 <- #114
PLEASE DO READ OUT ,9
DO RESUME #3

(113) DO .1 <- .6
DO .2 <- #1
DO (1000) NEXT
DO .1 <- .5
DO .2 <- .3
DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(114) DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

(15) DO ,9SUB#1 <- #252
DO ,9SUB#2 <- #4
PLEASE DO READ OUT ,9
DO RESUME #2

Боже мій. Це зайняло мене трохи, щоб розібратися. Номери етикетки безлад і тому відображають це. Я не буду намагатися пояснити це, якщо хтось не попросить.

Завдання 3

DO WRITE IN .5
DO WRITE IN .6

DO (1) NEXT

(1) PLEASE DO (3) NEXT
DO FORGET #1
DO (1) NEXT

(3) DO (4) NEXT
DO READ OUT .5
PLEASE GIVE UP

(4) DO .1 <- .5
DO .2 <- .6
PLEASE DO (1040) NEXT
DO .1 <- .3
DO .2 <- .6
PLEASE DO (1039) NEXT
DO .2 <- .3
DO .1 <- .5
DO (1010) NEXT
DO .5 <- .6
DO .6 <- .3
DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

Це один простіший. Через ... дивацтво INTERCAL, ви повинні ввести такі цифри:

THREE FIVE

Наприклад, щоб отримати GCD 42 та 16, я б ввів:

FOUR TWO
ONE SIX

Він також друкує число римськими цифрами ... адже це ІНТЕРКАЛ для вас!

1967 р. - АПЛ

У 1957 році в Гарвардському університеті Кен Іверсон почав розробляти математичні позначення для маніпулювання масивом. Протягом 1960-х його позначення переробили в мову програмування в IBM. Перша часткова реалізація була створена в 1963 році, і її навіть використовували в середній школі для навчання учнів про трансцендентальні функції. Повна, зручна реалізація повинна була чекати до 1965 року. Протягом двох років IBM її використовувала лише внутрішньо. У 1967 р. IBM випустила для громадськості перекладач APL, який працював на комп'ютері IBM 1130, який був закінчений у 1966 р. Ви можете зрозуміти, як трохи важко вибрати рік для цього, однак, я думаю, це має бути 1967 рік оскільки це перший рік, повне впровадження стало доступним для громадськості. Якщо хтось дійсно не погоджується, я міг би це змінити.

Вихідний код для APL \ 360 є онлайн , як і емулятор. Це те, що я використав для тестування цих прикладів. Він датується 1967 роком, а поряд з APL \ 1130 (для згаданого IBM 1130) є більш-менш справжнім оригіналом. Як і очікувалося, це дуже примітивно. Їй не вистачає підтримки для таких тонкощів, як малі літери, будь-які оператори працюють лише з вбудованими функціями, а набір вбудованих функцій дуже рідкий (зокрема, ∨є лише or і не подвоюється як gcd). Оригінальний, повний опис доступний тут , проте я помітив, що версія, яку я мав, не є навіть повною щодо цього документа, якої бракує ⍎серед інших.

Я надав програми як у форматі Unicode (щоб ви могли їх прочитати), так і в оригінальному кодуванні (щоб ви могли вирізати та вставити їх у вікно APL емулятора).

Неймовірно, що ці програми працюють коректно без будь-яких змін (крім кодування) в сучасних версіях Dyalog, NARS2000 та GNU APL. Тож я здогадуюсь, що знайшов спосіб написати портативний APL: просто прикинься, що це 1967 рік!

Завдання 1:

Unicode:

⎕←'APL WAS MADE IN 1967!'

APL \ 360:

L[Kapl was made in 1967ÝK

Завдання 2:

Unicode:

⎕←' N'[1+((2⍴N)⍴(⍳N)∊1,N)∨(⍳N)∘.=⍳N←⎕]

APL \ 360:

L[K nK;1-::2Rn"R:In"E1,n"(:In"J.%In[L'

Завдання 3:

Я вирішив це стандартним рекурсивним способом. Теоретично ви можете зробити щось розумне та орієнтоване на масив, як відповідь J; На практиці, однак, це використання O (N) пам’яті і швидко переповнює програмне забезпечення Flower-Power-era та програмне забезпечення.

Unicode:

∇R←A GCD B
R←A
→(B=0)/0
R←B GCD B|A
∇

⎕←⎕ GCD ⎕

APL \ 360:

Gr[a gcd b
r[a
{:b%0"/0
r[b gcd bMa
G

L[L gcd L

1996 - Окамл

Більше дня чекав, коли хтось заповнить 1996 рік, щоб я міг заповнити Рубі. Ну чому б не навчитися OCaml тоді, схоже, на haskell ...

Привіт Світ

print_endline "OCaml was made in 1996!";;

ASCII

let ascii n =
  let rec ascii' = function
    | 0 -> ()
    | i ->
        let s = "N" ^ String.make (n-2) ' ' ^ "N" in
        String.fill s (n-i) 1 'N';
        print_endline s;
        ascii' (i-1)
  in ascii' n;;

Змінні струни!

GCD

let rec gcd a b = if b = 0 then a else gcd b (a mod b);;

Ні ==та інфікс mod, це мило

2005 - прелюдія

Прелюдія - це дуже весела мова, вихідний код якого складається з декількох "голосів", які виконуються паралельно і в яких мені дуже подобається вирішувати проблеми . Мається на увазі представлення ASCII своєї сестринської мови Fugue , яка фактично приймає .midi файли як вихідний код і кодує інструкції, знайдені в Prelude, як інтервали в мелодіях голосів.

Прелюдія є досить мінімалістичною, але Тьюрінг завершена (за умови, що ви використовуєте принаймні 2 голоси). Як я вже сказав, голоси (рядки коду) виконуються одночасно, колонка за стовпцем. Кожен голос працює на власному стеку, який ініціалізується на нескінченну кількість нулів. Prelude підтримує такі інструкції:

0-9 ... Push the corresponding digit.
+   ... Add the top two numbers on the stack.
-   ... Subtract the top number from the one beneath.
#   ... Discard the top of the stack.
^   ... Copy the top value from the voice above.
v   ... Copy the top value from the voice below.
?   ... Read a number and push it onto the stack.
!   ... Print the top number (and pop it from the stack).
(   ... If the top of the stack is zero, jump past the matching ')'.
)   ... If the top of the stack is zero, jump to the column after the matching '('.

Деякі додаткові примітки:

• Голоси циклічні, тому ^вгорі голос копіюється з нижнього голосу (і навпаки).
• Кілька ?і !в тому ж стовпці виконуються зверху вниз.
• Як в специфікації мови , ?а !читати і писати символи з відповідним кодом символу. Однак інтерпретатор Python також має в своєму коді перемикач для друку самих чисел. Для тестування я фактично використовую модифіковану версію, яка також може читати числа замість символів. Але єдиний висновок тут полягає в тому, що числовий вхід / вихід насправді може бути заданий як байтові значення, отже, ці зміни не потрібні для створення дійсних програм, що мають справу з числами.
• Відповідність (і )не потрібно бути одним голосом. Голос, що використовується для умови, завжди є тим, де (з’являється. Отже, вертикальне положення )фігури абсолютно не має значення.
• Зважаючи на характер одночасного виконання Prelude, будь-яка інструкція в тому ж стовпці, що і a (, виконується лише один раз до початку циклу, незалежно від того, чи введено цикл. Аналогічно, будь-яка інструкція в тому ж стовпці, що і а ), виконується в кінці кожної ітерації, незалежно від того, чи буде цикл після цієї ітерації.

Я спочатку покажу вам три програми без особливих коментарів. Ви можете знайти пояснення нижче.

Програми

"Привіт Світ!" Варіант

9(1-)v98+^++!9v+!  v88++2+!^  ! ^9-3-! v      !    v2-!55+!
8 8+ !     7v+! 1v+!88+^+!^4-!^ v8-^ !!!9v+  !^9+9+!  v5+!
     ^98++4+! ^8-! ^4-   ^ #!^6-!    ^^  #5+! v    ^2-!1+!

Якщо ви використовуєте інтерпретатор Python, переконайтеся, що NUMERIC_OUTPUT = False.

ASCII Art N

      v2-(1-)v         
9(1-)?1-( v!  (1-55+!      0     (0)#  ))55+!
4-4+                  v^-#
     v!      v! v1-v!(1- ^(#^!0)# v! )v!
6 8+           v#

Для зручності використання ця програма отримує перевагу від зчитування введення у вигляді цифр, але вихід не повинен бути числовим. Отже, якщо ви використовуєте модифікований інтерпретатор Python, встановіть

NUMERIC_INPUT = True
NUMERIC_OUTPUT = False

GCD

?(                         v)
? (^-(0 # v   #       ^+0)#^ !
     ^^ (##v^v+)#  0 (0 )   
      1) ^ #  - 1+(#)#

Це найкраще використовувати для всіх числових входів / виходів, тобто

NUMERIC_INPUT = True
NUMERIC_OUTPUT = True

Пояснення

"Привіт Світ!" Варіант

Це досить прямо. Я використовую 3 голоси, щоб послідовно генерувати коди символів для всіх символів Prelude was made in 2005!. Почніть з обчислення 8 + 9*8 = 80, який є символьним кодом P:

 9(1-)
 8 8+

Після цього я здебільшого просто копіюю попередній код символів і додаю чи віднімаю різницю до наступного. Ось код, але кожен з них !замінюється символом, який друкується (і _для пробілів, і %для цифр):

9(1-)v98+^++r9v+u  v88++2+w^  _ ^9-3-a v      _    v2-%55+!
8 8+ P     7v+l 1v+e88+^+_^4-s^ v8-^ de_9v+  n^9+9+%  v5+%
     ^98++4+e ^8-d ^4-   ^ #a^6-m    ^^  #5+i v    ^2-%1+!

Остаточний 55+!друкує зворотний новий рядок, просто тому, що це приємніше.

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

ASCII Art N

      v2-(1-)v         
9(1-)?1-( v!  (1-55+!      0     (0)#  ))55+!
4-4+                  v^-#
     v!      v! v1-v!(1- ^(#^!0)# v! )v!
6 8+           v#

Маючи 5 голосів, це, безумовно, одна з найскладніших програм, про які я писав дотепер. Орієнтовно голоси мають такі цілі:

1. Просто голос-помічник, який зберігається N-1для використання у внутрішньому циклі.
2. Це свого роду "головний" голос, який читає введення, містить важливий перемикач, а також містить зовнішній цикл (тобто той, що знаходиться над рядками).
3. Це дозволяє зберігати місця 32для зручного друку.
4. Тут міститься внутрішня петля (та над стовпцями).
5. Це зберігає 78для зручного друку Ns.

Давайте переглянемо кодову частину за частиною. По-перше, я створюю 32як -4 + 9*4і 78як 6 + 9*8:

9(1-)
4-4+

6 8+

Тепер я друкую сингл N(тому що він нам завжди потрібен) під час читання введення Nта зберігання N-1та N-2в перших двох голосах:

      v2-
     ?1-

     v!

Далі, є "петля", що обумовлена N-1. В кінці циклу другий голос завжди зводиться до 0, і цикл виходить після першої ітерації. Так по суті, це тільки if(N > 1){...}. Після циклу друкуємо єдиний зворотний рядок. Для резюме, ми отримали таку основу:

      v2-
9(1-)?1-(                               )55+!
4-4+
     v!
6 8+

Всередині цього умовного значення ми спочатку робимо N-2пробіли та сингл Nдля завершення першого ряду, а також зберігаємо N-1перший голос для подальшого використання:

         (1-)v         
          v!  

             v!

Тепер справжнє м'ясо коду. По-перше, є зовнішня петля, на якій друкуються N-1рядки. Для кожного рядка спочатку друкуємо новий рядок та an N. Потім ми циклічаємо N-2рази, друкуючи або пробіли, або Ns (докладніше про це пізніше). І нарешті друкуємо ще N:

               1-55+!  

                v1-v!(               )v!
               v#

Нарешті, найцікавіша частина: друк кожного рядка (та отримання положення Nправоруч). Насправді в Prelude насправді немає if / else, тому я повинен будувати його сам, використовуючи дві петлі на різних голосах. Умову можна легко отримати, віднявши змінну внутрішньої та зовнішньої петлі - ми отримуємо, 0якщо ми хочемо надрукувати, Nі щось не нульове, якщо ми хочемо надрукувати пробіл.

Основна ідея if / else в Prelude - поставити цикл після відповідного значення - "if" (або не нульовий) код та негайно вийти з нього, натиснувши a 0. На іншому голосі ви зберігаєте ненульове значення та інший цикл після циклу "якщо". Під час циклу "if" ви ставите нуль поверх цього іншого голосу, щоб запобігти виконанню "else". Існує деяка гнучкість у тому, чи натискаєте нульові значення поверх ненульових значень або просто відкидаєте ненульове значення, якщо під ним є нуль, але це загальна ідея. Після цього, можливо, вам доведеться зробити чистку, якщо ви хочете продовжувати використовувати відповідний голос. Ось як виглядає код:

                           0     (0)#
                      v^-#
                      1- ^(#^!0)# v! 

І це все!

GCD

Це "просто" ітеративна реалізація алгоритму Евкліда. Але модуль у Prelude трохи дратує, головним чином тому, що ви не можете легко перевірити, чи є число позитивним чи негативним. Цей код робить використання Сігнум реалізації я написав якийсь час назад . Тобто значна частина коду просто перетворює число в -1, 0або 1. Потім це може бути легко перетворено на умову отримання додатних чи від'ємних чисел шляхом додавання чи віднімання 1.

?(                         v)
? (^-(0 # v   #       ^+0)#^ !
     ^^ (##v^v+)#  0 (0 )   
      1) ^ #  - 1+(#)#

Тож у нас цього разу чотири голоси. Перший голос просто відстежує bі містить головну умову припинення (тобто цикл виходить, коли bстає 0). Другий голос містить aі за допомогою голосів три і чотири обчислення a % b, перед тим як поміняти результат попереднім b. Нарешті, !відбитки aколи b == 0.

Розглянемо спочатку частину входу :

     (0 # v   #
     ^^ (##v^v+)#
      1) ^ #  -

Номер введення nзнаходиться на першому з цих голосів (другий голос у повній програмі). Результат закінчиться голосом внизу. Очікується, що інші два голоси будуть порожніми (тобто заповненими нулями). Зауважте, що якщо n == 0, то обидві петлі пропускаються, і голос внизу все ще містить 0саме те, що ми хочемо.

Якщо nнемає нуля, вводиться перший невеликий цикл. Ми натискаємо нуль, щоб негайно вийти з нього, ставимо дві копії nна середній голос і 1на нижній голос. Тепер основна ідея полягає в збільшенні однієї з копій, nпри цьому декрементування іншої копії до nтих пір, поки одна з них не досягне нуля. Роблячи це, 1голос знизу гортає свій знак весь час (що легко зробити, віднявши його з- 0під нього на стеку). Це налаштовано так, що коли одне з чисел дорівнює нулю, голос внизу міститиме правильний знак.

Тепер модуль реалізується відніманням bвід, aпоки результат не буде негативним. Коли це станеться, ми додаємо bще раз. Ось цей біт:

  (^-  signum         ^+0)#
       signum      0 (0 )   
       signum   1+(#)#

Зауважте конструкцію if / else внизу, яка схожа на ту, яку я використовував для завдання 2.

2007 - Скретч

Scratch - це мова, виготовлена ​​MIT для освітніх цілей. Я вже дуже 5 років цим займаюся; про це пізніше.

Все це можна переглянути тут .

Я зараз дуже кинувся і поясню фрагменти пізніше. Сподіваємось, вони все-таки чіткі роз'яснення.

Завдання 1

Завдання 2

Завдання 3

1972 - С

Ми всі знаємо про C, чи не так? C створений в Bell Labs, разом з Unix. Unix в значній мірі написаний на C. Всі сучасні похідні Unix досі в значній мірі написані в синтаксисі C. C вплинули на багато, багато мов програмування. Це, мабуть, найдавніша мова програмування, яка все ще широко використовується для нових розробок.

Сам по собі є нащадком Б, який, сподіваюся, опиниться і в цьому списку. Не було мови програмування "A": B - це варіант BCPL, який, у свою чергу, є зменшеним CPL. Жодна з цих мов ніколи не була дуже популярною. Однак BCPL була мовою, якою була написана перша програма «Hello World». Ще один цікавий факт полягає в тому, що B мав і свої, /* */і //коментарі, але C відмовився від //коментарів. Пізніше вони були знову введені в C зі стандартом C99.

Програми C тут були протестовані за допомогою компілятора Unix V5 C, починаючи з 1974 р. Це був найстаріший компілятор C, який я міг знайти та приступити до роботи, і ці програми не збиратимуться на сучасному компіляторі C. (Одна з внесених змін полягає в тому, що оператори мутації, як +=писали раніше =+).

#include <... >ще не існувало. Ні багато з стандартної бібліотеки. Довелося писати своє atoi. Я пройшов деякі вихідні коди V5, щоб зрозуміти, які речі дозволені, а які - ні. Я використовував першу версію structs, але оскільки я не використовував їх, і синтаксис, схоже, не сильно змінився до V7 (як K&R C), це може працювати і з більш ранніми версіями.

Я зробив усе можливе, щоб написати свій код у тому ж стилі, який використовує вихідний код V5. (Не все це дуже страшно.)

Шукайте тут посилання на емулятор Unix V5, інструкції щодо його запуску на сучасному комп’ютері.

Завдання 1

main()
{
   write(1, "C was made in 1972!\n", 20);
}

Завдання 2

atoi(str)
char *str;
{
    register num, digit;
    while (digit = *str++) {
        num =* 10;
        num =+ digit - '0';

    }
    return num;
}

N(n)
{
    register x, y;
    for (y=1; y<=n; y++) {
        for (x=1; x<=n; x++) {
            write(1, " N"+(x==1||x==y||x==n), 1);
        }
        write(1, "\n", 1);
    }
}

main(argc, argv)
char *argv[];
{
    N(atoi(argv[1]));
}

Завдання 3

atoi(str)
char *str;
{
    register num, digit;
    while (digit = *str++) {
        num =* 10;
        num =+ digit - '0';
    }
    return num;
}

gcd(a, b)
{
    return b ? gcd(b, a%b) : a;
}

main(argc, argv)
char *argv[];
{
    printf("%d\n", gcd(atoi(argv[1]), atoi(argv[2])));
}

2009 - Ідріс

Ідріс є чисто типовою функціональною мовою, яка підкреслює, що насправді практично корисна для реальних програм, крім пропонування надзвичайно жорстких можливостей доказування, досяжних залежних типів.

Завдання 1

module Main

main : IO ()
main = putStrLn "Idris was made in 2009!"

Завдання 2

module InN

import Data.Fin
import Data.Vect

genN : Vect n (Vect n Char)
genN = [[ if inN x y then 'N' else ' ' | x<-range ]| y<-range ]

||| Helper function, determines whether the char at coordinate (x,y)
||| is part of the letter:
inN : Fin n -> Fin n -> Bool
inN {n=S _} x y = x==0 || x==y || x==last

Цей не є програмою, а просто функцією (точніше, залежною величиною ), що створює бажану букву N як двовимірний масив.

$ idris ascii-n.idr 
     ____    __     _                                          
    /  _/___/ /____(_)____                                     
    / // __  / ___/ / ___/     Version 0.9.17.1-
  _/ // /_/ / /  / (__  )      http://www.idris-lang.org/      
 /___/\__,_/_/  /_/____/       Type :? for help               

Idris is free software with ABSOLUTELY NO WARRANTY.            
For details type :warranty.
Type checking ./ascii-n.idr
*ascii-n> genN {n=4}
[['N', ' ', ' ', 'N'],
 ['N', 'N', ' ', 'N'],
 ['N', ' ', 'N', 'N'],
 ['N', ' ', ' ', 'N']] : Vect 4 (Vect 4 Char)

Завдання 3

module gcd

gcd' : Nat -> Nat -> Nat
gcd' a Z = a
gcd' a b = gcd' b $ a`mod`b

Зауважте, що мені довелося вибрати ім'я, gcd'оскільки, як gcdце вже визначено в прелюдії Ідріса.

Type checking ./gcd.idr
*gcd> gcd' 8 12
4 : Nat
*gcd> gcd' 12 8
4 : Nat
*gcd> gcd' 234 876
6 : Nat

2014 - Піт

Оскільки у нас є CJam, ми можемо також мати Pyth для повноти :)

Pyth - мова для гри в гольф від @isaacg, яка збирається на Python. Він примітний тим, що є процедурним та використовує позначення префікса. Піт вперше з'явився близько червня 2014 року .

"Привіт Світ!" Варіант

"Pyth was made in 2014!

Зверніть увагу на відсутність кінцевої цитати, яка не є обов'язковою, якщо програма Pyth закінчується в рядку.

ASCII Art N

VQ+\Nt+P++*Nd\N*t-QNd\N

Спробуйте в Інтернеті . Еквівалентним Python є:

Q = eval(input())
for N in range(Q):
    print("N"+((" "*N+"N"+(Q-N-1)*" ")[:-1]+"N")[1:])

Або розширений (перший і третій рядки неявні):

Q = eval(input())                                        # 
for N in range(Q):                                       #   VQ
    print(                                          )    # 
          "N"+                                           #     +\N
              (                                )[1:]     #        t
                                           +"N"          #         +              \N
               (                     )[:-1]              #          P
                         +(Q-N-1)*" "                    #           +      *t-QNd
                     +"N"                                #            +   \N
                " "*N                                    #             *Nd

GCD

=GvwWQAGQ,Q%GQ)G

Ця програма використовує алгоритм Евкліда і приймає два числа, розділені новим рядком. Спробуйте в Інтернеті .

Q = eval(input())     #
G = eval(input())     #    =Gvw
while Q != 0:         #        WQ
  G, Q = Q, G % Q     #          AGQ,Q%GQ)
print(G)              #                   G

i.uQще коротше, якщо ми будемо використовувати вбудований для GCD. Це еквівалентно print(gcd(*eval(input())))(взяття в якості введення двох цифр, розділених комами).

1964 р. - Дартмутська ОСНОВА

BASIC - сімейство мов програмування високого рівня загального призначення, філософія дизайну підкреслює простоту використання. У 1964 році Джон Г. Кемені та Томас Е. Курц розробили оригінальну мову на базі Дартмутського коледжу в Нью-Гемпширі. Вони хотіли дозволити студентам інших галузей, крім науки та математики, використовувати комп'ютери.

Я дивлюся на цей посібник по BASIC з 1964 року, і цей емулятор системи обміну часом у Дартмуті, на якому він працював. Сервер все ще працює, але, на жаль, реєстрація акаунта здається неможливою. Наразі ці програми теоретично повинні працювати:

Завдання 1

10 PRINT "BASIC WAS MADE IN 1964"
20 END

Завдання 2

10 READ N
15 FOR Y = 1 TO N STEP 1
20 FOR X = 1 TO N STEP 1
25 IF X = 1 THEN 50
30 IF X = N THEN 50
35 IF X = Y THEN 50
40 PRINT " ",
45 GO TO 55
50 PRINT "N",
55 NEXT X
60 PRINT
65 NEXT Y
70 DATA 5
75 END

Виводимо щось на кшталт:

N                       N
N     N                 N
N           N           N
N                 N     N
N                       N

Зверніть увагу, як вводиться вхід як частина програми ( 70 DATA 5); READшлях інструкції у верхній частині витягує дані звідти. Не існує строкової конкатенації, але в розділі 3.1 цього посібника описано, як PRINTзаписуються результати у табличні "зони" на виході.

Завдання 3

Повільна версія алгоритму Евкліда:

10 READ A, B
20 IF A = B THEN 80
30 IF A < B THEN 60
40 LET A = A - B
50 GO TO 20
60 LET B = B - A
70 GO TO 20
80 PRINT A
85 DATA 144, 250
90 END

Виведення:

2

2010 р. - WTFZOMFG

WTFZOMFG - це езотеричні мови, засновані на Brainfuck. Це було зроблено Джеєм Сонгдахом у 2010 році. "WTFZOMFG" - це скорочення до "Що це за функція? .

Ось компілятор для * nix систем .

Завдання 1

'WTFZOMFG was made in 2010!\n"

Завдання 2

/&(-.N%3 >&>s-{-(-. ).N}>{-(-. ).N}_0 '\n")

Пояснення:

Вибачте. Мені недобре писати пояснення.

/                                           # read the number and store it in cell 0
 &                                          # copy it to cell 1
  (                                         # loop while cell 0 isn't 0
   -                                        # decrease the value of cell 0
    .N                                      # print "N"
      %3                                    # copy cell 0 to cell 3
                                            # a space must be added after the number. I don't know if it's a bug of the compiler or a feature.
         >                                  # move to cell 1
          &                                 # copy cell 1 to cell 2
           >                                # move cell 2
            s                               # let cell 2 = cell 2 - cell 3
             -                              # decrease the value of cell 2
              {                             # if cell 2 isn't 0
               -                            # decrease the value of cell 2
                (-. )                       # while cell 2 isn't 0, decrease it and print " "
                     .N                     # print "N"
                       }                    # end if
                        >                   # move cell 3
                         {                  # if cell 3 isn't 0
                          -                 # decrease the value of cell 3
                           (-. )            # while cell 3 isn't 0, decrease it and print " "
                                .N          # print "N"
                                  }         # end if
                                   _0       # move to cell 0
                                      '\n"  # print a newline
                                          ) # 

Завдання 3

/>>/(<<&>dm<s&>>%0 <&>)<<\

Евклідовий алгоритм. У WTFZOMFG немає команди для моди, тому мені доведеться використовувати d(ділити), m(множити) та s(відняти).

2009 р. - Ідіть

Go - мова програмування, розроблена Google. Розробка розпочалася в 2007 році, але Go було оголошено в листопаді 2009 року.

Go - це статично типова мова, на яку впливає C, яка підкреслює стислість, простоту та безпеку.

Завдання 1:

package main
import "fmt"

func main(){
    fmt.Println("Go was made in 2009!")
}

Перший рядок оголошує пакет коду. Навіть простий приклад, як друк однієї лінії, повинен бути частиною одного пакета. І виконуваний файл завжди називається main.

Завдання 2:

package main

import (
        "fmt"
        "strings"
)

func main(){
    var n int
    fmt.Scan(&n)

    for i := 0; i < n; i++ {
        a := make([]string, n, n)
        for j := 0; j < n; j++ { a[j] = " " }

        a[0] = "N"
        a[i] = "N"
        a[n-1] = "N"

        s := strings.Join(a, "")
        fmt.Println(s)
    }
}

Go має досить стисну заяву змінної ( i := 0те саме, що var i int = 0), і компілятор визначає тип. Зазвичай це функція, більш поширена в динамічних мовах. За допомогою цього короткого позначення також дуже просто призначити функції змінним ( f := func(x int) int {/* Code */}) та створити закриття.

Завдання 3:

package main

import "fmt"

func gcd(a, b int) int {
    for b != 0 {
        a, b = b, a%b
    }
    return a
}

func main(){
    var a, b int
    fmt.Scan(&a)
    fmt.Scan(&b)

    fmt.Println(gcd(a, b))
}

Тут ви можете побачити a, b = b, a%bсинтаксис, який справді приємний. Я не знаю точної назви, але в Python це називається розпакування кортежу. Використовуючи той самий спосіб, ви можете повернути кілька значень з функції ( func f() (int, string) { return 42, "Hallo"}).

Ще одна річ, що відбувається в цьому коді - це цикл. Цикл for - це єдиний цикл Go. Циклів while-циклів або do-while-циклів не існує. Але ви можете легко створити еквівалент циклу while for condition {}або нескінченного циклу for {}.

1991 - Пітон

Історія мови

Наприкінці 1980-х років Гвідо ван Россум почав мислити Python як хобі. Його назва походить від «Літаючого цирку Монті Пітона», британського телешоу, фанатом якого є Россум. Перша реалізація Python розпочалася в 1989 році і була випущена в 1991 році. З часом вона зросла популярністю, став мовою вибору для багатьох вступних курсів інформатики.

"Привіт Світ!" Варіант

print("Python was made in 1991!")

Зверніть увагу на круглі дужки навколо вводу в print. Хоча цей синтаксис працює в Python 2, як правило, в Python 2, ви опустите ці круглі дужки. Однак вони потрібні в Python 3. Як пропонує Зак Гейтс, круглі дужки використовуються для забезпечення того, що код, представлений тут, буде працювати в різних версіях.

ASCII Art N

def asciin(n):
    if n == 1:
        print("N")
    else:
        print("N" + " "*(n-2) + "N")

        for i in range(2, n):
            print("N" + " "*(i-2) + "N" + " "*(n-i-1) + "N")

        print("N" + " "*(n-2) + "N")

Функції визначаються за допомогою def. Зв'язування рядків виконується за допомогою +та повторення рядків за допомогою* .

GCD

def gcd(a, b):
    if b == 0:
        return(a)
    else:
        return(gcd(b, a % b))

Зауважте, що Python вимагає структурованого пробілу.

1968 - Алголь 68

Algol 68 була визначена робочою групою IFIP 2.1 як наступник Algol 60.

Це виразно орієнтована мова, в якій все має значення. Він також є ортогональним, в якому можна використовувати будь-яку конструкцію будь-яким способом. Це означає, що вирази можуть бути, наприклад, на RHS та LHS завдання.

Усі структури управління мають скорочену форму, а також довгу форму з використанням виразів. Він також дозволяє визначити операторів.

Цілі мови цитуються як:

Основні цілі та принципи дизайну ALGOL 68:

• Повнота та чіткість опису
• Ортогональна конструкція,
• Безпека,
• Ефективність
• Перевірка статичного режиму
• Розбір незалежно від режиму
• Самостійне складання
• Оптимізація циклу
• Представлення - у мінімальних та великих наборах символів

Ці програми були протестовані за допомогою інтерпретатора Algol 68 Genie , що є повною реалізацією мови.

Деякі особливості, які у сучасних програмістів можуть бути різними, - це те, що порожні заяви не дозволяються. Ви не можете просто додавати ;всюди. Ви повинні використовувати SKIPоператор, якщо ви хочете, щоб явно нічого не мали. Це також дозволило кодувати одночасні програми дуже легко. Algol 68, зокрема, використовував зворотні ключові слова як термінатори, такі як esac , od , fi тощо.

Мова містила представлення, яке використовується для написання коду, яке використовувало багато шрифтів, що представляють жирні слова , наприклад, ідентифікатори курсивом . У той час, і, мабуть, досі, жоден компілятор не реалізував цю особливість дизайну. Мова дозволяла кілька різних конкретних уявлень програм, використовуючи режими перемикання . Це дозволило готувати програми з використанням обмежених наборів символів, таких, як, наприклад, комп'ютери в 1960-х. Розглянемо короткий фрагмент програми, який буде представлений у вигляді:

якщо я < 0, то пропустити fi

Це може бути підготовлено для компілятора в праймі режимі stropping як:

'IF' I 'LT' 0 'THEN' 'SKIP' 'FI'

У режимі точкового відстеження це буде:

.IF I .LT 0 .THEN .SKIP .FI

У випадку, якщо режим переходу буде таким:

IF i < 0 THEN SKIP FI

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

Завдання 1

друк (("Algol 68 було зроблено в 1968 році!", новий рядок ))

Тут слід зазначити подвійні дужки. Це тому, що print - це функція, яка приймає єдиний аргумент, який є масивом змінної довжини об'єднання всіх типів. Внутрішні дужки є конструктором масиву. Ось як обробляється поліморфізм у цій сильно набраній мові.

У режимі затримки:

print (("Algol 68 was made in 1968!", newline))


C:\>a68g HelloWorld.a68
Algol 68 was made in 1968!

Завдання 2

     int n ;
     читати (( п ));
     для я від 1 до п зробити
          для J від 1 до п робити
               ¢ тут ми використовуємо скорочену IF умова ¢
               друку ((( J = 1 OR J = я OR J = п |
                    "N"
               |
                    ""
               )))
          од ;
     друк (( нова лінія)))
     од

У режимі затримки:

 INT n;
 read ((n));
 FOR i FROM 1 TO n DO
        FOR j FROM 1 TO n DO
            CO here we use an abbreviated IF clause CO
            print (( ( j = 1 OR j = i OR j = n |
                 "N"
            |
                 " "
            ) ))
        OD ;
        print ((newline))
    OD

C:\>a68g ASCIIart.a68
8
N      N
NN     N
N N    N
N  N   N
N   N  N
N    N N
N     NN
N      N

Завдання 3

     ¢ ми можемо визначити наші власні оператори в Алгол 68 ¢
     оп % = ( ІНТ , б ) INT :           (( Ь = 0 | | Ь % ( мод б )           )); int i , j ; читати (( i , j )); друк (( i % j , новий рядок ))

              
         
              

    
    
    

У режимі затримки:

COMMENT we can define our own operators in Algol 68 COMMENT
OP % = ( INT a, b) INT:
    ((b = 0 |
        a
    |
       b % (a MOD b)
    ));
INT i,j;
read((i,j));
print(( i % j , newline))


C:\>a68g GCD.a68
4 12
         +4

1962 - SNOBOL

"Орієнтована на StriNg та symBOlic Мова". Спочатку, мабуть, називали перекладача символічної виразності «SEXI», який потім довелося змінити, щоб запобігти одурманям епохи 1960-х років червоніти при поданні на роботу. Правдива історія.

Це була одна з перших мов, яка могла впоратись із рядками та візерунками. Дійсно, перша версія SNOBOL мала рядку як єдиний тип даних. Потім математику проводили шляхом розбору. Початкова реалізація була зроблена на IBM 7090. Здається, давно минуло, принаймні, я не міг її знайти. Я знайшов оригінальний документ, в якому описувався його , а також інтерпретатор SNOBOL3 на Java, який може працювати на сучасному комп'ютері .

Перший SNOBOL мав майже лише відповідність візерунка та основні арифметичні. SNOBOL 3 потім додав функції та змінив введення-вивід, але, як інакше, схоже, він залишився назад сумісним. SNOBOL 4 змінив синтаксис, і звідти він перетворився на Icon , який зберігає відповідність шаблону, але майже не виглядає як "нормальна" мова програмування в іншому випадку.

Програми, які я написав, використовують лише функціональність, описану в оригінальному документі, тому слід працювати з оригінальним SNOBOL за винятком вводу-виводу, який я робив у стилі SNOBOL3, щоб інтерпретатор Java міг запускати їх. З статті видно, що різниця полягає в тому, що SNOBOL1 використовує відповідність шаблону зі спеціальною SYSзмінною, тоді як SNOBOL3 використовує вхідні та вихідні змінні:

• Вхід:
  • 1 SYS .READ *DATA*
  • 3 DATA = SYSPPT
• Вихід:
  • 1 SYS .PRINT 'A STRING' AND VARIABLES
  • 3 SYSPOT = 'A STRING' AND VARIABLES

Здійснюючи ці заміни, ви отримаєте "справжній" SNOBOL 1. Звичайно, тоді ви не можете його запустити.

Завдання 1

START   SYSPOT = 'SNOBOL WAS MADE IN 1962!'

Завдання 2

Це показує математику, обробку струн та контроль потоку. SNOBOL3 має корисні функції, як EQперевірка рівності; оригінальних SNOBOL не зробив, тому я не використовував їх.

* READ N FROM INPUT
START   SYSPOT = 'SIZE?'
        SZ = SYSPPT

* INITIALIZE
        CS = ''
        ROW = '0'

* OUTPUT PREVIOUS ROW AND START NEXT ONE
ROW     COL = '0'
        SYSPOT = CS
        CS = ''

COL     SUCC = 'N'
        EQ1 = COL
        FAIL = 'CHKE'
        EQ2 = '0'         /(EQUAL)
CHKE    FAIL = 'CHKR'
        EQ2 = SZ - '1'    /(EQUAL)
CHKR    FAIL = 'SPACE'
        EQ2 = ROW         /(EQUAL)

* CONCATENATE THE RIGHT CHARACTER TO THE CURRENT LINE         
SPACE   CS = CS ' '       /(NEXT)
N       CS = CS 'N'       /(NEXT)

* FOR NUMBERS, SUBSTRING MATCH IS ENOUGH IF IT IS KNOWN A<=B
NEXT    COL = COL + '1'
        COL SZ            /F(COL)
        ROW = ROW + '1'
        ROW SZ            /F(ROW)S(FIN)

* THERE SEEMS TO BE NO EQUALITY CHECK, JUST SUBSTRING MATCHING
* OF COURSE, EQ1 == EQ2 IFF EQ1 CONTAINS EQ2 AND VICE VERSA
* THIS ALSO ILLUSTRATES INDIRECTION
EQUAL   EQ1 EQ2           /F($FAIL)
        EQ2 EQ1           /S($SUCC)F($FAIL)

* OUTPUT THE LAST LINE
FIN     SYSPOT = CS     

Завдання 3

По-перше, нудне. Єдине, що слід зазначити, це менша перевірка, яка показує, наскільки насправді SNOBOL був орієнтований на рядки: (B - A) '-'означає "чи містить результат BA мінус?". SNOBOL3 також може це зробити LE(B,A), але SNOBOL 1 не міг (принаймні папір не згадує про це).

* READ A AND B
START   SYSPOT = 'A?'
        A = SYSPPT
        SYSPOT = 'B?'
        B = SYSPPT

* GCD LOOP
STEP    '0' (A - B)          /S(DONE)
        (B - A) '-'          /S(AB)F(BA)
AB      A = A - B            /(STEP)
BA      B = B - A            /(STEP)
DONE    SYSPOT = 'GCD: ' A

Звичайно, коли у вас мова повністю базується на рядках і відповідності шаблонів, було б прикро не насправді брати участь у відповідності та заміні шаблонів. Таким чином, ось один з таких GCD, що базується на одинакових формах, включаючи підпрограми для перетворення в унарні та з них.

* READ A AND B
START   SYSPOT = 'A?'
        A = SYSPPT
        SYSPOT = 'B?'
        B = SYSPPT

* CONVERT TO UNARY
        UNA.IN = A
        UNA.FIN = 'ADONE'          /(UNA)
ADONE   A = UNA.R
        UNA.IN = B
        UNA.FIN = 'BDONE'          /(UNA)
BDONE   B = UNA.R


* USE STRING MATCHING TO FIND GCD
STEP    '' B                       /S(GDONE)
MATCH   A B =                      /S(MATCH)
        C = B
        B = A
        A = C                      /(STEP)

* CONVERT BACK TO DECIMAL
GDONE   DEC.IN = A
        DEC.FIN = 'DONE'           /(DEC)
DONE    SYSPOT = 'GCD: ' DEC.R     /(FIN)

***************************** 
* DECIMAL TO UNARY SUBROUTINE
UNA     UNA.R =
UNA.DGT UNA.IN *.DGT/'1'* =        /F($UNA.FIN)
        .X = UNA.R
        UNA.R =
UNA.MUL .X *.Y/'1'* =              /F(UNA.ADD)
        UNA.R = UNA.R '##########' /(UNA.MUL)
UNA.ADD '1' .DGT                   /S(UNA.1)
        '2' .DGT                   /S(UNA.2)
        '3' .DGT                   /S(UNA.3)
        '4' .DGT                   /S(UNA.4)
        '5' .DGT                   /S(UNA.5)
        '6' .DGT                   /S(UNA.6)
        '7' .DGT                   /S(UNA.7)
        '8' .DGT                   /S(UNA.8)
        '9' .DGT                   /S(UNA.9)
        '0' .DGT                   /S(UNA.DGT)
UNA.1   UNA.R = UNA.R '#'          /(UNA.DGT)
UNA.2   UNA.R = UNA.R '##'         /(UNA.DGT)
UNA.3   UNA.R = UNA.R '###'        /(UNA.DGT)
UNA.4   UNA.R = UNA.R '####'       /(UNA.DGT)
UNA.5   UNA.R = UNA.R '#####'      /(UNA.DGT)
UNA.6   UNA.R = UNA.R '######'     /(UNA.DGT)
UNA.7   UNA.R = UNA.R '#######'    /(UNA.DGT)
UNA.8   UNA.R = UNA.R '########'   /(UNA.DGT)
UNA.9   UNA.R = UNA.R '#########'  /(UNA.DGT)

*****************************
* UNARY TO DECIMAL SUBROUTINE
DEC     DEC.R =
DEC.DGT '' DEC.IN                  /S($DEC.FIN)
        .X = DEC.IN
        DEC.IN =
DEC.DIV .X '##########' =          /F(DEC.ADD)
        DEC.IN = DEC.IN '#'        /(DEC.DIV)
DEC.ADD '' .X                      /S(DEC.0)
        '#' .X                     /S(DEC.1)
        '##' .X                    /S(DEC.2)
        '###' .X                   /S(DEC.3)
        '####' .X                  /S(DEC.4)
        '#####' .X                 /S(DEC.5)
        '######' .X                /S(DEC.6)
        '#######' .X               /S(DEC.7)
        '########' .X              /S(DEC.8)
        '#########' .X             /S(DEC.9)
DEC.0   DEC.R = '0' DEC.R          /(DEC.DGT)
DEC.1   DEC.R = '1' DEC.R          /(DEC.DGT)
DEC.2   DEC.R = '2' DEC.R          /(DEC.DGT)
DEC.3   DEC.R = '3' DEC.R          /(DEC.DGT)
DEC.4   DEC.R = '4' DEC.R          /(DEC.DGT)
DEC.5   DEC.R = '5' DEC.R          /(DEC.DGT)
DEC.6   DEC.R = '6' DEC.R          /(DEC.DGT)
DEC.7   DEC.R = '7' DEC.R          /(DEC.DGT)
DEC.8   DEC.R = '8' DEC.R          /(DEC.DGT)
DEC.9   DEC.R = '9' DEC.R          /(DEC.DGT)

FIN     START

2012 - TypeScript

TypeScript - це вільна мова програмування з відкритим кодом, розроблена та підтримувана Microsoft.

Основна мета: будь-який браузер. Будь-який господар. Будь-яка ОС. Відкрите джерело. Вийшов у світ у жовтні 2012 року

Привіт TypeScript

Task1(name:string,year:number) {
    return name + " was made in "+ year +"!";
}

ASCII ст

Task2(n:number,separator:string,space:string) {
    var result:string = "";
    for (var k = 0; k < n; k++)
    {
        for (var j = 0; j < n; j++)
        {
            var i = ((n * k) + j) % n;
            result+=(i == 0 || i == n - 1 || i == k) ? "N" : space;
        }
        result+=separator;
    }
    return result;
}

GCD

Task3(a:number,b:number) {
    while (a != 0 && b != 0)
        {
            if (a > b)
                a %= b;
            else
                b %= a;
        }

        if (a == 0)
            return b;
        else
            return a;
}

спробуйте його в Інтернеті та його скріншот .

2011 - Дарт

Dart - це мова програмування з відкритим кодом, розроблена Google, яка розробляється як заміна Javascript (все-таки він компілюється в javascript). Він був оприлюднений Google у 2011 році під час конференції GOTO.

"Привіт Світ!" Варіант:

main() {
  print('Dart was made in 2011!');
}

ASCII Art N:

Метод Bruteforce працює на 0 (n²), але це не має значення, якщо ви не використовуєте гігантське число.

asciiN(int number){
    if(number == 1){
        print('N');
    }else{
        for(var i = 1; i <= number; i++){
            String currentLine = "";
            for(var j = 1; j <= number; j++){
                if(j==1 || j == number || j == i){
                    currentLine = currentLine + "N";
                }else{
                    currentLine = currentLine + " ";
                }
            }
            print(currentLine);
        }
    }
}

GCD

простий метод Евкліда, перенесений із Snap! Приклад вище.

int gcd(int first, int second){
if(second > first){
   return gcd(second, first);
    }else{
        if(first == 0){
            return second;
        }else{
            if(second ==0){
                return first;
            }else{
                return gcd(second, first-second);
            }
        }
    }
}

2010 р. - Іржа

Іржа - мульти-парадигма загального призначення, складена мова програмування, розроблена Mozilla Research. Він розроблений як "безпечна, паралельна, практична мова", що підтримує чистофункціональні, паралельно-діючі, імперативно-процедурні та об'єктно-орієнтовані стилі. Вікіпедія

Завдання1

fn main()
{
    println!("Rust was made in 2010!");
}

Завдання2

fn main()
{
    // get commandline arguments
    // "test 3"
    let args : Vec<_> = std::env::args().collect();

    // convert 2nd argument to integer
    let n = u32::from_str_radix( args[1].as_ref(), 10 ).unwrap();
    print_n( n );
}

fn print_n( n: u32 )
{
    for y in range( 0, n )
    {
        for x in range( 0, n )
        {
            if x == 0 || x == y || x + 1 == n
            {
                print!("N");
            }
            else
            {
                print!(" ");
            }
        }
        println!("");
    }
}

Пояснення:

if x == 0 || x == y || x + 1 == n

дбає про друк лише вертикальних (лівий і правий |) та діагональних ( \)

Завдання 3

проста реалізація евклідового_алгоритму

fn main()
{
    // get commandline arguments
    // "test 453 3"
    let args : Vec<_> = std::env::args().collect();

    // convert 2nd and 3rd argument to integers
    let a = u32::from_str_radix( args[1].as_ref(), 10 ).unwrap();
    let b = u32::from_str_radix( args[2].as_ref(), 10 ).unwrap();
    let g = gcd( a, b );
    println!( "GCD of {} and {} is {}", a, b, g );
}

fn gcd( mut a: u32, mut b: u32 ) -> u32
{
    while b != 0
    {
        let c = a % b;
        a = b;
        b = c;
    }
    return a;
}

2015 - Muffin MC

Muffin MC - це повноцінна, смішна (але серйозна) функціональна та мінімалістична макро мова, написана Франком Поршером ( http://franckys.com ) у середині лютого 2015 року з необхідності як (швидкий) інструмент для розширення можливостей електронну таблицю, яка буде використовуватися як єдиний контролер на передньому кінці для пілотування та керування всіма операціями, пов'язаними з інвентарем, пов'язаними з торговим сайтом, заснованим на Prestashop, для нового таїтського модного бренду: Mutiny Tahiti ( http://mutinytahiti.com - скоро буде запущено).

Muffin MC є абревіатурою MU крихітного F функціонального F lexible У лінії M Acro C ommand мови.

Щоб відповідати нашим вимогам, основні функції Muffin MC були розроблені навколо гнучких та ефективних вбудованих семантичних конструкцій першого класу, таких як ітератори , лінива оцінка , багатофункціональність , струнний продукт .

Muffin MC бере свої корені в (прагматичному) функціональному програмуванні, FLisp та Perl. Він повністю підтримує рекурсивність (без будь-якої оптимізації), динамічно набирається та динамічно визначається область (дрібнозв'язування). Він пропонує своїм користувачам лише одну структуру даних, крім основних атомів типів даних (атоми, рядки, цифри): списки!

Muffin MC перелічує семантику (вид) запозичень на семантику набору потужності , тобто:

1. Усі операції Muffin MC дають список, можливо, порожній.
2. Доступ до будь-якого окремого елемента списку завжди призводить до списку з одним значенням, складеного з цього елемента (думайте про це як одинарний).
3. Порожній список - нейтральний елемент операцій зі списком.

Для примирення з цим може допомогти наступне:

• Можна візуалізувати список як елемент набору потужностей списку, який має найбільшу кардинальність.
• Візуалізуйте елемент списку як елемент набору потужності списку, який є синглетом, виготовленим з цього елемента.
• Візуалізуйте порожній список як порожній набір; тобто єдиний елемент набору потужностей порожнього набору.

Таким чином, доступ до елемента порожнього списку дає порожній список, а не помилку! Дійсно, Muffin MC намагається викинути якомога менше помилок, розширивши таким чином семантику багатьох традиційних операцій.

Завдання 1

#(say "MuffinMC was born in 2015 out of necessity !")

#(...)- це макрокоманда Muffin MC для застосування функції у списку аргументів, що не евальована, тут вбудована функція say, запозичена у Perl.

#(say 1 2 3 ...) функціонально ідентичний map {say $_} (1,2,3,...)

Завдання 2

Визначте функцію ascii-art():

=(ascii-art
    '( =(*  x   #(2- $(_1))
        I   I( *($(x) " ") N)
            foo '( #(. #(I $(x))) ))
    #(say ?( #(== $(_1) 1) N "N#(map foo #(.. 1 $(_1)))N" ))
 ))

Ascii-art()найкоротша робоча форма (88 байт):

=(f'(=(* x#(2-)I I(*($(x)" ")N)g'(#(.#(I$(x)))))#(say?(#(==$(_1)1)N"N#(map g#(..))N"))))

• =(var val...)це макрокоманда Muffin MC для визначення змінної або перепризначення її.

• $(var)це макрокоманда Muffin MC для доступу до значення змінної. Він, природно, приймає форму, $(v1 v2 ...)щоб отримати доступ до багатьох змінних одночасно.

• =(* var1 val1 var2 val2 ...)- це розширення макрокоманди Muffin MC=(...) для роботи з паралельними призначеннями.

• Змінні _1, _2, ... динамічно охоплюються (механізм дрібної прив'язки) і автоматично встановлюються для прив'язки до аргументів функції. Запозичені у Perl5, системні змінні #(кількість аргументів) та @(список аргументів) також встановлюються автоматично.

• Функції - це просто змінні, пов'язані з будь-якою кількістю заяв Muffin MC .

Це цікаве рішення є поєднанням двох природних вбудованих функцій Muffin MC :

1. Макрокоманда Muffin MC I(...) для визначення циклічних ітераторів, пізніше використовуваних у функціональній формі #(my-iterator want-number-of-values),

2. Здоби MC -струнной продукт конструкція, розширення природної змінної інтерполяції, який, приймаючи будь-який рядок "F1 F2 F3...", де F я s є або булочка MC рядкові літерали або булочка MC макрокоманди (ака функціональні форми), буде виробляти стільки ж рядків , як заданий продуктом кардиналом (F1) x кардиналом (F2) x ....

Наприклад, задана змінна xa, яка містить 2 значення, каже a і b, а y інша змінна, яка містить 3 значення, скаже, 1 2 3, тоді оцінка рядка "x=$(x) y=$(y))"дасть 6 різних значень, а саме в такому порядку:

• "x = ay = 1"
• "x = ay = 2"
• "x = ay = 3"
• "x = by = 1"
• "x = by = 2"
• "x = by = 3"

Це одна з дуже бажаних функцій проекту MUTINY, для якої було створено Muffin MC .

Запусти!

#(ascii-art 1)

N


#(ascii-art 3)

N N  
NNN  
N N 


#(map '( #(ascii-art $(_1))) 5 7 9)

N   N
NN  N
N N N
N  NN
N   N

N     N
NN    N
N N   N
N  N  N
N   N N
N    NN
N     N

N       N
NN      N
N N     N
N  N    N
N   N   N
N    N  N
N     N N
N      NN
N       N

Як це працює

Наш алгоритм базується на наступному:

Дано заклик до ascii-art (n), {n = 2p + 1 | p integer, p> = 0}, мистецтво для створення складається з n рядків з n символів, серед яких два, найліпші та найправильніші, є фіксованими та завжди однаковими: 'N'. Це дозволяє зменшити проблему у створенні лише середніх рядків. Наприклад, задавши n = 5, ми створимо 5 наступних середніх рядків, кожна з яких складається з n-2 символів (ми замінили простір на '_' для кращої візуалізації):

    The 5 strings :
        _ _ _
        N _ _ 
        _ N _
        _ _ N
        _ _ _

    can be seen as resulting from splitting in groups of 3 characters
    the following infinite sequence of 4 characters :


        /---- < _ _ _ N > ----\
       |                       |
        \---------------------/    


    which, once unfolded, yields the infinite ruban : 

        _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N ...
              ^     ^     ^     ^     
        _ _ _ |     |     |     |
              N _ _ |     |     | 
                    _ N _ |     |
                          _ _ N |
                                _ _ _

• Такі середні струни можуть бути легко утворені циклами на послідовності 4 елементів ('_' '_' '_' 'N')у 5 групах по 3; заданий n, вхід функції, така послідовність складається з n-2 символів '_', за якими слідує символ 'N'. Переміщення по цій послідовності не вимагає нічого іншого, крім вбудовування послідовності у вбудований ітератор Muffin MC I(sequence) (ітератор, який назавжди циклами над початковою послідовністю значень).

• Потім ми просто виробляємо середні рядки довжиною n-2, попросивши наш ітератор дати нам наступні n-2 значення (n - 2 символи), які об'єднані разом для отримання очікуваного середнього рядка.

• N середніх рядків утворюються шляхом повторення n разів вищевказаного процесу, використовуючи карту для збору n результатів (n рядків n-2 символів).

• Ми використовуємо ще один потужний здоби MC вбудований в конструкцію, а саме рядок продукту , щоб отримати остаточні рядки п: "N#(map...)N".

• І це все !

  Commented script  
  
  =(ascii-art                    Define the 'ascii-art' variable to hold
                                 the function's definition.
                                 When called, its argument, the actual
                                 value of n, will be bound to the system
                                 variable _1, accessed as $( _1 ).
  
      '(                         '(...) quote macro-command -- protects 
                                 its arguments, here the function 
                                 definition, from being evaluated.
                                 We want to keep it literally for further evaluation.
  
         =(*                     =(*...) // assignment macro-command.
                                 Similar to the Lisp (let (...)...),
                                 not the let* !
  
             x #(2- $(_1))       Define the variable x to hold the value 
                                 n-2.   
  
             I I(                Define I to be an iterator over the 
                                 the x+1 characters sequence :
                  *( $(x) " ")   . x white-space characters
                  N              . 1 'N' character (here the atom N)
               )
  
             foo '(              Define the variable foo as a function 
                    #(.          to catenate ( #(. s1...) )
                       #(I $(x)) the iterator's next x elements.
                     )            
             )
         )                       End of =(*...
  
      #(say                      Print each element of:
         ?(                      If
            #(== $(_1) 1)        n equals 1
    N                    the atom N,
    "N#(map foo #(.. 1 $(_1)))N" else the n strings as a string-product 
                                 resulting from foo-computing the  
         )                       n middle-strings.
       )
   ))
  

Завдання 3

Визначте функцію gcd():

=(gcd '( ?( #(== $(_2) 0)
        $(_1)
            #(self $(_2) #(mod $(_1) $(_2)))) ))

gcd()«S реальна найкоротша форма (37 байт - 2bytes посилення завдяки Rodolvertice)

=(g'(?(#(z$(_2))$(_1)#(g$(_2)#(mod)))))

Запусти!

#(gcd 225 81)

врожайність 9.

Це воно.

Дякую за приємну гру та, можливо, за ваш інтерес. Мова доступна для кожного, хто хотів би пограти, використовувати її або навіть розширити її. Просто попросіть його, і я буду радий надіслати його.

Ура

Франк

PS. Поточна реалізація Muffin MC знаходиться в Perl5. Вихідний код - це близько 2000 рядків сучасного Perl, включаючи коментарі, і він поставляється в комплекті з нерегресійним тестовим набором, який чудово вивчить практичні конструкції та семантику Muffin MC .