Примітки

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

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

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

Як це працює

• Усі відповіді повинні містити назву мови програмування у верхній частині публікації з префіксом a #.

• Відповіді можуть містити один (і лише один) фактоїд, тобто пару речень без коду, що описують мову.

• Окрім фактоїда, відповіді повинні складатися з фрагментів коду, які можуть (але не повинні бути) програмами або функціями.

• Фрагменти не потрібно пов'язувати. Насправді, фрагменти, які занадто пов'язані, можуть бути зайвими.

• Оскільки це не конкурс, усі мови програмування вітаються, коли б вони були створені.

• У відповідях, що містять більше ніж кілька фрагментів коду, слід використовувати фрагмент стека, щоб згортати все, окрім фактоїда та одного з фрагментів.

• Коли це можливо, має бути лише одна відповідь на кожну мову програмування. Це вікі спільноти, тому сміливо додайте фрагменти до будь-якої відповіді, навіть якщо ви її не створили самі. Існує фрагмент стека для стискання публікацій , який повинен пом'якшити дію обмеження в 30 000 символів.

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

Поточні відповіді, відсортовані в алфавітному порядку за назвою мови

$.ajax({type:"GET",url:"https://api.stackexchange.com/2.2/questions/44680/answers?site=codegolf&filter=withbody",success:function(data){for(var i=0;i<data.items.length;i++){var temp=document.createElement('p');temp.innerHTML = data.items[i].body.split("\n")[0];$('#list').append('<li><a href="/a/' + data.items[i].answer_id + '">' + temp.innerText || temp.textContent + '</a>');}}})

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><base href="http://codegolf.stackexchange.com"><ul id="list"></ul>

Математика

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

Список зростає досить довго. Я почав видаляти менш цікаві фрагменти, і зараз почну пропускати фрагменти. Повний список фрагментів розміром до 41 дивіться в історії редагувань. Для деяких справжніх дорогоцінних каменів ознайомтеся з фрагментами 81 , 64 , 44 , 23 , 19 , 12 і 8 .

Довжина 143 та 144 фрагменти

Нарешті ... я чекав цього деякий час (і займався гольфом приблизно так довго, тому мені не доведеться чекати ще довше). Раніше я згадував, що ви можете також рівняння чисельно, а також ви можете розв'язувати диференціальні рівняння. Я хотів показати нетривіальний приклад цього.

Розглянемо подвійне маятник на стрижні (тобто маятник, прикріплений до іншого). Кожна штанга має одиничну довжину, і кожен з двох ваг маятника має одиничну масу. Я також використовував одиничну гравітацію, щоб скоротити рівняння. Наступний фрагмент 143 символів вирішує рівняння руху Лагрангія для такої системи (з точки зору кутів маятника та кутового моменту). Висновок можна знайти в цьому PDF-файлі , хоча це досить вправо, якщо ви знайомі з механікою Лагрангія.

Це зовсім нечитабельно, тому що мені довелося багато гольфувати його:

