Идентификаторы - это небольшие изображения геометрических узоров, которые представляют значение хеш-функции строки. Stack Exchange использует идентификаторы из Gravatar в качестве аватара каждого пользователя по умолчанию.

В этом соревновании мы также будем использовать идентификаторы Gravatar для создания текста для гольфа.

Вызов

Этот фрагмент стека (сокращенная версия этого JSFiddle ) позволяет вам вводить строку и возвращает черно-белую версию идентификатора этой строки размером 100 × 100 пикселей, а также текстовую версию, где 1для черного и 0для белого:

<!-- Click "Run code snippet" --> <div style='text-align:center;'> <input id='str' type='text' size='32' value='Python'> <button type='button' onclick='go()'>Go</button><br><br><input id='type1' name='type' type='radio' value='identicon' checked> <label for='type1'>Identicon</label> <input id='type2' name='type' type='radio' value='monsterid'> <label for='type2'>Monster</label> <input id='type3' name='type' type='radio' value='wavatar'> <label for='type3'>Wavatar</label> <input id='type4' name='type' type='radio' value='retro'> <label for='type4'>Retro</label> <br><br><a id='origLink'>original</a><br><canvas id='original' style='border:1px solid gray;'> Your browser does not support the canvas tag. </canvas> <br><br>binary<br><canvas id='binary' style='border:1px solid gray;'> </canvas> <br><br>text</br> <textarea id='text' style='background-color:#eee' readonly></textarea> <br><br>your text</br> <textarea id='userText'></textarea><br><button type='button' onclick='markDiffs()'>Mark Differences With X</button><br><br><span id='diffCount'></span> <br><br><small>(this snippet has only been tested in Chrome and Firefox)</small></div><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>function rgbDist(t,n){return Math.sqrt((Math.pow((t[0]-n[0])/255,2)+Math.pow((t[1]-n[1])/255,2)+Math.pow((t[2]-n[2])/255,2))/3)}function toBinImg(t,n){for(var r=0;r<t.data.length;r+=4){var e=rgbDist([t.data[r],t.data[r+1],t.data[r+2]],[255,255,255])<n;t.data[r]=t.data[r+1]=t.data[r+2]=e?255:0}}function getText(t){for(var n="",r=0,e=0;SIZE>e;e++){for(var o=0;SIZE>o;o++)n+=t.data[r]?"0":"1",r+=4;e!=SIZE-1&&(n+="\n")}return n}function markDiffs(){var t=0,n=$("#text").val().split("\n"),r=$("#userText").val(),e=new RegExp("(?:[01]{"+SIZE+"}\n){"+(SIZE-1)+"}(?:[01]{"+SIZE+"})\n?");if(!r.match(e))return void $("#diffCount").text("bad input");r=r.split("\n");for(var o="",a=0;SIZE>a;a++){for(var i=0;SIZE>i;i++)r[a][i]!==n[a][i]?(o+="X",t++):o+=r[a][i];o+="\n"}r[r.length-1].length&&(o=o.substring(0,o.length-1)),$("#diffCount").text(t+" differences found"),$("#userText").val(o)}function go(){var t=new Image;t.crossOrigin="anonymous",t.src="https://www.gravatar.com/avatar/"+md5($("#str").val())+"?&s="+SIZE+"&d="+$("input:radio[name=type]:checked").val(),$("#origLink").attr("href",t.src),t.onload=function(){ctxOrig.drawImage(t,0,0);var n=ctxOrig.getImageData(0,0,SIZE,SIZE);toBinImg(n,.05),$("#text").val(getText(n)),ctxBin.putImageData(n,0,0)}}var SIZE=100;$("#str").keyup(function(t){13==t.keyCode&&go()}),$("input[name=type]:radio").change(go),$(function(){var t=$("#original"),n=$("#binary");t.prop({width:SIZE,height:SIZE}),n.prop({width:SIZE,height:SIZE}),$("#text").prop({rows:SIZE+5,cols:SIZE+5}),$("#userText").prop({rows:SIZE+5,cols:SIZE+5}),ctxOrig=t[0].getContext("2d"),ctxBin=n[0].getContext("2d"),go()}),!function(t){"use strict";function n(t,n){var r=(65535&t)+(65535&n),e=(t>>16)+(n>>16)+(r>>16);return e<<16|65535&r}function r(t,n){return t<<n|t>>>32-n}function e(t,e,o,a,i,u){return n(r(n(n(e,t),n(a,u)),i),o)}function o(t,n,r,o,a,i,u){return e(n&r|~n&o,t,n,a,i,u)}function a(t,n,r,o,a,i,u){return e(n&o|r&~o,t,n,a,i,u)}function i(t,n,r,o,a,i,u){return e(n^r^o,t,n,a,i,u)}function u(t,n,r,o,a,i,u){return e(r^(n|~o),t,n,a,i,u)}function c(t,r){t[r>>5]|=128<<r%32,t[(r+64>>>9<<4)+14]=r;var e,c,f,g,d,h=1732584193,s=-271733879,v=-1732584194,I=271733878;for(e=0;e<t.length;e+=16)c=h,f=s,g=v,d=I,h=o(h,s,v,I,t[e],7,-680876936),I=o(I,h,s,v,t[e+1],12,-389564586),v=o(v,I,h,s,t[e+2],17,606105819),s=o(s,v,I,h,t[e+3],22,-1044525330),h=o(h,s,v,I,t[e+4],7,-176418897),I=o(I,h,s,v,t[e+5],12,1200080426),v=o(v,I,h,s,t[e+6],17,-1473231341),s=o(s,v,I,h,t[e+7],22,-45705983),h=o(h,s,v,I,t[e+8],7,1770035416),I=o(I,h,s,v,t[e+9],12,-1958414417),v=o(v,I,h,s,t[e+10],17,-42063),s=o(s,v,I,h,t[e+11],22,-1990404162),h=o(h,s,v,I,t[e+12],7,1804603682),I=o(I,h,s,v,t[e+13],12,-40341101),v=o(v,I,h,s,t[e+14],17,-1502002290),s=o(s,v,I,h,t[e+15],22,1236535329),h=a(h,s,v,I,t[e+1],5,-165796510),I=a(I,h,s,v,t[e+6],9,-1069501632),v=a(v,I,h,s,t[e+11],14,643717713),s=a(s,v,I,h,t[e],20,-373897302),h=a(h,s,v,I,t[e+5],5,-701558691),I=a(I,h,s,v,t[e+10],9,38016083),v=a(v,I,h,s,t[e+15],14,-660478335),s=a(s,v,I,h,t[e+4],20,-405537848),h=a(h,s,v,I,t[e+9],5,568446438),I=a(I,h,s,v,t[e+14],9,-1019803690),v=a(v,I,h,s,t[e+3],14,-187363961),s=a(s,v,I,h,t[e+8],20,1163531501),h=a(h,s,v,I,t[e+13],5,-1444681467),I=a(I,h,s,v,t[e+2],9,-51403784),v=a(v,I,h,s,t[e+7],14,1735328473),s=a(s,v,I,h,t[e+12],20,-1926607734),h=i(h,s,v,I,t[e+5],4,-378558),I=i(I,h,s,v,t[e+8],11,-2022574463),v=i(v,I,h,s,t[e+11],16,1839030562),s=i(s,v,I,h,t[e+14],23,-35309556),h=i(h,s,v,I,t[e+1],4,-1530992060),I=i(I,h,s,v,t[e+4],11,1272893353),v=i(v,I,h,s,t[e+7],16,-155497632),s=i(s,v,I,h,t[e+10],23,-1094730640),h=i(h,s,v,I,t[e+13],4,681279174),I=i(I,h,s,v,t[e],11,-358537222),v=i(v,I,h,s,t[e+3],16,-722521979),s=i(s,v,I,h,t[e+6],23,76029189),h=i(h,s,v,I,t[e+9],4,-640364487),I=i(I,h,s,v,t[e+12],11,-421815835),v=i(v,I,h,s,t[e+15],16,530742520),s=i(s,v,I,h,t[e+2],23,-995338651),h=u(h,s,v,I,t[e],6,-198630844),I=u(I,h,s,v,t[e+7],10,1126891415),v=u(v,I,h,s,t[e+14],15,-1416354905),s=u(s,v,I,h,t[e+5],21,-57434055),h=u(h,s,v,I,t[e+12],6,1700485571),I=u(I,h,s,v,t[e+3],10,-1894986606),v=u(v,I,h,s,t[e+10],15,-1051523),s=u(s,v,I,h,t[e+1],21,-2054922799),h=u(h,s,v,I,t[e+8],6,1873313359),I=u(I,h,s,v,t[e+15],10,-30611744),v=u(v,I,h,s,t[e+6],15,-1560198380),s=u(s,v,I,h,t[e+13],21,1309151649),h=u(h,s,v,I,t[e+4],6,-145523070),I=u(I,h,s,v,t[e+11],10,-1120210379),v=u(v,I,h,s,t[e+2],15,718787259),s=u(s,v,I,h,t[e+9],21,-343485551),h=n(h,c),s=n(s,f),v=n(v,g),I=n(I,d);return[h,s,v,I]}function f(t){var n,r="";for(n=0;n<32*t.length;n+=8)r+=String.fromCharCode(t[n>>5]>>>n%32&255);return r}function g(t){var n,r=[];for(r[(t.length>>2)-1]=void 0,n=0;n<r.length;n+=1)r[n]=0;for(n=0;n<8*t.length;n+=8)r[n>>5]|=(255&t.charCodeAt(n/8))<<n%32;return r}function d(t){return f(c(g(t),8*t.length))}function h(t,n){var r,e,o=g(t),a=[],i=[];for(a[15]=i[15]=void 0,o.length>16&&(o=c(o,8*t.length)),r=0;16>r;r+=1)a[r]=909522486^o[r],i[r]=1549556828^o[r];return e=c(a.concat(g(n)),512+8*n.length),f(c(i.concat(e),640))}function s(t){var n,r,e="0123456789abcdef",o="";for(r=0;r<t.length;r+=1)n=t.charCodeAt(r),o+=e.charAt(n>>>4&15)+e.charAt(15&n);return o}function v(t){return unescape(encodeURIComponent(t))}function I(t){return d(v(t))}function l(t){return s(I(t))}function p(t,n){return h(v(t),v(n))}function E(t,n){return s(p(t,n))}function S(t,n,r){return n?r?p(n,t):E(n,t):r?I(t):l(t)}"function"==typeof define&&define.amd?define(function(){return S}):t.md5=S}(this);//thanks https://github.com/blueimp/JavaScript-MD5/blob/master/js/md5.min.js</script>

(Он также позволяет загружать стили Monster, Wavatar и Retro Gravatar, но они просто для развлечения и не предназначены для использования в этом испытании. К сожалению, Unicornicons отсутствуют из-за ограничений XSS .: /)

Ваша задача - написать программу, которая выводит текстовый блок размером 100 × 100 символов 0«s» и 1«s», который генерируется, когда вы вводите имя вашего языка программирования в поле ввода фрагмента.

Например, если ваша заявка написана на Python , вы должны ввести Pythonфрагмент кода и увидеть, что

является идентичным для Python, и

это черно-белая (двоичная) версия, и

0000000000000000000000011111111111111111111111111100000000000000000000000010000000000000000000000000
0000000000000000000001111011111111111111111111111100000000000000000000011110000000000000000000000000
0000000000000000000111111011111111111111111111111100000000000000000001111110000000000000000000000000
0000000000000000011111111011111111111111111111111100000000000000000111111110000000000000000000000000
0000000000000001111111111001111111111111111111111100000000000000001111111110000000000000000000000000
0000000000000111111111111001111111111111111111111100000000000000111111111110000000000000000000000000
0000000000001111111111111000111111111111111111111100000000000111111111111110000000000000000000000000
0000000000000011111111111000111111111111111111111100000000011111111111111110000000000000000000000000
0000000000000000111111111000011111111111111111111100000001111111111111111110000000000000000000000000
0000000000000000001111111000001111111111111111111100000011111111111111111110000000000000000000000000
0000000000000000000011111000001111111111111111111100001111111111111111111110000000000000000000000000
0000000000000000000000111000000111111111111111111101111111111111111111111110000000000000000000000000
0000000000000000000000001000000111111111111111111111111111111111111111111110000001000000000001000000
0000000000000000000000111000000111111111111111111111111111111111111111111110000011000000000001100000
0000000000000000000011111000000011111111111111111111111111111111111111111110000011100000000011100000
0000000000000000001111111000000011111111111111111111111111111111111111111110000111100000000011110000
0000000000000000111111111000000001111111111111111111111111111111111111111110000111110000000111110000
0000000000000011111111111000000001111111111111111111111111111111111111111110001111110000000111111000
0000000000001111111111111000000000111111111111111111111111111111111111111110001111111000001111111000
0000000000000111111111111000000000011111111111111111111111111111111111111110011111111000001111111100
0000000000000001111111111000000000011111111111111111111111111111111111111110011111111100011111111100
0000000000000000011111111000000000001111111111111111111111111111111111111110111111111100011111111110
0000000000000000000111111000000000001111111111111111111111111111111111111110111111111110111111111110
0000000000000000000001111000000000001111111111111111111111111111111111111111111111111110111111111111
0000000000000000000000011000000000000111111111111111111111111111111111111111111111111111111111111111
1111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000001
0111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000001111
0111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000111111
0111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000011111111
0011111111111111111111111000000000000000000000000000000000000000000000000000000000000000000111111111
0011111111111111111111111000000000000000000000000000000000000000000000000000000000000000011111111111
0001111111111111111111111000000000000000000000000000000000000000000000000000000000000011111111111111
0001111111111111111111111000000000000000000000000000000000000000000000000000000000001111111111111111
0000111111111111111111111000000000000000000000000000000000000000000000000000000000111111111111111111
0000011111111111111111111000000000000000000000000000000000000000000000000000000001111111111111111111
0000011111111111111111111000000000000000000000000000000000000000000000000000000111111111111111111111
0000001111111111111111111000000000000000000000000000000000000000000000000000111111111111111111111111
0000001111111111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000001111111111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000111111111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000111111111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000011111111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000011111111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000001111111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000000111111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000000111111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000000011111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000000011111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000000011111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
0000000000001111111111111000000000000000000000000000000000000000000000000001111111111111111111111111
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111000000000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111100000000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111100000000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111110000000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111110000000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111111000000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111111000000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111111100000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111111100000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111111110000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111111110000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111111111000000
1111111111111111111111111000000000000000000000000000000000000000000000000001111111111111111111000000
1111111111111111111111110000000000000000000000000000000000000000000000000001111111111111111111100000
1111111111111111111111000000000000000000000000000000000000000000000000000001111111111111111111100000
1111111111111111111100000000000000000000000000000000000000000000000000000001111111111111111111110000
1111111111111111110000000000000000000000000000000000000000000000000000000001111111111111111111110000
1111111111111111000000000000000000000000000000000000000000000000000000000001111111111111111111111000
1111111111111100000000000000000000000000000000000000000000000000000000000001111111111111111111111000
1111111111110000000000000000000000000000000000000000000000000000000000000001111111111111111111111100
1111111111000000000000000000000000000000000000000000000000000000000000000001111111111111111111111100
1111111100000000000000000000000000000000000000000000000000000000000000000001111111111111111111111110
1111110000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111110
1111000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111
1100000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111
1111111111111111111111111111111111111111111111111111111111111110000000000001100000000000000000000000
1111111111111111111111111111111111111111111111111111111111111111000000000001111000000000000000000000
0111111111110111111111111111111111111111111111111111111111111111000000000001111110000000000000000000
0111111111110011111111110111111111111111111111111111111111111111100000000001111111100000000000000000
0011111111100011111111110111111111111111111111111111111111111111100000000001111111111000000000000000
0011111111000001111111100111111111111111111111111111111111111111110000000001111111111110000000000000
0001111111000001111111100111111111111111111111111111111111111111110000000001111111111111000000000000
0001111111000000111111000111111111111111111111111111111111111111111000000001111111111100000000000000
0000111110000000111111000111111111111111111111111111111111111111111000000001111111110000000000000000
0000111110000000011110000111111111111111111111111111111111111111111100000001111111000000000000000000
0000011100000000011100000111111111111111111111111111111111111111111100000001111100000000000000000000
0000011100000000001100000111111111111111111111111111111111111111111110000001110000000000000000000000
0000001000000000001100000111111111111111111111111111111111111111111110000001000000000000000000000000
0000000000000000000000000111111111111111111111111011111111111111111111000001110000000000000000000000
0000000000000000000000000111111111111111111111100011111111111111111111000001111100000000000000000000
0000000000000000000000000111111111111111111110000011111111111111111111100001111111000000000000000000
0000000000000000000000000111111111111111111000000011111111111111111111100001111111110000000000000000
0000000000000000000000000111111111111111100000000011111111111111111111110001111111111100000000000000
0000000000000000000000000111111111111110000000000011111111111111111111110001111111111111000000000000
0000000000000000000000000111111111111000000000000011111111111111111111111001111111111110000000000000
0000000000000000000000000111111111100000000000000011111111111111111111111001111111111000000000000000
0000000000000000000000000111111110000000000000000011111111111111111111111101111111100000000000000000
0000000000000000000000000111111000000000000000000011111111111111111111111101111110000000000000000000
0000000000000000000000000111100000000000000000000011111111111111111111111111111000000000000000000000
0000000000000000000000000110000000000000000000000011111111111111111111111111100000000000000000000000