d=θ@t-φ@t;NDSolve[{#''@t==-#4#2''[t]Cos@d-##3#2'@t^2Sin@d-Sin@#@t&@@@{{θ,φ,1,.5},{φ,θ,-1,1}},θ@0==2,φ@0==1,θ'@t==φ'@t==0/.t->0},{θ,φ},{t,0,60}]

Акуратно те, що Mathematica одразу показує мініатюрну схему того, як приблизно виглядають рішення:

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

Graphics@{Line@{{0,0},p=θ~(h={Sin@#@#2,-Cos@#@#2}&)~t,p+φ~h~t},White,{0,0}~Circle~2.2}~Show~ParametricPlot[θ~h~u+φ~h~u,{u,0,t}]~Animate~{t,0,60}

Отримана анімація виглядає приблизно так:

^{Мені довелося злегка обдурити: якщо ви задумуєте далі t = 30, ParametricPlotза замовчуванням використовується занадто мало точок сюжету, і лінія стає досить зазубриною. Але більшість цікавих динамік трапляється після цього часу, тому я використав варіант, PlotPoints -> 200щоб друга половина анімації виглядала плавніше. Нічого суттєво не відрізняється, і перший тайм все одно виглядав би невідрізним.}

Я думаю, що це буде мій останній фрагмент, якщо я не придумаю щось справді розумне. Сподіваюся, вам сподобалось це!

Довжина 100 фрагмента

GeoGraphics[{GeoStyling[Opacity[0.5]], NightHemisphere[]}, GeoBackground -> GeoStyling["ReliefMap"]]

Я думав про деякі приємні Geoфункції для 100 фрагмента, але в кінцевому підсумку я знайшов щось справді чудове в Tweet-a-Program , яке мені просто довелося вкрасти. Сказане генерує дуже приємну зовнішню карту Землі для поточного часу та дня, накладаючи напівпрозору форму нічної півкулі на рельєфну карту:

Довжина фрагмента 81

CellularAutomaton[{{0,2,3,If[0<Count[#,1,2]<3,1,3]}[[#[[2,2]]+1]]&,{},{1,1}},i,n]

Обіцяю, що це останній стільниковий автомат. Але це правильно є Wireworld у 81 символі. Цього разу я не кодував це правило в одному номері, а) тому що я вважаю, що це було б смішно величезно (я не намагався це з'ясувати) і б) показати вам ще одне використання CellularAutomaton. Цього разу правило просто визначається як чиста функція, яка отримує сусідство комірок і повертає нове значення комірки. Це набагато більш доцільний підхід для стільникових автоматів з більш ніж двома кольорами / станами.

У будь-якому випадку, я встановив приклад з Вікіпедії в i(два тактові годинники, що генерують сигнали, і XOR-шлюз) і даю йому працювати протягом 50 кроків:

Якщо вас зацікавило, власне змова та анімація могли бути фрагментом 77:

ListAnimate[ArrayPlot[#,ColorRules->{0->Black,1->Blue,2->Red,3->Yellow}]&/@w]

Довжина 69 фрагмента

DSolve[r^2*R''[r]+2r*R'[r]-R[r]==0&&(R[r]==1&&R'[r]==2/.r->1),R[r],r]

Назад до чогось корисного. Крім звичайних систем рівнянь, Mathematica також може вирішувати системи диференціальних рівнянь. Викладене технічно є лише одним диференціальним рівнянням з граничними умовами, але ви можете також подати це як система трьох рівнянь. Аналогічно інтегруючим функціям DSolveє точні рішення, тоді NDSolveяк система вирішить чисельно. Вищезазначене дає єдине рішення

{{R[r] -> 1/2 r^(-(1/2) - Sqrt[5]/2) (1 - Sqrt[5] + r^Sqrt[5] + Sqrt[5] r^Sqrt[5])}}

який тепер може бути легко використаний для подальших обчислень або побудови графіків.

Довжина 64 фрагмента

CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},i,n]

Я обіцяв тобі більше CellularAutomatonчарів! Цей фрагмент коду обчислює гру Conways 'життя з початковою умовою iдля nкроків і дає результат для всіх проміжних тимчасових кроків.

Кілька слів про параметри: 2це кількість клітинних станів. {{2,2,2},{2,1,2},{2,2,2}}дає ваги для 9 комірок в районі 3x3. Це гарантує, що сама клітина відрізняється від суми 8 сусідів. {1,1}говорить, що правило СА залежить від осередків на 1 крок в будь-якому напрямку. Нарешті, чи 224є фактичне правило оновлення закодованим в одне число. Зрозуміти це число може бути дещо хитро, але в документації є досить корисний підручник . Для більш складних автоматів одне число не буде скорочувати його (оскільки це число було б величезним). Можливо, ми приїдемо завтра! ;)

У будь-якому випадку, якщо я ввожу випадкову сітку в iі 200 в nі надішлю результат через анімований ArrayPlot, ми можемо побачити, що він насправді працює:

Довжина 59 фрагмента

SphericalPlot3D[Re[Sin[θ]Cos[θ]Exp[2I*φ]],{θ,0,π},{φ,0,2π}]

Пам’ятаєте полярний сюжет із фрагмента 26? Ми можемо зробити те ж саме в 3D! (Насправді є дві функції: RevolutionPlot3Dдля циліндричних полюсів і SphericalPlot3Dдля сферичних полюсів.) Як і Graphics3Dвсі тривимірні графіки, автоматично обертаються в Mathematica, тому вам не доведеться турбуватися про хороший кут камери вперед. Наведене вище накреслює щось на кшталт сферичної гармоніки (не все-таки) і виглядає так:

Довжина 52 фрагмента

Manipulate[Plot[x^2a+x*b,{x,-3,3}],{a,.1,3},{b,0,3}]

Цей досить витончений. Manipulateприймає будь-який вираз, параметризує його з купою змінних, а потім надає вам віджет, де ви можете налаштувати параметри і побачити, як змінюється вираз. Як вираз у вас зазвичай є якийсь сюжет. Це особливо корисно, якщо ви використовуєте Mathematica на лекціях, щоб продемонструвати, як сімейства рішень реагують на зміну параметрів. Сказане вище показує, як aі bкоефіцієнти масштабують і зміщують параболу:

Довжина 48 фрагмента

Import["http://www.google.com/doodles","Images"]

Import- досить потужна команда. Він використовується як для завантаження файлів з диска, так і з Інтернету. Він знає досить багато різних форматів файлів, і для деяких з них (наприклад, HTML-сторінок) він може фактично витягнути дані відразу. Вище завантажено всі зображення зі сторінки каракулі Google.

Довжина фрагмента 45

EdgeDetect@ExampleData@{"TestImage","Splash"}

Час на деяку обробку зображення. Mathematica постачається з цілою купою прикладних даних, включаючи зображення (наприклад, Lena), текстури, тривимірні моделі та звукові фрагменти. Спочатку ми завантажуємо одне з таких:

Хочете виявити краї? Це єдиний виклик функції:

Довжина 44 фрагмента

ArrayPlot@CellularAutomaton[110,{{1},0},100]

Нарешті, у мене достатньо символів для використання, CellularAutomatonа також надання результату. :) Наскільки мені відомо, CellularAutomatonце єдина функція в Mathematica, що стосується ЦО. Але Стівен Вольфрам, здається, вважає себе хлопцем номер один, якщо мова йде про стільникові автомати, тож ця функція неймовірно потужна. Сказане в значній мірі показує його найпростіше використання. Це імітує 1D стільниковий автомат на 100 кроків - і він фактично повертає стан автомата на кожному з цих кроків, тому результат є двовимірним. Правило є першим параметром, який може бути детально визначений за допомогою списків, або просто закодований в одне число. Для цього прикладу я вибрав досить відоме, правило Тюрінга, правило 110 . {{1},0}визначає початкову умову: одиничну1перед фоном нулів. Можливо, я покажу ще деякі функції CellularAutomatonв майбутньому, коли у мене буде більше доступних символів: він може імітувати КА у більш високих розмірах, використовуючи більші мікрорайони та більш ніж два стани.

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

Довжина 43 фрагмента

HighlightGraph[graph,FindVertexCover@graph]

Минув час, коли я згадав графіки. Існує багато загальних теоретичних задач графіків, вбудованих у Mathematica, разом із приємними інструментами візуалізації. Вищенаведене для даного graphзнаходить мінімальну кришку вершини графіка, а потім візуалізує графік із тими вершинами, які є високими. Наприклад , якщо graphце PetersenGraph[7,2]назад з сниппета 18, ми отримаємо:

Довжина 42 фрагмента

Animate[Plot[Sin[t-x],{x,0,10}], {t,0,10}]

Анімація речей в Mathematica досить проста (і вони навіть не повинні бути зображеннями). Ви просто даєте йому вираження, яке слід оцінювати для кожного кадру, і купу параметрів, які повинні змінюватися в межах кадру. Сказане просто оживляє сюжет рухомої синусоїди. Анімація буде виглядати приблизно так: GIF:

Довжина 40 фрагмента

SortBy[PlanetData[#, "EscapeVelocity"]&]

SortByробить те, що ви очікуєте: сортує список на основі значень, отриманих шляхом зіставлення заданої функції на кожен елемент списку. Але зачекайте, вищевказаний дзвінок зовсім не містить списку. Починаючи з Mathematica 10, для деяких функцій існує підтримка currying або часткове застосування . Це не мовна функція, як у більш пуристичних функціональних мовах, а просто реалізована вручну для цілого ряду функцій, де це часто корисно. Це означає , що вище фрагмент коду повертає нову функцію, яка тільки приймає список , а потім сортує по даній функції. Це може бути дуже корисно, якщо цей порядок сортування - це те, що ви будете використовувати частіше у коді.

І так, є ще одна приємна *Dataфункція - вищезгадане буде сортувати назви планет за швидкостями втечі планети .

Довжина 39 фрагмента

f[1]=1
f[2]=1
f[n_]:=f[n]=f[n-1]+f[n-2]

Я пообіцяв зробити функцію Фібоначчі більш ефективною. Цей фрагмент показує, наскільки тривіальне запам'ятовування в Mathematica. Зауважте, що все, що змінилося, є додатковим f[n]=у третьому рядку. Тож коли fбуде викликано нове значення (скажімо f[3]), тоді f[3]=f[3-1]+f[3-2]буде оцінено. Це обчислює f[2]+f[1], потім призначає його f[3](з =, а не з :=!), І в кінцевому підсумку повертає значення для нашого початкового виклику. Таким чином, виклик цієї функції додає нове визначення цього значення, яке, очевидно, є більш конкретним, ніж загальне правило - і, отже, воно буде використовуватися для всіх майбутніх викликів fз цим значенням.

Пам'ятайте, що іншій функції Фібоначчі було потрібно 4 секунди за 30 значень? На це потрібно 3 секунди для 300 000 значень.

Довжина 37 фрагмента

l//.{a___,x_,b___,x_,c___}:>{a,x,b,c}

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

{a___,x_,b___,x_,c___}:>{a,x,b,c}це правило. x_з одиничним підкресленням - це шаблон, який посилається на єдине довільне значення (яке може бути самим списком або подібним). a___являє собою шаблон послідовності (див. також фрагмент 15), який відноситься до послідовності 0 або більше значень. Зауважте, що я використовую x_двічі, а це означає, що ці дві частини списку мають бути однаковими. Отже цей шаблон відповідає будь-якому списку, який містить значення двічі, викликає цей елемент xі викликає три послідовності навколо цих двох елементів a, bі c. Це замінюється {a,x,b,c}- тобто другий xскидається.

Тепер //.застосовуватиметься правило, поки шаблон більше не збігатиметься. Отже, наведений вище фрагмент видаляє всі дублікати зі списку l. Однак він трохи потужніший за це: //.застосовує правило на всіх рівнях. Так що, якщо lвін містить списки (на будь-яку глибину), дублікати з цих підсписів також будуть видалені.

Довжина 36 фрагмента

f[1]=1
f[2]=1
f[n_]:=f[n-1] + f[n-2]

Час нових мовних особливостей! Математика має кілька приємних речей щодо визначення функцій. Для початку ви можете надати кілька визначень функцій для одного і того ж імені, для різних чисел та типів аргументів. Ви можете використовувати шаблони, щоб описати, до яких типів аргументів застосовується визначення. Крім того, ви можете навіть додати визначення для одиничних значень. Потім Mathematica вибере найбільш конкретне застосовне визначення для будь-якого виклику функції та залишить невизначені дзвінки без оцінки. Це дозволяє (серед іншого) записувати рекурсивні функції набагато більш природним способом, ніж використання Ifперемикача для базового випадку.

Ще одна річ, яку слід зазначити щодо вищевказаного фрагмента, - це те, що я використовую і =та, і :=. Різниця полягає в тому, що права частина =оцінюється лише один раз, під час визначення, тоді :=як повторно оцінюється щоразу, коли ліва сторона посилається на неї. Насправді :=навіть працює при призначенні змінних, які потім матимуть динамічне значення.

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

Довжина 35 фрагмента

StreamPlot[{x^2,y},{x,0,3},{y,0,3}]

Дуже акуратний сюжет, який виводить потоки 2D-векторного поля. Це схоже на звичайний векторний графік, оскільки кожна стрілка дотична до векторного поля. Однак стрілки не розміщуються на виправленій сітці, а з'єднуються в лінії (потокові лінії). Значення цих ліній полягає в тому, що вони вказують на траєкторію частинки (скажімо, в рідині), якщо векторне поле було полем швидкості. Вищенаведений вхід виглядає так:

Довжина 34 фрагмента

Solve[a*x^4+b*x^3+c*x^2+d*x==0, x]

Mathematica також може розв’язувати рівняння (або системи рівнянь, але у нас зараз стільки символів). Результат, як завжди, буде символічним.

{
  {x -> 0}, 
  {x -> -(b/(3 a)) - (2^(1/3) (-b^2 + 3 a c))/(3 a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) + (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)/(3 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 + I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 - I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/(6 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 - I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 + I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/( 6 2^(1/3) a)}
}

Зауважте, що рішення наводяться як правила , які я, мабуть, більш детально покажу в деякому майбутньому фрагменті.

Довжина 33 фрагмента

Dynamic@EdgeDetect@CurrentImage[]

Завдяки бензаффлу за цю ідею. CurrentImage[]завантажує поточне зображення вашої веб-камери.EdgeDetectперетворює зображення у чорно-біле зображення, де краї білі, а решта чорні (див. приклад 45 для прикладу). Справжня розвага приходитьDynamic якій вираз оновлюється сам. Таким чином, результат цього насправді передаватиме фотографії з вашої веб-камери та виконувати їх виявлення в реальних краях.

Довжина 32 фрагмента

NumberLinePlot[x^2<2^x,{x,-2,5}]

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

Стрілка вказує, що регіон продовжує нескінченність. Білі кола вказують на те, що це відкриті інтервали (кінцеві точки не є частиною інтервалу). Для закритих кінців кола будуть заповнені.

Довжина фрагмента 28

Graphics3D@{Sphere[],Cone[]}

Час для 3D-графіки. Вищезазначене дає надзвичайно накладену сферу та конус із типовими параметрами, який виглядає як кришталевий куля:

У Mathematica ви можете фактично клацнути та перетягнути цей маленький віджет, щоб повернути його.

Довжина фрагмента 27

CountryData["ITA", "Shape"]

Більше *Data! CountryDataдосить божевільний. Отримати форму країни - це навіть не верхівка айсберга. Існує так багато даних про країни, ви, напевно, могли написати цілу книгу про цю функцію. Мовляв ... є FemaleLiteracyFraction. Ви також можете запитувати ці дані за різні моменти часу. Повний список див. У посиланні.

Довжина фрагмента 26

PolarPlot[Sin[5θ],{θ,0,π}]

Час для більш цікавого сюжету. PolarPlotпросто графік у полярних координатах. Замість того, щоб вказати y для даного x, ви задаєте радіус r для заданого кута θ:

Довжина фрагмента 25

{{1,5},{2,3},{7,4}}.{8,9}

Нарешті у нас є достатня кількість символів для математики. Наведене вище обчислює множення матриці на матрицю 2x3 та рядок 2-вектор:

{53, 43, 92}

Довжина 23 фрагмента

Rotate[Rectangle, Pi/2]

Хе. Хе-хе. Ви думаєте, що знаєте, що це робить. Але ти цього не робиш. Rectangleсама по собі є лише названою функцією. Щоб насправді отримати об’єкт, що представляє прямокутник, вам потрібно буде викликати цю функцію з деякими параметрами. Отже, що ви думаєте, що відбувається, коли ви намагаєтесь обертатись Rectangle? Це:

Довжина 22 фрагмента

30~ElementData~"Color"

Ще одна з вбудованих *Dataфункцій. Так, для хімічних елементів ви не просто отримуєте такі речі, як їх атомний номер, температура плавлення та назва ... Ви можете фактично отримати їх колір при кімнатній температурі. Сказане надає колір цинку:

SlateGray

Фрагмент довжини 21

Integrate[E^(-x^2),x]

Ми мали диференціацію деякий час тому. Час інтеграції. Mathematica може обробляти як визначені, так і невизначені інтеграли. Зокрема, Integrateви дасте точне рішення, і воно може мати справу з тонкою стандартних інтегралів та методів інтеграції (для числових результатів є NIntegrate). Якщо ви знаєте своє обчислення, ви помітили, що вищевказаний інтеграл Гаусса насправді не має невизначений інтеграл закритої форми ... якщо ви не вважаєте функцію помилки закритою формою, тобто. Mathematica повертає:

1/2 Sqrt[π] Erf[x]

Довжина фрагмента 20

"Sun"~StarData~"Age"

Повернутися до вбудованих даних . Повинно бути щонайменше два десятки *Dataфункцій для всього, що ви могли б придумати. Кожен з них приймає ідентифікатор того, для чого потрібно отримати дані, та властивість (або список властивостей) для отримання. Вищезазначене - лише одна з найкоротших, яку ви можете отримати Sun, Starі Ageвсе це досить коротко, тому що я не міг дочекатися показу цієї функції.

О так, і я згадав, що Mathematica (починаючи з 9) підтримує величини з одиницями? (Детальніше про це пізніше.) Сказане вище оцінює:

Quantity[4.57*10^9, "Years"]

який відображається як

Довжина 19 фрагмента

MandelbrotSetPlot[]

Так ... дуже корисна функція ... Я її постійно використовую. (Іноді їхнє бажання підтримати все, що можливо обчислимо, може зайти трохи далеко ...)

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

Довжина фрагмента 18

PetersenGraph[7,2]

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

Фрагмент довжини 17

Plot[x^x,{x,0,2}]

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

Довжина фрагмента 15

{##4,#,#2,#3}&

Це показує дві найпотужніші функції (а також корисні для гри в гольф). Вся справа - це неназвана чиста функція , порівнянна з lambdas у Python або Procs у Ruby. Чиста функція просто припиняється a &. Цей оператор має дуже низький пріоритет, так що він зазвичай включає майже все, що від нього залишилося. Аргументи чистої функції посилаються на #, іноді йдуть інші речі. Перший аргумент є #або #1, другий - #2і так далі.

Інша особливість - Sequences. В основному вони подібні до знаків інших мов. Послідовність подібна списку без списку навколо нього - це буквально просто послідовність значень, яка може бути використана у списках, аргументах функцій тощо, ##зокрема це послідовність усіх аргументів чистої функції. ##2- це послідовність усіх аргументів, починаючи з другого. Отже, якщо ми назвали вищевказану функцію f, і називали її подібною

f[1,2,3,4,5]

Ми б дісталися

{4,5,1,2,3}

тому функція повертає вхідні аргументи 3 елемента ліворуч. Зауважте, що ##4посилання на 4,5які були сплощені у списку.

Довжина фрагмента 12

D[x^y^x,x,y]

Часткова диференціація. Dбуде диференціювати перший вираз послідовно щодо інших його аргументів, даючи вам символічне вираження як результат. Отже, вище d² (x ^ y ^ x) / dxdy (де d s часткові), що, як повідомляє Mathematica,

x^y^x (y^(-1 + x) + y^(-1 + x) Log[x] + x y^(-1 + x) Log[x] Log[y]) + 
  x^(1 + y^x) y^(-1 + x) Log[x] (y^x/x + y^x Log[x] Log[y])

Фрагмент довжини 9

Exp[I*Pi]

Ми ще не виконали жодної складної арифметики! Як бачите, πнасправді це був лише псевдонім для Pi. У будь-якому випадку, вищезазначене фактично вірно поверне ціле число -1 .

Фрагмент довжини 8

Sunset[]

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

Фрагмент довжини 7

9!/43!!

Цей фрагмент демонструє кілька цікавих речей.

Математика не просто має вбудований факторіальний оператор !, вона також має подвійний факторіал !!(який множує кожне інше число nзнизу вниз 1). Крім того, він підтримує цілі числа з довільною точністю. 43!!Оцінюватиметься точно, аж до останньої цифри. Крім того, раціональні числа також будуть точно оцінені. Отже, оскільки і чисельник, і знаменник є цілими числами, Mathematica зменшить частки, наскільки це можливо, а потім представить вам

128/198893132162463319205625

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

Довжина 4 фрагмента

Here

Настав час, коли ми почали з багатства Mathematica божевільних вбудованих модулів. Сказане робить те, що йдеться про олово і (для мене) оцінює GeoPosition[{51.51, -0.09}].

Фрагмент довжини 3

x-x

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

Фрагмент довжини 2

3x

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

Фрагмент довжини 1

π

Вгадайте що, це Пі. Насправді це не якесь приблизне подання з плаваючою комою, це саме Pi - тому всілякі складні та тригонометричні функції, в яких це використовується, дадуть точні результати, якщо вони будуть відомі.

Фактоїдні

Mathematica може виконувати символічні маніпуляції, тому змінним не потрібні значення для роботи з ними.

Сумнівна мова програмування Шекспіра

Мова програмування Шекспіра була створена в 2001 році двома шведськими студентами, Карлом Хассельстремом та Джоном Ослундом, і вона поєднується як заявляють автори ,

виразність BASIC щодо зручності використання мови монтажу.

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

( посилання для себе: редагувати )

Фактоїд:

Код Шекспіра нагадує, як можна було б очікувати, п’єси Шекспіра, де змінні є персонажами п'єси і їх значення змінюється, оскільки їх "ображають" або хвалять ".

Фрагмент довжини 1:

I

Код Шекспіра розділений на Дії, а самі дії поділяються на сценах, для випадковості "стрибка до". Визначення акта якAct I означає, що це буде перший фрагмент коду, який буде запущений, наприклад, але не тільки.

Фрагмент довжини 2:

as

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

Фрагмент довжини 3:

day

На даний момент у вас може виникнути відчуття, що SPL дуже багатослівний. І дивно. І ви ще нічого не бачили. day, в SPL - це 1. Усі іменники "позитивний" і "нейтральний" вважаються такими 1, як і всі "негативні"-1 .

Фрагмент довжини 4:

rich

Що таке rich? Прикметник. У SPL прикметники роблять значення іменника, який вони додають, помножуючи на два. Див. Реалізацію на фрагменті 14.

Фрагмент довжини 5:

Act I

Реалізація першого фрагмента. Усі дії можуть мати назву, наприклад Act I: Hamlet must die!, оскільки все після римської цифри парсер ігнорує.

Фрагмент довжини 6:

better

Кожна мова має умови, і SPL не є винятком. За винятком випадків, оскільки це мова з тривалим синтаксисом (а чи я згадував це дивно?), Її умовні висловлювання будуть довгими. Попросити Офелію попросити Джульєтту Am I better than you?- це як би if (Ophelia > Juliet)на більшості "нормальних" мов. І, звичайно, можна попросити навпаки: Am I not better than you?це еквівалент if (Ophelia < Juliet). І ви вже можете здогадатися, як =перекладається на SPL: as good as- використання фрагмента коду 2.

Однак good/betterце не єдиний спосіб порівняння на цій шексперській мові, ви можете використовувати будь-який прикметник. Тут застосовується той самий принцип фрагмента 3, який має значення "позитивні" прикметники >, а "негативні" <.

Фрагмент довжини 7:

Juliet:

Це виклик змінної; після цього, його вказівки / декларації / все, що буде далі.

Обмеженням SPL є те, що він має обмежену кількість змінних: Ромео, Джульєтта, Гамлет, Офелія, МакБет тощо - це кілька прикладів "персонажів", які з'являться в програмі Шекспіра.

Фрагмент довжини 8:

[Exeunt]

[Exeunt]розміщується, коли всі "персонажі" залишають "сцену". Сподіваюся, я можу трохи пізніше детальніше розповісти про взаємодію між персонажами. Як правило, це остання інструкція будь-якої програми SPL, хоча [Exeunt]конкретно не є термінальним "символом" мови. Для іншого прикладу див. Фрагмент 27.

Фрагмент довжини 9:

as bad as

Дев'ять символів просто представити просто =- використовуючи фрагмент 2. Я вже згадував, що SPL є дивним? Див. Приклади 30 для прикладів. (і так, є кілька способів вивести це)

Фрагмент довжини 10:

difference

Вигадливий спосіб представлення -, віднімання. Ви можете проводити математичні операції на SPL, хоча вам, напевно, знадобиться цілий день, щоб виправити це.

Фактоїд (оскільки мені вдалося якось досягти десяти фрагментів коду, давайте трохи перервемося та ще один фактіо про SPL)

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

Ще один сайт для запуску SPL-коду - це той, який працює за допомогою внутрішньої трансляції коду SPL на іншу езотеричну мову: Oracle PL / SQL.

Фрагмент довжини 11:

[Exit Romeo]

Так! Нарешті я можу поговорити про взаємодію між персонажами! Для того, щоб змінити його значення або взаємодіяти з іншими, на сцені повинен бути "персонаж" [Enter Romeo]. Якщо персонаж адресується, але його немає, виникає помилка під час виконання програми, і програма зупиняється. Тому що в SPL значення змінних встановлюється кількістю імен, якими вони хвалять - або ображають - іншими символами на сцені. Я відчуваю, що я повинен навести приклад, щоб очистити деяку плутанину, яку може створити моє кульгаве пояснення, але, можливо, найкраще відкласти кілька фрагментів.

Фрагмент довжини 12:

Remember me.

SPL досить "базовий", добре - але він має стеки! Коли, наприклад, Ромео каже Джульєтті «пам'ятати його», він насправді говорить своїй коханій людині, щоб підштовхнути значення Ромео у її стек. Зміна значень виконується за допомогою Recall your happy childhood!, абоRecall your love for me , або в основному, будь-якого речення, яке починається з Recall- решта - це лише художній рух, як фрагмент 22.

Фрагмент довжини 13

Let us return

Шекспірівський спосіб існування а goto. І ось тут стають у нагоді Дії та Сцени. Якщо Ромео каже Джульєттіwe shall return to Act II (так, знову ж, існує кілька способів її написання), програма перейде до тієї конкретної частини коду. Це також спостерігається поряд із умовними твердженнями.

Довжина фрагмента 14

my little pony

Так, це була серія ще в 80-х. Ось, це 2*1. Чому? Тому що a pony- дещо позитивний іменник і littleє прикметником. Отже, запам'ятовуючи фрагменти 3 і 4, ми маємо little = "2 *"іpony = "1" .

Довжина фрагмента 15

Speak thy mind!

У програмі SPL ви побачите це (або Speak your mind!, те саме) багато . Це в основному виводить значення кожного "символу" в цифрі, букві чи будь-що інше, залежно від набору символів, який використовується на вашому комп'ютері. Існує також Open your mind.те, що робить майже те ж саме, хоча і лише виводиться в числовій формі.

Довжина 16 фрагмента

You are nothing!

Коли хтось скаже вам це в реальному житті, ви відчуєте себе пригніченим. Коли Офелія розповідає про це Гамлету в програмі Шекспіра, Гамлет відчуває себе нікчемним. Що це значить? Це Hamlet = 0.

Фрагмент довжини 17

Ophelia, a wench.

У сценарії перед початком фактичної п’єси персонажі повинні бути представлені. У більшості мов програмування змінні також повинні бути оголошені перед використанням. Побачивши, що SPL - це мова програмування, що нагадує сценарій, саме так ви оголошуєте його змінні, зазначаючи, які саме з'являються під час програми.

Але що означає «відросток»? Чи означає це, що це конкретна (і крута) назва типу даних? Ну ... я ненавиджу вас розчаровувати, але це нічого не означає: все після коми не розглядається парсером, це означає, що ви можете помістити туди найвиразніший потік, про який ви можете придумати.

Довжина фрагмента 18

lying sorry coward

-4для всіх земних істот. Чому? Тому що 2*2*(-1) = -4.

Довжина 19 фрагмента

Romeo:
 Remember me.

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

Довжина фрагмента 20

cube of thy codpiece

Я хотів би трохи більше розробити цю проблему, але, правда кажучи, речі, які я придумаю, все ще занадто короткі для цієї довжини фрагмента. І ось я приношу вам це, що в кінцевому підсумку є -1- тому що (-1) ³ = -1 (і codpieceє "негативним" іменником, оскільки вони незручні і всі). SPL розуміє декілька більш складних арифметичних операцій як деяких експоненцію та квадратні корені.

Фактоїд (ще один, оскільки ми досягли ще однієї віхи)

Програма "Hello World" у Шекспіріана має 89 рядків і понад 2400 символів, як видно тут .

Фрагмент довжини 21

Listen to your heart.

У фрагменті 15 ви вивели щось; тут ви вводите номер програми. Якщо ви хочете ввести символ, ви скористаєтесь ним Open your mind.. І, що зайве сказати, це значення буде зберігатися в "символі", про який говорять.

Довжина 22 фрагмента

Recall your childhood!

Викопування цілого числа з стека робиться з цим, як пояснено на фрагменті 12. Коли, наприклад, Офелія повідомляє Гамлету вищезгадане речення, це змушує Гамлета взяти з його стека ціле число і прийняти це значення.

Зрозуміло, що, поки слово recallпочинає речення, ви можете заповнити решту майже всім, чим захоче ваш творчий шексперський розум.

Довжина 23 фрагмента

Are you better than me?

Реалізація фрагмента 6. Коли "персонаж" ставить подібне питання іншому, те, що він / вона робить, еквівалентно if (x > y)більш поширеним мовам програмування. Виконання цієї інструкції має бути відкладено, поки у мене не буде більше символів.

Довжина фрагмента 24

[Enter Romeo and Juliet]

Так, "символи" можуть вводитися парами. Не потрібно, щоб один "персонаж" виходив на сцену, за ним супроводжувався інший.

Довжина фрагмента 25

remainder of the quotient

25 символів просто для написання %. 25 символів мають залишок частини. А користуватися ним? Ну, це ще більше - див. Фрагмент 75.

Довжина фрагмента 26

Let us return to scene II.

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

Довжина фрагмента 27

[Exeunt Ophelia and Hamlet]

Коли більше одного "персонажа" покидають сцену замість цього Exitі зберігають традиції з театральним характером SPL, використовується латинське слово "Exeunt". Іноді його можна замінити просто фрагментом 8.

Довжина фрагмента 28

Scene I: Ophelia's flattery.

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

Були зроблені деякі компілятори (як, наприклад, цей, який компілюється від SPL до C, написаний на Python ), які замість цього посилаються на текст після нумерації Act / Scene. Хоча більш логічно (зрештою, під час п'єси, коли персонажі, які говорять такі рядки, як "повернемося до дії I", можна вважати дурними), я дотримуюся оригінального способу.

Довжина фрагмента 29

You pretty little warm thing!

Так, ще одна константа (оскільки для арифметичних операцій нам потрібно більше символів). Цей дорівнює 8, тому що 2*2*2*1 = 8.

Довжина фрагмента 30

You are as cowardly as Hamlet!

Якщо сказати це, наприклад, Ромео, це означає Romeo = Hamlet. Як і фрагмент 9.

Фактоїд (так, ще одна орієнтир досягнута!)

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

Довжина 31 фрагмент

Am I as horrid as a flirt-gill?

Так, я знаю, це дещо повторюється фрагмент 23, хоча тут ми порівнюємо "персонажа", який розмовляє з "фліртом-зяброю" (з, якщо ви хочете, if (Ophelia == -1)). Річ у тім...

Довжина 32 фрагмента

If so, let us return to scene I.

... тепер я можу представити і thenSPL, і умовний стрибок до, і шексперський спосіб реалізації циклів. Ви можете, наприклад, змусити Ромео приймати значення 0, збільшувати його значення, виконуючи якесь інше завдання, і зупинятися, коли він досягає 10, продовжуючи програму після цього.

Довжина 33 фрагмента

If not, let us return to scene I.

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

Довжина 34 фрагмента

Open your mind! Remember yourself.

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

Довжина 35 фрагмента

Act I: Death!

Scene I: Oh, shit.

Правильний спосіб декларування акта та сцени. Зі смаком додайте художню кашку.

Довжина 36 фрагмента

Thou art as sweet as a summer's day!

Ще один спосіб сказати, що «персонаж», про який говорять, отримає цінність 1- адже літні дні приємні та приємні.

Довжина 37 фрагмента

Art thou more cunning than the Ghost?

Офелія задають це питання Гамлета кошти, переводячи це менш читаним мовою програмування if (Hamlet > the Ghost). Це фрагмент 23 знов, так - але це показує вам, що не потрібно запитувати "персонажів", якщо вони кращі один за одного: будь-яке інше питання також буде спрацьовувати.

Довжина 38 фрагмента

[Enter the Ghost, Romeo and the Ghost]

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

Довжина 39 фрагмента

the sum of a fat lazy pig and yourself!

Повна інструкція краще виглядає, що це, я дам вам це, але ... ось наша перша арифметична операція! Що це все означає насправді? Ну, pigце брудна тварина (хоч і смачна), тому вона рівнозначна -1, має два прикметники, що означає fat lazy pigрівне 2*2*(-1) = -4. А як же yourself? Це рефлексивна вимова, а не ім’я та прикметник. Ну, пам’ятайте, що SPL заснований на діалогах між "персонажами"; таким чином, yourselfвідноситься до іншого "персонажа" на сцені. Отже, ми підходимо до кінця і виявляємо, що "сума товстої лінивої свині та себе" насправді є -4 + x.

Довжина 40 фрагмента

the sum of a squirrel and a white horse.

Так, ще одна сума, але ця є простішою за фрагмент 39. Це просто 1 + 2- 3якщо моя математика правильна.

Фактоїд (як і раніше зі мною після цих сорок фрагментів художнього пуху? Ти заслужив приз.)

SPL у версії 1.2.1 можна завантажити тут .

Довжина 41 фрагмент

Juliet:
 Speak thy mind!

[Exit Romeo]

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

Довжина 42 фрагмента

Speak YOUR mind! You are as bad as Hamlet!

Знову дві інструкції в одному рядку (у нас може бути кілька, але довжина фрагмента ще не дозволяє); тут у нас є "персонаж", який говорить іншому, щоб вивести його значення і припустити, яке значення має Гамлет. Заплутано? Mayhap.

Довжина 43 фрагмента

Am I as horrid as a half-witted flirt-gill?

Джульєтта, яка запитує це, не означає, що вона має низьку повагу (хоча це може бути і в реальному житті); це просто інше if, як фрагменти 23 і 37. О, я майже забув: це означає if (Juliet == -2).

Довжина 44 фрагмента

You are as evil as the square root of Romeo!

Так, квадратне коріння - це зло, хіба ви не знали? У будь-якому випадку ця інструкція є достатньо простою, щоб зрозуміти, що вона робить: приписує "символу", який вимовляється, значенню квадратного кореня значення, що зберігається в Ромео.

Довжина фрагмента 45

Hamlet:
 Art thou more cunning than the Ghost?

Фрагмент 37 правильно написаний разом із персонажем, який розмовляє рядком.

Довжина 46 фрагмент

the product of a rural town and my rich purse.

Гаразд ... так чи інакше, SPL може бути єдиною мовою в світі, яка дозволяє вам примножувати міста з гаманцями. Це означає, (2*1)*(2*1)що, якщо я не дуже помиляюся, дорівнює 4.

Довжина 47 фрагмента

Romeo:
 Speak your mind.

Juliet:
 Speak YOUR mind!

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

Довжина 48 фрагмента

You lying fatherless useless half-witted coward!

Перекладаючи його безпосередньо, 2*2*2*2*(-1). -16, правда?

Довжина 49 фрагмента

Scene V: Closure.

Hamlet:
 Speak your mind!

[Exeunt]

Приклад того, як припинити програму в SPL. Ви можете оголосити сцену спеціально для неї (хоча це не потрібно), тоді Гамлет просить іншого "персонажа" вивести їх значення, потім вони всі вийдуть з сцени. І так, потрібно, щоб усі вони зійшли зі сцени.

Довжина фрагмента 50

Othello, a young squire.
Lady Macbeth, an old fart.

Більше "персонаж" презентації, перш ніж відповідні інструкції. Як завжди, єдине, що має значення для компілятора, це OthelloіLady Macbeth , тому решта рядка - це захоплення ...

І ще одне: "персонажі" не повинні бути пов’язані один з одним, щоб вони з'явилися в програмі SPL - щоб ви могли мати Ромео, Отелло та Гамлета в одній виставі.

Фактоїд (півстоліття цих речей? Фу, після цього я думаю, що я буду ненавидіти Вільяма Шекспіра ...)

Перекладач SPL на C, згаданий деякий час тому і розроблений творцями SPL, базувався на Flex та Bison .

Довжина 51 фрагмент

Othello:
 Recall your great dreams. Speak your mind!

(Настільки хворіють Ромео, Джульєтта та Гамлет ... давайте привеземо Отелло, щоб змінити!)

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

Довжина 52 фрагмента

Thou art as pretty as the sum of thyself and my dog!

Ще одна сума. Позіхання. Якщо припустити, що ця адресована Гамлету, це означає Hamlet = Hamlet + 1. Або Hamlet += 1. Або Hamlet++.

Довжина 53 фрагмента

Romeo:
 You are as vile as the sum of me and yourself!

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

Довжина 54 фрагмента

Juliet:
 Is the sum of Romeo and me as good as nothing?

Ще один приклад попереднього фрагмента, включеного в умову. Отже, що ми маємо тут if (Romeo + Juliet == 0).

Довжина 55 фрагмента

Juliet:
 You are as lovely as the sweetest reddest rose.

Отже, тут Джульєтта хвалить "персонажа", з яким вона розмовляє (припустимо, це Ромео, ради Шекспіра), заявивши, що йому / їй 4. Так, чергове присвоєння цінностей.

Довжина 56 фрагмента

Othello:
 You lying fatherless useless half-witted coward!

Знімок 48 зроблено правильно, з "символом". Якщо ви лінуєтеся прокручувати вгору (як я б), це означає, що той, кого образили, отримує значення -16.

Довжина 57 фрагмента

Romeo:
 If not, let us return to Act I. Recall thy riches!

Я вже пояснив, як працюють умови щодо SPL на загальних підставах; однак, потрібен більш детальний аналіз. У нас немає elseтут: наприклад, у цьому прикладі, якщо умова не вдалася, програма повернеться до Акту I; але якби це було правдою, воно продовжувало б наступну інструкцію, а це Recall- поп із стека, тобто.

Довжина 58 фрагмента

Romeo:
 You are as disgusting as the square root of Juliet!

Захоплення фрагмента 44 та представлення способу подання інструкції. Якщо це був діалог між Ромео та Отелло, то ми могли б перекласти це на Яву як Othello = Math.sqrt(Juliet).

Довжина 59 фрагмента

Othello:
 You are as vile as the sum of yourself and a toad!

Гаразд, якщо Отелло розмовляє з Ромео, це було б рівнозначно Romeo+(-1); Romeo--, коротко. Досить базовий, правда? Це SPL для вас.

Довжина 60 фрагмента

Is the quotient between the Ghost and me as good as nothing?

Коротше кажучи, if (The Ghost/Hamlet == 0)якщо припустити, що "я" належить Гамлету.

Довжина 61 фрагмент

Thou art as handsome as the sum of yourself and my chihuahua!

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

Довжина 62 фрагмента

twice the difference between a mistletoe and a oozing blister!

Так, так, більше арифметичних операцій. Приблизно ці 62 байти SPL можуть бути переведені в 2*(1-2*(-1)). Це було б дуже приголомшливою мовою для гольфу, правда? Правильно.

Довжина 63 фрагмента

You lying stupid fatherless rotten stinking half-witted coward!

Сніппет 48 , виведений -16, це один дорівнює -64: 2*2*2*2*2*2*(-1).

Довжина 64 фрагмента

your coward sorry little stuffed misused dusty oozing rotten sky

З того, що я розумію щодо SPL, це абсолютно законно. У вас є чимало образливих прикметників, які продовжують іменник "позитивний". Оскільки прикметники не мають особливого розрізнення, чи є вони негативними чи ні (єдине їх значення - це множення числа праворуч на два), ми можемо мати абсолютно нерозумні речення, як це. Що еквівалентно 256. Тому 2*2*2*2*2*2*2*2*1=256.

Довжина 65 фрагмента

You are nothing! You are as vile as the sum of thyself and a pig.

Хм, стільки ненависті, чи не так? Отже, те, що ми маємо тут, еквівалентне, y=0; y=y+(-1);ймовірно, можна було б "гольфувати" You are a pig!, але так.

Довжина 66 фрагмента

You are as beautiful as the difference between Juliet and thyself.

Отже, відняти Джульєтту від себе, так? Це досить просто розшифрувати: Romeo=Juliet-Romeo;якщо припустити, що з ним говорять Ромео.

Довжина фрагмента 67

Juliet:
 Am I better than you?

Romeo:
 If so, let us proceed to Act V.

Як більшість умов працює на SPL. Ви перевіряєте вираз і, якщо це правда (чи ні: див. Фрагмент 33), переходите до іншої частини програми; в іншому випадку ви продовжите наступне речення.

Довжина 68 фрагмента

The Ghost:
 You are as small as the sum of yourself and a stone wall!

Так, так, я стаю трохи одноманітним. Але SPL така. Як я вже говорив трохи раніше, його вирази - це суміш арифметичних операцій. Таким чином, це ще одне нарощення - оскільки stone wallє нейтральним "іменником".

Довжина 69 фрагмента

Thou art as disgusting as the difference between Othello and thyself!

Замість суми ми маємо віднімання між двома персонажами, Отелло та тим, з ким говорять.

Довжина фрагмента 70

You are as handsome as the sum of Romeo and his black lazy squirrel!

Повертаємось до доповнень, так - називайте мене формульним, хе. Ми перекладаємо це на Romeo + 2*2*1.

Довжина 71 фрагмент

Scene I: Dialogues.

[Enter Juliet]

Othello:
 Speak your mind!

[Exit Juliet]

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

Довжина фрагмента 72

twice the difference between a mistletoe and an oozing infected blister!

Ще одна арифметична операція - адже SPL пронизана ними. Ми можемо перекласти це на 2*(1-2*2*(-1)).

Довжина 73 фрагмента

You are nothing! Remember me. Recall your unhappy story! Speak your mind!

Чотири інструкції поспіль ?! Насправді я дуже пишаюся собою. У будь-якому випадку, припустимо, що це діалог між Ромео і Джульєттою (і він говорить): це означає, що значення Джульєтти починається з 0; тоді Джульєтта підштовхне значення Ромео до її стека пам’яті, викладе його та виведе його у введеному вигляді. Просте, правда?

Довжина 74 фрагмента

You are as sweet as the sum of the sum of Romeo and his horse and his cat!

Так, я знаю, нудний приклад. Але це так X = (Romeo + 1) + 1.

Довжина 75 фрагмента

Is the remainder of the quotient between Othello and me as good as nothing?

Ну, це досить просто. Якщо ваші навички декодування несправні, це перекладається на if (Othello % X == 0).

Довжина 76 фрагмента

Thou art as rich as the sum of thyself and my dog! Let us return to scene I.

Стрибок з фрагмента 26 з виразом перед ним. A gotoна SPL не завжди знаходиться поруч із умовою, він може бути таким - і, звичайно, такий тип gotoзавжди буде знайдений наприкінці акту чи сцени, оскільки інструкції після нього ніколи не будуть складені / виконані. Перша команда досить проста: x=x+1.

Фрагмент довжини 77

[Exit Hamlet]

[Enter Romeo]

Juliet:
 Open your heart.

[Exit Juliet]

[Enter Hamlet]

Отже, у нас на сцені є Джульєтта та Гамлет; але нам потрібна цінність від Ромео. Таким чином, для того, щоб врятувати компілятора від дуже неприємного головного болю, спочатку ми знімаємо Гамлета зі сцени (хоча це могло бути Джульєттою та йти), ми кажемо Ромео вийти на сцену, Джульєтта дає йому інструкцію вивести номер (див. пояснення фрагмента 21), потім Ромео виходить зі сцени, і Гамлет повертається. Досить прямо і просто.

Довжина 78 фрагмента

The Ghost:
 Speak thy mind.

Lady Macbeth:
 Listen to thy heart! Remember thyself.

Отже, Привид (померлий батько Гамлета) каже леді Макбет вивести її цінність, в той час як вона наказує «Привид» прочитати номер і підштовхнути його до своєї стопки.

Пієт

Фактоїдні

Piet - мова програмування, де вихідний код складається із зображень. Потік програми починається з верхнього лівого пікселя і переміщується навколо зображення між пікселями та групами пікселів, поки воно не припиняється.

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

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

1 Кодекс

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

У цьому випадку піксель може бути будь-якого кольору для точно такого ж ефекту.

2 коделі

Це буде постійно читати символи з stdin та зберігати загальну кількість своїх значень унікоду (хоча з цим сумарним показником нічого не робиться і воно не відображається)

Прогамовий потік рухається вперед-назад між двома коделами, оскільки єдиний вихід з кожного - в інший. Команди в пієті виконуються переміщенням від одного кодера або області до іншої, залежно від різниці відтінку та легкості 2 регіонів. Команда input- це переміщення вліво-вправо, а потім addсправа-вліво. На першомуadd команді нічого не відбудеться, оскільки на стеку є лише одне значення, а специфікація говорить про те, що команди без достатньої кількості доступних значень ігноруються.

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

3 коделі

Це основна програма ехо-типу, вона одночасно зчитує персонаж із stdin та друкує його до stdout.

Знову це нескінченна петля. Програма починається з подорожі зліва направо, що робить і inputтоді output. Програма буде продовжувати текти в тому ж напрямку, коли тільки зможе. На світло-зеленому коделі єдиний вихід - почати рухатися назад іншим шляхом. Під час подорожі назад справа наліво намагається виконати subtractіadd команди, але стек порожній, тому вони стають непотрібними.

4 коделі

Виводить 2 для stdout нескінченно.

Не особливо цікава програма функціонально, але тепер, коли ми нарешті є складеною кількістю коделів, ми можемо продемонструвати трохи більш розвинений потік, ніж зліва направо. Коли потік програми намагається вийти з кодела, він спершу спробує поточний напрямок. Якщо він не в змозі (у цьому випадку через край зображення), він обертається на 90 градусів за годинниковою стрілкою та намагається вийти знову. У цьому випадку програма одночасно обертається по 1 коделі за годинниковою стрілкою, переводячи push1 на стек двічі, addз'єднуючи їх разом, потім outputотримуючи результат.

5 коделів

Неодноразово читає символ за раз зі stdin і відстежує суму їх значень унікоду.

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

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

6 коделів

Знову ж, повторення попередньої функціональності з іншим виглядом. Це ще одна ехо-програма, яка читає персонаж за раз від stdin до stdout.

Тут ми бачимо наш перший чорний кодекс. Потік програми не може ввести чорний кодекс, тому зі світло-пурпурного коделя у верхньому правому куті програма не зможе вийти праворуч через край зображення, не зможе вийти вниз через чорний кодекс і відскочить назад вліво до червоного кодера . Сині та зелені коделі суто декоративні, програма ніколи їх не вводить.

7 коделів

Ще одна ехо-програма з іншим виглядом.

Тут ми бачимо наші перші кодельні блоки, що перевищують розмір 1. У пієті будь-який суміжний блок коделів одного кольору трактується як один блок. Розмір блоку не має значення, крім випадків, коли виконується pushінструкція, тому ця програма трактується точно так само, як 3-кодова версія, за винятком різних кольорів.

8 коделів

Читає число від stdin і повторно виводить квадрат у stdout.

Контрольний потік є базовим малюнком за годинниковою стрілкою так само, як у програмі 4-коду. Починаючи з верхнього лівого, операції в порядку є input, duplicate(виштовхує додаткову копію верхнього значення стека в стек), multiply, output. Потім воно pushнабирає значення 1 на стек, ковзає по білому, так що команда не виконується, а потім pops, що відключається від стека, коли рухається від нижнього лівого до верхнього лівого кодера. Це повертає його до початку програми з порожнім стеком, і він повторюється.

9 коделів

Додає 1 + 2 = 3, а потім закінчується.

Тепер, коли у нас є програма з більш ніж 2 коделями в обох вимірах, ми можемо нарешті створити область, яка буде захоплювати програму і закінчувати її замість циклу назавжди. Перша операція, що рухається від червоного кодера до темно-червоної області, дорівнює push1, потім програма обертається і впадає в світло-червоний кодел посередині і pushстановить значення 2. Протікає від світло-червоного до світло-жовтого виконується addоперації. Нижня світло-жовта смуга змушує програму закінчитися, оскільки немає можливості її витікати, оскільки всі кути заблоковані.

Програми 1- та 2 швидко стають некрасивими та нецікавими, тому з цього моменту я зупинюсь на цифрах, що дозволяють принаймні по кілька коделів у кожному напрямку.

12 коделів

Нарешті програма, яка робить щось, що можна стверджувати як корисне (хоча це все-таки трохи розтягує). Читає 2 числа від stdin послідовно, а потім виводить їх суму, і робить це повторно.

Програма протікає зліва направо через 4 кольорові смуги, що виконують 2, inputsпісля чого addкоманда. Потім він переміщується в нижній правий кодекс і виконує output, а потім йде ліворуч по білій області назад до початку.

Це можна було зробити в 8 коделів, але оскільки у нас є додатковий простір, ми можемо зробити щось, що трохи натхнене старим телевізійним екраном без сигналу.

15 коделів

Читає число від stdin і виводить його 'квадрат.

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

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

20 коделів

Читає числа від stdin до зчитування 0, після чого він виводить суму всіх введених чисел та виходів.

Нарешті, у нас є достатньо місця для управління потоком у формі pointerоперації. 4 коделі вздовж верху виконують input, duplicateі виконують notоперації, а потім ще одну notоперацію, що рухається від пурпурового вгорі праворуч до 2-кодового жовтого під ним. notОперація виштовхує верхнє значення з стека і натискає 1 , якщо верхнє значення було 0, і 1 в іншому випадку. Отже, подвійне - notзамінює будь-яке ненулеве значення на 1. Переміщення від жовтої смуги до темно-синього виконує pointerоперацію, яка вискакує верхнє значення зі стека та переміщує вказівник за годинниковою стрілкою, як багато разів.

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

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

25 коделів

Відлік часу! Читає число з stdin, а потім друкує зворотний відлік до 1, щоб викреслити одне число за один раз. Наприклад, якщо прочитано 5, буде надруковано 54321.

Перша операція від блакитного до жовтого - це input. Тоді жовтий - це те, де починається програма "цикл". Жовтий> Пурпурний> Синій - це duplicateтоді output, тому він друкує найвище значення на стеку, але зберігає копію. Переміщення вниз по правій стороні, ми pushзначення 1 в стек потім виконати subtraction, зменшуючи наше введене значення на 1. Далі йде duplicate, notі інше notпереміщення від світло - пурпурні в нижньому правому кутку на темно - жовтий поруч з ним. Це та сама перевірка нуля / нуля, що і попередня програма. Переміщення ліворуч у світло-блакитний кодекс виконує pointerоперацію, яка або перейде ліворуч у темний блакитний кінець, щоб закінчити програму, якщо ми закінчимо, або до жовтого, щоб знову запустити цикл без початкового введення, але початкове значення зменшилось на 1.

Усі 3 червоних коделі декоративні і можуть бути будь-якого кольору.

30 коделів

Генератор Фібоначчі. Виводить умови послідовності Фібоначчі до stdout і не зупиняється.

Це перше введення rollоператора, а також перший раз, коли розмір області більший за 1 використовується з pushоператором для отримання конкретного значення на стек.

Як завжди починається в лівій верхній частині праворуч. Перші 2 операції pusha 1 над стеком, а потім, outputоскільки послідовність Фібоначчі починається з двох 1s, але основний цикл програми надрукує 1 лише один раз. Потім це ще push2 секунди на стек, щоб опинитися в темній пурпурі вгорі праворуч, щоб запустити основний цикл програми.

Рухаючись вниз правою стороною ми duplicateі outputроздруковуємо наступний додаток послідовності, а потім duplicateзнову, щоб отримати копію поточного значення послідовності. Переміщення ліворуч внизу виконує 2 pushоперації. Оскільки світло-червона область в правій нижній частині має розмір 3 коделі, перший натисне push3 на стек замість 1.

Перехід до світло-синього кольору - це rollоперація. Це вискакує 2 верхніх значення зі стека та виконує кількість рулонів, рівних першому висунутому значенню, на глибину, рівну другому значення, що спливе. У цьому випадку він виконає 1 рулон на глибину 3. Рулон на глибину nприймає верхнє значення стека (наше дубльоване поточне значення) і закопує його в nглибину. Наш стек зараз лише 3 глибокі, тому він поховає верхнє значення внизу.

Переміщення вгору виконує addоперацію додавання поточного значення послідовності з попереднім значенням послідовності. Тепер наш стек має наступне (нове поточне) значення послідовності зверху та останнє значення під ним. Тепер програма переходить прямо по білому в темну пурпурову, щоб знову запустити цикл.

Жовтий візерунок посередині ніколи не використовується.

54 коделі

Друкує "привіт!" до stdout

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

Програма починається з push5 із синього краю зліва. Звідси він протікає прямо вздовж верху на 6 duplicateоперацій, щоб прокласти стек з купою 5с. Далі push1, subtractщоб поставити 4 зверху стека, потім 2 multiplyоперації, щоб поставити 4 * 5 * 5 = 100 поверх стека. Тоді duplicateза 2 100с.

Тепер програма відскакує від чорного і починає працювати вліво по нижній частині. Pushоперації 3 і 2, а потім a, rollщоб поховати 2 100 під 5. 5. Далі push1, віднімаємо і додаємо, щоб отримати 100 + 5-1 = 104 на вершині стека, який є унікодом "h". Наступні 2 операції - це push1, pointerщоб обійти кут і почати рухатися прямо вздовж середини, а потім outputнадрукувати "h".

Далі - add100 + 5 = 105 на вершині стека, і outputнадрукувати "i". Стек тепер містить дві 5s. Push1, add, multiplyдає (1 + 5) * 5 = 30. Нарешті push3 і addдля 33, і outputдля останнього "!". Потім програма проходить прямо через залишок білого простору і закінчується зеленим кольором праворуч.

> <> (Риба)

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

Фактоїд:

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

Фрагмент довжини 1:

X

Xє недійсною командою в <<>, тому something smells fishy...друкується повідомлення про помилку . Насправді це єдине повідомлення про помилку в <<>, незалежно від того, чи є причина поділу на нуль або спроба вивести порожній стек.

Фрагмент довжини 2:

1n

Потік програми в меню <<> починається зліва вгорі і спочатку праворуч. 1натискає на стек 1, а потім nдрукує його як число (на відміну від символу ASCII). Але> <> програми є тороїдальними, це означає, що вказівник інструкції загортається, коли він доходить до кінця рядка. Тож після того, як nми закінчимось початком, натисніть 1, роздрукуйте, заверніть до початку, натисніть 1, надрукуйте ..., і ми закінчимо друк 1s назавжди!

Фрагмент довжини 3:

"o;

Ось "синтаксичний аналіз, oвиводиться як символ ASCII та ;завершує програму. Але що насправді робить програма в цілому?

Ну, спочатку ми починаємо розбір рядків, висуваючи кожну бачину на стек, поки не знайдемо закриття ". Натискаємо o, потім ;... і повертаємо вказівник до початку. Але тепер ми перебуваємо на "тому, ми зупиняємо синтаксичний розбір рядків і, нарешті, виконуємо oі, ;як звичайно, друкуємо верхню частину стека (the ;) та завершуємо.

Так, ми просто використовували ту саму діаграму цитат, щоб почати і закінчити рядок!

Фрагмент довжини 4:

42n;

Виходячи з того, що ми бачили до цього часу, ви можете розраховувати, що це натисне 42, вивести як число, а потім припинити. Але всі вказівки в <<> є одиничними знаками, тому це насправді висуває 4 і 2 , потім виводить верхню частину стека як число (лише 2) і закінчується.

Фрагмент довжини 5:

<v
;>

Пам'ятайте, що <<> є двовимірною мовою. Це означає, що повинні бути способи змінити напрямок потоку програми!

Як і Befunge, один із способів зробити це можна за допомогою стрілок >^v<. Щоб проілюструвати, як вони працюють, розглянемо вищевказану програму:

• Потік програми спочатку направо
• < робить потік програми ліворуч - ми йдемо ліворуч і загортаємо до v
• v змушує програму протікати вниз - ми спускаємось до >
• > змушує програму протікати вправо - ми йдемо праворуч і загортаємо до ;
• Нарешті, ми припиняємо.

Фрагмент довжини 6:

";"00p

Ще одна цікава особливість програми <<> - це те, що вона рефлексивна - програма може змінювати власний вихідний код на льоту!

Тут ми натискаємо a ;, а потім два нулі. pПотім спливає три верхніх елемента y, x, v( yбудучи в верхній частині стека) і місця vна позиції x,y. Іншими словами, програма pв цій програмі ставить крапку з комою 0,0, перетворюючи код у ;;"00p. Це дозволяє програмі закінчуватися, оскільки вказівник інструкції тепер обертається та виконує щойно розміщений ;.

Фрагмент довжини 7:

\7*n;
6

Крім Befunge,> <> також має дзеркала ( \/|_#), які відображають напрямок потоку програми. Отже, ось ми:

• Почніть праворуч, але \відбиває нас вниз
• Натисніть на 6 і загорніть
• Натисніть на \тильну сторону та відбийте назад праворуч
• Натисніть на 7
• Помножте два верхні стопки
• Виведіть і припиніть

Переміщення по горизонталі через _дзеркало або вертикально через |дзеркало - неоперативне.

Фрагмент довжини 8:

"r00g>o<

Цілком можливо, найпростіший> <> quine, якщо помилка дозволена для видалення. Дві нові інструкції тут:

• r: Зворотний стік
• g: Get - поп y, xі натиснути символ в x,yстек (аналог в p)

Використовуючи фокус обертання рядків від раніше, програма спочатку натискає, r00g>o<а потім знову натискає першу цитату. Потім стопку перевертають, даючи <o>g00r. Після цього ми штовхаємо char 0,0, щоб ", щоб дати <o>g00r". Нарешті, oми потрапляємо між двома стрілками, виводячи верхню частину стека, поки не залишиться нічого, і ми отримаємо помилку.

Фрагмент довжини 9:

x0\>
\1n>

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

Фрагмент довжини 10:

;a comment

Синтаксис коментарів у <<> не потрібен. Просто напишіть те, що вам потрібно де завгодно, і переконайтеся, що воно не виконується як код!

Фрагмент довжини 11:

1!X2!X+!Xn;

!- батут, який пропускає інструкції. Це особливо корисно при використанні ?, в умовному батут , який вискакує на вершину стека і виконує таку інструкцію , якщо сунув елемент НЕ дорівнює нулю. Ми побачимо, як це працює згодом.

Наведений вище код друкує 3, пропускаючи по Xs, лише виконуючи 1! 2! +! n;.

Фрагмент довжини 12:

01v
ao>:@+:n

Друкує числа Фібоначчі назавжди, починаючи з другого 1, по одному у кожному рядку. Нові команди:

• a: Натисніть 10, що нам потрібно для нового рядка. a-fнатисніть 10 на 15 відповідно.
• :: Дублювання верхньої частини стека
• @: Оберніть три верхні елементи стека, наприклад [5 4 3 2 1] -> [5 4 1 3 2].

Простежте за першими кількома ітераціями:

Фрагмент довжини 13:

i:d=?v
l?!;o>

Програма "tac", яка читає в рядку вводу та виводить її на зворотній бік. Завдяки @tomsmeding за фрагмент.

=спливає два верхні елементи та штовхає 1, якщо вони рівні, 0 інакше. Перший рядок продовжує читати на вході, поки не буде знайдено графік ASCII 13 (повернення каретки), після чого він перейде до другого рядка.

l?!;oПетля є важливою конструкцією в> <> , який виводить весь стек. На відміну від>o< , це не викликає помилок. Ось як це працює:

• l висуває довжину штабеля
• Перевіряємо довжину за допомогою ? :
  • Якщо довжина була ненульовою, то наступна інструкція ! виконується , пропускаючи;
  • Якщо довжина дорівнювала нулю, ми не виконуємо !і не припиняємо через;

Зауважте, що жодного виходу насправді не відбувається, поки ви не натиснете на повернення каретки.

Фрагмент довжини 14:

32.

   X67*n;

Крім зміни напрямку потоку програми, ви можете фактично переміщувати покажчик інструкцій куди завгодно!

.з'являється y, xі телепортує вказівник на інструкцію x,y, підтримуючи напрямок. Однак зауважте, що вам потрібно перейти до одного квадрата перед тим, куди ви хочете піти - покажчик інструкцій оновлюється до виконання наступної інструкції. Тож тут вказівник інструкції припадає на недійсний X, але все нормально, оскільки покажчик переходить до 6попереднього виконання.

.дає можливість перетворити більшість програм <<> в однолінійку, але чому б ви хотіли втратити задоволення від 2D? :)

Фрагмент довжини 15:

01+:aa*=?;:nao!

Друкує числа, 0по 99одному у кожному рядку. Ця програма демонструє акуратне використання !батута, щоб переконатися, що початковий 0 натисне лише один раз.

Фрагмент довжини 16:

"r00g!;oooooooo|

Правильна лайка, яка не кидає помилок, натхненна лайкою на сторінці esolang .

Якщо ви задумалися про те, як змінити попередню quine (фрагмент №8), щоб вона не спричинила помилку, і подумали, "чому я не додам тону oінструкцій?", То ви можете зрозуміти, що для кожного доданого oвами , вам потрібно вивести інший o! Це Куайн акуратно вирішує цю проблему, поміщаючи |дзеркало в кінці, яка дозволяє кожному oбути використані двічі .

Якщо ми переходимо до одинарних лапок (які також призначені для розбору рядків), то альтернативна квінка, яка не використовується, gє

'r3d*!;oooooooo|

Фрагмент довжини 17:

b2,63,.

   17,n;

У нас є складання ( +), віднімання ( -), множення ( *), модуль ( %) ... але як щодо поділу? Він є, але, оскільки /це вже дзеркало, ,символом було призначено замість нього. Цікаво, що поділ є плаваючим поділ, а не ціле ділення!

Вищеописана програма досліджує деяку невизначену поведінку, намагаючись перейти до 11/2, 6/3. Intepreter Python здається , добре , якщо перша координата не є цілим числом (хоча він стрибає в неправильному місці), але дроселі , якщо другий немає.

Фрагмент довжини 18:

123456${{$}nnnnnn;

Ми бачили, rщо обертає стек, а @який обертає три найкращі елементи. Ось ще кілька команд, які переміщують елементи на стеку:

• $: Поміняйте місцями на два верхні елементи
• {: Зсуньте всю стечку вліво
• }: Зсуньте всю стек праворуч

Щоб показати, як це працює, ось програмний слід:

123456 ------> 123465 ------> 234651 ------> 346512 ------> 346521 ------> 134652
       $ Swap        { L shift      { L shift       $ Swap        } R shift

Потім виводимо, даючи 256431.

Фрагмент довжини 19:

"reward"4[roooo]oo;

До сих пір я казав "стек", "стек" ...

Хоча більшість програм використовує лише один стек,> <> може насправді мати кілька стеків! Ось відповідні інструкції:

• [: З'являється xта переміщує верхні xелементи до нового стеку
• ]: Видаляє поточний стек і переміщує його значення до базового стеку.

Ось слід для наведеної програми:

       [r e w a r d]       Push "reward"
4[     [r e] [w a r d]     Move four elements to a new stack
r      [r e] [d r a w]     Reverse the current stack
oooo   [r e] []            Output "ward"
]      [r e]               Remove the current stack, no values to move
oo     []                  Output "er", giving "warder" altogether

Зауважте, що просто натискання rewardта повторне виведення його з ooooooдруком виводиться за drawerрахунок характеру стеків "перший у, останній".

Фрагмент довжини 20:

aa*5+\
7a*2+\
oo;  \

Маловідома особливість> <> полягає в тому, що, як і в Python, зворотні косої риси можна використовувати для продовження рядків у багатьох випадках. *

Наведений вище код функціонально такий же, як і

aa*5+7a*2+oo;

^{* Відмова від відповідальності: Причина, по якій це працює, може бути, а не може бути зовсім з іншої причини}

Фрагмент довжини 22:

1&fv ;n&<
&1->:0=?^:&*

Крім стеків,> <> також має регістри (по одному для кожної стеки), які можна використовувати для зберігання значень. &Перший виклик переміщує верхнє значення стека в регістр, а виконання &знову переміщує значення назад. Це може бути дуже корисно при накопиченні вартості, наприклад сум і фактичних даних.

Програма вище обчислює факториал f(15), друкуючи 1307674368000. Ось слід fзамінити на 4:

Фрагмент довжини 24:

"Hello, World!"rl?!;of0.

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

Фрагмент довжини 25:

0i:0(?v$a*$"0"-+!
   ;n~<

На жаль, <<дозволяє лише читати зі STDIN по одному знаку за раз, що робить читання цифр трохи складним. Для введення, що складається з цифр 0-9, ця програма по суті є atoi, перетворюючи рядок цифр з STDIN в число на стеку (яке потім друкується).

Ще одна примітка полягає в тому, що на EOF iнатискає -1 на стек. Це полегшує перевірку EOF шляхом порівняння з 0 (або "менше".

Цей фрагмент також використовує ~, який з'являється та відкидає верхній елемент стеку.

Довжина фрагмента 33:

i>:nao:1=?;\
 ^  ,2v?%2:/
 ^+1*3<

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

Програма читає один символ ASCII і запускає 3x+1алгоритм у своїй кодовій точці (In> <>, символи - це в основному цілі числа). Кожен крок алгоритму друкується, поки ми не натиснемо 1.

Ось слід для перших кількох ітерацій із введенням a(кодова точка 97):

Довжина 44 фрагмента:

a&>i:0(?v"+"$\
/&^?=0l< "a*"/
\:1+&2p/\0
n
;

Я не відчуваю, що я виконав pсправедливість команд, використовуючи її лише один раз увесь час у фрагменті №6, тому ось інша функція atoi. Що круто в цьому? Програма записує вираз, необхідний для обчислення числа під час зчитування введення!

Таким чином, для введення, як-от 573, після того, як всі символи будуть прочитані, буде виглядати кінець третього рядка \0a*5+a*7+a*3+, який оцінює до 573!

Ще раз очікується, що вхід буде лише цифрами. Простежте GIF тут .

Фрагмент довжини 74:

>i:'A'(?v:'N'(?v:'['(?v\
  :'a'(?v:'n'(?v:'{'(?v\
^      o<    +d<  -d-d<o

Якщо вам вдалося потрапити сюди, то ви можете погодитися зі мною, коли я скажу, що це одна дуже читана програма ROT13. З огляду на таблицю c1, ми знаходимо першу таблицю c2в AN[an{такому c1 < c2, а потім застосуємо відповідне зміщення додаванням / відніманням d(13). Зауважте, що [і {є символи безпосередньо після Zіz відповідно.

Спробуйте це в консолі і спостерігайте за перетворенням літер під час введення!

^{(Ви також можете :0(?;подати на вхід, але оскільки мені не вистачає перевірки EOF, він зупиниться з помилкою, коли він намагатиметься надрукувати -1 як графік)}

C - редагувати

Дякую за голоси! У порівнянні з іншими мовами та тим, що вони можуть робити в обмежених байтах, C виглядає застарілим, метушливим і занадто залежним від розробника. Багато в чому це так: сценарії та мови вищого рівня з автоматичним управлінням пам’яттю набагато більш виразні та швидші у виробництві, ніж коли-небудь.

То чому функція C?

Прихований секрет усіх цих мов сценаріїв полягає в тому, що перекладачі, ймовірно, написані на C (або останнім часом C ++ або Java). Перші компілятори C ++ фактично складені до коду С. Насправді, поки не існує ринку для прямого компілятора, зазвичай вигідніше написати компілятор для створення C, а потім компілювати його.

Якщо ви працюєте на дуже маленьких платформах, можливо, навіть без наявної операційної системи, ви, ймовірно, працюєте в C. У ці дні майже на кожному пристрої вбудований мікроконтролер, без сумніву, запрограмований на C. Коли їм це потрібно. малий і швидкий, С - шлях. (Також НАЧАЛО, для мазохістів.)

Знаючи C, ви можете наблизитись до металу, наскільки ви можете пройти, не потрапляючи в асемблер, і допоможе вам іншими мовами. Ви маєте гарне уявлення про те, як, ймовірно, працює віртуальна функція C ++. Ви знаєте, коли ви пишете в PHP ці рекурсивні функції прохідної вартості, що внутрішньо це робить багато розподілу пам'яті та копіювання, тому ви інстинктивно випробовуєте пропуск через посилання. Зворотні виклики та посилання не вигадують розробників C, можливо, Haskell це робить.

Як згадували Керніган та Річі у передмові до класичної мови програмування на С , 2-е видання, C - це не велика мова, і вона не дуже добре обслуговується великою книгою. Я намагаюся дотримуватися цієї поради: приклади виконують подвійний, потрійний або більше обов'язків, якщо це можливо.

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

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

Фактоїдні

C скелі.

Довжина фрагмента 0

Найкоротша у світі програма самовідтворення http://www.ioccc.org/1994/smr.hint

Фрагмент довжини 1

;

C робить відмінність між складанням і зв’язуванням. Багато об'єктів на С просто складаються та з’єднуються пізніше - прикладом є всі статичні та динамічні бібліотеки.

Інші об'єкти просто включені і самі не генерують код.

Вищевказана крапка з двокрапкою неодмінно складеться в об'єктний код, і нічого не робити!

Фрагмент довжини 2

x;

C, будучи старшою мовою програмування, пройшов кілька ітерацій. Найбільш раннє в широкому застосуванні було розроблено Керніган і Річі і скорочено K&R. Компанія K&R C відрізняється тим, що робить багато припущень щодо свого коду, якщо ви прямо не надаєте їх.

Зокрема, у K&R C наведений вище код вважається глобальним цілим числом, xініційованим на 0. Якщо скласти його в режимі K&R, вийде об’єктний файл, який забезпечує будь-яку програму, що пов'язує з ним цю змінну для його використання.

Фрагмент довжини 3

??/

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

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

Довжина 4 фрагмента

f();

Знову з K&R, вищезгадане "заповнюється", щоб після компіляції означати, що "Існує, з глобальним зв'язком, функція f, яка надається пізніше, яка бере фіксовану, але не визначену кількість аргументів і повертає ціле число".

Зверніть увагу на принципові відмінності між цим та f;.

Фрагмент довжини 5

s="";

K&R C відомий тим, що справді прощає. Після компіляції цей код надасть ціле число sдля глобального зв’язку, яке ініціалізується на вихідну адресу порожнього рядка (я думаю). K&R спокійно обробляє всі примуси, включаючи усічення, якщо ціле число недостатньо велике, щоб утримувати адресу.

Саме такі конструкції створили багато важко знайдених помилок та надали великого натхнення у змаганнях МОККК.

Довжина фрагмента 6

o=042;

Отримка навіть старих таймерів, що веде 0 в прямому значенні, означає, що наступні цифри знаходяться в восьмеричній базі. Вищевказаний код після компіляції дасть ціле число oдля глобальної зв'язку, ініціалізованої до десяткової 34.

Ця особливість C покусала багатьох розробників, які прагнули змінити свої номери, щоб вони вирівнялися приємно і рівно!

Фрагмент довжини 7

f(){f;}

Вищевказаний код - це функція з тілом. Але що це робить? Він отримує адресу функції і нічого не робить з нею! Зазвичай те, що функція повернеться, не визначено. Безглуздий код, подібний цьому, часто може складатися без попередження.

Фрагмент довжини 8

main(){}

Це являє собою найкоротший компільований та пов'язаний код у C. Хоча в сучасних версіях C функції, як правило, неможливо визначити неявно, з історичних причин це обмеження обмежено main.

Ця дива програми, яка не робить нічого, крім повернення 0, буде компілювати до несуттєвого розміру та посилатися на різні підпрограми виконання C. Ви можете скласти та зв’язати багатослівним набором, щоб побачити, що відбувається під капотом.

Фрагмент довжини 9

#define Z

Основою файлів заголовків C є #defineдиректива препроцесора. Програми C складаються на різних етапах, і на одному з цих етапів ці визначення замінені їх фактичними значеннями.

Коли аргумент відсутній, C має на увазі 1, тож вищезазначене замінить те, 1де Zвикористовується вихідний код.

Вищезазначене, як правило, поміщається у файл заголовка та #included за потребою.

Довжина фрагмента 10

enum{P,Q};

enumКлючове слово забезпечує спосіб іноді тіпобезопасний визначити ряд констант. Як і визначення, вони часто використовуються у файлах заголовків. Вищевказаний код при включенні визначав би Pяк ціле число 0 і Q1.

Фрагмент довжини 11

volatile v;

The volatileКлючове слово, щоб дозволити компілятору знати , що змінне може бути змінений іншими агентами , а не робити припущення , що він буде залишатися постійним між доступами.

Довжина фрагмента 12

#pragma once

#pragma once - це нестандартна, але широко підтримувана препроцесорна директива, яка вказує на те, що поточний вихідний файл буде включений лише один раз в одну компіляцію.

Традиційною і повністю підтримуваною технікою є використання #include охоронці з недоліками доданого коду та можливими зіткненнями імен.

Фрагмент довжини 13

w(){for(;;);}

У С є численні конвенції, і одна з них - як зобразити нескінченні петлі. В цьому випадку,for(;;) вказується не ініціалізація, ні перевірка виходу, які за замовчуванням мають значення 1, тобто true - тобто не ламаються та не мають циклічного коду.

Іноді можна зробити все всередині () і сама петля не потребує тіла. У цьому випадку в кінці додається манекенна крапка з комою.

У наведеному вище коді при компіляції він надасть функцію, яка ввійде в щільний цикл зайнятості - один із "ні-ні" в розробці програмного забезпечення - і ніколи не повернеться.

Довжина фрагмента 14

int a[]={1,2};

Для масивів в С не потрібні вказані довжини. Порожні квадратні дужки []підказують компілятору "розібратися самі". Однак у C, на відміну від інших мов, не існує вбудованого способу запобігання доступу до масиву поза цими межами, що призводить до метафори "стріляй собі в ногу", для якої C відомий.

Код, наведений вище, при компіляції надасть глобальний змінний масив aз двох цілих чисел, ініціалізованих з 1 і 2.

Довжина фрагмента 15

const long k=7;

constSpecifer є більш пізнім доповненням до C запозичений з C ++. Поширене запитання для інтерв'ю: "Чи має сенс визначати змінну як volatile const?". constразом із enumі inlineпризначені для зменшення опори на#define якої виникають проблеми із безпекою типу.

Довжина 16 фрагмента

extern void **q;

externвикористовується для вказівки, що змінна оголошена в іншому місці. void *Типу є стандартним універсальним типом в C, тобто він не повинен бути явно кинутий або відлитий з в операторах присвоювання. Послідовність **операторів означає вказівник на вказівник, який часто дує розумом новачків, але цілком справедливий і часто використовується С.

Фрагмент довжини 17

double d=4/3-1/3;

Якби ви надрукували вище, результат був би один, і ви б подумали, супер! Змінитись double d=4/3-2/3;і на що відповідь? Це все одно! C використовує арифметику з цілим числом для обчислення 4/3 → 1 і 2/3 → 0, а 1 - 0 → 1!

Довжина фрагмента 18

main(){puts("!");}

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

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

Довжина 19 фрагмента

#include <stdlib.h>

Включення файлів заголовків часто є особистим підписом розробників. Багато з них включають libі ioнезалежно, якщо вони потрібні. Деякі впорядковують файли заголовків, щоб довжина збільшувалася або зменшувалася. Більшість ставлять <>раніше"" . Особисто я використовував цей підпис у своїх днях технічної допомоги, щоб перевірити чи підступ серед студентів: такий же підпис заголовка? придивіться уважніше!

Довжина фрагмента 20

char*p=(char*)0x300;

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

У коді вище адреса порту визначається як шістнадцятковий 300. Ви можете отримати доступ до значення порту, використовуючи *p, як *p=0xff;для включення всіх бітів, або v=*p;для отримання поточного значення.

Фрагмент довжини 21

int w=sizeof(double);

sizeofОператор забезпечує розмір в байтах типу. З назви змінних дужки не потрібні, наприкладdouble d;int w=sizeof d; .

Довжина 22 фрагмента

asm("xorl %ecx,%ecx");

Спосіб asmвикористання визначається компілятором. Вищенаведений приклад вбудованого коду Linux gcc на платформі Intel.

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

На сумісних системах код буде складений вище, і це буде буквально ізольована інструкція по збірці без звичайних засобів доступу до нього! BTW xor R,R- це загальна ідіома мови збірки для швидкого очищення реєстру.

Довжина 23 фрагмента

union u{char c;int i;};

A unionзабезпечить принаймні достатньо місця для найбільшого елемента. Ви можете бачити, що він використовується спільно зvoid * для надання загального типу "непрозорий" у певних бібліотеках. У цьому випадку об'єднання зазвичай буде частиною більшої структури, структура має поле для ідентифікації типу об'єднання.

Довжина фрагмента 24

/*INTS*/int i,j,k;//INTS

Оригінальний коментар C був обмежений як /* comment */і запозичив // comment to end of lineформат у C ++.

Довжина фрагмента 25

int main(void){return 1;}

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

Конвенція в C полягає у використанні повернутого значення 0для успіху та 1невдачі, або якщо ви хочете бути суворовідповідними EXIT_SUCCESSта EXIT_FAILUREвизначеними в stdlib.h.

Довжина фрагмента 26

typedef struct{int x,y;}P;

typedef є надзвичайно корисним, зокрема, typedef struct . По-сучасному, ви можете назвати це "світло-орієнтація на об'єкт".

Після включення вищевказаного код може використовуватись Pяк звичайний тип у деклараціях та функціях, з повною перевіркою типу. Однак, на відміну від C ++, ви не можете визначити операторів, таких як +, * або <<, отже, "об'єкт-орієнтація-світло".

Довжина фрагмента 27

#define C(x,y)(((x)+1)*(y))

C має зручний #defineсинтаксис макросу .

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

Довжина фрагмента 28

struct f{int s:1,e:8,m:23;};

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

Вищенаведене є наближенням структури даних плаваючої крапки з плаваючою точкою IEEE.

Довжина 36 фрагмента

f(unsigned x){return!!x&!(x&(x-1));}

У багатьох мовах вам не потрібно дбати про те, як представлені числа. В С потрібно глибоко усвідомлювати їх внутрішнє представлення.

Найкращим прикладом цього, про який я можу придумати, є визначення, чи є ціле число силою двох {1, 2, 4, 8, ...}. Ті, хто не знайомий з C, робитимуть цикли і зсуви і всілякі речі для виконання (O (log (n)) часу роботи, непогано, але вище функція, яка буде робити те ж саме в O (1) час виконання. Я залишу це як вправу для читача, щоб підтвердити, що це працює, але це дійсно так ...

!!Конвенції часто використовується , щоб змусити ціле число від ненульових і нуля до 1 і 0 відповідно. Багато розробників C люблять використовувати подібні хитрощі (найчастіше розходячись із тими, хто цінує чіткість коду).

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

Довжина 48 фрагмента

#include<complex.h>
double complex c=3.0+I*4.0;

C99 включає підтримку складних чисел. Як видно з коду, він має форму модифікатора для реального типу. Ви також можете використовувати, int complex c=3+I*4;але внутрішньо це примушує до типу з плаваючою точкою. Вищевказаний код буде компілюватися в gcc за допомогою gcc -std=c99 -c length-48.c.

Якщо ви хочете побачити більше внутрішніх даних, спробуйте компілювати перемикач -E. Для моєї версії gcc декларація вище стає double _Complex c=3.0+(__extension__ 1.0iF)*4.0;. Зауважте, що складний тип є суттєвим доповненням до мови, а не лише кількома дешевими макросами.

Це просто тизер, коли ми дістаємося до більш ніж 125 символів, тоді ми можемо почати веселитися із складними числами!

Довжина 51 фрагмент

#include <math.h>
main(){double d=sqrt(sin(3.2));}

З різних причин C автоматично не пов'язується зі стандартними математичними функціями, такими як sin, cos, tan, sqrt тощо. Отже, якщо вони використовуються, але не пов'язані між собою, розробнику буде представлено помилку лінкера з невизначеною посиланням на 'sqrt' або інша помилка.

У gcc код вище буде компілюватися та посилатися за допомогою gcc length-51.c -lm.

Примітка sin(3.2)поверне від’ємне число, з яких квадратний корінь не є законним у реальній області. В C NaNповертається спеціальне значення для позначення цієї помилки, яку програма вільна ігнорувати!

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

Довжина 63 фрагмента

static int w;static int X(int x){static int s=0;s^=x;return s;}

Або відформатовано більш здорово:

static int w;
static int X(int x)
{
    static int s=7;
    s^=x;
    return s;
}

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

У перших двох випадках staticповідомляє компілятору, що цілі wта функції Xне видно за межами цього файлу чи одиниці компіляції, тобто вони є внутрішніми.

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

В останньому випадку staticвказує, що ціле число sзберігає своє значення між викликами функцій. Перший Xвиклик, sбуде його початковим значенням 7, коли воно буде виключно-ORed з x, нове значення буде збережено.

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

Отриманий в C - це сутички з глобальними змінними. До wі Xфактично визначається як static, якщо вони визначені глобально де - то, то wі Xбуде ставитися до глобальних особам замість цього.

Тут qі wне може бути ініціалізовано однакове значення, оскільки глобальний wвикористовується для встановлення q:

static int q = w;
static int w;

Якщо глобальної wверсії не існує, компіляція повинна провалитися.

Тут qі wбуде ініціалізовано те саме значення:

static int w;
static int q = w;

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

У C99 staticотримав інше використання, наприклад, int Y(int a[static 10]);це означає, що існує функція, Yяка займає масив щонайменше з 10 цілих чисел.

Довжина 74 фрагмента

void f(register int*p,register int*q,register int l){while(l--)*p++=*q++;}

Або викладено красиво:

void f(register int *p, register int *q, register int l)
{
    while (l--)
        *p++ = *q++;
}

Ключове слово registerнадає підказку компілятору, що використання апаратних регістрів було б вигідним тут. Вищеописана функція буде скопійованаl цілі числа від qдо p, використовуючи апаратні регістри , якщо це можливо.

Іноді скорочення можуть бути значними. Наприклад, у сімействі мікропроцесорів 68K лінія *p++ = *q++може бути переведена в одну інструкцію MOVE.W (Ap)+,(Aq)+проти шести або восьми, якщо ви не використовували register. Мікропроцесор 68K мав явні режими після збільшення та попереднього зменшення, тому кмітливий розробник, якби він знав платформу, підробив би код, використовуючи x++та --yvs.++x та y--.

У наші дні компілятори здебільшого ігнорують register, крім того, що не дозволяють приймати адреси з них (наприклад, у вищесказанні &lце призведе до помилки компілятора).

Довжина 88 фрагмента

#include<stdio.h>
int f(int x){return(x>1)?x*f(x-1):1;}int main(){printf("%d\n",f(12));}

Або з макером збереження:

#include <stdio.h>

int f(int x)
{
    return (x > 1)? x * f(x - 1): 1;
}

int main()
{
    printf("%d\n", f(12));
}

Ах, рекурсія! Фрагмент - це повна програма для збирання, зв’язування та запуску. Функція fобчислює факторіал свого аргументу x, використовуючи рекурсивну формулу f (x) = x * f (x - 1). Фактори швидко збільшуються, тому, наприклад f(12), найбільше значення ви можете отримати в підписаному 32-бітному цілому.

Для прикладу дійсно рекурсивного коду розгляньте наївні реалізації функції Ackermann .

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

f(12)

Стає:

12 * 11 * 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1

Без будь-яких функцій необхідні дзвінки!

Інші компілятори можуть реорганізувати функцію:

int f(int x)
{
    return (x < 2)? 1: f(x - 1);
}

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

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

Довжина 117 фрагмент

#include<stdio.h>
int main(int c,char**v){int a,b;sscanf(v[1],"%d%*[\t ,]%d",&a,&b);printf("%d\t%d\n",a,b);return 0;}

Або:

#include <stdio.h>

int main(int c, char **v)
{
    int a, b;

    sscanf(v[1], "%d%*[\t ,]%d", &a, &b);
    printf("%d\t%d\n", a, b);

    return 0;
}

C запозичена з сучасних мов того часу, поняття універсального вводу / виводу, яке можна було б послідовно застосовувати до будь-якого пристрою - консолі, перфокарти, стрічки, диска чи принтера, але в справжній формі С дозволило розробнику створити дуже лаконічні, але потужні заяви.

У наведеному вище фрагменті буде проведено введення командного рядка, проаналізовано два цілих числа, розділених пробілами, вкладками чи комами, та виведення їх. Він використовує новіший scanfспецифікатор, %*[\t ,]який буде: [\t ,]витягувати всі вкладки, пробіли та коми та: *ігнорувати їх.

Я пам’ятаю, переглядав якийсь код C ++, де розробник робив усе «чистим» способом C ++ <<і арсеналом методів, як findі substr. Це було щонайменше десяток рядків, і він все ще не міг обробляти коми як роздільники. Я замінив увесь цей незграбний код на один sscanfрядок, як вище!

Довжина 132 фрагмента

#include<stdio.h>
int main(int c,char**v){while(--c){++v;printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n",*v,*v,*v,*v,*v);}return 0;}

Або:

#include <stdio.h>

int main(int c, char **v)
{
    while (--c)
    {
        ++v;
        printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n", *v, *v, *v, *v, *v);
    }

    return 0;
}

Функції printf, sprintf, fprintfспецифікатор і т.д. використовувати формат , щоб визначити ширину і відступи на виході.

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

> main xyz 123456
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                              
|xyz  |                                                                                                                                              
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                 
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|12345|                                                                                                                                              
|12345| 

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

x86 Код машини

Фактоїд:

Машинний код x86 - це зібрана версія збірки x86, якою фактично працює процесор. Він був розроблений ще тоді, коли пам'ять та місце для зберігання даних були дорогими, і він був розроблений таким чином, щоб бути дещо назад сумісним аж до Intel 8008. Збереження виконавчого коду невеликим було однією з цілей, і він використовує інструкції змінної довжини та архітектуру CISC, щоб допомогти досягти цього (що мало недолік, що ускладнює підвищення продуктивності сучасних процесорів). Це, поряд із характером складання голих кісток та загальним машинним кодом, дає програмам x86 можливість бути надзвичайно компактними.

Довжина 1:

Тепер для першої програми:

0xC3

Відкрийте шестигранний редактор, введіть цей байт і збережіть його як test.com.

Тепер у вас є дійсна програма MS-DOS, яка негайно повертається, не роблячи нічого, оскільки 0xC3 - це інструкція "RET". Однак це показує ще один цікавий аспект для гольфу з x86: формат файлу .com. Цей виконуваний формат абсолютно не має заголовка - файл просто завантажується в пам'ять, починаючи з адреси 0x100, після чого виконання починається з 0x100. Це означає, що жодні байти не витрачаються на метадані!

Довжина 2:

Наступна наша програма:

0x4D 0x5A

або "MZ" в ASCII.

Гаразд, я трохи обдурив, що насправді це не корисна програма, оскільки вона відповідає інструкціям

DEC     BP
POP     DX

Які насправді не корисні для запуску програми .com. Насправді в цьому і полягає вся суть цих двох значень - жоден розумний файл .com не повинен починатися з них! .com файли були обмежені розміром 65280 байт (64KiB - 0x100), тому коли почали потрібні більші програми, потрібно було розробити новий формат. Це був формат файлу .exe, який має заголовок. Однак MS-DOS потрібно було зберегти розширення .com для певних компонентів для зворотної сумісності, тому потрібен був спосіб виявити, чи файл .com був справді .exe. Вони вибрали жало "MZ" як це магічне число, і до цього дня, якщо ви відкриєте файл Windows .exe (або .dll) у шестигранному редакторі, ви побачите, що вони починаються з цих двох байтів. Мене дивує, що навіть найсучасніша програма Windows починається з обмеження сумісності з 70-х.

Довжина 3:

Тепер для нескінченного циклу:

41 E2 FD

Що перекладається на

start:
inc cx
loop start 

Ця програма збільшує значення CX (для початку буде> 0), після чого виконує інструкцію циклу. Цикл - прекрасний приклад інструкції CISC, оскільки він поєднує 3 прості операції в одну операцію спеціального призначення: він зменшує значення CX, перевіряє, чи не дорівнює 0, а якщо ні - переходить до цільової мітки. Існують також форми циклу, які перевіряють інші прапори, крім того, що вони закінчуються, коли CX дорівнює 0. Ми могли б зробити лише «стрибковий старт» для 2-байтного нескінченного циклу, але це було цікавіше.

Довжина 4:

Програма, яка мінімально корисна:

40 CD 10 C3

Перекладено на збірку:

inc ax    ; 1 byte
int 10h   ; 2 bytes
ret       ; 1 byte

Ця програма встановлює консоль на 40x25 символів, очищає екран, а потім повертається до командного рядка. AX встановлений у потрібному нам режимі (1), тоді переривання BIOS 10h викликається, щоб насправді встановити режим відео та очистити вікно, перш ніж повернутися. Розраховуйте побачити більше таких переривань BIOS у майбутньому.

Довжина 5:

Тепер ми можемо реалізувати програму пауз:

B4 01 CD 21 C3

Перекладено на збірку:

mov ah,1  ; 2 bytes
int 21h   ; 2 bytes
ret       ; 1 byte

Ця програма повідомляє BIOS чекати натискання клавіші та повторює її на екрані перед поверненням. Це також демонструє, як на x86 деякі регістри можуть бути частково прочитані або записані. У цьому випадку ми встановлюємо верхній байт AX (AH) на 1. На 32-бітових процесорах ви також можете працювати з низькими 16 бітами, не впливаючи на верхні 16 біт. Ця здатність змінювати часткові регістри може бути зручною для програмістів-монтажників, але має недоліки для сучасних процесорів, які намагаються виконувати виконання поза замовленням , оскільки вони можуть вводити помилкові залежності даних.

Довжина 9:

Тепер, щоб фактично відобразити вихід:

68 00 B7 07 AB 40 79 FC C3

Перекладено на збірку:

; These two instructions set up ES, the 'extra segment'
push 0xb700 ; 3 bytes
pop  es     ; 1 byte
label:
stosw       ; 1 byte, Store Word - Copy AX to [ES:DI] then add 2 to DI
inc  ax     ; 1 byte
jns  label  ; 2 bytes, Jump Not Signed - Jump unless the sign flag is set (when inc AX yields 0x8000
ret         ; 1 byte

Вихід - це набір символів за замовчуванням, повторюваний різними кольорами. Низький байт AX - це символ символу, а високий байт вказує кольори, які слід використовувати.

16-бітові програми могли безпосередньо адресувати до 64 КБ. Щоб обійти це, x86 використовував "сегменти" - спеціальні регістри, які б помножили на 16 і додали до всіх доступів до пам'яті, щоб отримати 20 біт адреси адреси. Програма може змінити значення цих регістрів сегменту, щоб отримати доступ до більшої кількості пам'яті - або спеціальних областей пам'яті: ця програма змінює додатковий сегмент для запису у відеопам'ять. Різні типи доступу до пам’яті використовували різні сегментні регістри, що дозволяють коду, даних та стеку бути доступними в різних фрагментах пам’яті одночасно. Сегмент за замовчуванням також може бути замінений для багатьох інструкцій.

Довжина 20:

Давайте зробимо щось впізнаване - ми будемо використовувати «Правило 90», щоб намалювати трикутники Серпінського.

B0 13 CD 10 68 0F A0 1F AC 31 C2 88 94 3E 01 87 D3 93 EB F4

У зборі:

mov al,13h      ; 2b
int 10h         ; 2b - Set the video mode to 13h

push    0xA00F  ; 3b
pop     ds      ; 1b - Set the data segment to video memory

start:          ; This loop runs 'Rule 90' to draw Sierpinski triangles
lodsb           ; 1b - load al with [ds:si] then increment si

xor     dx,ax   ; 2b - xor the left and right values of the previous row of pixels
mov     [si+318],dl ;4b - store result to memory

xchg    dx,bx   ; 2b - swap register values
xchg    ax,bx   ; 1b - swapping with ax is 1 byte shorter

jmp     start   ; 2b - infinite loop

Вибірка зразка:

Для цієї програми ми використовуємо дещо відомий 'Mode 13' - графічний режим, який має роздільну здатність 320x200 з 256 кольорами. Його використовували багато популярних ігор DOS , наприклад Doom.

Довжина 21

Давайте подивимося, хто виробляв процесор, на якому ми працюємо.

0F A2 66 60 BB EE FF B9 0C 00 8A 17 43 B4 02 CD 21 E2 F7 FF E1

Перекладено на збірку:

cpuid         ; 2b  CPU ID - retrieve processor information based on the value in AX. For AX=0,
              ;     the 12 bytes in EBX, ECX, and EDX are loaded with a vendor identification string
pushad        ; 2b  Push all registers on the stack (32 bit version)
mov  bx,0xffee; 3b  Start of the vendor identification string on the stack
mov  cx,12    ; 3b  12 characters to print
print:    
mov  dl,[bx]  ; 2b  Character to print
inc  bx       ; 1b  Advance string position
mov  ah,2     ; 2b  Set AH to the 'Print character to STDOUT' value
int  21h      ; 2b  Call the bios interrupt to print
loop print    ; 2b  Decrement CX and jump if it is not zero
jmp  cx       ; 2b  Instead of restoring the stack, just jump right to the exit point

Вибірка зразка:

c:\misc>cpuid.com
GenuineIntel

Ця програма використовує інструкцію CPUID для отримання інформації про процесор, на якому він працює, зокрема про рядок ідентифікації постачальника. Більшість людей побачать "GenuineIntel" або "AuthenticAMD", якщо вони не є рідким виробником процесора або працюють на певних віртуальних машинах.

Довжина 26

Зараз ми можемо робити цікаві анімації

B0 13 CD 10 C4 07 BB 40 01 59 99 89 F8 F7 F3 31 D0 AA E2 F6 26 FE 05 47 EB FA

В Асамблеї

mov al,13h     ;2b
int 10h        ;2b Enter Video Mode 13h

les ax,[bx]    ;2b Set ES to (roughtly) video memory
mov     bx,320 ;3b Set up  BX asdivisor
pop     cx     ;1b Zeroize CX

start:
cwd            ;1b Sign extend AX to DX, AX will never have the sign bit set so this zeroizes DX in 1 byte
mov     ax,di  ;2b Copy video memory pointer
div     bx     ;2b Divide by width to get AX = Y pos, DX = X pos
xor     ax,dx  ;2b X pos ^ Y pos
stosb          ;1b Store and increment video pointer
loop    start  ;2b CX starts at 0, so this will loop until it wraps around

cycle:
inc     byte [es:di];3b Increment value in video memory to animate
inc     di     ;1b Increment video memory pointer
jmp     cycle  ;2b Infinite loop 

І вихід буде виглядати приблизно так:

Функція X pos ^ Y pos створює цікавий фрактал, особливо при анімації

Довжина 27

Ви не тільки можете генерувати текст та графіку в невеликій програмі x86 .com, ви також можете створювати звук та музику:

BA 31 03 B0 3F EE BA 30 03 B0 93 EE B4 01 CD 21 3C 1B EE 3C 1B B0 7F EE 75 EC C3

У зборі:

    mov dx,0x331            ; value for the midi control port
    mov al,0x3F             ; command value to set midi mode to UART
    out dx,al               ; output the command to the midi control port
play_loop:
    mov dx,0x330            ; value for the midi data port
    mov al,0x93             ; midi instrument value (piano)
    out dx,al               ; output to midi data port
    mov ah,1
    int 0x21                ; read character from stdin, with echo
    cmp al,27               ; test if it is escape
    out dx,al               ; output the ascii value as the midi note to play
    mov al,0x7F             ; note duration
    out dx,al               ; output note duration
    jne play_loop           ; loop if escape was not pressed
    ret  

Ця програма використовує карту midi для перетворення клавіатури на фортепіано. Для цього картка midi встановлюється в режим UART, який відтворює нотатки midi, як тільки вони отримуються. Далі програма чекає натискання символу та виводить значення ASCII у вигляді примітки до картки midi. Програма працює до тих пір, поки не буде натиснуто клавішу Escape.

Довжина 29

Давайте скористаємось ітераційною системою функцій для генерації фрактала Кривої Дракона:

B0 13 CD 10 89 D0 01 CA 29 C1 D1 FA D1 F9 73 03 83 E9 7A B4 01 CD 16 B8 02 0C 74 E6 C3

Перекладено на збірку:

mov  al,13h
start:
int  0x10    ; This does double duty, setting the video mode to 13h at program start,
             ; and calling the 'draw pixel at coordinates' interrupt when looping
mov  ax,dx   ; The next couple instructions are our IFS, the algorithm is aproximately
add  dx,cx   ; f(y) = 0.5x + 0.5y
sub  cx,ax   ; f(x) = 0.5x - 0.5y OR f(x) = 0.5x - 0.5y - 1
sar  dx,1    ;
sar  cx,1    ;
jnc  skip    ; This jump handles pseudo-randomly switching between the two functions for x,
             ; based on if the previous value of x was odd or not.
sub  cx,122  ; Magic number, chosen since it provides sufficent 'randomness' for a filled in
             ; fractal and a good scale to the fractal. 102 and 130 also work.
skip:
mov  ah,1
int  0x16    ; Get keyboard state, zero flag will be set if no key has been pressed
mov  ax,0xC02; Set up AH for the draw pixel function when int 0x10 is executed,
             ; AL = color, CX = column, DX = row
jz   start   ; Loop if a key hasn't been pressed
ret  

Вихід:

Якщо натиснути клавішу, що не контролюється, програма вийде з програми. Це базується на Fire Coral від Desire на Pouet.net.

Довжина 52

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

B3 07 D9 E8 B1 11 DE 0E 32 01 E2 FA BE 0A 24 56 B1 09 DF 34 AC D4 10 
86 E0 05 30 30 50 E2 F5 44 B4 2E 50 89 E2 B4 09 CD 21 FE 06 03 01 4B
75 D2 CD 20 0A 00

Під час запуску програма виведе кілька математичних констант:

1.00000000000000000
3.32192809488736235
1.44269504088896341
3.14159265358979324
0.30102999566398120
0.69314718055994531
0.00000000000000000

Це Один, Log2 (10), Log2 (e), Pi, Log10 (2), Log e (2) та Zero.

У зборі:

org 100h

mov     bl,7         ;Counter for the total number of constants to print
start:
fld1                 ;Floating point constant to load on the FP stack,
                     ;start with 1 since it's op-code is the lowest

mov     cl,17        ;Multiply the constant by 10, 17 times to get the
mult:                ;printing part as an integer
fimul   word[ten]
loop    mult

mov     si,10+'$'*256;ASCII new line (10) and the end-of-string ($)
                     ;characters. These are used both as
push    si           ;a constant memory location, and stored to the
                     ;stack to format and printing

mov     cl,9         ;print 18 digits (9 pairs)
fbstp   [si]         ;store the integer part of the floating point
                     ;number on top of the FP stack as a packed
                     ;binary-coded decimal number (1 digit/nibble),
                     ;and then pop the number off the FP stack

convert:
lodsb                ;load a pair of packed digits

db 0xd4,16 ; AAM 16  ;ASCII Adjust For Multiply instruction using
                     ;non-standard base 16. This puts AL/16 in AH,
                     ;and AL%16 in AL, unpacking the digit pair.

xchg    ah,al        ;Swap the digit order
add     ax,'00'      ;Convert the digits to ASCII values
push    ax           ;Store digits on the stack
loop    convert

inc     sp           ;AX now holds the 1st 2 digits to print,
mov     ah,'.'       ;so to insert a decimal point, the 2nd digit
push    ax           ;is replaced with a '.', the stack pointer
                     ;is adjusted to overwrite 1 byte, and then
                     ;AX is pushed on the stack

mov     dx,sp        ;Load DX with the start of the print string
mov     ah,9         ;Load AH with the 'Print String' constant
int     21h          ;Call the 'Print String' interrupt to display
                     ;the constant

inc     byte[start+1];Self-modifying code - increment the load
                     ;floating point constant op-code to iterate
                     ;through all of them

dec     bx
jnz     start        ;Exit when all 7 constants have been printed
int     20h


ten: dw  10

Математику з плаваючою точкою в системах x86 спочатку обробляв необов'язковий спільний процесор x87, і лише до 486 року він перемістився на один і той же чіп. У x87 також була досить інша архітектура, вона була заснована на стеці, з 8 доступними 80-бітовими регістрами. Він також мав різні режими округлення, точність та маскуючі винятки, які можна встановити.

Ця програма друкує значення для семи констант, запечених у процесорах. Може здатися дивним, що простір інструкцій буде витрачено на прості константи, такі як 0 і 1, але майте на увазі, що набір інструкцій був створений, коли пам'яті було мало, і ці інструкції, як правило, на 2 байти менше, ніж еквівалентні операції. Програма також використовує незрозумілу інструкцію, FBSTP -'Store BCD Integer and Pop '. Ще коли було розроблено x86, операції над номерами BCD були більш поширеними, і x86 / x87 має кілька інструкцій, що спеціально спрощують математику BCD, наприклад інструкція AAM "ASCII Adjust for Multiple", яка також використовується в програмі.

У незахищеній моделі пам'яті, що використовується ранніми програмами x86, немає різниці між даними та кодом. Через це легко повторити через послідовно закодовані вказівки "Завантажити постійну", просто збільшивши відповідне значення.

Довжина 64

Перекресливши мій запис для Mandelbrot Challenge , можна написати програму, яка відображає кольоровий фрактал Мандельброта розміром 320x200 усього 64 байти.

B0 13 CD 10 C4 07 99 89 F8 B9 40 01 F7 F1 83 E8 64 FE CE 31 DB 31 F6 
89 F5 0F AF F3 01 F6 0F AF DB 70 19 0F AF ED 70 14 01 EB 70 10 29 EB
29 EB C1 FB 06 01 D3 C1 FE 06 01 C6 E2 DB 91 AA EB C6

У зборі:

mov al,13h ; set up graphics mode 13
int 10h

les ax,[bx]; trick to set video memory

FillLoop:
cwd
mov ax,di  ; di is the current position on screen
mov cx,320 ; convert di int x,y screen coordinates
div cx     ; CX is the iteration counter, exit the loop if it hits
           ; zero before the value escapes.
sub ax,100 ; center the fractal vertically
dec dh     ; center the fractal horizontally

xor bx,bx
xor si,si

MandelLoop: ; Fairly standard Mandelbrot routine,
mov bp,si   ; exits if the values overflow
imul si,bx
add si,si
imul bx,bx
jo MandelBreak
imul bp,bp
jo MandelBreak
add bx,bp
jo MandelBreak
sub bx,bp
sub bx,bp

sar bx,6   ; We use fixed point math with the lowest 6
add bx,dx  ; bits being the fractional portion, so this
sar si,6   ; rescales the values after multiplication
add si,ax

loop MandelLoop

MandelBreak:
xchg ax,cx ; Write the escape itteraction as the color
stosb
jmp FillLoop

Кінцевий результат - це зображення:

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

Хаскелл

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

Читачі, які не знають Haskell: я зрозумів? Коли мені не ясно? Я не можу сказати.

Довжина 86 фрагмента

Складний екземпляр для нашої структури даних про дерево (фрагмент 23). Складне - це клас типу - як і у класі (/ група) типів. Вони паралельні інтерфейсам на Java. Вони по суті узагальнюють над типами, об'єднуючи типи, які мають загальні характеристики; наприклад, вони можуть бути додані разом ( Monoid), контейнери ( Functor), можуть бути надруковані у вигляді тексту (з Showяким ми вже зустрічалися, у showфункції) тощо. Цей тип уніфікує типи даних, подібні до списку, оскільки вони можуть бути повторені або сплющені до списку.

У цьому фрагменті ми визначаємо екземпляр, визначаючи foldr, який по суті повторює тип даних справа наліво. Тепер ми можемо використовувати купу загального попередньо написаного коду. По- перше, ми визначимо допоміжну функцію , щоб отримати одноплодной дерево, щоб уникнути всіх перешкод: s a = N E a E. Зараз:

sum (N (s 3) 7 (N E 5 (s 8))     === 23
product (N (s 3) 7 (N E 5 (s 8)) === 840
toList (N (s 3) 7 (N E 5 (s 8))  === [3,7,5,8]

і так далі.

Ось малюнок нашого дерева:

7
| \
3  5
    \
     8

Довжина фрагмента 70

primes=sieve[2..] where
 sieve(p:xs)=p:sieve(filter(\x->x`mod`p/=0)xs)

Це просте сито!

(зверніть увагу: /=це те, що !=є іншими мовами)

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

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

take 4 primes === [2,3,5,7]

Довжина 68 фрагмента

Нарешті, королева!

main=do putStr s;print s where s="main=do putStr s;print s where s="

Коли ви вперше читаєте це, ви можете подумати, що у випуску цієї лайки не вистачить лапок, а чому б ви один раз писали putStrі раз print? Це звучить так само.

У Haskell putStr- це функція, яка просто виводить вміст рядка, який він отримує до stdout; print, однак, друкує речі для stdout. Отже, print 4рівнозначно putStr "4\n", але putStr 4безглуздо - 4це не рядок! Отже, коли printотримує значення, він спочатку перетворює його в рядок, а потім друкує цей рядок. Як правило, спосіб перетворення речей у рядки - це пошук способу, який ви записали б у код. Отже, те, як ви б написали рядок abcу рядку в коді Haskell "abc", таким чином print "abc"насправді друкує "abc", ні abc.

_{Як мені пощастило, що зараз я маю достатньо голосів, мені не доведеться грати в ці речі}

Довжина фрагмента 33:

main=go 0
go n=do print n;go(n+1)

Важливо зазначити, що ми не використовували цикл. Haskell не циклічно. Хаскелл повторюється. У Haskell немає циклів. Це глибше, ніж це: у Haskell навіть немає потоку управління . Як, запитаєте ви? Ну, вона не потрібна.

Про деталі. Ця програма друкує нескінченну збільшувальну послідовність цілих чисел, починаючи з 0. goдрукує їх, починаючи з його введення, а потім mainвикликає його 0.

doє особливою синтаксичною силою Хаскелла. У цьому сценарії він просто поєднує дії вводу-виводу, як >>і (див. Фрагмент 22).

Довжина фрагмента 26:

map f=foldr(\x y->f x:y)[]

Це визначає mapфункцію, яку, мабуть, знайомий всім, використовуючи foldr. Зауважте, що хоча ми не оголосили mapтип, комп'ютер якось знає його тип (a -> b) -> [a] -> [b], тобто, отримавши функцію від aдо b, та список as, повернути список bs.

Звідки це знали ?? ;-)

Фрагмент довжини 25:

main=putStr"Hello World"

Стандартний Hello World. Зверніть увагу на типи: mainмає тип IO ()і putStrмає тип String -> IO ()(функція від рядків до дій вводу / виводу, які нічого не повертають).

Фрагмент довжини 23:

data T a=E|N(T a)a(T a)

Це стандартне визначення Дерева. Наскільки простіше, ніж усі ці рядки, необхідні для визначення дерева в Java, C або будь-що інше.

(див. фрагмент 10)

Давайте розбимо його:

data- ця декларація оголошує тип даних. T a- дерево, що містить елементи типу a. Це тип, який ми визначаємо. =- кожне значення T aбуде будь-яке з наведених нижче, розділене трубою |. E- одне з можливих значень T s- порожнє дерево. N (T a) a (T a)- інше можливе значення дерева - вузол. Кожен вузол складається з лівого дочірнього ( (T a)) елемента ( a) та правого дочірнього ( (T a)).

Фрагмент довжини 22:

main=putStrLn"y">>main

Haskell yesфункція. >>це оператор, який поєднує та послідовно виконує дві дії вводу / виводу. Він має тип >> :: IO a -> IO b -> IO b.

mainвизначається рекурсивно само собою, як дія вводу / виводу, яка спочатку друкує, "y"а потім робить все main, що робить сама.

Фрагмент довжини 18:

fix f=r where r=f r

Краще визначення для fix. (Див сниппет 14) Проблема з першим визначенням, fix f = f(fix f)є те , що кожен раз , коли ми називаємо fix f fixвідкликання fix f, що нагадує fix f, породжуючи нескінченні копії одного і того ж розрахунку. Ця версія виправляє її, визначаючи r(результат) результат; як такий f r = r,. Отже, давайте визначимось r = f r. Тепер ми повертаємось r.

Фрагмент довжини 17:

f n=product[1..n]

Це функціональний спосіб визначення факторіалу.

Фрагмент довжини 16:

f n=(\x->x+x+x)n

(\x -> x + x + x)- лямбда (хтось думав, що \нагадує букву.).

(\x -> x + x + x) n- застосовується лямбда n(це точно те саме, що n + n + n).

f- функція множення на три (також f = (*3))

Фрагмент довжини 15:

sum=foldl (+) 0

Це визначає sumфункцію, використовуючи складку. Згинання - це в основному цикл над елементами списку з одним акумулятором.
foldlприймає в якості аргументів деяку функцію fі деяке початкове значення xдля акумулятора і списку xs. Функція fповинна отримувати як вхід попереднє значення акумулятора та поточне значення списку, і воно повертає наступний акумулятор.
Потім складка повторює значення списку, застосовуючи fпопередній акумулятор, а потім повертає останній акумулятор.

Ще один спосіб подумати про складки - це як "складок" fміж значеннями списку та з початковим акумулятором в одній із сторін. Наприклад, foldl (*) 1 [4,2,5]оцінює до 1 * 4 * 2 * 5.

Фрагмент довжини 14:

fix f=f(fix f)

yКомбінатор. Зазвичай його називають fixтому, що він знаходить фіксацію рівняння f x = x. Зауважте, що x = infinite loopіноді також може бути рішення, тому fix (\x -> x^2 + 5*x + 7)не буде вирішено рівняння, x^2 + 4*x + 7 = 0а натомість поверне нескінченний цикл.

Ви також можете відзначити, що не завжди x = infinite loopце рішення, через лінь Хаскелла.

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

Фрагмент довжини 13:

f=sum.map(^2)

Це визначає функцію, f яка надає список повертає суму його квадратів. Це функціональний склад функції sum і функціяmap(^2) , яка в свою чергу є функцією, map застосованою до функції (^2) ( квадрат функція ), що, у свою чергу, є розділом функції ^ (секції були введені на фрагменті 2, а композиція - за фрагментом 3 ).

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

До речі, технічно кожна функція з двома або більше аргументами - це функція, яка повертає функції як результати (це називається currying).

Фрагмент довжини 10:

data B=T|F

Це визначення букелів Haskell з різними назвами. Булівський тип названий B.
Це визначення вводить два конструктори: true ( T) та false ( F).
Цей фрагмент коду в основному говорить компілятору , що кожен логічний ( B) є або істинним ( T) або БРЕХНЯ ( F), або іншими словами, B=T|F.

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

Фрагмент довжини 9:

main=main

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

Цікавим фактом є те, що компілятор GHC Haskell може виявити ці види нескінченних циклів і викинути винятковий (!) Виняток під час його запуску.

Фрагмент довжини 8:

f(x:_)=x

Це визначає функцію f яка, даючи не порожній список, поверне голову.

Шаблони в Haskell схожі на розпакування послідовностей Python, але узагальнені для всіх типів. Шаблони можуть або відхиляти, або відповідати значенню, і якщо воно відповідає, може прив'язувати змінні до значень.

Шаблони цього фрагмента:

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

Відповідність шаблонів сильно узагальнена. Насправді, лише визначення нових типів даних автоматично вводить шаблони для роботи з ними.

Фрагмент довжини 5:

x=2:x

Ого, на цьому є стільки пояснити.

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

Примітка. Цей фрагмент коду не містить призначення, а визначення. Haskell не має призначення.

Цей фрагмент коду визначений x, нескінченний список, повністю складається з 2. Зазвичай в інших мовах xдоводиться оцінюватись раніше, ніж 2:xколи-небудь можна оцінити, але в Haskell ми можемо це зробити.

Нескінченні списки Haskell - це свого роду суміш ітераторів і регулярних пов'язаних списків: вони діють як обидва (наприклад, ітерація діапазону використовує постійну пам'ять).

Фрагмент довжини 4:

2:[]

Цей фрагмент просто кодує єдиний список [2]. :це Cons оператор в Haskell. Насправді, синтаксис звичайного списку - це лише синтаксичний цукор для оператора «мінус» та «пустий список». Це тісно пов'язане з тим, як Haskell має справу з узгодженням шаблонів та типами даних (особливо концепцією конструктора).

Фрагмент довжини 3:

f.g

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

Фрагмент довжини 2:

1-

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

Фрагмент довжини 1:

1

У Haskell, 1може бути як Int, Float, Double, Wordі так далі. Насправді ви можете написати код, щоб визначити версію 1будь-якого типу та вільно використовувати її.
це також робиться в JavaScript, Python тощо, але на відміну від них, це робиться з повною безпекою.

фактоїд:

Спочатку комітет Haskell мав намір назвати мову "Каррі" після імені Haskell B. Curry, але вирішив змінити ім'я на Haskell, оскільки можуть виникнути деякі каламбури. Лише пізніше вони помітили схожість Хаскелла з "Паскалем" та "Скрутом"!

C #

C # - це весела, шалена суміш функцій від Java, C, Haskell, SQL та багатьох інших мов, і вона пропонує безліч справді приємних функцій та API. Тут також відомо, що він досить багатослівний, але ми побачимо, що ми можемо зробити!

Я проігнорую звичайну необхідну котельну плиту:

class Program { public static void Main(string[] args) { ... } }

Довжина 1:

;

Команди закінчуються крапками з комою в C #! Порожній рядок - абсолютно правильний синтаксис.

Довжина 5:

x=5f;

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

Довжина 7 (байти):

s=@"
";

Якщо ви встановите префікс рядкового букваря зі знаком @, він стає "дослівним" рядковим літералом. Звичайні рядкові літерали розбирають послідовності втечі, такі як '\ n', на спеціальні символи, але дослівні літерали цього не роблять, дозволяючи використовувати символ зворотної косої риски, не уникаючи цього. Вони також можуть включати повернення рядків, як показано. Це може заощадити кілька байтів у гольфі, або зробить ваші багаторядкові буквені рядки більш читабельними. Просто слідкуйте за тим, щоб в рядку було включено відступи.

Довжина 8:

()=>x=y;

Цей вираз є анонімною функцією. Він повертає об'єкт типу, Actionякий можна передавати навколо, а також називати функцією. Анонімні функції успадковують область, в якій вони були оголошені, і вони тягнуть будь-які локальні змінні в цьому масштабі з собою, куди б вони не потрапили.

Довжина 9:

(a)=>a.p;

Ось ще одна анонімна функція, яка використовує параметр і значення повернення. Вираз повертає об'єкт типу Func(сам Func повертає тип a.p. Ви Funcбагато використовуєте для взаємодії з Linq.

Довжина 10:

enm.Any();

Це наше перше знайомство з Linq! Linq - це набір методів розширення, які можна викликати на будь-якому об'єкті, що перелічується (реалізуючи інтерфейс IEnumerable) - як Arrayі List. У безлічі використовується ледача оцінка: вона проходить через колекцію по одному предмету, не знаючи про колекцію в цілому - це навіть може бути нескінченним!

Ось тут і Anyнадходить - він повертається, trueякщо «Перелічений» містить хоча б 1 предмет. Набагато краще, ніж обчислити всю довжину.

Довжина 11:

var a=1.5f;

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

Довжина 15:

yield return 0;

Ось божевільне твердження, з яким ви, можливо, менш знайомі. Ви знаєте, що об'єкти можна перелічити, успадкувавши IEnumerable, але чи знали ви, що функції можуть бути численні? Оголосіть функцію із типом повернення IEnumerableта майте її yield returnстільки разів, скільки вам потрібно. Коли ви отримаєте функцію «Перелік», кожен виклик GetNextпрограми повинен виконати весь код до наступного yield return, повернути це значення, а потім зробити паузу, поки ви не пересунете її знову. Ви використовуєте yield breakдля завершення ітерації.

Довжина 16:

[Obsolete]int a;

Цей фрагмент показує атрибут. Атрибут - це такий тег, який ви можете наклеїти на будь-яку декларацію у своєму коді. Деякі доручають компілятору робити певні дії, наприклад, ця, яка надсилає застаріле попередження, якщо ви телефонуєте a. Ви можете створити власні, розширивши їх Attribute, і ви можете запитувати їх за допомогою Reflection (докладніше про це пізніше, можливо). Ви можете перейти до мета та обмежити, який тип декларацій може використовуватись з AttributeUsageатрибутом.

Довжина 17

c.Count(t=>t==3);

Ось зручний метод гольфу. З огляду на , Funcщо відображає елемент з перелічуваних cдо bool, вона повертає кількість елементів в cпротягом якого це Funcповертається true. Набагато приємніше, ніж виписувати цикл.

Довжина 18:

foreach(T t in c);

Це цикл для кожного. З усією цією розмовою про численні речі, це дуже потрібна структура. foreachє синтаксичним цукром, який встановить Enumerator для c(який повинен бути перелічений) і повторює через нього один елемент tза один раз. Ви можете змінити або вивчити кожен окремий елемент, але зміна самої колекції призведе до недійсності перерахувача.

Довжина 19

c.Select(t=>t.a/2);

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

Довжина 21

Console.Write("Hi!");

Цей рядок пише деякий текст у stdout, і це, мабуть, одна з головних причин, коли C # не використовується для гольфу багато!

Довжина 23

typeof(T).GetMethods();

C # підтримує дуже потужну функцію під назвою Reflection. Відображення дозволяє вивчити структуру вашого коду під час виконання. Наприклад, цей виклик поверне масив усіх методів вказаного типу. Ви можете вивчити ці методи, викликати їх або навіть змінити значення полів та властивостей. Атрибути (див. Довжина 16) - хороший спосіб позначати частини коду для використання з відображенням.

Довжина 25

from t in c select t.a/2;

Це SQL? В C # код? Досить близько. Цей вираз робить те саме, що і висловлювання на Довжині 19.

Довжина 27

for(var l;;l=new object());

C # - мова, зібрана сміттям, що означає, що будь-яка виділена пам'ять (за допомогою newключового слова) може бути автоматично звільнена до тих пір, поки немає посилань на неї. Цей код працюватиме щасливо назавжди, хоча я ніколи не звільняю створену пам'ять. Хоча збирання сміття має витрати - пошукайте в Інтернеті, щоб дізнатися більше.

Довжина 29

var e=Enumerable.Range(0,99);

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

Довжина 31

public int pr{get;private set;}

Тут ми можемо показати просте "властивість", функцію OOP та іншу ознаку C #. Якщо ви коли-небудь використовували Java, ви, ймовірно, зробили методи "get" і "set" для поля, щоб розділити їх доступність або запустити код при зміні. Ну, C # дозволяє вам оголосити цей код вгорі поля, а також встановити окремі модифікатори доступу для отримання та налаштування. Цей конкретний фрагмент автоматично створює геттер і сеттер за замовчуванням, але робить програму приватною.

Довжина 32

public static void m(this T o){}

Цей фрагмент показує функцію C #, яка підходить для дизайну API. Застосовуючи thisмодифікатор до першого параметра статичного методу, цей метод стає методом "розширення". Як тільки це оголошено,T.m тепер можна викликати будь-який об’єкт типу T так, ніби це насправді метод Т. Це можна використовувати для додавання нової функціональності до будь-якого існуючого класу, не змінюючи і навіть не маючи доступу до його вихідного коду.

Довжина 38

int f(int a,ref int b,out int c){c=0;}

Цей метод демонструє різні типи передачі параметрів, які ви можете мати у C #. Немодифіковані параметри передаються за значенням . Параметри з префіксом refпередаються посиланням: ви можете призначити їм абсолютно новий об'єкт, і вони перенесуть його назад із методу. Параметри з префіксом outє подібними до додаткових значень повернення: вам потрібно призначити їм значення в методі, і вони виводяться назад так само, як параметри ref.

Довжина 42

Console.Write("It is \{DateTime.Now()}.");

Новий стандарт C # 6 може заощадити деякі символи, коли вам доведеться виводити зібрані рядки, використовуючи рядкову інтерполяцію. Ця функція дозволяє записувати будь-який вираз фігурними дужками всередині рядкового літералу, і рядок автоматично збирається зі значеннями цих виразів під час виконання.

Довжина 48

IEnumerable f(){for(int a=0;;)yield return a++;}

Зараз достатньо символів, щоб зробити щось із фактичною метою! Цей метод використовує деякі ідеї, які ми вивчали вище, щоб створити нескінченну кількість, яка просто поверне цілі числа, по одному, починаючи з 0. Пам'ятайте, що C # використовує ледачу оцінку за допомогою перелічувачів, тому нескінченна послідовність цілком справедлива - ви можете повторіть скільки завгодно послідовностей і вирвіться в будь-який час.

Довжина 56

int p{get{return mP;}set{mP=Math.Max(value,0);}};int mP;

Ось ще один приклад "властивості" (див. Фрагмент 31). Ось, я на самому справі визначені різні фрагменти коду для getі setзамість того , щоб використовувати автоматичні ті , як і раніше. Цей приклад демонструє, як можна використовувати властивість для перевірки значення, присвоєного змінній - тут значення не дозволяється ставати менше 0. Інші хороші властивості властивостей включають повідомлення про подію при зміні значення або відновлення кешованих значень що може бути засноване на цьому.

Довжина 65

int v;public static implicit operator int(Program o){return o.v;}

Ця особливість називається неявною роллю. Це на зразок методу розширення тим, що це статичний код, який працює на певному класі (див. Фрагмент 32). Однак неявний амплуа не використовується, називаючи його - він використовується просто обробкою Programоб'єкта як цілим числом (наприклад int i=new Program()). Коли ви це зробите, об'єкт буде мовчки перетворений у тип, яким ви його використовуєте, на основі коду в неявному складі. Найкраща практика говорить, що робити це потрібно лише тоді, коли в результаті конверсії не втрачається жодна інформація.

Java

Довжина 44 фрагмента

Object a=System.out.append("Hello, World!");

Друкує Hello, World!до STDOUT.

Довжина 43 фрагмента

float[][][][][]a=new float[5][3][7][2][10];

aмістить 10 масивів, кожен з яких містить 2 масиви, кожен з яких містить 7 масивів, кожен з яких містить 3 масиви, кожен з яких містить 5 floatс.

Довжина 42 фрагмента

interface A{static void main(String[]a){}}

Повна програма. Оскільки все в а interfaceє суттєво public, ми можемо опустити слово publicз основного методу.

Довжина 36 фрагмента

class A{class B extends A{B.B.B b;}}

Aмає внутрішній клас B. Це означає, що ми можемо оголосити змінну типу A.B.

Але Bце підклас A, який означає , що він має всі методи, поля і внутрішні класи в A. Таким чином, ми можемо також посилатися на тип B.B.

У цьому коді робимо цей крок далі і надаємо Bзмінну типу екземпляра B.B.B.

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

Довжина 35 фрагмента

l.stream().map("a"::equals).count()

Якщо lце список рядків, це говорить про те, скільки з них дорівнює"a" .

Довжина 34 фрагмента

public static void main(String[]a)

Підпис методу основного методу програми. Ще 11 символів і ми можемо скласти повноцінну програму!

Довжина 33 фрагмента

enum D {NORTH, EAST, SOUTH, WEST}

NORTH, EAST, SOUTH, І WESTвсе константи типуD .

Довжина 32 фрагмента

Files.readAllBytes("hello.txt");

Читає весь файл, повертаючи byte[] вміст.

Довжина 31 фрагмент

new String(new char[]{'h','i'})

Еквівалентно "hi". Корисно, якщо" ключ зламаний.

Довжина фрагмента 30

new JFrame().setVisible(true);

Створює новий видимий кадр, в який можна розмістити інші компоненти.

Довжина фрагмента 29

throws ClassNotFoundException

Примушує кожен метод, який закликає це використовувати try:catch блок, або передати помилку в стек. Перевірені винятки - одне з найбільш суперечливих рішень дизайнерів Java.

Довжина фрагмента 28

int f(int x){return f(x-1);}

Ця функція не працює вічно; насправді на типовому комп’ютері потрібно менше секунди. Спасибі, стек переповнення.

Довжина фрагмента 27

Object a=new String[]{"a"};

Створює новий масив рядків.

Довжина фрагмента 26

Object.class.newInstance()

Створює нове Object.

Довжина фрагмента 25

((Supplier)()->-~0).get()

Краще уникати жорстких констант. Це об'єктно-орієнтований спосіб отримання значення 1без використання інших констант, окрім 0.

Довжина фрагмента 24

(Function<Long,?>)x->x+1

Функція правонаступника.

Довжина 23 фрагмента

l.removeIf(x->x%10==0);

Якщо lє список цілих чисел, це видаляє всі значення, що поділяються на 10.

Довжина 22 фрагмента

int i=(new int[7])[5];

Створює новий масив із семи цілих чисел і отримує п’ятий елемент.

Фрагмент довжини 21

Arrays.asList(2L,"a")

Створює ArrayList з цими елементами.

Довжина фрагмента 20

System.out.print(s);

Друкує s.

Довжина 19 фрагмента

import java.util.*;

Дозволяє стислий використання класів , таких як List, Map, Scanner, Timerі Random.

Довжина фрагмента 18

Math.addExact(x,y)

Додає два цілих числа xі y. Якщо відбувається переповнення, метод видає виняток, а не дає неправильну відповідь.

Фрагмент довжини 17

Double.MIN_NORMAL

Найменше додатне значення типу double, де провідний біт ознаки дорівнює 0.

Довжина 16 фрагмента

System.in.read()

Читає один символ із консолі.

Довжина фрагмента 15

Long.reverse(x)

Повертає біти у двійковому поданні x.

Довжина фрагмента 14

int x=050+120;

xзараз 160, оскільки все, що починається з 0, трактується як восьмеричне.

Фрагмент довжини 13

private C(){}

Приватний конструктор заважає іншим класам інстанціювати його. Ця модель використовується, зокрема, Systemі Mathкласами. Приватний конструктор також може бути використаний для виконання Singleton шаблону.

Довжина фрагмента 12

static class

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

Фрагмент довжини 11

throw null;

Часто доводиться кидати NullPointerException, але це теж досить багатослівно. Це набагато простіша альтернатива.

Довжина фрагмента 10

int[]a,b[]

Визначає дві змінні: aі b. aє типу int[]і bмає типint[][] .

Фрагмент довжини 9

switch(x)

Переходить на місце, залежно від значення x.

Фрагмент довжини 8

break a;

Вирветься з блоку з маркуванням a.

Фрагмент довжини 7

goto x;

gotoКлючове слово зарезервовано в C, C ++ і Java. Якщо xце мітка, то цей код відправляє програму у відповідну мітку - на C та C ++. Але це Java, вона запускає загадкове RuntimeException. Насправді, взагалі немає можливості використовувати gotoключове слово на Java.

Довжина фрагмента 6

\u003b

Закінчується заявою. Ява дивна .

Фрагмент довжини 5

a-=-a

Подвоюється a, віднімаючи її заперечення.

Довжина 4 фрагмента

a&=b

Встановлює значення aдо бітових та aі b.

Фрагмент довжини 3

...

Будь-яка кількість аргументів, консолідованих у масив.

Фрагмент довжини 2

<>

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

Фрагмент довжини 1

@

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

Фактоїдні

У Java нескінченні цикли іноді викликають помилки компілятора. Наприклад, цикл while(true);не може бути припинений без виходу з методу, тому будь-який код після цього призведе до помилки "недоступного твердження". Як зазначав @Optimizer, лише деякі нескінченні петлі будуть зафіксовані таким чином.

Пітон

Тепер почніть з найновішого для вашої зручності! Щоб прочитати довжину 30, починаючи з самого початку, перейдіть до історії редагування.

Якщо хтось має пропозиції, сміливо коментуйте.

Довжина 52:

i=0
while s[i-n:]:print(' '*n+s)[i:n+i];i+=1;i**7**7

Взяте з мого запису у виклику « Підроблений текст оформлення тексту» . sі їх nпотрібно встановити на строку і ціле число достроково. Насправді це не добре працює у безкоштовному інтерпретаторі Python 2, який я використовував, тому я додав круглі дужки навколо(' '*n+s)[i:n+i] , і ви можете побачити, як він працює в інтерпретаторі Python 3 тут .

Довжина 43:

#-*-coding:rot13-*-
cevag h"Una fubg svefg"

У Python ви можете кодувати джерело певним кодеком. Це показує, як джерело можна записати в Rot13. Загальний синтаксис такий: # -*- coding: <codec-name-goes-here> -*-.

Ось це перекладено:

#-*-coding:rot13-*-
print u"Han shot first"

В uвказує , що наступний рядок літерал є рядком Unicode. Це необхідно, якщо ви хочете, щоб ваші рядки також були в Rot13, інакше кожна рядок у джерелі легко читається, незважаючи на шифрування. Крім того, ви можете використовувати .encode("Rot13")після кожного рядка (не забудьте також використовувати Rot13 і для цього.) Відповідно до цієї статті , деякі альтернативні кодування є "base64 ″," uuencode "," zlib "або" bz2 ″.

Довжина 33:

import cmath
print cmath.sqrt(-1)

Це модуль Python для складних (уявних) чисел . Це друкує 1j, оскільки Python відповідає інженерним стандартам і використовує jяк уявну одиницю, хоча я вважаю за краще i, що частіше використовується в математиці, а також використовує jі kдодатково iдля четвертинників , але я відхиляюся. Прочитайте помилку / порядок зміни тут (не змінюватиметься).

Довжина 30:

f=lambda n:n*f(n-1)if n else 1

Тепер ми визначаємо свою власну функціональну функцію за допомогою рекурсії та потрійного, якщо ще! Наскільки я знаю, це так само гольф, як і в Python. Це також можна записати так: f=lambda n:n and f(n-1)*n or 1демонструючи пару булевих операторів Python (а також виконано в 30 символів). Інформацію про lambdaсинтаксис див. У фрагменті довжини 15 .

Довжина 29:

import math
math.factorial(7)

Знаходить фактор 7, повертаючись 5040.

Довжина 25:

import math
print math.pi

Математичний модуль Python пропонує безліч корисних функцій і констант. Ось ПІ. Повертається 3.14159265359. (У наведеному вище коді я порахував новий рядок як символ.)

Довжина 24:

f=lambda y:lambda x:x**y

Це приклад закриття. Виклик cube = f(3)зробить кубічну функцію, яку потім можна викликати print cube(24), друкуючи 13824.

Довжина 19:

print"Hello World!"

Нарешті, достатньо місця для друку базового результату! Тут не потрібно місця, оскільки лапки та дужки також є роздільниками. Це буде працювати лише в Python 2, оскільки Python 3 змінив printфункцію, яку потрібно викликати, як і будь-яку іншу функцію. У Python 3 використовуйте print("Hello World!"). Щоб отримати додаткові відомості про функцію друку та різницю між Python 2 та 3, див. Що нового в Python 3.0 .

Довжина 16:

[x*3 for x in l]

Ще раз припустимо l, це список або будь-який інший ітерабельний об'єкт, такий як рядок або генератор. Це твердження відоме як розуміння списку . Це набагато коротше, ніж використання стандарту для структури циклу. Тут він повертає список із усіма числами, помноженими на 3. ТАКОЖ, рядки можна множити!Тож будь-який рядок у списку буде доданий (приєднаний до себе) стільки разів.

Довжина 15:

import this #:)

Це насправді фрагмент довжиною 11, але я зрозумів, що забув продемонструвати (дивовижне) великоднє яйце Python ! Імпорт цього модуля друкує Zen of Python (Див. Фактоїд.) Цікавий факт: модуль this.pyбув закодований в rot13, який, сподіваюся, озвучую пізніше.

Довжина 14:

lambda x:x**.5

Це визначає функцію квадратного кореня, використовуючи lambdaсинтаксис Python для функції буквал. Функціональні літерали в Python можуть містити лише вирази, а не твердження. Ця лямбда може бути присвоєна змінній, переданій функції або виконана в рядку (lambda x:x**.5)(9), яка повертається 3.0. Використання експонентів для квадратного кореня є альтернативою імпорту sqrtфункції в mathмодуль.

Довжина 13:

1 if x else 0

Це приклад потрійного оператора, якщо оператор Python. Це було додано в Python 2.5, щоб відмовити кодерам вручну реалізовувати його за допомогою булевих операцій. Тут 1повертається, якщо xоцінюється True, інакше 0повертається.

Довжина 12:

s=input(">")

Це надрукує >текст підказки та дозволить користувачеві ввести значення. Python 2 інтерпретує будь-яке значення, тому будь-яка рядок потребує лапок. Python 3 змінив це, так що введене введення не інтерпретується автоматично. Щоб ввести вхід, не інтерпретуючи його в Python 2, використовуйте raw_input(). У Python 2 input()рівносильноeval(raw_input()) .

Довжина 11:

eval("2e3")

2e3є науковим позначенням поплавця 2 х 10³. evalФункція інтерпретує і оцінює будь-який рядок як вираз. У цьому випадку він має той самий результат, що і при використанні буквального 2e3або float("2e3"). Це повертається 2000.0.

Довжина 10:

range(013)

Ця функція повертає список цілих чисел від 0восьмеричного значення 013, яке є 11(ексклюзивним), тобто список буде [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]. Функція приймає до трьох параметрів, подібних доslice функції ми розглянули раніше: range(start, stop[, step]). Різниця полягає в тому, що лише з одним параметром параметр представляє зупиняюче значення.

Зауважте, що Python 3.x не має еквівалента. Це rangeсхоже, але насправді те саме, що і Python 2xrange , повертаючи генератор-об’єкт замість списку.

Довжина 9:

a,b = b,a

Багаторазове призначення. Це проста, але елегантна функція, що дозволяє призначити кілька значень одночасно. У наданому фрагменті він міняється місцями aіb . Як щодо порядку оцінювання, запитаєте ви? Усі вирази праворуч від оператора присвоєння оцінюються перед тим, як зробити будь-яке із призначень. Це перемагає багато мов, які потребують проміжного призначення тимчасової змінної.

Довжина 8:

#comment

Ви знаєте, що це ... Зачекайте, чи ні? Знаєте, ті речі, які дозволяють вводити довільний текст для опису рядка коду, полегшуючи розуміння? Немає? О, гаразд...

Довжина 7:

l[::-1]

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

Ми дістаємось до того, де ми можемо почати використовувати ще кілька цікавих конструкцій!

Довжина 6:

l[-6:]

Це називається операцією зрізу . Якщо lце список, це поверне новий список, що містить останні шість елементів у lвигляді списку. -6являє собою початковий індекс (6 від кінця), а двокрапка означає продовжити до кінця індекс після нього (який ми залишили порожнім, так до кінця.) Якби наш список містив числа від 1 до 10, це повернеться [5, 6, 7, 8, 9, 10].

Довжина 5:

1<x<5

Однією з дивовижних особливостей Python є можливість ланцюга операторів порівняння. У багатьох інших мовах це буде набрано як 1 < x && x < 5. Це стає ще краще, якщо врахувати багаторазове порівняння: 1 < x < y < 5цілком справедливо!

Довжина 4:

0256

Ціле число з провідним нулем - це буквальне вісімкове значення. Це хороший трюк і для затухання коду. Це повертає десяткове значення 174. У Python 3.x восьмеричне значення запишеться як 0o256.

Довжина 3:

`3`

Оточуючий вираз на задній панелі - це те саме, що використовувати repr(), що повертає рядкове представлення об'єкта. Функція намагається повернути рядок таким чином, що коли вона буде передана як аргумент evalфункції, вона поверне початковий об'єкт. Це не те саме, що використання str(), хоча результати іноді однакові. Для цього введення '3'повертається в обох випадках. Це мій улюбленець кодового гольфу!

Працює лише в Python 2!

Довжина 2:

[]

Порожній список.

Довжина 1:

_

Символ підкреслення - це широко використовуване ім'я змінної, що викидається. Якщо ви використовуєте оболонку Python (інтерактивний інтерпретатор), проте вона містить результат останнього виконаного оператора (і повертає його знову.) Також, відповідно до цього потоку , він також використовується для пошуку перекладу в i18n.

Фактоїд : Python - мова, схожа на Java та C. Він був побудований із специфічною філософією дизайну (взято з " PEP 20 - Zen of Python ":

• Красиве краще, ніж потворне
• Явне краще, ніж неявне
• Простий - краще, ніж складний
• Комплекс краще, ніж складний
• Читання рахується

Через те, хоча напівколонки дозволені як розділювач тверджень, вони зазвичай опускаються на користь використання декількох рядків для читабельності. Також відступ рядків дуже важливий!

JavaScript

Це найновіше до найдавнішого. Посилання для себе: [ редагувати ]

Фрагмент довжини 51:

console.log(require('fs').readFileSync(__filename))

Цього разу Node.JS поставив лайк, хоча він не зміг би будь-яких "строгих quine" вимог через читання власного вихідного коду.

Довжина фрагмента 50:

a=new XMLHttpRequest;a.open('GET','file');a.send()

Нарешті! Запит AJAX (використовуючи Vanilla.JS ). Ми ініціалізуємо, відкриваємо та надсилаємо запит, але я вибіг із місця, щоб додати обробників і насправді все робити з результатом.

Довжина фрагмента 49:

msg=new SpeechSynthesisUtterance('Hello World!');

Підготуйте вокал «Здрастуйте, світ!». Насправді це буде трохи більше роботи. Ми також можемо регулювати гучність, висоту, темп та акцент. Див. API синтезу мовлення на HTML5Rocks .Ще не підтримується Firefox, звичайно, не IE .

Довжина 48 фрагмента:

function repeat(){setTimeout(repeat,48)}repeat()

Моделюйте setIntervalрекурсивноsetTimeout ing.

Фрагмент довжини 47:

module.exports=function MyModule(a) {this.a=a};

Ще раз NodeJS, але принцип однаковий скрізь у JS. Це дуже основна конструкторська функція, яка створює об’єкт з однією властивістю ( a). Налаштування module.exportsекспортує функцію для використанняrequire() її.

Фрагмент довжини 46:

canvas.getContext('2d').fillRect(46,46,46,46);

Для цього потрібен <canvas id="canvas"></canvas>елемент. Скористається тим, що елементи з ідентифікаторами заповнюються як глобальні змінні, тому елемент доступний якcanvas з JS. Потім заповнюємо його квадратом 46x46 при x = 46, y = 46.

Довжина фрагмента 45:

JSON.parse(require('fs').readFileSync('jsn'))

Назад до Вузла. Тут ми розбираємо файл JSON, названий jsnз поточного каталогу.

Довжина 44 фрагмента:

(a=document.createElement('a')).href="/url";

На основі №39. Тепер ми створюємо елемент і призначаємо атрибут. Це все ще не в DOM.

Фрагмент довжини 43:

sq=[1,2,3,4,5].map(function(n){return n*n})

Створює масив з перших 5 квадратів, використовуючи map().

Довжина фрагмента 42:

six="1+5",nine="8+1";eval(six+' * '+nine);

Це працює за тим же принципом, що і цей , але JS не вистачає, #defineі в результаті стає гірше. Він повертає, звичайно, відповідь на життя, Всесвіт і все .

Фрагмент довжини 41:

c=function(){var i;return function(){}}()

Початок закриття. cтепер це функція (внутрішня) з доступом до внутрішньої змінноїi , але вона нічого не робить.

Довжина 40 фрагмента:

$('p').click(function(){$(this).hide()})

Ми повністю скидаємо ці абзаци і використовуємо jQuery.

Фрагмент довжини 39:

script=document.createElement('script')

Це початок додавання нового зовнішнього сценарію. Створіть порожній <script>елемент і збережіть посилання на нього.

Фрагмент довжини 38:

document.getElementsByClassName('abc')

Знайдіть усі .abcелементи в документі. Звичайно, з jQuery це лише $('.abc')...

Фрагмент довжини 37:

b=JSON.parse(JSON.stringify(a={3:7}))

Створює два однакові, але нероз'єднані об'єкти a, і b. Якби ти зробив

a={a:1};
b=a;
b.a=3;

ви закінчите a=={a:3}, тому що aі bвкажіть на той самий об'єкт. Ми використовуємо JSON для їх декупажу.

Довжина 36 фрагмента:

(function f(){return "("+f+")()"})()

Куайн . Він друкує власний вихідний код.

Довжина 35 фрагмента:

document.body.style.display="none";

Див. №32. Цей документ просто приховує, не перезаписуючи вміст.

Фрагмент довжини 34:

Object.prototype.toString.call(34)

Виклик Object.prototype.toString- це хороший спосіб визначити тип об’єкта. Поки 34..toString()є "34", фрагмент є [object Number].

Фрагмент довжини 33: (кредит за цей анонімний користувач )

+0%-0.&(v\u0061r=~void[{}<<!(0)])

Думаєте, що це невірний JavaScript? Краще спробуйте ... (використовуйте Chrome);)

Довжина 32 фрагмента:

document.body.innerHTML="hacked"

Халп! Hazxxors! Одинадцять !! 11!

Фрагмент довжини 31:

a=[];for(i=0;i<31;i++)a.push(i)

Не жартую, я так довго чекав, щоб насправді використати forцикл! Цей створює масив від 0-30.

Довжина фрагмента 30:

new Date().getDay()==1?"S":"E"

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

Фрагмент довжини 29:

Object.keys(window).push('i')

Object.keys(window)отримає масив глобальних змінних (властивості window). .push()додасть елемент до цього масиву. Думаєте, це еквівалент window.i=undefined? Ні!

Фрагмент довжини 28:

setTimeout("a=confirm()",28)

Очікування 28 мілісекунд не так корисно, за винятком створення нової нитки.

Фрагмент довжини 27:

document.querySelector('a')

Прикро, що імена DOM такі довгі. Тут я міг отримати лише одне посилання.

Довжина фрагмента 26:

JSON.stringify({twenty:6})

Див. №16. Тепер ми отримуємо фактичний JSON - рядок.

Фрагмент довжини 25:

new Badge("Good Answer");

Якщо припустити Badge(), що це конструкторська функція, яка бере аргумент ... Значок хорошого відповіді був просто створений!

Фрагмент довжини 24:

do {alert(24)} while(!1)

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

Фрагмент довжини 23:

window.parent==self.top

Всі вони відносяться до одного і того ж об'єкта, загальновідомому як window. Якщо ви викликаєте функцію нормально, також є this. Ось 5 способів доступу до глобального об’єкта!

Фрагмент довжини 22:

for(i in self)alert(i)

Сповіщення про всі глобальні змінні. Буває так self==window. (Дивіться наступний фрагмент.)

Фрагмент довжини 21:

"2"+1==21 && 2+1=="3"

О, дивіться, це знову правила керування JS. Це твердження вірно, btw.

Фрагмент довжини 20:

Math.random()<.5?0:1

Виберіть випадкове число від 0-1 та обведіть його за допомогою потрійного оператора. Хоча це було б простіше у використанні Math.round...

Фрагмент довжини 19:

[1,2,3].map(i=>i*i)

Цей новий. Мовляв, справді нове. Він використовує функції стрілок ES6 для обчислення квадратів 1, 2 і 3. В даний час це, здається, підтримується Firefox.

Фрагмент довжини 18:

location.href="/";

Як і №15, але цього разу він переходить на домашню сторінку PPCG, а не на SE.

Фрагмент довжини 17:

(function(){})()

Це фрагмент з 14, але краще! Тепер це IIFE.

Фрагмент довжини 16:

obj={not:'json'}

Це пояснює один із моїх вихованців-вихованців. Це об’єкт , а не JSON ! JSON - формат обміну даними, заснований на об’єктах JavaScript, але має більш суворий формат.

Фрагмент довжини 15:

open('//s.tk/')

Уяви що. Відкрийте домашню сторінку SE, використовуючи http://s.tk/ переспрямування.

Фрагмент довжини 14:

function f(){}

W00t! Функції! Шкода, що тут нічого не можна робити .

Фрагмент довжини 13:

Math.random()

Створіть випадкове число від 0 до 1. Хочете визначити власні межі? Жорстка удача. (Насправді це не так просто.)

Фрагмент довжини 12:

new Date<=12

Це твердження ніколи не було правдивим у JS. JS був створений до 95 року (див. Фактоїд), довго після 1.01.1970 00: 00: 00.012.

Фрагмент довжини 11:

Math.PI*121

Площа кола з радіусом 11.

Фрагмент довжини 10:

if('j')9+1