это соответствующий текстовый вывод, который должна создать ваша программа на Python.

Однако, поскольку у идентификаторов может быть много неловких углов, и их растеризация в виде черно-белого изображения может оставить неровности , ваш вывод может иметь до 300 0-х или 2 1-х, которые являются противоположностями того, чем они должны быть. (Это 3% от 10000 общего 0«ы и 1» с.)

В нижней части фрагмента вы можете вставить в вывод вашей программы и проверить, сколько 0или 1нет, чем они должны быть. Любое количество различий в пределах или ниже 300 действительно.

счет

Представление с наименьшим количеством байтов выигрывает. ( Удобный счетчик байтов. )
Tiebreaker переходит к представлению с наименьшим количеством неправильных 0«и 1».
Если есть еще связь, выигрывает более раннее представление.

подробности

• Вывод идет в стандартный вывод или подобную альтернативу, если ваш язык не имеет стандартного вывода.
• Выходные данные могут дополнительно иметь завершающий символ новой строки.
• Пожалуйста, включите цветное изображение в ваш пост вместе с точной строкой, которая его генерирует. Нет необходимости тратить пространство и публиковать весь текстовый вывод.
• Ваша программа должна работать без подключения к интернету. Вам нужно создать текст в своем коде, а не запрашивать его с сайта Gravatar.
• Используйте здравый смысл, когда называете свой язык. Используйте название языка, которое вы обычно используете на этом сайте. Не надо раздражать и придумать имя, которое делает игру в гольф легкой. Например, Python 2это хорошо для Python, но python 2.7.2растягивает его и python 2.7.2 by Guido van Rossumбыло бы смешно.
• Я понимаю, что некоторые языки по своей природе проще, чем другие, потому что их идентичные формы проще. Так оно и будет, не слишком обижайтесь и не соревнуйтесь об этом. ;)

CJam, 92 81 79 71 байт, 120 ошибок

25:M{'0*MXe[}%2/z:~M,_ff{_)2$)d/2mLz1>@@+38<^}:A.+AM'1*f++_W%z.+N*N1$W%

Вероятно, еще есть место для игры в гольф.

Проверьте это здесь.

объяснение

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

Первая плитка теоретически должна выглядеть так:

1111111111111111111111111
1111111111111111111111100
1111111111111111111110000
1111111111111111111000000
1111111111111111100000000
1111111111111110000000000
1111111111111000000000000
1111111111100000000000000
1111111110000000000000000
1111111000000000000000000
1111100000000000000000000
1110000000000000000000000
1111111111111111111111111
1111111111111111111111110
1111111111111111111111000
1111111111111111111100000
1111111111111111110000000
1111111111111111000000000
1111111111111100000000000
1111111111110000000000000
1111111111000000000000000
1111111100000000000000000
1111110000000000000000000
1111000000000000000000000
1100000000000000000000000

Это 12 линий, затем 13 линий точки между 1s и 0s, уменьшающиеся на 2 за раз. Обратите внимание, что первый блок имеет четное число 0s, а второй блок нечетное число. Мы можем сделать шаблон еще более равномерным, если пожертвуем точностью в среднем ряду и включим 124 0с. Тогда у нас фактически есть одна строка для каждого числа нулей от 0 до 24, чередующихся между верхней и нижней частями. Таким образом, мы можем просто сгенерировать их по порядку (как один треугольник), а затем вытащить все остальные строки:

25:M{'0*MXe[}%2/z:~
25:M                e# Push 25 and store it in M for future use.
    {       }%      e# Map this block onto the range [0 ... 24].
     '0*            e# Create a string of i zeroes.
        MXe[        e# Pad to width 25 with 1s from the left.
              2/    e# Group the lines into pairs.
                z   e# Zip the pairs, thereby grouping even and odd lines.
                 :~ e# Flatten the two groups so we've got a plain 2D grid again.

Далее этот причудливый треугольник справа от этой плитки:

1100000000000000000000000
1111000000000000000000000
0111110000000000000000000
0111111100000000000000000
0011111111000000000000000
0011111111110000000000000
0001111111111100000000000
0001111111111111000000000
0000111111111111110000000
0000111111111111111100000
0000011111111111111111000
0000011111111111111111110
0000001111111111111111111
0000001111111111111111111
0000000111111111111111110
0000000111111111111111100
0000000011111111111111000
0000000011111111111110000
0000000001111111111100000
0000000001111111111000000
0000000000111111110000000
0000000000111111100000000
0000000000011111000000000
0000000000011110000000000
0000000000001100000000000

Если рассматривать систему координат с началом в верхнем правом углу и xидти направо и yидти вниз, то область 1з удовлетворяет 3 неравенства: x/y ≥ 1/2, x/y ≥ 2, x + y < 38. Мы можем просто вычислить их отдельно и принять логический конец. Он не сохраняет никаких символов, но немного очищает код, если мы объединяем первые два неравенства:

    1/2 ≤ x/y ≤ 2
=>  -1 ≤ log2(x/y) ≤ 1
=>  |log2(x/y)| ≤ 1

В конечном итоге мы сохраним еще один байт, проверив обратное и используя xorвместо того, andчтобы объединять результат с другим неравенством:

M,_ff{_)2$)d/2mLz1>@@+38<^}
M,_                         e# Create a range [0 .. 24] and duplicate it.
   ff{                    } e# This creates a 25x25 array, where each element is 
                            e# determined by executing the block on the pair of its
                            e# x and y coordinates.
      _)                    e# Copy x and increment.
        2$)                 e# Copy y and increment.
           d/               e# Convert to double and divide.
             2mL            e# Get base-2 logarithm.
                z1>         e# Take modulus and check if it's greater than 1.
                   @@       e# Get the other two copies of x and y.
                     +38<   e# Add them and check that they are less than 38.
                         ^  e# Take the XOR with the other condition.

Теперь у нас все есть - оставшиеся плитки - это просто копии и повороты, а также сплошная (скучная) плитка в центре. Итак, давайте соберем все вместе:

:A.+AM'1*f++_W%z.+N*N1$W%
:A                         e# Store the fancy triangle in A.
  .+                       e# Join the two existing tiles horizontally.
    A                      e# Push the triangle again.
     M'1*                  e# Create a string of 25 ones.
         f+                e# Add it to each line of the triangle.
           +               e# Add these two tiles to the first two tiles, completing
                           e# the upper left quadrant.
            _W%z           e# Duplicate the quadrant, reverse the rows, transpose.
                           e# These two operations together perform a 90 degree
                           e# clockwise rotation.
                .+         e# Join the two quadrants horizontally.
                  N*       e# Join the lines together with newline characters.
                    N1$    e# Push a newline to separate the two halves and copy the
                           e# first half.
                       W%  e# Reverse the entire string. Since this reverse the string
                           e# both vertically and horizontally, this rotates the
                           e# half by 180 degrees.

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

Октава 166 164 байта, 0 ошибок

Octave обладает отличной стойкостью в обработке / построении матриц. Для «алмазов» я создал систему координат xy и использовал манхэттенскую норму для определения, будут ли записи 1 или 0. Поскольку алмазы не являются полностью симметричными, мне пришлось возиться с «расстоянием» и центральной точкой, так что с центральной точкой (13.1,13.1) он работал для обоих видов «ромбовидных» форм.

После этого я мог просто установить четверть из них на ноль, чтобы получить эти C-формы. Квадраты и матричная конкатенация были просты.

Новые символы версии -2 (работают так же, как и старые, но мне удалось еще немного злоупотребить синтаксисом Octave:

C=ones(25);M=(R=(R=meshgrid(abs(-12.1:12)))+R')>12|R<6.5;S=T=U=V=13.1>R&R>5.8;C(k=8:19,k)=S(f,s)=T(f,f)=U(s,f=1:12)=V(s=14:25,s)=0;[C,U,T,C;U,M,M,T;V,M,M,S;C,V,S,C]

Старая версия:

C=ones(25);                               %corner squares
C(k=8:19,k)=0;                            %set the inner squares to 0
X=meshgrid(abs(-12.1:12));                %build coordinate system
R=X+X';                                   %R already has the distances to the chosen centerpoint (13.1, 13.1)
M=R>12|R<6.5;                             %diamond (for the center)
S=T=U=V=13.1>R&R>5.8;                     %diamond (for the edges)
S(f,s)=T(f,f)=U(s,f=1:12)=V(s=14:25,s)=0; %set each one quarter to 0 for the C-shape
[C,U,T,C;U,M,M,T;V,M,M,S;C,V,S,C]         %concatenate and display the big matrix

Выход

1111111111111111111111111000000000000110000000000000000000000011000000000001111111111111111111111111
1111111111111111111111111000000000001111000000000000000000000011100000000001111111111111111111111111
1111111111111111111111111000000000011111100000000000000000000011110000000001111111111111111111111111
1111111111111111111111111000000000111111110000000000000000000011111000000001111111111111111111111111
1111111111111111111111111000000001111111111000000000000000000011111100000001111111111111111111111111
1111111111111111111111111000000011111111111100000000000000000011111110000001111111111111111111111111
1111111111111111111111111000000111111111111110000000000000000011111111000001111111111111111111111111
1111111000000000000111111000001111111011111111000000000000000001111111100001111111000000000000111111
1111111000000000000111111000011111110001111111100000000000000000111111110001111111000000000000111111
1111111000000000000111111000111111100000111111110000000000000000011111111001111111000000000000111111
1111111000000000000111111001111111000000011111111000000000000000001111111101111111000000000000111111
1111111000000000000111111011111110000000001111111100000000000000000111111111111111000000000000111111
1111111000000000000111111111111100000000000111111111111110000000000011111111111111000000000000111111
1111111000000000000111111000000000000000001111111111111111000000000111111111111111000000000000111111
1111111000000000000111111000000000000000011111111001111111100000001111111101111111000000000000111111
1111111000000000000111111000000000000000111111110000111111110000011111111001111111000000000000111111
1111111000000000000111111000000000000001111111100000011111111000111111110001111111000000000000111111
1111111000000000000111111000000000000011111111000000001111111101111111100001111111000000000000111111
1111111000000000000111111000000000000111111110000000000111111111111111000001111111000000000000111111
1111111111111111111111111000000000000111111100000000000011111111111110000001111111111111111111111111
1111111111111111111111111000000000000111111000000000000001111111111100000001111111111111111111111111
1111111111111111111111111000000000000111110000000000000000111111111000000001111111111111111111111111
1111111111111111111111111000000000000111100000000000000000011111110000000001111111111111111111111111
1111111111111111111111111000000000000111000000000000000000001111100000000001111111111111111111111111
1111111111111111111111111000000000000110000000000000000000000111000000000001111111111111111111111111
0000000000001100000000000111111111111111111111111111111111111111111111111110000000000001100000000000
0000000000011110000000000111111111111001111111111111111111111100111111111110000000000001110000000000
0000000000111111000000000111111111110000111111111111111111111000011111111110000000000001111000000000
0000000001111111100000000111111111100000011111111111111111110000001111111110000000000001111100000000
0000000011111111110000000111111111000000001111111111111111100000000111111110000000000001111110000000
0000000111111111111000000111111110000000000111111111111111000000000011111110000000000001111111000000
0000001111111111111100000111111100000100000011111111111110000010000001111110000000000001111111100000
0000011111110111111110000111111000001110000001111111111100000111000000111110000000000000111111110000
0000111111100011111111000111110000011111000000111111111000001111100000011110000000000000011111111000
0001111111000001111111100111100000111111100000011111110000011111110000001110000000000000001111111100
0011111110000000111111110111000001111111110000001111100000111111111000000110000000000000000111111110
0111111100000000011111111110000011111111111000000111000001111111111100000010000000000000000011111111
1111111000000000001111111100000111111111111100000010000011111111111110000001111111000000000001111111
0000000000000000011111111100000011111111111000000110000001111111111100000011111111100000000011111111
0000000000000000111111110110000001111111110000001111000000111111111000000110111111110000000111111110
0000000000000001111111100111000000111111100000011111100000011111110000001110011111111000001111111100
0000000000000011111111000111100000011111000000111111110000001111100000011110001111111100011111111000
0000000000000111111110000111110000001110000001111111111000000111000000111110000111111110111111110000
0000000000001111111100000111111000000100000011111111111100000010000001111110000011111111111111100000
0000000000001111111000000111111100000000000111111111111110000000000011111110000001111111111111000000
0000000000001111110000000111111110000000001111111111111111000000000111111110000000111111111110000000
0000000000001111100000000111111111000000011111111111111111100000001111111110000000011111111100000000
0000000000001111000000000111111111100000111111111111111111110000011111111110000000001111111000000000
0000000000001110000000000111111111110001111111111111111111111000111111111110000000000111110000000000
0000000000001100000000000111111111111011111111111111111111111101111111111110000000000011100000000000
0000000000001100000000000111111111111111111111111111111111111111111111111110000000000001000000000000
0000000000011110000000000111111111111001111111111111111111111100111111111110000000000011000000000000
0000000000111111000000000111111111110000111111111111111111111000011111111110000000000111000000000000
0000000001111111100000000111111111100000011111111111111111110000001111111110000000001111000000000000
0000000011111111110000000111111111000000001111111111111111100000000111111110000000011111000000000000
0000000111111111111000000111111110000000000111111111111111000000000011111110000000111111000000000000
0000001111111111111100000111111100000100000011111111111110000010000001111110000001111111000000000000
0000011111110111111110000111111000001110000001111111111100000111000000111110000011111110000000000000
0000111111100011111111000111110000011111000000111111111000001111100000011110000111111100000000000000
0001111111000001111111100111100000111111100000011111110000011111110000001110001111111000000000000000
0011111110000000111111110111000001111111110000001111100000111111111000000110011111110000000000000000
0111111100000000011111111110000011111111111000000111000001111111111100000010111111100000000000000000
1111111000000000001111111100000111111111111100000010000011111111111110000001111111000000000001111111
1111111100000000000000000100000011111111111000000110000001111111111100000011111111100000000011111111
0111111110000000000000000110000001111111110000001111000000111111111000000110111111110000000111111110
0011111111000000000000000111000000111111100000011111100000011111110000001110011111111000001111111100
0001111111100000000000000111100000011111000000111111110000001111100000011110001111111100011111111000
0000111111110000000000000111110000001110000001111111111000000111000000111110000111111110111111110000
0000011111111000000000000111111000000100000011111111111100000010000001111110000011111111111111100000
0000001111111000000000000111111100000000000111111111111110000000000011111110000001111111111111000000
0000000111111000000000000111111110000000001111111111111111000000000111111110000000111111111110000000
0000000011111000000000000111111111000000011111111111111111100000001111111110000000011111111100000000
0000000001111000000000000111111111100000111111111111111111110000011111111110000000001111111000000000
0000000000111000000000000111111111110001111111111111111111111000111111111110000000000111110000000000
0000000000011000000000000111111111111011111111111111111111111101111111111110000000000011100000000000
1111111111111111111111111000000000000110000000000000000000000010000000000001111111111111111111111111
1111111111111111111111111000000000001111000000000000000000000110000000000001111111111111111111111111
1111111111111111111111111000000000011111100000000000000000001110000000000001111111111111111111111111
1111111111111111111111111000000000111111110000000000000000011110000000000001111111111111111111111111
1111111111111111111111111000000001111111111000000000000000111110000000000001111111111111111111111111
1111111111111111111111111000000011111111111100000000000001111110000000000001111111111111111111111111
1111111111111111111111111000000111111111111110000000000011111110000000000001111111111111111111111111
1111111000000000000111111000001111111011111111000000000111111100000000000001111111000000000000111111
1111111000000000000111111000011111110001111111100000001111111000000000000001111111000000000000111111
1111111000000000000111111000111111100000111111110000011111110000000000000001111111000000000000111111
1111111000000000000111111001111111000000011111111000111111100000000000000001111111000000000000111111
1111111000000000000111111011111110000000001111111101111111000000000000000001111111000000000000111111
1111111000000000000111111111111100000000000111111111111110000000000011111111111111000000000000111111
1111111000000000000111111111111110000000000000000011111111000000000111111111111111000000000000111111
1111111000000000000111111011111111000000000000000001111111100000001111111101111111000000000000111111
1111111000000000000111111001111111100000000000000000111111110000011111111001111111000000000000111111
1111111000000000000111111000111111110000000000000000011111111000111111110001111111000000000000111111
1111111000000000000111111000011111111000000000000000001111111101111111100001111111000000000000111111
1111111000000000000111111000001111111100000000000000000111111111111111000001111111000000000000111111
1111111111111111111111111000000111111100000000000000000011111111111110000001111111111111111111111111
1111111111111111111111111000000011111100000000000000000001111111111100000001111111111111111111111111
1111111111111111111111111000000001111100000000000000000000111111111000000001111111111111111111111111
1111111111111111111111111000000000111100000000000000000000011111110000000001111111111111111111111111
1111111111111111111111111000000000011100000000000000000000001111100000000001111111111111111111111111
1111111111111111111111111000000000001100000000000000000000000111000000000001111111111111111111111111

Brainfuck 9418 2237 байт, 88 ошибок

Изменить: Как mbomb007 указал, что «официальное» имя, кажется, не с большой буквы, это не упоминается в Википедии, но на esolangs . Это раздражает меня, но не достаточно, чтобы переделать это;).

Моя первая программа Brainfuck!

Теперь на самом деле использует математику, логику и прочее! (для каждого пикселя он принимает решение 0 или 1 в зависимости от нескольких условий). Это было довольно весело сделать; это, как говорится, я не думаю, что я собираюсь снова писать код с Brainfuck в течение длительного времени.

>>>++[<+>+++++]<-->>++[<+>+++++]<--[->+++++[>+++++<-]<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>[-<+>]<+<[->>>>>>>+<<<<<<<]>>>>>>>->+++++[>+++++<-]<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>[-<<<<<<<<+>>>>>>>>]<<<<<<<<+>>>>>>+>>>>>>+<<<<<<[>>+++<<<[>>>-<+<<-]>>[<<+>>-]>[<<->>[-]]<<<[->>+<<]>+>[<->[-<<+>>]]>>>>>]<<<<<<[-<<<<<<+>>>>>>]<<<<<+<[-[->-<>>>>[->>>+>>>>>>>++>>>>>>>>>>>>>>>>>+>>>>>>>++<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<]<[->>>>>>>>>>>>>>>>+>>>>>>>++>>>>>>>>>>>>>>>>>+>>>>>>>++<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<]<<<<<[->>>>>>>>>>++>>>>>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>++>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<]<[->>>>>>>>>>>>>>>>>>>>>>>++>>>>>+>>>>>>>++>>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<]>>>>>>>>>>>+>>>+>>>+>>>+>>>>>>+>>+>>>>+>>++>>>>+>>>++>>>+>>>++>>>+>>++>>>>+<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[<<<[>+>+<<-]>>[<<+>>-]<<<[>>>+<<<-]>>>[>-]>[<<<<+>>[-]>>->]<+<<[>-[>-]>[<<<<+>>[-]+>>->]<+<<-]>>[-]<[-]<<[-]>>>>>>>>>]<<<<<<<<<<[<<<<<<[<<<<<<[<<<<<<[<+>-]>>>>>>-]>>>>>>-]>>>>>>-]<<<<<<[-]<<<<<<[-]<<<<<<[-]<<<<<<[<<<<<<[<<<<<<[<<<<<<[<+>-]>>>>>>-]>>>>>>-]>>>>>>-]<<<<<<[-]<<<<<<[-]<<<<<<[-]>>>>>>>>>>>>>>>>>>>>>>>[-<<<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>>>>]<<<<<<<<<<<<<<<<<<<<<<<<[<<<<<<<<<<<<<+>>>>>>>>>>>>>[-]]<[-]<<<<<<[-]>]>[-<<[[->+<]>-<]>[<<[-]<[->+<]>->>[-]]>>>>>[[->+<]>-<]>[<<[-]<[->+<]->->>[-]]>>>+>>>>++[<++>+++++++]>>+<<<<<<<<<<+<[->+<<<<<++>>>>>>>>>>>+<<<<<<<]<[-]+<<<<+<[->+>>>>>>>++>>>>>+<<<<<<<<<<<<<]>>>>>[<<<[>+>+<<-]>>[<<+>>-]<<<[>>>+<<<-]>>>[>-]>[<<<<+>>[-]>>->]<+<<[>-[>-]>[<<<<+>>[-]+>>->]<+<<-]>>[-]<[-]<<[-]>>>>>>>>>]<<<<<<<<<<[-<<<<<<+>>>>>>]<<<<<<[-<<<<<<+>>>>>>]<<<<<<<+++>[-<->]<[<<<<<+>>>>>[-]]<[-]>>>]<]>[-<<<[->>>>>+>+<<<<<<]>>>>>[->>>>>>>>>>>>>>>+>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<]>[->>+>>>>>>>+<<<<<<<<<]>>>>++++[<++++>-]<+>>>+>+++++[>++++++<-]>>>>>+>>>>+++[<++++++>-]<+>>>+>+++++[>++++++<-]>+>>>>+[<<<[>+>+<<-]>>[<<+>>-]<<<[>>>+<<<-]>>>[>-]>[<<<<+>>[-]>>->]<+<<[>-[>-]>[<<<<+>>[-]+>>->]<+<<-]>>[-]<[-]<<[-]<<<]>>>>>>>>>>>>>>>>>>>>[-<<<<<<+>>>>>>]<<<<<<[-<<<<<<+>>>>>>]<<<<<<[-<<<<<<+>>>>>>]<<<<<<[-<<<<<<<<<<<<<+>>>>>>>>>>>>>[-]]<[-]<<<<<<[-]<<[-]>>>]<<<<<<<<<+[>+<+++++]>---.[-]>-[->>+<<]>>>+<[>-<[-<<+>>]]>[<<->++[<<+>>+++++]<<-->>>[-]++++++++++.[-]]<<]

создание растрового изображения:

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

>>
>++[<+>+++++]<--
>
>++[<+>+++++]<--            100 100     x y range from 1 to 100 (min is not 0) 

[                                           while y
    -                                           x       * y_1
    >+++++[>+++++<-]<
    [->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]           x       * 0     y_1     25_(y_1)%25     (y_1)%25    y//25
    >[-<+>]<+                                   x       * y     0       25_(y_1)%25     (y_1)%25    y//25
    <[->>>>>>>+<<<<<<<]>>>>>>>-                 0       y       0       25_(y_1)%25     (y_1)%25    y//25       0           * x_1
    >+++++[>+++++<-]<
    [->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]           0       y       0       25_(y_1)%25     (y_1)%25    y//25       0           * 0     x_1     25_(x_1)%25     (x_1)%25    x//25
    >[-<<<<<<<<+>>>>>>>>]<<<<<<<<+              * x     y       0       25_(y_1)%25     (y_1)%25    y//25       0           0       0       25_(x_1)%25     (x_1)%25    x//25

    >>>>>>+>>>>>>+<<<<<<
    [
        >>+++<<
        <[>>>-<+<<-]
        >>[<<+>>-]
        >[<<->>[-]]                             x       y       0       25_(y_1)%25     (y_1)%25    y//25       y//25=3     0       * 0     25_(x_1)%25     (x_1)%25    x//25

        <<<[->>+<<]
        >+>
        [<->[-<<+>>]]                           x       y       0       25_(y_1)%25     (y_1)%25    y//25       y//25=0|3   *0      0       25_(x_1)%25     (x_1)%25    x//25

        >>>>>
    ]
    <<<<<<                                      x       y       0       25_(y_1)%25     (y_1)%25    y//25       y//25=0|3   0       0       25_(x_1)%25     (x_1)%25    x//25       * x//25=0|3
    [-<<<<<<+>>>>>>]                            x       y       0       25_(y_1)%25     (y_1)%25    y//25       p           0       0       25_(x_1)%25     (x_1)%25    x//25       * 0
    <<<<<

    +<
    [
        -
        [   
            ->-<

            ### p == 2 ###                      x       y       0       v1              v0          y//25       0           * 0     0       u1              u0          x//25       0

            >>>>
            [->>>+ >>>>>>>++ >>>>>>>>>>>>>>>>>+ >>>>>>>++<<<<<<< <<<<<<<<<<<<<<<<< <<<<<<< <<<]
            <
            [->>>>>>>>>>>>>>>>+ >>>>>>>++ >>>>>>>>>>>>>>>>>+ >>>>>>>++ <<<<<<< <<<<<<<<<<<<<<<<< <<<<<<< <<<<<<<<<<<<<<<<]
            <<<<<
            [->>>>>>>>>>++ >>>>>+ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>++ >>>>>+ <<<<< <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<<<< <<<<<<<<<<]
            <
            [->>>>>>>>>>>>>>>>>>>>>>>++ >>>>>+ >>>>>>>++ >>>>>+ <<<<< <<<<<<< <<<<< <<<<<<<<<<<<<<<<<<<<<<<]

            >>>>>>>>
            >>>+
            >>>+>>>+
            >>>+>>>
            >>>+>>+>
            >>>+>>++>
            >>>+>>>++
            >>>+>>>++
            >>>+>>++>
            >>>+<<<
            <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                                                x       y       0       0               0           y//25       0           0       0       0               0           x//25       * 0
            [
                <
                <<[>+>+<<-]
                >>[<<+>>-]
                <<<[>>>+<<<-]
                >>>[>-]> [< <<<+ >>[-] > >->]<+<
                <[>- [>-]> [< <<<+ >>[-]+ > >->]<+< <-]
                >>[-]<[-]<<[-]>>>>>>>>>
            ]

            <<<<<<<<<<
            [<<<<<<[<<<<<<[<<<<<<[<+>-]>>>>>>-]>>>>>>-]>>>>>>-]
            <<<<<<[-]<<<<<<[-]<<<<<<[-]
            <<<<<<
            [<<<<<<[<<<<<<[<<<<<<[<+>-]>>>>>>-]>>>>>>-]>>>>>>-]
            <<<<<<[-]<<<<<<[-]<<<<<<[-]
            >>>>>> >>>>>> >>>>>> >>>>>
            [-<<<<<< <<<<<< <<<<<< <<<<<< + >>>>>> >>>>>> >>>>>> >>>>>>]
            <<<<<< <<<<<< <<<<<< <<<<<<
            [<<<<<<<<<<<<<+>>>>>>>>>>>>>[-]]
            <[-]<<<<<<[-]>
        ]
        >
        [
            -
            ### p == 1 ###                      x       y       0       v1              v0          y//25       0           * 0     0       u1              u0          x//25       0
            <<
            [
                [->+<]
                >-<
            ]
            >
            [
                <<[-]<[->+<]
                >->>[-]
            ]                                   x       y       0       ~               v           0           * 0         0       0       u1              u0          x//25       0
            >>>>>
            [
                [->+<]
                >-<
            ]
            >
            [
                <<[-]<[->+<]-
                >->>[-]
            ]                                   x       y       0       ~               v           0           0           0       0       ~               u           0           * 0
            >>>+>>>
            >++[<++>+++++++]
            >>+<<<
            <<<<<<<+<
            [->+<<<<<++>>>> >>>>>>>+<<<<<<<]
            <[-]+<<<<+<
            [->+>>>>>>>++>>>>>+<<<<<<<<<<<<<]   x       y       0       ~               * 0         v           2u_1        0       0       ~               0           u           2v_1
            >>>>>

            [
                <
                <<[>+>+<<-]
                >>[<<+>>-]
                <<<[>>>+<<<-]
                >>>[>-]> [< <<<+ >>[-] > >->]<+<
                <[>- [>-]> [< <<<+ >>[-]+ > >->]<+< <-]
                >>[-]<[-]<<[-]>>>>>>>>>
            ]                                   
            <<<<<<<<<<                          x       y       0       ~               0           v~2u_1      0           0       0       0               0           u~2v_1      0
            [-<<<<<<+>>>>>>]<<<<<<
            [-<<<<<<+>>>>>>]<<<<<<
            <+++>
            [-<->]
            <[<<<<<+>>>>>[-]]
            <[-]>>>
        ]
        <
    ]
    >
    [
        -
        ### p = 0 ###
                                                x       y       0       v1              v0          y//25       p           * 0     0       u1              u0          x//25

        <<<[->>>>>+>+<<<<<<]                    x       y       0       v1              * 0         y//25       p           0       0       v0|u1           v0|u0       x//25
        >>>>>
        [->>>>>>>>>>>>>>>+>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<]               x       y       0       v1              0           y//25       p           0       0       * 0             v0|u0       x//25       x y t0 t1 _ _  x y t0 t1 _ _  x y t0 t1 _ _ x y t0 t1 _ _
        >[->>+>>>>>>>+<<<<<<<<<]                                        x       y       0       v1              0           y//25       p           0       0       0               *0          x//25       x y t0 t1 _ _  x y t0 t1 _ _  x y t0 t1 _ _ x y t0 t1 _ _
        >>>>++++[<++++>-]<+
        >>>+
        >+++++[>++++++<-]>
        >>>>+
        >>>>+++[<++++++>-]<+
        >>>+
        >+++++[>++++++<-]>+
        >>>>+
        [
            <
            <<[>+>+<<-]
            >>[<<+>>-]
            <<<[>>>+<<<-]
            >>>[>-]> [< <<<+ >>[-] > >->]<+<
            <[>- [>-]> [< <<<+ >>[-]+ > >->]<+< <-]
            >>[-]<[-]<<[-]<<<
        ]
        >>
        >>>>>>
        >>>>>>
        >>>>>>
        [-<<<<<<+>>>>>>]<<<<<<
        [-<<<<<<+>>>>>>]<<<<<<
        [-<<<<<<+>>>>>>]<<<<<<
        [-<<<<<<<<<<<<<+>>>>>>>>>>>>>[-]]                               x       y       0       v1              0           y//25       p           0       0       0               0           x//25       *0

        <[-]<<<<<<[-]<<[-]
        >>>
    ]

    <
    <<<<<
    <<<
    +[>+<+++++]>---.[-]

    >
    -                                           decrement x
    [->>+<<]>>>+<
    [
        >-<
        [-<<+>>]
    ]
    >
    [                                           if x is 0
        <<-                                     decrement y
        >++[<<+>>+++++]<<--                     set x to 100
        >>>[-]
        ++++++++++.                             output '/n'
        [-]
    ]
    <<
]

Python, 294 273 239 188 179 170 159 154 байта

Вот 158-байтовая версия:

I=100*[100*"0"]
for j in range(7500):i=j%25;j/=100;I=map(list,zip(*I[::-1]));I[i][j]=`+[abs(i%12-6)+5<j/2,j>i/2+24,2*i>72-j][j/25]`
for r in I:print"".join(r)

Это только программа на Python 2, но я использую тождество для "Python" (то есть, в OP). Разница должна быть 78 бит.

Выбрасывая точность за дверь, вот 154-байтовая версия:

I=100*[100*"0"]
for j in range(7425):i=j%25;j/=99;I=map(list,zip(*I[::-1]));I[i][j]=`+[~i%12<j/2>i%12,j>i/2+24,2*i>72-j][j/25]`
for r in I:print"".join(r)

который имеет разность 224 бит вместо.

(-4 байта благодаря Стефану Похманну)

объяснение

Вот альтернативная расширенная версия:

I=100*[100*"0"]

for _ in range(4):
 I=map(list,zip(*I[::-1]))

 for i in range(25):
  for j in range(75):
   I[i][j]=`+[abs(i%12-6)+5<j/2,j>i/2+24,2*i>72-j][j/25]`

for r in I:print"".join(r)

Для этой версии мы рассматриваем тождество как сетку шаблонов 4х4. Мы начинаем с сетки 100x100, равной 0, и делаем следующее четыре раза:

• Заполните первые три шаблона в строке 1 шаблона, используя неравенства
• Поверните все это по часовой стрелке

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

C 255 245 237 234 байта

Идентичность Си действительно симметрична.

Гольф: (добавлены новые строки для «читабельности»)

d[100],j,y,i,o[100];
main(c){
for(;i<100;++i){j=i>12?25-i:i,y=j<7?-1u>>63-j:127,d[i]=y<<12-j|y<<(j<7?12:j+6),
o[i]=i<25?(-1<<12|-1u>>76-i|-(i<13))<<25|d[i]:d[i-25]<<25;
for(c=50;c--+50;putchar(o[i<50?i:99-i]>>(c<0?~c:c)&1|48));puts("");}}

Это сохраняет половину каждой строки в верхней половине в 64-битное целое число, а затем печатает младшие 50 битов соответствующего целого числа в двоичном виде дважды, при этом вторая печать переворачивается.

64-разрядные Интсы необходимы для этого , чтобы работать (если система не использует 64-битный Интс, то вы можете добавить longили long longдо того d[50], и (long)или (long long)после o[i-1]=i<26?).

Развернулся и прокомментировал:

int diamond[25], j, y, i, out[50];
main(c){
    // generate diamond pattern
    for(i = 0; i < 25; ++i){
        j = i > 12 ? 25 - i : i;
        y = j < 7 ? -1u >> 63 - j : 127;
        diamond[i] = y << 12 - j | y << (j < 7 ? 12 : j + 6);
    }

    // generate top half outputs in reverse order
    for(i = 0; i < 50; ++i){
        if(i < 25)
            // i < 50: out[i] = [diamond] [0 ... x25]
            out[i] = diamond[i] << 25;
        else
            // i < 25: out[i] = [1...x25] [diamond]
            out[i] = (int)(-1 << 12 | -1u >> 27 + i | -(i > 36)) << 25 | diamond[i - 25];
        // i >= 50: use out[100 - i]
    }
    // print rows
    for(i = 50; i-- + 50; putchar('\n')){
        // print last 50 bits of the correct 64-bit integer, then print it reversed
        for(c = 50; c-- + 50; putchar(out[i < 0 ? -i - 1 : i] >> (c < 0 ? -c - 1 : c) & 1 | '0'));
    }
}

Выход имеет 291 ошибку.

Спасибо асе за советы по использованию puts("")

C, 224 206 200 176 байтов, 243 ошибки

char b[101],i,j,k=1,s,a;main(){for(;i+1;i+=k=i-50?puts(b),k:-1)for(j=0;j<50;j++)s=i-j,a=i+j-49|1,b[j]=b[99-j]=(i/25+j/25?14/a&&s/12&&38/s&&a/6|19/s+s/31:i<13||j<13^i+j>36)+48;}

Копировать:

Приведенный выше код выводит двоичный файл, который соответствует этому изображению, с 243 ошибками:

Из того, что я могу сказать, я использую довольно другой метод из решения es1024. Этот метод, вероятно, может быть усовершенствован, так что я немного задержусь на объяснениях, но здесь он в своем великолепном великолепии:

char b[101],i,j,k=1,s,a;
main(){
    for(;i+1;i+=k=i-50?puts(b),k:-1)
        for(j=0;j<50;j++)
            s=i-j,
            a=i+j-49|1,
            b[j]=b[99-j]=(i/25+j/25?14/a&&s/12&&38/s&&a/6|19/s+s/31:i<13||j<13^i+j>36)+48;
}

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

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

Забавный факт, это не только самая короткая версия, которую я придумал, но и gcc не выдает предупреждений !

gs2 : 72 байта, 200 ошибок

Пока еще не играл в гольф, не уверен, что смогу. Мнемоника:

# Square
abs both1 biggest 6 <= b5
# Left triangle
{ over abs both1 + 13 <= swap 1 < and }
# Diagonal triangle
{ >= @0 double 10 + @4 <= or }
              # ^ 12 gives way more accuracy here but pushing 10 saves a byte.

# Plot each of these
3 make-array
{ pop-a -12 13 crange dup cartesian-product
  dump swap push-a eval show m5
  25 / } map

# Make corner
dump
reverse zip @1 rot zip +
unlines lines

dup reverse transpose zip
dup reverse show reverse m2
+ unlines

Сама программа:

23 f8 39 16 75 e4 08 45 23 f8 30 01 0d 75 42 11
70 35 09 08 73 a0 2a 1a 30 a4 75 36 09 13 0e 08
cc 02 f4 ff 01 0d 4f 40 83 0e 42 d0 20 52 ec 01
19 33 09 34 0e 20 b0 a1 43 b0 30 2b 2a 40 20 9a
b0 40 20 52 20 e9 30 2b

Z80, 194 байта, 0 ошибок

Z80, 178 байт, 80 ошибок

Ошибки подсвечиваются зеленым.

Поскольку это процессор старой школы, я использовал соглашения старой школы. Я использовал & 8000 для шестнадцатеричных значений вместо более привычного 0x8000, и я решил завершить каждую строку шаблона с "\ r" вместо "\ n".

Исходный код закодирован в HEX

         0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
        -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
&8000   69 31 18 00 DB 42 81 E7 21 00 40 11 04 80 0E 04
&8010   06 19 D5 1A F5 C5 E6 03 5F 1A 32 20 80 06 19 18
&8020   00 36 31 23 10 F9 C1 F1 E6 FC 0F 0F 20 E6 36 0D
&8030   23 D1 10 DE 13 0D 20 D8 C9 3E 1A 90 58 C1 C5 D5
&8040   58 47 7B 87 FE 1A 38 02 D6 19 5F 80 FE 1B 28 34
&8050   18 0E 78 C1 C5 5F D5 87 FE 1A 38 02 D6 19 5F 80
&8060   FE 1A 28 20 30 06 90 90 30 1A 18 14 90 90 38 14
&8070   FE 01 38 10 20 0A 7B D6 05 30 FC C6 05 0F 38 04
&8080   36 30 18 02 36 31 D1 43 18 99 58 C1 C5 78 83 FE
&8090   0D 38 26 FE 27 30 22 93 93 30 04 FE F3 30 04 FE
&80A0   0E 30 16 83 83 FE 15 38 14 FE 20 30 10 93 93 30
&80B0   04 FE FB 30 04 FE 06 30 04 36 30 18 02 36 31 43
&80C0   18 C6

Исходный код объяснил

Поскольку Z80 является процессором, у него нет собственного стандартного выхода. Таким образом, я просто записывал каждый символ непосредственно в память, начиная с & 4000, а затем MEMDUMP выдавал 10 100 байт, чтобы проверить правильный шаблон.

Z80 имеет следующие регистры:

+-------+
| B / C |  8-bit general purpose B & C or 16-bit general purpose BC
+-------+
| D / E |  8-bit general purpose D & E or 16-bit general purpose DE
+-------+
| H / L |  8-bit general purpose H & L or 16-bit specialised HL
+-------+
| A | F |  8-bit accumulator A (main working register) & Flag register F
+-------+

Специальный регистр флагов содержит следующие флаги: SZ-H-VNC. S ign, Z ero, H alf-carry, O v erflow (также используется как P arity ), N egative и C arry. Позиции, помеченные -как, не используются. Н ALF-кэрри и N egative флаги используются только внутри ЦП. S ign и O v erflow / P arity используют дополнительные байты, поэтому я использую только Z ero и C arry, которые устанавливаются или сбрасываются после каждого вычисления, но не при перемещении значений.

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

• LD л оа д а м значение в регистр или адрес, например , LD C, 4это C = 4. Значение может быть прямым (один или два дополнительных байта для 8-битного или 16-битного значения соответственно) или может быть скопировано из другого регистра. Значение (HL)означает скопировать на или с адреса, на который указывает HL.
• PUSHи POP толчок (Сохранить в) и поп (восстановить из) стек, который может хранить только 16-битные значения. Таким образом, AFрассматривается как один 16-битный регистр, хотя никакие другие инструкции не используют его таким образом.
• ANDпоразрядно и . Z80 не имеет инструкций логической логики, но имеет логические флаги.
• JR J UMP г elative используя один байт Подписанные смещение. При этом используется один байт меньше , чем абсолютное J ит р JP , но имеет меньшее количество условий , которые могут быть проверены на.
• INCи DEC вкл rement и декабрем rement 8 и 16 битовых регистров.
• DJNZ д ecrement и J UMP , если п на- г эро. Это точно так же, как DEC B; JR NZ, ##;в одном меньшем байте, но доступно только для Bрегистра.
• RET ретр урны к месту вызова. Это может иметь условия на это.
• ADDи SUB добавить к и к югу тракта от любого бита 8 Aрегистра или бита 16 HLрегистра.
• CP c om p вычитает значение из Aрегистра, устанавливает соответствующие флаги, но отбрасывает результат, оставляя Aбез изменений.
• RRCA г Повернуть по г РАВ с ircular в ccumulator. Поворачивает все биты Aодин раз вправо, копируя бит 0 в бит 7. Он также копирует бит 0 во Cфлаг Carry ( ), не путая с Cрегистром.

Каждый шаблон Identicon можно разбить следующим образом:

0451
4885
6887
2673

где 0-3 - углы, повернутые соответствующим образом, 4-7 - плитки краев, повернутые соответствующим образом, и 8 - центральная плитка, которая (насколько я могу судить) всегда симметрична по вращению.

К счастью, Z80 Identicon можно упростить до:

3123
1002
2001
3213

Я поставил «0» в центре, чтобы я мог эффективно проверить состояние конца. На самом деле, для игры в гольф имело смысл делать почти все задом наперед!

:Offsetsэто блок из четырех байтовых значений, которые я использую в качестве смещения для шаблона для каждого блока. Программа решает, какой блок запустить, затем меняет себя, чтобы перейти к нужному коду. Как ни странно, это, кажется, использует меньше байтов, чем при прямой проверке!

:DATA(также называемый магическими данными в комментариях!) - это закодированный порядок, в котором необходимо визуализировать блоки. Есть 16 значений, обычно требующих 16 байтов, но поскольку каждое значение имеет длину всего 2 бита, я смог поместить 4 в один байт, сэкономив 12 байтов! Код для хранения, восстановления и декодирования этих значений составляет 6 байтов. Кроме того, избегая использования числа 0 в старших 2 битах, я смог удвоить его в качестве счетчика, сэкономив не менее 3 байтов (2 для инициализации, 1 для уменьшения)! Всего сохранено байтов: 12 - 6 + 3 = 9.

Для корректной работы данные смещения должны храниться в месте, оканчивающемся на гекс 00. Я выбрал & 8000, так как это было похоже на удачное расположение. Это означает, что программа начинается с & 8008. По совпадению, Intel выпустила ранний процессор под названием 8008, который можно считать дедушкой Z80! Intel также выпустила 8080, на которой Zilog основал свой Z80, полностью совместимый с. У Z80 есть ряд расширенных инструкций, которых нет у 8080. Я избегал использования этих расширенных инструкций, так как каждая из них имеет однобайтовый префикс, что означает, что эта программа также выдаст те же результаты на 8080!

Так как шаблон для Block-3 - это все «1», я включил его в основной цикл, поэтому он имеет смещение 00. Это экономит 2 байта, не возвращаясь из Block-3! К счастью, мне удалось разместить начальные местоположения для всех четырех блоков менее чем в 128 байтов. Это хорошо, потому что диапазон относительного скачка составляет от -128 до 127 от текущей позиции, рассчитанной после считывания байта смещения. Т.е. JRинструкция читает два байта, затем выполняет вычисление. JR 00ничего не делает. JR 01пропускает один байт. JR FFвозвращается на один байт, в результате чего следующая инструкция будет смещением JRтолько что выполненного, что очень плохо, потому что инструкция FFне для слабонервных! JR FE возвращается на два байта, вызывая бесконечный цикл, и т. д. Однако, отскок назад от Block-0 слишком далек (меньше -128), поэтому я просто возвращаюсь к предыдущему блоку, который затем снова переходит!

#### DATA ####
:Offsets (&8000)                        # It is important that this address is of the form &XX00
69 (#Block-0, &808A)
31 (#Block-1, &8052)
18 (#Block-2, &8039)
00 (#Block-3, &8021)
:DATA (&8004)
DB 42 81 E7                             # Magic data

#### CODE ####
:MAIN (&8008)
21 00 40 ..   LD    HL, &4000           # Start address of pattern output
11 04 80 ..   LD    DE, #DATA (&8004)   # Load DE with data address
0E 04 .. ..   LD    C, 4                # Load C with 4 (outer loop)
:OUTY (&8010)
06 19 .. ..     LD    B, 25               # Load B with 25 (outer loop)
:INRY (&8012)
D5 .. .. ..     ! PUSH  DE                  # DE -> Stack, Stack = "DE" (save block pattern address)
1A .. .. ..     ! LD    A, (DE)             # Get block mask (ppoonnmm)
:OUTX (&8014)
F5 .. .. ..         PUSH  AF                  # AF -> Stack, Stack = "DE, AF" (save block mask)
C5 .. .. ..         PUSH  BC                  # BC -> Stack, Stack = "DE, AF, BC" (save outer loop variables)
E6 03 .. ..         AND   &03                 # Get block number (0, 1, 2 or 3). A = 000000XX where each X can be 0 or 1
5F .. .. ..         LD    E, A                # Copy A to E. DE now contains &800X where X is one of (0, 1, 2 or 3)
1A .. .. ..         LD    A, (DE)             # Copy the byte at address pointed to by DE to A
32 20 80 ..         LD    (&8020!), A         # Alter JR instruction in innermost loop with offset of current pattern block
06 19 .. ..         LD    B, 25               # Load B with 25 (inner loop)
:INRX (&801F)
18 00 .. ..           JR    00                  # (Relative) Jump to overridden pattern block location (Mock CALL). The second byte of this instruction is at address &8020 (see instruction two above)
:Block-3 (&8021 + &00 = &8021)
36 31 .. ..           LD    (HL), 49            # Write ASCII "1" to address in HL
:RESUME (&8023)
23 .. .. ..           INC   HL                  # Move pointer to next (8 bit) memory location
10 F9 .. ..           DJNZ  #INRX (&801F)       # Repeat B times (end of inner B loop)
&8026
C1 .. .. ..         POP   BC                  # Stack -> BC, Stack = "DE, AF"
F1 .. .. ..         POP   AF                  # Stack -> AF, Stack = "DE"
E6 FC .. ..         AND   &FC                 # Zero out current block number: A = XXXXXX00 where each X can be 0 or 1
0F .. .. ..         RRCA                      # Rotate Right A. (rotate bits to the right by one place. Bit 0 is copied into bit 7)
0F .. .. ..         RRCA                      # Rotate Right A again. The next pattern block is now in bits 1 & 0.
20 E6 .. ..         JR    NZ, #OUTX (&8014)   # If A is Non-Zero (Relative) Jump (Repeat until pattern is empty)
&802E
36 0D .. ..       LD (HL), 0D               # Write "\r"
23 .. .. ..       INC HL                    # Move pointer
D1 .. .. ..       POP DE                    # Stack -> DE, Stack = ""
10 DE .. ..       DJNZ  #INRY (&8012)       # Repeat B times (end of outer B loop)
&8034
13 .. .. ..     INC   DE                  # Move DE to next pattern of blocks
0D .. .. ..     DEC   C                   # Decrement C (end of outer C loop)
20 D8 .. ..     JR    NZ, #OUTY (&8010)   # If C is Non-Zero (Relative) Jump (Repeat C times)
&8038
C9 .. .. ..   RET                       # Return

:Block-2 (&8039)
3E 1A .. ..   LD    A, 26               # A = 26
90 .. .. ..   SUB   A, B                # A = 26 - x
58 .. .. ..   LD    E, B                # Copy B to E, E = x
C1 .. .. ..   POP   BC                  # Restore B (& C), B = y
C5 .. .. ..   PUSH  BC                  # Save B (& C) again
D5 .. .. ..   PUSH  DE                  # Save (D &) E
58 .. .. ..   LD    E, B                # E = y
47 .. .. ..   LD    B, A                # B = 26 - x
7B .. .. ..   LD    A, E                # A = y
87 .. .. ..   ADD   A, A                # A = 2 * y
FE 1A .. ..   CP    26                  # A - 26 (compare)
38 02 .. ..   JR    C, 2                # if Carry, skip next instruction
D6 19 .. ..     SUB   A, 25               # A = 2 * y % 25
5F .. .. ..   LD    E, A                # Copy A to E, E = 2 * y % 25, B = 26 - x
80 .. .. ..   ADD   A, B                # A = 2 * y % 25 + 26 - x
:Extra-1s
FE 1B .. ..   CP    27                  # A - 27 (compare)
28 34 .. ..   JR    Z, #Bl1-1           # if Zero, (Relative) Jump to Block-1 "1"
:End-Extra-1s
18 0E .. ..   JR    #BL1a               # (Relative) Jump to Block-1a

:Block-1 (&8052)
78 .. .. ..   LD    A, B                # A = x
C1 .. .. ..   POP   BC                  # Restore B (& C), B = y
C5 .. .. ..   PUSH  BC                  # Save B (& C) again
5F .. .. ..   LD    E, A                # Save A (copy of B) in E, E = x
D5 .. .. ..   PUSH  DE                  # Save (D &) E
87 .. .. ..   ADD   A, A                # A = 2 * x
FE 1A .. ..   CP    26                  # A - 26 (compare)
38 02 .. ..   JR    C, 2                # if Carry, skip next instruction
D6 19 .. ..     SUB   A, 25             # A = 2 * x % 25
5F .. .. ..   LD    E, A                # Copy A to E, E = 2 * x % 25, B = y
80 .. .. ..   ADD   A, B                # A = 2 * x % 25 + y
:BL1a                                   # From this point on until character written to memory, swap x and y in comments if from Block-2
FE 1A .. ..   CP    26                  # A - 26 (compare)
28 20 .. ..   JR    Z, #Bl1-1           # if Zero, (Relative) Jump to Block-1 "1"
30 06 .. ..   JR    NC, #BL1b           # if Non-Carry, (Relative) Jump to Block-1b
90 .. .. ..   SUB   A, B                # A = 2 * x % 25
90 .. .. ..   SUB   A, B                # A = 2 * x % 25 - y
30 1A .. ..   JR    NC, #Bl1-1          # if Non-Carry, (Relative) Jump to Block-1 "1"
18 14 .. ..   JR    #Bl1-0              # (Relative) Jump to Block-1 "0"
:BL1b
90 .. .. ..   SUB   A, B                # A = 2 * x % 25
90 .. .. ..   SUB   A, B                # A = 2 * x % 25 - y
38 14 .. ..   JR    C, #Bl1-1           # if Carry, (Relative) Jump to Block-1 "1"
FE 01 .. ..   CP    1                   # A - 1 (compare)
38 10 .. ..   JR    C, #Bl1-1           # if Carry, (Relative) Jump to Block-1 "1"
:Jaggies
20 0A .. ..   JR    NZ, #Bl1-0          # if Non-Zero, (Relative) Jump to Block-1 "0"
7B .. .. ..   LD    A, E                # A = 2 * x % 25
:MOD5
D6 05 .. ..   SUB   A, 5                # A = A - 5
30 FC .. ..   JR    NC, MOD5            # if Non-Carry (A >= 0), (Relative) Jump to #MOD5
C6 05 .. ..   ADD   5                   # A = 2 * x % 5. A was [-5,-1], needed to add 5 for positive mod 5
0F .. .. ..   RRCA                      # Rotate Right A. Bit 0 is copied into Carry flag
38 04 .. ..   JR    C, #Bl1-1           # if Carry, (Relative) Jump to Block-1 "1"
:End-Jaggies
36 30 .. ..   LD    (HL), 0             # Write "0"
18 02 .. ..   JR    #B1-end             # Skip next instruction
36 31 .. ..   LD    (HL), 1             # Write "1"
:B1-end
D1 .. .. ..   POP   DE                  # Restore (D &) E, E = x
43 .. .. ..   LD    B, E                # Restore B from E
18 99 .. ..   JR    #RESUME (&8023)     # (Relative) Jump back into inner loop

:Block-0 (&808A)
58 .. .. ..   LD    E, B                # Copy B to E, E = x
C1 .. .. ..   POP   BC                  # Restore B (& C), B = y
C5 .. .. ..   PUSH  BC                  # Save B (& C) again
78 .. .. ..   LD    A, B                # A = y
83 .. .. ..   ADD   A, E                # A = y + x
FE 0D .. ..   CP    13                  # A - 13 (compare)
38 26 .. ..   JR    C, #Bl0-0           # if Carry, (Relative) Jump to Block-0 "0"
FE 27 .. ..   CP    39                  # A - 39 (compare)
30 22 .. ..   JR    NC, #Bl0-0          # if Non-Carry, (Relative) Jump to Block-0 "0"
93 .. .. ..   SUB   A, E                # A = y
93 .. .. ..   SUB   A, E                # A = y - x
30 04 .. ..   JR    NC, 4               # if Non-Carry (A >= 0), skip next two instructions
FE F3 .. ..   CP    -13                 # A - -13 (compare)
30 04 .. ..   JR    NC, 4               # if Non-Carry, skip next two instructions
FE 0E .. ..   CP    14                  # A - 14 (compare)
30 16 .. ..   JR    NC, #Bl0-0          # if Non-Carry, (Relative) Jump to Block-0 "0"
83 .. .. ..   ADD   A, E                # A = y
83 .. .. ..   ADD   A, E                # A = y + x
FE 15 .. ..   CP    21                  # A - 21 (compare)
38 14 .. ..   JR    C, #Bl0-1           # if Carry, (Relative) Jump to Block-0 "1"
FE 20 .. ..   CP    32                  # A - 32 (compare)
30 10 .. ..   JR    NC, #Bl0-1          # if Non-Carry, (Relative) Jump to Block-0 "1"
93 .. .. ..   SUB   A, E                # A = y
93 .. .. ..   SUB   A, E                # A = y - x
30 04 .. ..   JR    NC, 4               # if Non-Carry, skip next two instructions
FE FB .. ..   CP    -5                  # A - -5 (compare)
30 04 .. ..   JR    NC, #Bl0-0          # if Non-Carry, (Relative) Jump to Block-0 "0"
FE 06 .. ..   CP    6                   # A - 6
30 04 .. ..   JR    NC, #Bl0-1          # if Non-Carry, (Relative) Jump to Block-0 "1"
:Bl0-0 (&80B9)
36 30 .. ..   LD    (HL), 30            # Write "0"
18 02 .. ..   JR    2                   # Skip next instruction
:Bl0-1 (&80BD)
36 31 .. ..   LD    (HL), 31            # Write "1"
43 .. .. ..   LD    B, E                # Restore B from E
18 C6 .. ..   JR    -39!=&8041          # (Relative) Jump back into inner loop
&80C2

Конечно, есть место для игры в гольф немного дальше. Моя первая полностью рабочая версия была 239 байт. 4 байта можно сохранить, удалив раздел «Extra-1s» за счет 48 ошибок, а еще 12 байтов можно сохранить, удалив раздел «Jaggies» за счет 32 ошибок.

Haskell, 201 190 байтов, 44 ошибки

main=mapM_ putStrLn$h++map v(v h)
h=[[b$p i j|p<-q,j<-x]|q<-[[a,r,d,a],[r,w,w,d]],i<-x]
a i j=abs i+abs j>13
d i j=i>0&&abs j+i<12
r=flip d
w _ _=1<3
v=reverse
x=[-12..12]
b x|x='0'|1<3='1'

Использует матрицу функций для каждой формы: a(ромб); u, d, l, r(Треугольники , обращенные друг к направлению) и w(белый), и применяет к каждому 25x25 сетке с координатами [-12..12]. Формы ромба и треугольника вычисляются с использованием нормы Манхэттена, аналогично октавному решению Flawr .

На самом деле только генерировать верхнюю половину, которая нуждается только a, w, d, и r. Произведите нижнюю половину через зеркальное отображение ( map reverse . reverse).

C # - 423 байта, 237 ошибок

Просто накапливаются неравенства. Большинство ошибок происходит из-за того, что я подставил t (= 25) в местах, которые должны использовать 24.

using System;class A{static void Main(string[]a){for(int t=25,k,l,i,j=0;j<100;j++){for(i=0;i<100;i++){Console.Write((((i>12&&i<87&&j>12&&j<87)||Math.Abs(i-49.5)+Math.Abs(j-49.5)<63)&&!((i>36&&i<63)||(j>36&&j<63)||(i>11&&i<88&&j>t&&j<75)||(j>11&&j<88&&i>t&&i<75)))||(i>t&&i<75&&j>t&&j<75&&(((k=i%t)*2<(l=j%t)&&k*-2+t>l)||(l*2<k&&l*-2+t>k)||((k=t-k)*2<(l=t-l)&&k*-2+t>l)||(l*2<k&&l*-2+t>k)))?"0":"1");}Console.WriteLine();}}}

Вот попытка визуализировать, как это работает:

Более читаемый код:

using System;
class A
{
    static void Main(string[]a)
    {
        for(int t=25,k,l,i,j=0;j<100;j++){for(i=0;i<100;i++){
        Console.Write(
        (((i>12&&i<87&&j>12&&j<87) //big square
        ||Math.Abs(i-49.5)+Math.Abs(j-49.5)<63) //big diamond
        &&!((i>36&&i<63)||(j>36&&j<63)||(i>11&&i<88&&j>t&&j<75)||(j>11&&j<88&&i>t&&i<75))) //subtract four central rects
        ||(i>t&&i<75&&j>t&&j<75 //add the central square
        &&(((k=i%t)*2<(l=j%t)&&k*-2+t>l) //stars: subtract left sides
        ||(l*2<k&&l*-2+t>k) //stars: subtract top sides
        ||((k=t-k)*2<(l=t-l)&&k*-2+t>l) //stars: subtract right sides
        ||(l*2<k&&l*-2+t>k)) //stars: subtract bottom sides
        )
        ?"0":"1");
        }Console.WriteLine();}
    }
}

Вероятно, смог бы немного поиграть в паренов и логических операторов, но я получаю воспоминания о Лиспе.

Perl 186 184 181 151 147 байт, 0 ошибок

for$y(@i=0..99){$l=24-($k=$_%25-$y%25)-$y%25*2,$c=!($_/25%3)+!($y/25%3),print$c-2?abs$k>5|abs$l>5&&$c:$k<0^$l>0^$_>49^$y>49|!$k|!$l,'
'x/99/ for@i}

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

JavaScript (ES6), 239 байт, 99 разных

f=(c,n=50)=>Array(n).fill().map(c)
a=f((e,y)=>f((_,x)=>+((x+y>48&(x+y<68|x+y>80|x<y-6|x>y+6))|x>y-13&x<13&y>11)))
f((e,i)=>f((g,j)=>a[i].push(a[49-j][i])))
f((e,i)=>a.push(f((g,j)=>a[49-i][99-j],100)))
alert(a.map(e=>e.join('')).join(`
`))

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

Текст был просто JavaScript. Это довольно простой идентификатор:

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

f=function(c,n){
  n=n||50
  for(arr=[];n>0;n--)arr.push(undefined)
  return arr.map(c)
}
a=f(function(e,y){
  return f(function(_,x){
    return +((x+y>48&(x+y<68|x+y>80|x<y-6|x>y+6))|x>y-13&x<13&y>11)
  })
})
f(function(e,i){
  f(function(g,j){
    a[i].push(a[49-j][i])
  })
})
f(function(e,i){
  a.push(f(function(g,j){
    return a[49-i][99-j]
  },100))
})
document.getElementById('p').innerHTML=a.map(function(e){return e.join('')}).join('\n')

<style>pre{font-size:12px;line-height:100%}</style><pre id="p"></pre>

Python 3, 975 963 байта

Z,L,J=zip,list,''.join;y=[134217727,520093695,2130706431,8573157375,34334572543,137413787647,274848546815,68690116607,17148411903,4262461439,1041235967,235405311,34078719,235405311,1040449535,4261675007,17146445823,68686053375,274844418047,137405431807,34326216703,8556396543,2113945599,503332863,100671487,1125899873288192,562949919866880,562949919866880,562949919866880,281474943156224,281474943156224,140737454800896,140737454800896,70368710623232,35184338534400,35184338534400,17592152489984,17592152489984,17592152489984,8796059467776,8796059467776,4398012956672,4398012956672,2198989701120,1099478073344,1099478073344,549722259456,549722259456,549722259456,274844352512];C=[L(n) for n in map(lambda j:'0'*(50-len(j[2:]))+j[2:],[bin(i) for i in y])];U=L(Z(*C[::-1]));Q=L(Z(*U[::-1]));Y=L(Z(*Q[::-1]));Y=[J(i) for i in Y];Q=[J(i) for i in Q];U=[J(i) for i in U];C=[J(i) for i in C];H=[i+j for i,j in Z(C,U)];R=[i+j for i,j in Z(Y,Q)];r='\n'.join(H+R);print(r)

Выводится строка размером "Python"975 байт с 30 ошибками.

Ибо "Python 3"я использовал

Z,L,J=zip,list,''.join;y=[206183596032,515427532800,1082364788736,2190466744320,4393785065472,8793979084800,17591145854976,35046429810176,69887472902016,139672235548640,279293098729464,558560492658686,1117108092018687,1121510446079998,560768075440120,280409723903968,140256217079680,70230801899008,35183331899392,17590072107008,8791831576576,4389489999872,2181876416512,1065183346688,481061502976,844424930131968,1055531162664960,1108307720798208,1121501860331520,1124800395214848,1125625028935680,1125831187369984,1125607849080832,1123971466558464,1117377618050560,1090990144356096,985437229547392,563224798298048,985437229547456,1090990144356224,1117377618050816,1123971466558976,1125607849081856,1125831187372032,1125625028935680,1124800395214848,1121501860331520,1108307720798208,1055531162664960,844424930131968];C=[L(n) for n in map(lambda j:'0'*(50-len(j[2:]))+j[2:],[bin(i) for i in y])];U=L(Z(*C[::-1]));Q=L(Z(*U[::-1]));Y=L(Z(*Q[::-1]));Y=[J(i) for i in Y];Q=[J(i) for i in Q];U=[J(i) for i in U];C=[J(i) for i in C];H=[i+j for i,j in Z(C,U)];R=[i+j for i,j in Z(Y,Q)];r='\n'.join(H+R);print(r)

Что увеличило бы его до 1104 байтов с 124 ошибками, но я думаю, что я буду придерживаться только, "Python"если не будет запрошено OP.

HTML - 223 210 193 191 байт, 0 ошибок

<!DOCTYPE html><title>A</title><script>D=document;M=Math.abs;for(y=0;b=y%75/25&3,y<100;D.write('<br>'),++y)for(x=0;a=x%75/25&3,x<100;++x)D.write(+!(a+b?a*b:M(x%25-12)+M(y%25-12)>13))</script>

100% действительный HTML. И HTML, и JavaScript довольно многословны, поэтому, несмотря на простоту идентификации, код все еще очень длинный.

PowerShell 2.0, 448 399 392 374 349 байт, 49 ошибок

это просто печать одной строки за раз, с некоторыми причудливыми мета-заменами / выражениями для игры в гольф

filter a{switch($_){1{"1"*13;"0"*12}2{"0"*12;"1"*13}3{"1"*25}4{"0"*25}6{"1"*$b;"0"*(25-2*$b);"1"*$b}7{$b--;"0"*$b;"1"*(25-2*$b);"0"*$b}}}$a='1164132c6417dd3317c26317116313164441d847717d3771163441162443d827737d27741624441132362c7236dd7233c27246113246';$x='$($a[$d++])';0..17|%{iex "`"0x$x..0x$x|%{```$b=```$_;```$($x|a;$x|a;$x|a;$x|a)-join''}`""}|iex

ungolfed:

filter a
{
    switch($_)
    {
        1 { "1"*13; "0"*12 }
        2 { "0"*12; "1"*13 }
        3 { "1"*25 }
        4 { "0"*25 }
        6 {       "1"*$b; "0"*(25-2*$b); "1"*$b }
        7 { $b--; "0"*$b; "1"*(25-2*$b); "0"*$b }
    }
}
$a='1164132c6417dd3317c26317116313164441d847717d3771163441162443d827737d27741624441132362c7236dd7233c27246113246';
$x='$($a[$d++])';
0..17|%{iex "`"0x$x..0x$x|%{```$b=```$_;```$($x|a;$x|a;$x|a;$x|a)-join''}`""}|iex

это то, что в конечном итоге получает iex:

0x1..0x1|%{$b=$_;$(6|a;4|a;1|a;3|a)-join''}
0x2..0xc|%{$b=$_;$(6|a;4|a;1|a;7|a)-join''}
0xd..0xd|%{$b=$_;$(3|a;3|a;1|a;7|a)-join''}
0xc..0x2|%{$b=$_;$(6|a;3|a;1|a;7|a)-join''}
0x1..0x1|%{$b=$_;$(6|a;3|a;1|a;3|a)-join''}
0x1..0x6|%{$b=$_;$(4|a;4|a;4|a;1|a)-join''}
0xd..0x8|%{$b=$_;$(4|a;7|a;7|a;1|a)-join''}
0x7..0xd|%{$b=$_;$(3|a;7|a;7|a;1|a)-join''}
0x1..0x6|%{$b=$_;$(3|a;4|a;4|a;1|a)-join''}
0x1..0x6|%{$b=$_;$(2|a;4|a;4|a;3|a)-join''}
0xd..0x8|%{$b=$_;$(2|a;7|a;7|a;3|a)-join''}
0x7..0xd|%{$b=$_;$(2|a;7|a;7|a;4|a)-join''}
0x1..0x6|%{$b=$_;$(2|a;4|a;4|a;4|a)-join''}
0x1..0x1|%{$b=$_;$(3|a;2|a;3|a;6|a)-join''}
0x2..0xc|%{$b=$_;$(7|a;2|a;3|a;6|a)-join''}
0xd..0xd|%{$b=$_;$(7|a;2|a;3|a;3|a)-join''}
0xc..0x2|%{$b=$_;$(7|a;2|a;4|a;6|a)-join''}
0x1..0x1|%{$b=$_;$(3|a;2|a;4|a;6|a)-join''}

и этот, который составляет 471 байт, 104 ошибки, который использует логику вращения

filter x($x,$y){1..$_|%{$t=49-$x;$x=$y;$y=$t};$x;$y}0..9999|%{$i=$_;$x=$i%100;$y=[math]::floor($i/100);if($x-ge50){$x-=50;if($y-ge50){$y-=50;$x,$y=2|x $x $y}else{$x,$y=1|x $x $y}}else{if($y-ge50){$y-=50;$x,$y=3|x $x $y}}if($x-ge25){$x-=25;if($y-ge25){$y-=25;[int]([math]::abs(13-$x)+[math]::abs(12-$y)-lt7)}else{[int]($y-gt11)}}else{if($y-ge25){$y-=25;[int]($y-gt11)}else{[int](($y-le$x-or$y-le24-$x)-and($y-ge$x-or$y-ge24-$x))}}}|%{if($i%100){$s+=$_}else{$s;$s="$_"}};$s

(относительно) негольфированный:

function rotate($x, $y, $n)
{
    1..$n|%{
        $t = 49-$x
        $x = $y
        $y = $t
    }
    $x
    $y
}

$s=''
0..9999|%{
    $i=$_
    $x = $i%100
    $y = [math]::floor($i/100)
    if ($x -ge 50)
    {
        $x-=50
        if ($y -ge 50)
        {
            # bottom right
            $y -= 50
            $x,$y = rotate $x $y 2
        }
        else
        {
            # top right
            $x,$y = rotate $x $y 1
        }
    }
    else {if ($y -ge 50)
    {
        # bottom left
        $y -= 50
        $x,$y = rotate $x $y 3
    }}

    if ($x -ge 25)
    {
        $x-=25
        if ($y -ge 25)
        {
            $y-=25
            # bottom right
            [int]([math]::abs(13-$x)+[math]::abs(12-$y) -lt 7)
        }
        else
        {
            # top right
            [int]($y -gt 11)
        }
    }
    else
    {
        if ($y -ge 25)
        {
            $y-=25
            # bottom left
            [int]($y -gt 11)
        }
        else
        {
            # top left
            [int](($y -le $x -or $y -le 24-$x) -and ($y -ge $x -or $y -ge 24-$x))
        }
    }
}|%{if ($i%100){$s+=$_}else{$s;$s="$_"}};$s

Python 2, 712 711 байт

Эта программа генерирует битовый массив для Python, используя кодирование длин серий и сохраняя серии в виде символов.

a=":>;$ 8'$;8' 6)$;6) 4+$;4+ 2-%:3, 0/%:1. /0&9.1 1.&9,3 3,'8*5 5*(7)6 7((7'8 9&)6$; ;$)O)$.$ 9&)O(%.% 7(*N(&,& 5**N'',' 3,+M'(*( 1.+M&)*) /0,L&*(* 0/-K%+(+ 2--K%,&, 4+.J$-&- 6).J$.$. 8'.V$ :%/ #<m $;j $;h $;f %:e %:c &9` &9^ '8\ (7[ (7Y )6V )6U )6U *5U *5U +4U +4U ,3U -2U -2U .1U .1U .1U /0U #<U0 #<U1 #<U1 #<U2 #<U2 #<U3 #<U3 #<U4 #<U4 #<U5 #<U5 #<U6 #<U6 #;V7 #9X7 #7Z8 #5\8 #3^9 #1`9 #/b: #-d: #+f; #)h; #'j #%l #b/% #c.' $.$V.) $.%-$K-+ %,&-$K-- %+(+%L,/ &*(+%L,0 &*))&M+. '(*)&M+, '(+''N** (&,&(N*( (&-%(O)& )$.%(O)$ <;$7(& <9&7(( <7(8'* <5*8', <3,9&. <1.9&0 </0:%/ <-2:%- <+4;$+ <)6;$) <'8@ <%:>".split()
for b in[[ord(c)-35for c in L]for L in a]:print''.join(c*n for c,n in zip('01'*8,b+[100-sum(b)]))

До авто-гольфиста это выглядело (очень похоже!) Примерно так:

ctext = ":>;$ 8'$;8' 6)$;6) 4+$;4+ 2-%:3, 0/%:1. /0&9.1 1.&9,3 3,'8*5 5*(7)6 7((7'8 9&)6$; ;$)O)$.$ 9&)O(%.% 7(*N(&,& 5**N'',' 3,+M'(*( 1.+M&)*) /0,L&*(* 0/-K%+(+ 2--K%,&, 4+.J$-&- 6).J$.$. 8'.V$ :%/ #<m $;j $;h $;f %:e %:c &9` &9^ '8\ (7[ (7Y )6V )6U )6U *5U *5U +4U +4U ,3U -2U -2U .1U .1U .1U /0U #<U0 #<U1 #<U1 #<U2 #<U2 #<U3 #<U3 #<U4 #<U4 #<U5 #<U5 #<U6 #<U6 #;V7 #9X7 #7Z8 #5\8 #3^9 #1`9 #/b: #-d: #+f; #)h; #'j #%l #b/% #c.' $.$V.) $.%-$K-+ %,&-$K-- %+(+%L,/ &*(+%L,0 &*))&M+. '(*)&M+, '(+''N** (&,&(N*( (&-%(O)& )$.%(O)$ <;$7(& <9&7(( <7(8'* <5*8', <3,9&. <1.9&0 </0:%/ <-2:%- <+4;$+ <)6;$) <'8@ <%:>".split()

for seq in [[ord(c)-35 for c in L] for L in ctext] :
    print ''.join(c*n for c,n in zip('01'*8, seq + [100 - sum(seq)]))

Этот метод RLE должен привести к нулевым ошибкам.

Массив идентификаторов для 'python' выглядит намного проще, но я подумал, что это будет обманом, если я воспользуюсь этим.

IDL, 472 байта, 290 ошибок

Тьфу. Это было бы намного короче, если бы я мог хранить функции как переменные или делать несколько замен строк одновременно и т. Д.

v=execute(repstr(repstr(repstr("n=25&a=12&b=24&r='IDLanROI'&x=rebin([0:b],n,n,/s)&y=#x,4)&w=.5*(x-1)&h=(y ge w@y lt b-.5*x)@~(y ge a-w@y lt a+w@x lt a)&i=reform((obj_new(r,[0,a,13,b,b,18,a,6,a,a,11,0],[a,0,0,11,a,a,6,a,18,b,b,a^,n,n)&j=reform(~((obj_new(r,[a,7,a,13,17,17,a],[7,a,17,17,13,a,7^),n,n)&print,string([[h,i,#i,1),#h,1)],[i,j,j,#i,1)],[#i,3),j,j,#i,2)],[#h,3),#i,3),#i,2),#h,2)]],'(100I1)')",'@',' and '),'#','rotate('),'^','])).containspoints(x,y)<1'))

1100000000000000000000000000000000000110000000000000000000000010000000000000111111111111111111111111
1111000000000000000000000000000000001111000000000000000000000111000000000000111111111111111111111111
1111110000000000000000000000000000011111100000000000000000001111100000000000011111111110111111111110
1111111100000000000000000000000000111111110000000000000000011111110000000000011111111110011111111110
1111111111000000000000000000000001111111111000000000000000111111111000000000001111111100011111111100
1111111111110000000000000000000011111111111100000000000001111111111100000000001111111100001111111100
1111111111111100000000000000000111111111111110000000000011111111111110000000000111111000001111111000
1111111111101111000000000000001111111011111111000000000111111101111111000000000111111000000111111000
1111111110001111110000000000011111110001111111100000001111111000111111100000000011110000000111110000
1111111000001111111100000000111111100000111111110000011111110000011111110000000011110000000011110000
1111100000001111111111000001111111000000011111111000111111100000001111111000000001100000000011100000
1110000000001111111111110011111110000000001111111111111111000000000111111100000001100000000001100000
1100000000001111111111110111111100000000000111111111111110000000000011111110000000111111111111000000
1111000000001111111111000011111110000000000000000000000000000000000111111110000000111111111111000000
1111110000001111111100000001111111000000000000000000000000000000001111111100000000011111111110000000
1111111100001111110000000000111111100000000000000000000000000000011111111000000000011111111110000000
1111111111001111000000000000011111110000000000000000000000000000111111110000000000001111111100000000
1111111111111100000000000000001111111000000000000000000000000001111111100000000000001111111100000000
1111111111110000000000000000000111111100000000000000000000000011111111000000000000000111111000000000
1111111111000000000000000000000011111100000000000000000000000011111110000000000000000111111000000000
1111111100000000000000000000000001111100000000000000000000000011111100000000000000000011110000000000
1111110000000000000000000000000000111100000000000000000000000011111000000000000000000011110000000000
1111000000000000000000000000000000011100000000000000000000000011110000000000000000000001100000000000
1100000000000000000000000000000000001100000000000000000000000011100000000000000000000001100000000000
0000000000000000000000000000000000001100000000000000000000000011000000000000000000000000000000000000
0000000000001100000000000111111111111111111111111111111111111111111111111110000000000001000000000000
0000000000011110000000000111111111111111111111111111111111111111111111111110000000000011100000000000
0000000000111111000000000111111111111111111111111111111111111111111111111110000000000111110000000000
0000000001111111100000000111111111111111111111111111111111111111111111111110000000001111111000000000
0000000011111111110000000111111111111111111111111111111111111111111111111110000000011111111100000000
0000000111111111111000000111111111111111111111111111111111111111111111111110000000111111111110000000
0000001111111111111100000111111111111111111111111111111111111111111111111110000001111111111111000000
0000011111110111111110000111111111111011111111111111111111111101111111111110000011111110111111100000
0000111111100011111111000111111111110001111111111111111111111000111111111110000111111100011111110000
0001111111000001111111100111111111100000111111111111111111110000011111111110001111111000001111111000
0011111110000000111111110111111111000000011111111111111111100000001111111110011111110000000111111100
0111111100000000011111111111111110000000001111111111111111000000000111111111111111100000000011111110
1111111000000000001111111111111100000000000111111111111110000000000011111111111111000000000001111111
0111111100000000000000000111111110000000000111111111111111000000000011111110000000000000000011111111
0011111110000000000000000111111111000000001111111111111111100000000111111110000000000000000111111110
0001111111000000000000000111111111100000011111111111111111110000001111111110000000000000001111111100
0000111111100000000000000111111111110000111111111111111111111000011111111110000000000000011111111000
0000011111110000000000000111111111111001111111111111111111111100111111111110000000000000111111110000
0000001111111000000000000111111111111111111111111111111111111111111111111110000000000001111111100000
0000000111111000000000000111111111111111111111111111111111111111111111111110000000000001111111000000
0000000011111000000000000111111111111111111111111111111111111111111111111110000000000001111110000000
0000000001111000000000000111111111111111111111111111111111111111111111111110000000000001111100000000
0000000000111000000000000111111111111111111111111111111111111111111111111110000000000001111000000000
0000000000011000000000000111111111111111111111111111111111111111111111111110000000000001110000000000
0000000000011000000000000111111111111111111111111111111111111111111111111110000000000001100000000000
0000000000011000000000000111111111111111111111111111111111111111111111111110000000000001100000000000
0000000000111000000000000111111111111111111111111111111111111111111111111110000000000001100000000000
0000000001111000000000000111111111111111111111111111111111111111111111111110000000000001110000000000
0000000011111000000000000111111111111111111111111111111111111111111111111110000000000001111000000000
0000000111111000000000000111111111111111111111111111111111111111111111111110000000000001111100000000
0000001111111000000000000111111111111111111111111111111111111111111111111110000000000001111110000000
0000011111111000000000000111111111111111111111111111111111111111111111111110000000000001111111000000
0000111111110000000000000111111111111011111111111111111111111101111111111110000000000000111111100000
0001111111100000000000000111111111110001111111111111111111111000111111111110000000000000011111110000
0011111111000000000000000111111111100000111111111111111111110000011111111110000000000000001111111000
0111111110000000000000000111111111000000011111111111111111100000001111111110000000000000000111111100
1111111100000000000000000111111110000000001111111111111111000000000111111110000000000000000011111110
1111111000000000001111111111111100000000000111111111111110000000000011111111111111000000000001111111
0111111100000000011111111111111110000000000111111111111111000000000011111111111111100000000011111110
0011111110000000111111100111111111000000001111111111111111100000000111111110111111110000000111111100
0001111111000001111111000111111111100000011111111111111111110000001111111110011111111000001111111000
0000111111100011111110000111111111110000111111111111111111111000011111111110001111111100011111110000
0000011111110111111100000111111111111001111111111111111111111100111111111110000111111110111111100000
0000001111111111111000000111111111111111111111111111111111111111111111111110000011111111111111000000
0000000111111111110000000111111111111111111111111111111111111111111111111110000001111111111110000000
0000000011111111100000000111111111111111111111111111111111111111111111111110000000111111111100000000
0000000001111111000000000111111111111111111111111111111111111111111111111110000000011111111000000000
0000000000111110000000000111111111111111111111111111111111111111111111111110000000001111110000000000
0000000000011100000000000111111111111111111111111111111111111111111111111110000000000111100000000000
0000000000001000000000000111111111111111111111111111111111111111111111111110000000000011000000000000
0000000000000000000000000000000000001100000000000000000000000110000000000000000000000000000000000000
0000000000011000000000000000000000011100000000000000000000001110000000000000000000000000000000000011
0000000000011000000000000000000000111100000000000000000000011110000000000000000000000000000000001111
0000000000111100000000000000000001111100000000000000000000111110000000000000000000000000000000111111
0000000000111100000000000000000011111100000000000000000001111110000000000000000000000000000011111111
0000000001111110000000000000000111111100000000000000000011111110000000000000000000000000001111111111
0000000001111110000000000000001111111100000000000000000111111110000000000000000000000000111111111111
0000000011111111000000000000011111111000000000000000001111111100000000000000000000000011111111111111
0000000011111111000000000000111111110000000000000000011111111000000000000000000000001111001111111111
0000000111111111100000000001111111100000000000000000111111110000000000000000000000111111000011111111
0000000111111111100000000011111111000000000000000001111111100000000000000000000011111111000000111111
0000001111111111110000000111111110000000000000000011111111000000000000000000001111111111000000001111
0000001111111111110000000111111100000000000111111111111110000000000011111110111111111111000000000011
0000011000000000011000000011111110000000001111111101111111000000000111111110111111111111000000000111
0000011100000000011000000001111111000000011111110000111111100000001111111000001111111111000000011111
0000111100000000111100000000111111100000111111100000011111110000011111110000000011111111000001111111
0000111110000000111100000000011111110001111111000000001111111000111111100000000000111111000111111111
0001111110000001111110000000001111111011111110000000000111111101111111000000000000001111011111111111
0001111111000001111110000000000111111111111100000000000011111111111110000000000000000011111111111111
0011111111000011111111000000000011111111111000000000000001111111111100000000000000000000111111111111
0011111111100011111111000000000001111111110000000000000000111111111000000000000000000000001111111111
0111111111100111111111100000000000111111100000000000000000011111110000000000000000000000000011111111
0111111111110111111111100000000000011111000000000000000000001111100000000000000000000000000000111111
1111111111111111111111110000000000001110000000000000000000000111000000000000000000000000000000001111
1111111111111111111111110000000000000100000000000000000000000010000000000000000000000000000000000011

PHP - 417 414 413 410 байт, 0 ошибок, ( 2 0 предупреждений!)

<?eval(preg_replace(['/[&|]/','/[a-z]/'],['$0$0','$$0'],"FOR(y=0,r=49+s=1+t=99;y<s;++y,PRINT'
')FOR(x=0;u=2*x-y,v=2*x+y,w=x-2*y,z=x+2*y,x<s;++x)ECHO-(w<-150&z<198|u>0&v<49|w>51&z>t|u<t&v>249|x<50&(w>26&z>49|z>74&(w>1|x<25&(w>-49|z>t&w>-74)))|y<50&(v>224&u<r|u<124&(v>199|y<25&(v>r|v>124&u<t)))|y>49&(v<74&u>-50|u>-25&(v<t|y>74&(v<r|v<174&u>0)))|x>49&(z<248&w<-125|z<223&(w<-s|x>74&(w<-50|w<-25&z<198))))+1;"));

Требуется PHP> = 5.4.

PHP разрешает использовать ключевые слова в любом случае, поэтому я использовал прописные буквы для ключевых слов и строчные буквы для переменных в загаданном коде. preg_replaceиспользуется только для разгона кода и evalего запуска. Я удалил $из всех переменных и вставил их с регулярным выражением. Я также изменил каждый экземпляр &&и ||на &и |и удвоил их с помощью регулярного выражения. Я не могу сделать тот же трюк, ++потому что я также использую +то, что я не хочу удвоить. Я попытался поменять логику, чтобы избавиться от -только что, echoно она превратила слишком много 99s в 100s. Однако мне удалось избежать использования одного пробела!

Я смог применить предложение Измаила Мигеля и к другому набору {}скобок для forцикла, однако мне пришлось использовать printвместо него echo. printи echoобе языковые конструкции («магические» ключевые слова, которые не нуждаются в скобках ()) и поэтому не допускаются внутри forобъявления. Однако, поскольку printимеет возвращаемое значение, как у функции, оно разрешено внутри for. Переместив присвоения переменных из третьего во второй раздел, я также смог устранить предупреждения!

Пип , 116 байт (96 ошибок)

Новые строки предназначены только для форматирования и не влияют на код:

l:24-_*2
b:1X25RL25
t:0Xl.1X25-lM,13
tAL:t@>1
g:(b@<13AL(1X12-_RL2J0X2*_+1M,12)).tALt.b
Fi,50Fj,50g@i.:(g50-j-1i)
PgJ:n
RVg

Слегка безразличен к комментариям:

l: 24-_*2                               Lambda function for use in calculating t
b: (1 X 25) RL 25                       25x25 block of 1s
t: (0 X l).(1 X (25-l)) M ,13           One of the skinny white triangles
t AL: t@>1                              Append t[1:] to t, so as to have two triangles
w: (1 X 12-_) RL 2 J (0 X 2*_+1) M ,12  The white wedge shape
g: (b@<13 AL w).t AL t.b                Build top left quadrant
Fi ,50
 Fj ,50
  g@i .: g@(50-j-1)@i                   Copy, rotating, and add as top right quadrant
P(g J: n)                               Join on newline and print as top half
RV g                                    Reverse top half for bottom half (auto-printed)

Код строит тождество как список строк. Как только вы узнаете, что Xэто умножение строк, RLповторный список, ALдобавление списка и Jобъединение, оно становится достаточно читабельным (IMHO). Переменные b, tи w(в негольфированной версии) соответствуют следующим частям идентификатора:

Верхний левый квадрант составляется так:

Wt
tb

где Wпредставляет 13 строк bсверху w. Затем мы поворачиваем и поворачиваем назад, чтобы получить остальную часть фигуры.

Ошибки возникают из-за того, как мы генерируем узкие белые треугольники (вторая часть выше). Они не совсем одинакового размера - у одного есть нечетные числа белых пикселей, а у другого четные числа, но если рассматривать их как одинаковые (без верхней строки нижней, всего 25 строк), то экономит несколько байт. Вот 122-байтовая версия, которая выполняет четно-нечетные шаги по лестнице (0 ошибок):

f:25
l:23-_*2+f*(_>12)
b:1XfRLf
t:(0Xl.1Xf-l)@<fM,f
g:(b@<13AL(1X12-_RL2J0X2*_+1M,12)).tALt.b
Fi,50Fj,50g@i.:(g50-j-1i)
PgJ:nRVg

И, просто для удовольствия, перевод оригинала на Python (не в гольф):

l = lambda a: 24 - a * 2
b = ["1" * 25] * 25
t = list(map(lambda a: "0"*l(a) + "1"*(25-l(a)), range(13)))
t += t[1:]
w = list(map(lambda a: ("0"*(2*a+1)).join(["1"*(12-a)]*2), range(12)))
g = list(map(str.__add__, b[:13] + w, t)) + list(map(str.__add__, t, b))
for i in range(50):
    for j in range(50):
        g[i] += g[50-j-1][i]
g = "\n".join(g)
print(g)
print(g[::-1])

Ruby, 324 байта, 216 ошибок

Идентикон использует строку Ruby, и мне это нравится. Чистая геометрия + симметрия. Уравнения краев для треугольника, вращение на 45 ゜ для прямоугольников, чтобы выровнять их оси. Около 100 ошибок было принесено в жертву на несколько байт меньше.

A=[]
5.times{|b|0.upto(49){|j|b<2&&A<<[0]*50&&next
0.upto(49){|i|A[99-j][i]=A[j][99-i]=A[i][j]=A[99-i][99-j]=A[i][j]
i<25&&j>24?0:next
A[i][j]=2*j-i<50?0:j>37&&i>13&&j-i+2<26?0:1
b<3&&A[j-13][24-i]=A[i][j]
A[i+=25][j-25]=A[i-25][j]
x=i-j
y=i+j
A[i][j]=x>-7&&x<7&&y>67&&y<81||x<-12||x>12||y<63||y>86?1:0}}}
puts A.map(&:join)

/// , 1319 байт, 0 ошибок

/=/gD//_/QPG//-/NAN//)/N0M//(/M0F//*/LCL//&/GTQ//%/GRG//$/GIG//#/DPK//@/BcQ//!/BH//z/BAQ//y/CI//x/AP//w/ALOK//v/ALIL//u/NRM//t/CR//s/SRS//r/NPN//q/MIM//p/GcG//o/DAAD//n/CP//m/C0//l/1AFK//k/CT//j/CE//i/FAF//h/CH//g/CO//f/AO//e/FMHFM//d/FD//c/AH//b/FF//a/QH1HQ//Z/LHBHL//Y/KHGHK//X/DHMHD//W/1HSH1//V/BHKHB//U/JA//T/EE//S/F1//R/E0//Q/B1//P/IE//O/I0//N/G1//M/GD//L/DD//K/D1//J/CA//I/AE//H/A0//G/BD//F/BB//E/00//D/11//C/AAA//B/11111//A/00000/bBAIFKUbB
sfdUs
ifdUi
qxSUq
rxSUr
pCFUp
aCFUa
VmMUV
ZmMUZ
YjNUY
XjNUX
WtGUW
lnGUlH
WkQgKHSH1
XkQhQHMHD
YJBkMHGHK
ZJBjdH!L
VhLCFV
ahLfFNH1HQ
pyKcFScG
ryKPbLPN
q=IbGIM
i=Abi
sn1RbFKRS
d0dn10bFQ0d
AIFL=g1U
fd0DkK0DkKU
fd0*E*JH
xSE@R@JH
xSE$T$JI
CFRuAuJI
CFReJO
mMT)I)JO
mMT%O%JP
jNAzPzJP
jNvAvCC
tGH#c#CC
tGt1n1Cm
kQHocoJOD
kQwAwJHL
JBA!BP!BgQ
JBT&O&hN
hLTNENINENtF
hLRemd
yKR(A(fFL
yKE-T-cFQ
=E_R_OFN
=0BfBEBf!b
n10KjL0KjLRbD
nKhLhD0bL
bQ==n
bKRDkK0DkLn
FSA*E*0Dg
FMO@R@0Dg
FGAA$T$EKy
FBfuAuEKy
FKCeRLh
St)I)RLh
MJ%O%TBJ
GgzPzTBJ
BULILAvAQk
KJO#c#AQk
1CJI1n1HGt
CmocoAGt
CCLOKAwANj
CC!BP!BTNj
JP&O&TMm
JPNENINEum
JOeRFC
JO(A(EFC
JI-T-ESx
JI_R_0Sx
JHBfBEBfB0df
JHKjL0KjFQf
UDhLhFBAI
bbSnbB
SRbFLE1ns
FAbSTDgi
MIbNHDgq
NPbBOKyr
GcbDAAKyp
QH1HFMAILha
!KHFQxLhV
LH!FKmBJZ
KHGHFtBJY
DHMHGJQkX
1HSHLyQkW
lH1nGtlH
WUGtW
XUNjX
YUNjY
ZUMmZ
VUMmV
aUFCa
pUFCp
rUSxr
qUSxq
iUdfi
sUdfs
d0dUFKAId0d

Попробуйте онлайн!

Это заняло у меня около 2 часов, потому что я заменял вещи вручную. Самое большое, что я сделал в ///.

Вероятно, я могу сыграть в гольф еще несколько байтов.

Также см. Ответ Эрика Гольфиста в /// (на 4 байта меньше моего).

Фортран, 214 байт, 200 ошибок

Fortran, возможно, не лучший выбор для Code Golf, но его идентичность выглядела так просто, что я решил попробовать. На самом деле я не могу конкурировать с некоторыми более краткими языками, но используя неявные переменные и другие подобные тонкости (например, -удваивается как xor), это не так уж и плохо - я сократил его до 214 байтов:

logical A(-12:87,-12:87)
do 1 r=-12,12
do 1 s=-12,12
x=abs(r)
y=abs(s)
l=x+y<6
k=(x<y/2+7.and.y<x/2+7)-l
A((/r+25,r+50/),(/s,s+75/))=k
A((/r,r+75/),(/s+25,s+50/))=k
1A((/r,r+75/),(/s,s+75/))=l
print'(100I1)',-A
end

Примечание: это не будет работать с gfortran. Он компилируется, ifortесли вы дадите файлу .f90расширение (это активирует источник свободной формы).

Perl - 3244 3188 1609 1387 байт, 0 13 66 78 ошибок

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

@i=qw(1;76 0;24 1;77 0;21 1;2 1;78 0;22 1;79 0;21 0;4 1;17 0;4 1;55 0;20 1;81 0;13 1;6 0;6 1;13 0;6 1;57 0;11 1;7 0;7 1;11 0;7 1;12 0;1 1;45 0;9 1;8 0;8 1;9 0;8 1;11 0;3 1;22 0;3 1;20 0;7 1;9 0;9 1;7 0;9 1;10 0;5 1;20 0;5 1;20 0;5 1;10 0;10 1;5 0;10 1;9 0;7 1;18 0;7 1;20 0;3 1;11 0;11 1;3 0;11 1;8 0;9 1;16 0;9 1;20 0;1 1;12 0;12 1;1 0;12 1;7 0;11 1;14 0;11 1;32 0;11 1;3 0;11 1;8 0;9 1;16 0;9 1;33 0;10 1;5 0;10 1;9 0;7 1;18 0;7 1;20 0;3 1;11 0;9 1;7 0;9 1;10 0;5 1;20 0;5 1;20 0;5 1;10 0;8 1;9 0;8 1;11 0;3 1;22 0;3 1;20 0;7 1;9 0;7 1;11 0;7 1;12 0;1 1;24 0;1 1;20 0;9 1;8 0;6 1;13 0;6 1;57 0;11 1;7 0;5 1;15 0;5 1;56 0;13 1;6 0;4 1;17 0;4 1;55 0;15 1;5 0;3 1;19 0;3 1;54 0;17 1;4 0;2 1;21 0;2 1;53 0;19 1;3 0;1 1;23 0;1 1;52 0;21 1;2 1;76 0;23 1;1 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25 1;12 0;1 1;12 0;50 1;12 0;1 1;12 1;11 0;3 1;11 0;50 1;11 0;3 1;11 1;10 0;5 1;10 0;50 1;10 0;5 1;10 1;9 0;7 1;9 0;50 1;9 0;7 1;9 1;8 0;9 1;8 0;50 1;8 0;9 1;8 1;7 0;11 1;7 0;50 1;7 0;11 1;7 1;8 0;9 1;8 0;50 1;8 0;9 1;8 1;9 0;7 1;9 0;50 1;9 0;7 1;9 1;10 0;5 1;10 0;50 1;10 0;5 1;10 1;11 0;3 1;11 0;50 1;11 0;3 1;11 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25 1;25 0;50 1;25);$n=0;for(@i,reverse@i){@p=split';';$n+=$p[1];print $p[0]x int($p[1]);if($n>=100){print"\n";$n=0}}

Создает текст для этого:

/// , 1315 байт, 0 ошибок

/-/\/\///O/00000-I/11111-o/OOO-i/11-@/000-!/II-8/O0-|/Ii-*/O@-+/0|-_/i1-=/oO-#/ii-$/I1-%/|i-^/!1-&/*0-2/+1-3/=O-4/I8_8I-5/!!-6/#8I8#-7/$818$-9/18^81-A/_8|8_-B/i8%8i-C/o@-D/O8-d/o8-E/o0-F/|1-g/+i-H/O*-h/o*-j/!%8!%-k/!i-l/!O!-m/#80#-n/0_-p/1O!_-q/^@^-r/iOOi-s/0$-t/
=-u/%8g-v/o&-w/|D|-x/
F*2-y/#*_O-z/#o#0-Z/0IHI-Y/E0/5i_D0!_35I
qHk3q
lHk3l
uO&^3uxO&^3F*2
wo!3w
7o!37
4og34
6og36
AE23A
BE23B
9C|39
ph+3p8
9Csh_8^81
BCsd$8%8i
A=ICg8|8_
6=IYk8I8#
4d#o!4
7d#H!F818$
wdnD!^D|xdn&5#*2
uhi805|8g
lhiO5l
qv1@5!_@^
k0kv105!$0k
D0!#hih13
Hk0iCn0iCn3
Hk0z0#o#=8
O&^00ID$@ID$=8
O&^0+8+@+8+=80
o!@F@%OF@%=80
o!@j=*
og@2g82g=*
og@+@|*|@|=&
E2OIO$&IO$=&
E2OmOOmoo
C|8i&_Di&_oo
C|C1v1oE
Cs8rDr=*i
CsOyO#*_=8#tIOI8I&I8Ih$tI@+@s*|@sdF
d#@2028202C!
d#@jEk
dn@%0!O%0!H!#
dn02OF@2OFD!$
hi0s*+@$*+*!F
hiZ0Z85
v1nY#nY#@5i
v_d#di05#
5$hihiv
5_@iCn0iC0#v
!^Oz0zih
!%*ID$@ID$0ih
!|OO|8+@+8+0nd0
!IHF@%OF@%0nd0
!_oj@#d
^CFg82g@#d
%=|@|*|@|@0I=
|hIO$&IO$@0I=
I3mOOmO$C0
_=*i&_Di&_O$C0
1o=801v18|C
oErDrO|C
ooyOyFY
ooI8I&I8I@2Yt*+@s*|@s@gEt*2028202@%Et*j@!ot*%0!O%0!00!ot82OF@2OF00^O&t8s*+@$*+0^O&t8IHI0Z0kHt8_Y#nY!$H
3id#d!ID0
55^v5I
^@5!#001vq
!O5^@0ihl
%805F8ihu
F&5I*_d2*2
|D5iOO_d+D|
$818!%D0#d7
I8_8!$O&#d4
#8I8!_EI=6
_8|8!CI=A
i8%8|=$C0B
18^8#dsC09
p81h+Cp8
93|C9
B3FYB
A3FYA
63%E6
43%E4
73!o7
w3!owx3^H2*2
u3^Hg8g
l3kHl
q3kHq
k0k3!_D0k0k

Попробуйте онлайн!

Это идентичность для ///. Возможно, это самая большая вещь, которую я когда-либо делал в ///!

IDL 8,4, 333 байта, 105 ошибок

Это дало другой идентификатор, и я смог сыграть в него намного больше, используя совершенно другой метод.

b=byte('AKMLOJMLPIMLQHMLRGMLSFMLTEMLUDMLVCMLWBMLXAMLfLfLNKBWOJCVPIDUQHETRGFSSFGRTEHQUDIPVCJOWBKNXALMfLMLfLfLfLfLfLfLfLTLFLTLFLTLFLTLFLTLFLTLFLTLFLTLFLTLFLTLFLTLFLTLFLfLfLfLfLfLf')-64
f=[]
for i=1,169 do f=[f,replicate(i mod 2,b[i-1])]
f=reform(f,50,50)
print,[[rotate(f,4),rotate(f,5)],[rotate(f,7),rotate(f,6)]],format='(100I1)'
end

Сначала преобразуйте символы в строке 1 в байтовые значения и вычтите 64 (чтобы A = 1, B = 2 и т. Д.). Затем вставьте эти многочисленные последовательные 1 и 0 в массив и преобразуйте его в 50x50 (т. Е. Верхний левый квадрант, но транспонированный). Затем транспонируйте и вращайте его 4 раза, соедините их вместе и распечатайте.

1111111111111111111111111000000000000000000000000011111111111110000000000001111111111111000000000001
0111111111111011111111111000000000000000000000000011111111111110000000000001111111111111000000000011
0011111111111001111111111000000000000000000000000011111111111110000000000001111111111111000000000111
0001111111111000111111111000000000000000000000000011111111111110000000000001111111111111000000001111
0000111111111000011111111000000000000000000000000011111111111110000000000001111111111111000000011111
0000011111111000001111111000000000000000000000000011111111111110000000000001111111111111000000111111
0000001111111000000111111000000000000000000000000011111111111110000000000001111111111111000001111111
0000000111111000000011111000000000000000000000000011111111111110000000000001111111111111000011111111
0000000011111000000001111000000000000000000000000011111111111110000000000001111111111111000111111111
0000000001111000000000111000000000000000000000000011111111111110000000000001111111111111001111111111
0000000000111000000000011000000000000000000000000011111111111110000000000001111111111111011111111111
0000000000011000000000001000000000000000000000000011111111111110000000000001111111111111111111111111
1111111111111111111111111111111111111111111111111111111111111110000000000001111111111111111111111111
1111111111111111111111111111111111111111111111111111111111111110000000000000000000000011000000000001
1111111111111011111111111111111111111111111111111111111111111110000000000000000000000111000000000011
1111111111111001111111111111111111111111111111111111111111111110000000000000000000001111000000000111
1111111111111000111111111111111111111111111111111111111111111110000000000000000000011111000000001111
1111111111111000011111111111111111111111111111111111111111111110000000000000000000111111000000011111
1111111111111000001111111111111111111111111111111111111111111110000000000000000001111111000000111111
1111111111111000000111111111111111111111111111111111111111111110000000000000000011111111000001111111
1111111111111000000011111111111111111111111111111111111111111110000000000000000111111111000011111111
1111111111111000000001111111111111111111111111111111111111111110000000000000001111111111000111111111
1111111111111000000000111111111111111111111111111111111111111110000000000000011111111111001111111111
1111111111111000000000011111111111111111111111111111111111111110000000000000111111111111011111111111
1111111111111000000000001111111111111111111111111111111111111110000000000001111111111111111111111111
0000000000000000000000000111111111111111111111111111111111111111111111111111111111111111000000000000
0000000000000000000000000111111111111111111111111111111111111111111111111111111111111111000000000000
0000000000000000000000000111111111111111111111111111111111111111111111111111111111111111000000000000
0000000000000000000000000111111111111111111111111111111111111111111111111111111111111111000000000000
0000000000000000000000000111111111111111111111111111111111111111111111111111111111111111000000000000
0000000000000000000000000111111111111111111111111111111111111111111111111111111111111111000000000000
0000000000000000000000000111111111111111111111111111111111111111111111111111111111111111000000000000
0000000000000000000000000111111100000000000011111111111100000000000011111111111111111111000000000000
0000000000000000000000000111111100000000000011111111111100000000000011111111111111111111000000000000
0000000000000000000000000111111100000000000011111111111100000000000011111111111111111111000000000000
0000000000000000000000000111111100000000000011111111111100000000000011111111111111111111000000000000
0000000000000000000000000111111100000000000011111111111100000000000011111111111111111111000000000000
1111111111111111111111111111111100000000000011111111111100000000000011111111111111111111000000000000
1111111111111111111111111111111100000000000011111111111100000000000011111111111111111111000000000000
1111111111111111111111111111111100000000000011111111111100000000000011111111111111111111000000000000
1111111111111111111111111111111100000000000011111111111100000000000011111111111111111111000000000000
1111111111111111111111111111111100000000000011111111111100000000000011111111111111111111000000000000
1111111111111111111111111111111100000000000011111111111100000000000011111111111111111111000000000000
1111111111111111111111111111111100000000000011111111111100000000000011111111111111111111000000000000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000
0000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
0000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
0000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
0000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
0000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
0000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
0000000000001111111111111111111100000000000011111111111100000000000011111111111111111111111111111111
0000000000001111111111111111111100000000000011111111111100000000000011111111111111111111111111111111
0000000000001111111111111111111100000000000011111111111100000000000011111111111111111111111111111111
0000000000001111111111111111111100000000000011111111111100000000000011111111111111111111111111111111
0000000000001111111111111111111100000000000011111111111100000000000011111111111111111111111111111111
0000000000001111111111111111111100000000000011111111111100000000000011111111111111111111111111111111
0000000000001111111111111111111100000000000011111111111100000000000011111111111111111111111111111111
0000000000001111111111111111111100000000000011111111111100000000000011111110000000000000000000000000
0000000000001111111111111111111100000000000011111111111100000000000011111110000000000000000000000000
0000000000001111111111111111111100000000000011111111111100000000000011111110000000000000000000000000
0000000000001111111111111111111100000000000011111111111100000000000011111110000000000000000000000000
0000000000001111111111111111111100000000000011111111111100000000000011111110000000000000000000000000
0000000000001111111111111111111111111111111111111111111111111111111111111110000000000000000000000000
0000000000001111111111111111111111111111111111111111111111111111111111111110000000000000000000000000
0000000000001111111111111111111111111111111111111111111111111111111111111110000000000000000000000000
0000000000001111111111111111111111111111111111111111111111111111111111111110000000000000000000000000
0000000000001111111111111111111111111111111111111111111111111111111111111110000000000000000000000000
0000000000001111111111111111111111111111111111111111111111111111111111111110000000000000000000000000
0000000000001111111111111111111111111111111111111111111111111111111111111110000000000000000000000000
1111111111111111111111111000000000000111111111111111111111111111111111111111000000000001111111111111
1111111111101111111111110000000000000111111111111111111111111111111111111111100000000001111111111111
1111111111001111111111100000000000000111111111111111111111111111111111111111110000000001111111111111
1111111110001111111111000000000000000111111111111111111111111111111111111111111000000001111111111111
1111111100001111111110000000000000000111111111111111111111111111111111111111111100000001111111111111
1111111000001111111100000000000000000111111111111111111111111111111111111111111110000001111111111111
1111110000001111111000000000000000000111111111111111111111111111111111111111111111000001111111111111
1111100000001111110000000000000000000111111111111111111111111111111111111111111111100001111111111111
1111000000001111100000000000000000000111111111111111111111111111111111111111111111110001111111111111
1110000000001111000000000000000000000111111111111111111111111111111111111111111111111001111111111111
1100000000001110000000000000000000000111111111111111111111111111111111111111111111111101111111111111
1000000000001100000000000000000000000111111111111111111111111111111111111111111111111111111111111111
1111111111111111111111111000000000000111111111111111111111111111111111111111111111111111111111111111
1111111111111111111111111000000000000111111111111100000000000000000000000001000000000001100000000000
1111111111101111111111111000000000000111111111111100000000000000000000000001100000000001110000000000
1111111111001111111111111000000000000111111111111100000000000000000000000001110000000001111000000000
1111111110001111111111111000000000000111111111111100000000000000000000000001111000000001111100000000
1111111100001111111111111000000000000111111111111100000000000000000000000001111100000001111110000000
1111111000001111111111111000000000000111111111111100000000000000000000000001111110000001111111000000
1111110000001111111111111000000000000111111111111100000000000000000000000001111111000001111111100000
1111100000001111111111111000000000000111111111111100000000000000000000000001111111100001111111110000
1111000000001111111111111000000000000111111111111100000000000000000000000001111111110001111111111000
1110000000001111111111111000000000000111111111111100000000000000000000000001111111111001111111111100
1100000000001111111111111000000000000111111111111100000000000000000000000001111111111101111111111110
1000000000001111111111111000000000000111111111111100000000000000000000000001111111111111111111111111

Bubblegum, 535 байт, 0 ошибок

0000000: bd96 410a 4431 0843 f739 4d73 ffcb cdf2  ..A.D1.C.9Ms....
0000010: 93a1 0f2a 04b3 ab22 b1ad 1acf 07fb c489  ...*..."........
0000020: 70ee 7006 9f0f 0207 b31c 60b1 33d4 3792  p.p.......`.3.7.
0000030: b033 4b24 03b9 dbc9 2220 2796 6b36 9f31  .3K$...." '.k6.1
0000040: c3fe 49d2 8a2c 904e d8fc 2149 d288 2c90  ..I..,.N..!I..,.
0000050: 4f98 9c01 1f49 da90 0512 0a8b 131f 0914  O....I..........
0000060: 275c 3e8e 61a0 0756 384e 00be 9148 8da5  '\>.a..V8N...H..
0000070: a25b ae09 4adc cea3 b1e8 75e2 cc2c f080  .[..J.....u..,..
0000080: 71a2 f655 1e91 056a 210e 0822 4938 0e63  q..U...j!.."I8.c
0000090: 346f 7208 d53f 2174 ab0b 50ed 1342 b5e3  4or..?!t..P..B..
00000a0: 01dd d905 e84e 6142 554f 0855 6524 5435  .....NaBUO.Ue$T5
00000b0: 1ed0 dd56 086a ee5d 04b9 0666 d7a1 801a  ...V.j.]...f....
00000c0: 8b2d fedf 128b 6d71 a54e c1ed 2cee b939  .-....mq.N..,..9
00000d0: a8d5 c4d3 630c 9c37 e239 3806 4e4e e144  ....c..7.98.NN.D
00000e0: e752 6307 6880 509b b80c d801 696a aeb2  .Rc.h.P.....ij..
00000f0: 7387 705c 635e e4e0 2b8a 0629 ab2c 39f8  s.p\c^..+..).,9.
0000100: b384 230e 6b85 1c8c ed9b f4ff 64b1 ba16  ..#.k.......d...
0000110: fa64 a1e3 7766 d7f2 145e d093 0565 5cd0  .d..wf...^...e\.
0000120: f89d 6d65 67ef 424f 11b2 6b1c 87ec c2df  ..meg.BO..k.....
0000130: 9a03 6b48 5877 7360 3708 3b68 0eec 6be1  ..kHXws`7.;h..k.
0000140: 2c98 0327 94e6 628a c059 abb1 98b2 0355  ,..'..b..Y.....U
0000150: 4363 3165 07ea 9f8a 2a8b 4aae b198 b203  Cc1e....*.J.....
0000160: 7712 8dc5 941d b85d 692c a6ec c03d 71fd  w......]i,...=q.
0000170: 26fd 3f59 acae 853e 59e8 f89d d9b5 3c85  &.?Y...>Y.....<.
0000180: 17f4 6441 1917 347e 655b d9d9 bb0e 61cc  ..dA..4~e[....a.
0000190: 1e01 7162 129b cccc 11a9 bc91 98ac cc11  ..qb............
00001a0: f77d 2331 199d a056 7b23 c150 e4c8 9f7b  .}#1...V{#.P...{
00001b0: 2331 999c 8068 bf91 982c c891 ee37 1293  #1...h...,...7..
00001c0: 0139 d2fb 4662 38a7 01a3 fd40 3250 5988  .9..Fb8....@2PY.
00001d0: f61b 89e9 7198 2315 9349 5865 b161 21da  ....q.#..IXe.a!.
00001e0: f218 3ce0 e624 cd9b d0b8 2bff 896f a857  ..<..$....+..o.W
00001f0: d795 a3de 2737 8e7e c73b 519f 5d10 d29e  ....'7.~.;Q.]...
0000200: c270 f9b2 9ef0 bfb6 9531 2f58 d678 20ef  .p.......1/X.x .
0000210: 6e2b e0e8 ee5d 3f                        n+...]?

Сжатый с помощью zopfli ( --deflate --i10000). Попробуйте онлайн.

Довольно просто; Я мог бы поэкспериментировать с добавлением некоторых ошибок позже.

ForceLang, 2749 2499 2495 байт

Неконкурентоспособен, язык задает вопрос.

def S set
S W io.writeln
S R string.rev
S a ""+0x6D79F82328EA3DA61E0701C9182D91DDE8B1C71C7
S b ""+0x786C90F379CE770387732B1CDC3135DC3CE1C71C6
S c ""+0x7984D36EB5187CC012312A961B9A27CB5BF9C71BC
S d ""+0x79A0DA14A16CB0862210C8BE24D40F55C1D5C7158
S e ""+0x79A3A78B9F751C1A0472203FA900BFF60DEBC6D70
S f ""+0x79A3EF4AB8DC5A0FFC9CDC4D56BD69F1DBBAC4660
S g ""+0x79A3F6776E99E049FE5189BC60823AF3FB1C2BFC0
S h ""+0x79A3F72F1A60079DE42E0BC3623C9CC0D0A4F7D80
S i ""+0x79A3F741785A41CCDA794C67E9EBDAB9EAC2CE700
S j ""+0x79A3F7434E8CFFB9AC2E70DEA901D141036760600
S k ""+0x79A3F7437D9343C8FBEF208311B066CF95614BC00
S l ""+0x79A3F7438253021069541D3C0D7DBD353F18E9800
S m ""+0x79A3F74382CB60F176B1C1A99D8D000C45AA51000
W a+a
W b+b
W c+c
W d+d
W e+e
W f+f
W g+g
W h+h
W i+i
W j+j
W k+k
W l+l
W m+m
W l+l
W k+k
W j+j
W i+i
W h+h
W g+g
W f+f
W e+e
W d+d
W c+c
W b+b
W a+a
W S n ""+0x2082FAED7A3F16F730463D6FB0529164157A6772E72577EC590ADCDD251957F2BC21BCECCEDA1000001
W S o "0"+0x3404C4AF29FE8B251A078D51F3422C44257DE9CCEE48C93AB6DDD70037D6F058EF1E96AE389780000B
W S p "00"+0x533AD44B766411D4F4ED5F3E08CDC08896ADBCDC1213E71D9792DAFE2655B4B0D387777F349C0006F
W S q "000"+0x852AED458A39B62094B066CF194EDEE006289DFD2093DCC403A9A369F588AB436E4125B928600457
W S r "0000"+0xD5117BA276C2BC68EEC80E4BF8D5C1A068B3ABB7496F715789D4298974E6B48DA0883E68B702B67
W S s "00000"+0x154E8C5D0BE0401A871156A755E768D3BEF3334F8FA7C61A4F116CE6907EB4964CFA6EB1559B207
W S t "000000"+0x221746FB462FE3C989A43900F01111A46D39389143FAB11D7C222D858D8B7420DC570C3CCCF447
W S u "0000000"+0x368BA4C53AC7AFE49E5162CA0DA3D0B1C8CDBE64A8195738CB712D2038B74223F9C849AEF8AC7
W S v "00000000"+0x5745D46D515CD860B238C63288EE96F8425A28BBF8CE27A5F060FE9F8B742263237710A66BC7
W S w "000000000"+0x8BA2EC93C7B8B205605DCC1242ACE73FE320C62A60CEC941E4474B78B742266B0F5F107B5C7
W S x "0000000000"+0xDF6A832B1C8B32B27AA702FBBFD960651EAB9E37CE30AD4E093DA78B7422670BEB558DD9C7
W S y "00000000000"+0x1651C9F6F18C5FB47C580D61E4F69EB8CFDD04644901F0B5CFB5078B742267151AEC7761C7
W S z "000000000000"+0x202C1796B182D85E5704E2B93930E38C74A50C6F9CC338492A1C78B7422671603C11C71C7
W y
W x
W w
W v
W u
W t
W s
W r
W q
W p
W o
W n
W R n
W R o
W R p
W R q
W R r
W R s
W R t
W R u
W R v
W R w
W R x
W R y
W R z
W R y
W R x
W R w
W R v
W R u
W R t
W R s
W R r
W R q
W R p
W R o
W R n
W S a R a+a
W S b R b+b
W S c R c+c
W S d R d+d
W S e R e+e
W S f R f+f
W S g R g+g
W S h R h+h
W S i R i+i
W S j R j+j
W S k R k+k
W S l R l+l
W R m+m
W l
W k
W j
W i
W h
W g
W f
W e
W d
W c
W b
W a