Identicons sind kleine Bilder von geometrischen Mustern, die den Hashwert einer Zeichenfolge darstellen. Stack Exchange verwendet die Identicons von Gravatar als Standard- Avatarbild jedes Benutzers.
In dieser Herausforderung werden wir auch die Gravatar-Identicons verwenden, um Text zum Golfen zu generieren.
Herausforderung
Mit diesem Stack-Snippet (einer verkleinerten Version von JSFiddle ) können Sie eine Zeichenfolge eingeben und eine 100 × 100-Pixel-Schwarzweiß- Version des Identicons dieser Zeichenfolge sowie eine Textversion zurückgeben, in der 1
für Schwarz und 0
Weiß steht:
<!-- 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>
(Sie können damit auch die Stile Monster, Wavatar und Retro Gravatar laden, diese dienen jedoch nur zum Spaß und sind nicht für diese Herausforderung vorgesehen. Unicornicons fehlen aufgrund von XSS Einschränkungen.: /)
Ihre Aufgabe ist es, ein Programm zu schreiben, das den Textblock mit 100 × 100 Zeichen von 0
's und' s ausgibt1
' s generiert wird, wenn Sie den Namen Ihrer Programmiersprache in das Snippet-Eingabefeld eingeben.
Wenn Ihre Übermittlung beispielsweise in Python geschrieben ist , geben Sie Python
den Stack-Snippet ein und sehen, dass
ist das Identicon für Python und
ist die Schwarz-Weiß-Version (binär) und
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
ist die entsprechende Textausgabe, die Ihr Python-Programm erzeugen muss.
Da Identicons jedoch viele unangenehme Winkel aufweisen können und ihre Rasterung als Schwarzweißbild zu Unregelmäßigkeiten führen kann , darf Ihre Ausgabe bis zu 300 0
oder mehr 1
Punkte enthalten, die dem Gegenteil von dem entsprechen, was sie sein sollen. (Das sind 3% der 10000 Gesamt 0
's und 1
' s.)
Am unteren Rand des Snippets können Sie in der Ausgabe Ihres Programms einfügen und überprüfen , wie viele 0
's oder 1
ist anders als das, was sie sein sollten. Eine beliebige Anzahl von Differenzen bei oder unter 300 ist gültig.
Wertung
Die Einsendung mit den wenigsten Bytes gewinnt. ( Handlicher Bytezähler. )
Tiebreaker geht zur Einreichung mit den wenigsten Fehlern 0
und 1
Fehlern.
Wenn es immer noch ein Unentschieden gibt, gewinnt die frühere Einreichung.
Einzelheiten
- Die Ausgabe erfolgt nach stdout oder einer ähnlichen Alternative, wenn Ihre Sprache nicht über stdout verfügt.
- Die Ausgabe kann optional eine nachgestellte Newline enthalten.
- Bitte fügen Sie das Farbidenticon-Bild zusammen mit der genauen Zeichenfolge, die es generiert, in Ihren Beitrag ein. Es ist nicht erforderlich, Speicherplatz zu verschwenden und Ihre gesamte Textausgabe zu veröffentlichen.
- Ihr Programm sollte ohne Internetverbindung ausgeführt werden. Sie müssen den Text in Ihrem Code generieren und dürfen ihn nicht von der Gravatar-Site aus abfragen.
- Verwenden Sie gesunden Menschenverstand, wenn Sie Ihre Sprache "benennen". Verwenden Sie den Namen der Sprache, die Sie normalerweise auf dieser Site verwenden würden. Ärgern Sie sich nicht und erfinden Sie einen Namen, der das Golfspiel mit dem Identicon einfacher macht. zB
Python 2
ist in Ordnung für Python, aber espython 2.7.2
wird gedehnt undpython 2.7.2 by Guido van Rossum
wäre lächerlich. - Mir ist klar, dass einige Sprachen von Natur aus einfacher sind als andere, weil ihre Identicon-Formen einfacher sind. So wird es auch sein, sei nicht zu verärgert oder konkurrierend. ;)
quelle
Antworten:
CJam,
92817971 Bytes, 120 FehlerHier ist wahrscheinlich noch Platz zum Golfen.
Teste es hier.
Erläuterung
Ich verwende keine Komprimierung, sondern berechne die einzelnen Kacheln und setze daraus das Ergebnis zusammen. Die Kachel oben links ist absichtlich angenähert. Einige andere Fehler resultieren daraus, dass das binärisierte Bild nicht vollständig rotationssymmetrisch ist. Lass uns den Code durchgehen.
Die erste Kachel sollte theoretisch so aussehen:
Das sind 12 Linien, dann 13 Linien des Punktes zwischen
1
s und0
s, die jeweils um 2 abnehmen. Beachten Sie, dass der erste Block eine gerade Zahl von0
s und der zweite Block eine ungerade Zahl hat. Wir können das Muster noch regelmäßiger machen, wenn wir die Genauigkeit in der mittleren Reihe opfern und es in1
240
s umwandeln. Dann haben wir tatsächlich eine Zeile für jede Anzahl von Nullen von 0 bis 24, die sich zwischen dem oberen und unteren Teil abwechseln. Also können wir sie einfach in der richtigen Reihenfolge erzeugen (als einzelnes Dreieck) und dann jede zweite Zeile herausziehen:Als nächstes sehen Sie das ausgefallene Dreieck rechts von dieser Kachel:
Wenn wir ein Koordinatensystem mit Ursprung in der oberen rechten Ecke betrachten und
x
ging nach rechts undy
nach unten geht, dann ist die Region1
s erfüllen 3 Ungleichheiten:x/y ≥ 1/2
,x/y ≥ 2
,x + y < 38
. Wir können diese einfach separat berechnen und das logische Ende nehmen. Es werden keine Zeichen gespeichert, aber der Code wird leicht aufgeräumt, wenn die ersten beiden Ungleichungen kombiniert werden:Letztendlich werden wir ein weiteres Byte sparen, indem wir das Gegenteil überprüfen und verwenden,
xor
anstattand
das Ergebnis mit der anderen Ungleichung zu kombinieren:Wir haben jetzt alles an der richtigen Stelle - die verbleibenden Kacheln sind nur Kopien und Rotationen davon sowie die festen (langweiligen) Kacheln in der Mitte. Also lassen Sie uns alles zusammenziehen:
Am Ende des Programms druckt CJam den Stapelinhalt einfach nacheinander aus und erstellt das gewünschte Ergebnis.
quelle
Oktave
166164 Bytes, 0 FehlerOctave hat eine große Stärke im Umgang mit / beim Aufbau von Matrizen. Für die 'Diamanten' habe ich ein xy-Koordinatensystem erstellt und die Manhattan-Norm verwendet, um zu entscheiden, ob die Einträge 1 oder 0 sind. Da die Diamanten nicht vollständig symmetrisch sind, musste ich also mit der 'Entfernung' und dem Mittelpunkt herumspielen Mit dem Mittelpunkt (13.1.13.1) funktionierte es für beide Arten von 'Diamant'-Formen.
Danach konnte ich nur ein Viertel davon auf Null setzen, um diese C-Formen zu erhalten. Die Quadrate und die Matrixverknüpfung waren einfach.
Neue Version -2 Zeichen (funktioniert genauso wie die alten, aber ich habe es geschafft, die Octave-Syntax noch etwas mehr zu missbrauchen:
Alte Version:
Ausgabe
quelle
Brainfuck
94182237 Bytes, 88 FehlerEdit: Wie mbomb007 hervorhob, scheint der 'offizielle' Name nicht großgeschrieben zu sein, dies wird in Wikipedia nicht erwähnt, steht aber auf Esolangs . Das ärgert mich, reicht aber bei weitem nicht, um dies zu wiederholen;).
Mein erstes Brainfuck-Programm!
Benutzt jetzt tatsächlich Mathe und Logik und so! (für jedes Pixel entscheidet es 0 oder 1, abhängig von einigen Bedingungen). Das hat ziemlich viel Spaß gemacht. dass gesagt wird Ich glaube nicht , ich werde für eine lange mit Brainfuck wieder codieren langen Zeit.
Erzeugen der Bitmap des Bildes:
Eine Version mit einigen Kommentaren (möglicherweise nicht sehr nützlich, da sie hauptsächlich zu meinem eigenen Vorteil waren):
quelle
Python,
294273239188179170159154 BytesHier ist die 158-Byte- Version:
Dies ist ein Python 2-Programm, aber ich verwende das Identicon für "Python" (dh das im OP). Das Diff sollte 78 Bit sein.
Hier ist die 154-Byte- Version:
Das hat einen Unterschied von 224 Bits statt.
(-4 Bytes dank Stefan Pochmann)
Erläuterung
Hier ist eine alternative erweiterte Version:
In dieser Version wird das Identicon als ein 4x4-Raster von Mustern behandelt. Wir beginnen mit einem 100x100-Raster von 0s und führen die folgenden vier Schritte aus:
Die ursprüngliche Version ist ähnlich, aber anstatt sich nach Abschluss der drei Muster zu drehen, drehen wir uns jedes Mal, wenn wir eine einzelne Zelle ändern . Dadurch dauert das Programm einige Sekunden, aber die Ausgabe ist dieselbe.
quelle
J
undr
in einer Zeile mit einem Semikolon verbinden.~i%12<j/2>i%12
ist 3 kürzer alsabs(i%12-6)+5<j/2
aber führt zu 224 diff denke ich.C
255245237234 BytesDas Identicon von C ist wirklich symmetrisch.
Golf: (Zeilenumbrüche für "Lesbarkeit" hinzugefügt)
Dadurch wird die Hälfte jeder Zeile in der oberen Hälfte in einer 64-Bit-Ganzzahl gespeichert. Anschließend werden die unteren 50 Bits der entsprechenden Ganzzahl zweimal binär gedruckt, wobei der zweite Ausdruck umgekehrt wird.
Damit dies ausgeführt werden kann, sind 64-Bit-Eingaben erforderlich (wenn Ihr System keine 64-Bit-Eingaben verwendet, können Sie
long
oderlong long
vorherd[50]
und(long)
oder(long long)
nachher hinzufügeno[i-1]=i<26?
).Ungolfed und kommentiert:
Die Ausgabe weist 291 Fehler auf.
Danke an ace für den Tipp
puts("")
quelle
putchar(10)
durchputs("")
, um 3 Bytes zu sparen.C,
224206200176 Bytes, 243 FehlerReplizieren:
Der obige Code gibt eine Binärdatei mit 243 Fehlern aus, die mit diesem Bild korreliert:
Nach allem, was ich sagen kann, verwende ich eine andere Methode als die von es1024. Diese Methode kann wahrscheinlich noch weiter vertieft werden, weshalb ich mich mit Erklärungen kurz zurückhalten werde, aber hier ist sie in ihrer enträtselten Pracht:
Es verwendet im Wesentlichen eine Reihe von Ungleichungen, um die Polygone zu definieren, und stützt sich stark auf Symmetrie.
Es ist zur Zeit Mitternacht und meine Fähigkeit, meinen eigenen Code zu lesen, verschlechtert sich rapide. Sie können wahrscheinlich mit einigen Konstanten fummeln, um die Fehler zu verringern, aber ich kann nur konsequent alles brechen.
Das ist nicht nur die kürzeste Version, die ich mir ausgedacht habe, sondern auch, dass gcc keine Warnungen ausgibt !
quelle
for
Schleifefor(;i+1;i+=k=i-50?puts(b),k:-1)
so her, dass ein Semikolon und zwei geschweifte Klammern eingespart werden. Dies spart 3 Byte.k=1
zumain(k)
3 Bytes zu speichern.gs2 : 72 bytes, 200 fehler
Ich habe noch nicht wirklich Golf gespielt und bin mir nicht sicher, ob ich das will. Mnemonik:
Das Programm selbst:
quelle
Z80, 194 Bytes, 0 Fehler
Z80, 178 Bytes, 80 Fehler
Die Fehler werden grün hervorgehoben.
Da dies eine alte CPU ist, habe ich alte Konventionen verwendet. Ich habe & 8000 für hexadezimale Werte anstelle des bekannteren 0x8000 verwendet und mich dafür entschieden, jede Zeile des Musters mit einem "\ r" anstelle eines "\ n" zu beenden.
Quellcode HEX-codiert
Quellcode erklärt
Da die Z80 eine CPU ist, hat sie keine eigene Standardausgabe. Als solches habe ich lediglich jedes Zeichen direkt in den Speicher geschrieben, beginnend mit & 4000, und dann die 10.100 Bytes mit MEMDUMP eingegeben, um das richtige Muster zu überprüfen.
Der Z80 hat folgende Register:
Das spezielle Flag - Register enthält die folgenden Flags:
SZ-H-VNC
. S ign, Z ero, H alf-Carry, O v erflow (auch als P arity verwendet), N egativ und C arry. Die mit gekennzeichneten Positionen-
sind nicht belegt. Die H alf- Carry- und N egative-Flags werden nur intern von der CPU verwendet. S ign und O v erflow / P arity nehmen zusätzliche Bytes zu verwenden , so ich nur mit Z ero und C arry die fertig oder nach jeder Berechnung zurückgesetzt, aber nicht , wenn die Werte bewegen.Es gibt andere Register, die jedoch für eine Golfherausforderung nicht relevant sind, da sie zusätzliche Bytes benötigen, um verwendet zu werden.
LD
l oa d s ein Wert in ein Register oder eine Adresse, zBLD C, 4
istC = 4
. Der Wert kann direkt sein (ein oder zwei zusätzliche Bytes für einen 8-Bit- oder 16-Bit-Wert) oder aus einem anderen Register kopiert werden. Ein Mittelwert, der(HL)
an oder von der Adresse kopiert wird, auf die von verwiesen wirdHL
.PUSH
undPOP
Push (Speichern in) und Pop (Wiederherstellen von) dem Stapel, der nur 16-Bit-Werte speichern kann. Als solches wirdAF
es als ein einzelnes 16-Bit-Register behandelt, obwohl es von keinem anderen Befehl so verwendet wird.AND
ist bitweise und . Der Z80 hat keine booleschen Logikbefehle, sondern Boolesche Flags.JR
j ump r elativ mit einem vorzeichenbehafteten Offset von einem Byte. Dies verwendet ein Byte weniger als das absolute j um pJP
, hat jedoch weniger Bedingungen, auf die getestet werden kann.INC
undDEC
inc rement und Dezember rement 8 und 16 - Bit - Register.DJNZ
d ecrement und j UMP wenn n on- Z ero. Dies entspricht genauDEC B; JR NZ, ##;
einem Byte weniger, ist jedoch nur für dasB
Register verfügbar .RET
kehrt zum anrufenden Standort zurück. Es kann optional Bedingungen enthalten.ADD
undSUB
fügt zu und sub - Darm - Trakt von entweder den 8 - Bit -A
Registern oder den 16 - Bit -HL
Registern.CP
c om p are subtrahiert den Wert vomA
Register, setzt die entsprechenden Flags, verwirft jedoch dasA
unveränderte Ergebnis .RRCA
r Otate r ight c ircular eine ccumulator. Dreht alle BitsA
einmal nach rechts und kopiert Bit 0 in Bit 7. Außerdem kopiert es Bit 0 in das Carry (C
) - Flag, nicht zu verwechseln mit demC
Register.Jedes Identicon-Muster kann folgendermaßen aufgeteilt werden:
wo 0-3 die Ecken sind, entsprechend gedreht, 4-7 die Randkacheln sind, entsprechend gedreht und 8 die Mittelkacheln sind, die (soweit ich das beurteilen kann) immer rotationssymmetrisch sind.
Glücklicherweise kann das Z80 Identicon vereinfacht werden, um:
Ich stelle die "0" in die Mitte, damit ich effizient nach einer Endbedingung suchen kann. In der Tat machte es Sinn, fast alles rückwärts zu machen, um den Code zu spielen!
:Offsets
ist ein Block mit vier Bytewerten, die ich als Versatz zum Muster für jeden Block verwende. Das Programm ermittelt den auszuführenden Block und ändert sich dann, um zum richtigen Code zu springen. Seltsamerweise scheint dies weniger Bytes zu verbrauchen als durch direktes Überprüfen!:DATA
(in den Kommentaren auch Magic Data genannt!) ist die codierte Reihenfolge, in der die Blöcke gerendert werden müssen. Es gibt 16 Werte, die normalerweise 16 Bytes erfordern, aber da jeder Wert nur 2 Bits lang ist, konnte ich 4 in ein Byte setzen und 12 Bytes einsparen! Der Code zum Speichern, Wiederherstellen und Dekodieren dieser Werte beträgt 6 Byte. Außerdem konnte ich durch Vermeidung der Verwendung der Zahl 0 in den höchsten 2 Bits dies als Zähler verdoppeln und mindestens 3 Bytes einsparen (2 zum Initialisieren, 1 zum Dekrementieren)! Gesamtzahl der gespeicherten Bytes: 12 - 6 + 3 = 9.Die Versatzdaten müssen an einem Ort gespeichert werden, der mit 00 hex endet, damit sie ordnungsgemäß funktionieren. Ich entschied mich für & 8000, da es ein guter abgelegener Ort zu sein schien. Dies bedeutet, dass das Programm bei & 8008 startet. Zufälligerweise produzierte Intel eine frühe CPU namens 8008, die als der Großvater des Z80 gelten könnte! Intel produzierte auch den 8080, auf dem Zilog seinen Z80 basierte und mit dem es vollständig kompatibel ist. Der Z80 verfügt über eine Reihe erweiterter Anweisungen, die der 8080 nicht bietet. Ich habe es vermieden, diese erweiterten Anweisungen zu verwenden, da jede ein Ein-Byte-Präfix hat, was bedeutet, dass dieses Programm auf dem 8080 auch die gleichen Ergebnisse liefert!
Da das Muster für Block-3 alle "1" ist, habe ich es in die Hauptschleife eingebettet, weshalb es einen Versatz von 00 hat. Dies spart 2 Bytes, indem es nicht von Block-3 zurückkehren muss! Zum Glück konnte ich die Startpositionen für alle vier Blöcke in weniger als 128 Bytes einpassen. Dies ist gut, da der Bereich eines relativen Sprungs von der aktuellen Position -128 bis 127 beträgt, berechnet nach dem Lesen des Offset-Bytes. Dh ein
JR
Befehl liest zwei Bytes und führt dann die Berechnung durch.JR 00
tut nichts.JR 01
überspringt ein Byte.JR FF
geht um ein Byte zurück und bewirkt, dass der nächste Befehl der Offset desJR
gerade ausgeführten Befehls ist, was wirklich schlecht ist, weil der BefehlFF
ist nichts für schwache Nerven ist!JR FE
geht um zwei Bytes zurück und verursacht eine Endlosschleife usw. Der Rücksprung von Block-0 ist jedoch zu weit (weniger als -128), sodass ich einfach in einen vorherigen Block zurückspringe, der dann wieder springt!Hier gibt es sicherlich noch etwas mehr Platz zum Golfen. Meine erste voll funktionsfähige Version war 239 Bytes. Durch Entfernen des Abschnitts "Extra-1s" auf Kosten von 48 Fehlern können 4 Byte und durch Entfernen des Abschnitts "Jaggies" auf Kosten von 32 Fehlern weitere 12 Byte gespeichert werden.
quelle
Haskell,
201190 Bytes, 44 FehlerVerwendet eine Funktionsmatrix für jede Form:
a
(Diamant);u
,d
,l
,r
(Dreiecke jede Richtung zugewandt ist ) undw
(weiß), und wendet die jeweils ein 25x25 - Raster mit Koordinaten[-12..12]
. Die Rauten- und Dreiecksformen werden nach der Manhattan-Norm berechnet, ähnlich der Octave-Lösung von flawr .Tatsächlich erzeugt nur die obere Hälfte, die nur benötigt
a
,w
,d
, undr
. Produziere die untere Hälfte durch Spiegeln (map reverse . reverse
).quelle
flip
tatsächlich eine geometrische Rotation ausgeführt wird._
in fallenmapM_
. Wenn Sie die Definition von entfernenl
und die Matrix durch: ersetzen[[a,r,d,a],[r,w,w,d],[u,w,w,flip u],[a,u,u,a]]
, können Sie einige Bytes speichern und einige Fehler hinzufügen.abs j+i+1<13
ist nurabs j+i<12
C # - 423 Bytes, 237 Fehler
Nur Ungleichheiten aufhäufen. Die meisten Fehler sind darauf zurückzuführen, dass ich t (= 25) an Stellen einsetze, an denen 24 verwendet werden soll.
Hier ist ein Versuch zu veranschaulichen, wie es funktioniert:
Mehr lesbarer Code:
Vielleicht könnten die Parens und die logischen Operatoren ein bisschen Golf spielen, aber ich bekomme Lisp-Flashbacks.
quelle
Perl
186184181151147 Bytes, 0 FehlerDer Code ist
fast so einfach wie das Bild! Ich könnte es um zwei weitere Bytes reduzieren, indem ich das Muster mit einer neuen Zeile beginnen lasse, anstatt mit dieser zu enden, aber technisch kann es nicht ohne Fehler validiert werden.es fällt mir schwer, es zu verstehen!quelle
x/99$/
.JavaScript (ES6), 239 Bytes, 99 verschiedene
Dabei werden Ungleichungen verwendet, um die Formen für einen Quadranten zu generieren, und der Rest des Codes wird gedreht, um die anderen zu füllen.
Der Text war gerade
JavaScript
. Dies ist ein ziemlich einfaches Identicon:Verwenden Sie das folgende Snippet, um dies zu überprüfen, da es besser unterstütztes JavaScript und Ausgaben in einer Monospace-Schriftart verwendet. Sie müssen wahrscheinlich auf "Ganze Seite" klicken, um alles zu sehen.
Code-Snippet anzeigen
quelle
Python 3,
975963 BytesDie gedruckte Zeichenfolge ist
"Python"
975 Byte mit 30 Fehlern.Denn
"Python 3"
ich habe verwendetDas würde es auf 1104 Bytes mit 124 Fehlern bringen, aber ich denke, ich bleibe dabei, es
"Python"
sei denn, OP fordert es an.quelle
J=''.join
im Lambda nur 12 Zeichen ausführen und speichern.map
; 2) Sparen Sie ein paar Bytes, indem Sie definierenR=lambda x:L(Z(*x[::-1]))
; 3) Nach dem Schließen der Klammern brauchen Sie keine Leerzeichen.HTML -
223210193191 Bytes, 0 Fehler100% gültiges HTML. Sowohl HTML als auch JavaScript sind ziemlich ausführlich, so dass der Code trotz der Einfachheit des Identicons immer noch sehr lang ist.
quelle
document.write()
mitdocument.write(c?2-c/2:+(Math.abs(i)+Math.abs(j)<14)),++x);
. Wenn Sie auf das Symbol mit klicken<>
, können Sie auch ein Stacksnippet erstellen, um Ihren Code zu präsentieren.<!DOCTYPE html><title>A</title><script>for(W=document.write,y=0,A=25;b=y/A&3,j=y%A-12,y<100;W('<br>'),++y)for(x=0;a=x/A&3,c=a*(3-a)+b*(3-b),i=x%A-12,x<100;W(c?2-c/2:+(Math.abs(i)+Math.abs(j)<14)),++x);</script>
.<p style=font-size:25px>◆■■◆<br>■ ■<br>■ ■<br>◆■■◆</p>
PowerShell 2.0,
448399392374349 Bytes, 49 FehlerDies druckt nur eine Zeile nach der anderen, mit einigen ausgefallenen Meta-Ersetzungen / Ausdrücken zum Golfen
ungolfed:
Darauf wird irgendwann hingewiesen
iex
:und dies ist 471 Bytes, 104 Fehler, die Rotationslogik verwendet
(relativ) ungolfed:
quelle
Python 2,
712711 BytesDieses Programm generiert das Bit-Array für 'Python', indem es die Lauflängencodierung verwendet und Läufe als Zeichen speichert.
Vor dem Autogolfer sah es (ziemlich ähnlich!) So aus:
Diese RLE-Methode sollte zu Null-Fehlern führen.
Das Identicon-Array für 'Python' sieht viel einfacher aus, aber ich dachte, es wäre ein Betrug, wenn ich das verwenden würde.
quelle
in
und einzufügenzip
. Es scheint den Raum zwischen35
undfor
zwar verpasst zu haben .35 for
(achten Sie darauf, das Leerzeichen beizubehalten, wenn der folgende Bezeichner mit eineme
! Beginnt ). Danke für deinen Rat.e
. Möglicherweise versuchen Sie, zu aktualisieren und zu prüfen? (als Referenz habe ich am 2.7.9 versucht)IDL, 472 Bytes, 290 Fehler
Pfui. Dies wäre viel kürzer, wenn ich Funktionen als Variablen speichern oder mehrere Zeichenfolgen gleichzeitig ersetzen könnte usw.
quelle
PHP -
417414413410 Bytes, 0 Fehler, (20 Warnungen!)Benötigt PHP> = 5.4.
PHP lässt zu, dass die Schlüsselwörter in jedem Fall verwendet werden. Daher habe ich Großbuchstaben für Schlüsselwörter und Kleinbuchstaben für Variablen innerhalb des Golf-Codes verwendet.
preg_replace
wird nur verwendet, um den Code zu entgolfen undeval
auszuführen. Ich entfernte$
von allen Variablen und fügte sie mit einem regulären Ausdruck wieder ein. Ich habe auch jede Instanz von&&
und||
zu&
und geändert|
und sie mit einem regulären Ausdruck verdoppelt. Ich kann nicht den gleichen Trick machen,++
weil ich auch benutze,+
dass ich nicht verdoppelt werden möchte. Ich habe versucht, die Logik umzukehren, um das-
Kurz danach loszuwerden,echo
aber es wurden zu viele99
s zu100
s. Es ist mir jedoch gelungen, die Verwendung eines einzelnen Leerzeichens zu vermeiden!Ich konnte Ismael Miguels Vorschlag auch auf den anderen Satz von
{}
Zahnspangen für diefor
Schleife anwenden , musste ihn jedochprint
anstelle von verwendenecho
.print
undecho
sind beide Sprachkonstrukte ("magische" Schlüsselwörter, die keine Klammern benötigen()
) und daher in einerfor
Deklaration nicht zulässig sind . Daprint
jedoch ein Rückgabewert wie eine Funktion vorhanden ist, ist dieser innerhalb von zulässigfor
. Durch Verschieben der Variablenzuordnungen vom dritten zum zweiten Abschnitt konnte ich auch die Warnungen beseitigen!quelle
\r\n
Zeilenenden, aber ich habe sie geändert, um nur\n
das von Ihnen vorgeschlagene Byte zu speichern.Pip , 116 Bytes (96 Fehler)
Zeilenumbrüche dienen nur Formatierungszwecken und haben keine Auswirkung auf den Code:
Leicht ungolfed mit Kommentaren:
Der Code erstellt das Identicon als Liste von Zeichenfolgen. Sobald Sie wissen, dass
X
es sich bei der Multiplikation um eine Zeichenfolge handelt,RL
es sich um eine Wiederholungsliste, eineAL
Anfügungsliste und eineJ
Verknüpfung handelt, ist sie ziemlich lesbar (IMHO). Die Variablenb
,t
undw
(in der Version ungolfed) entsprechen den folgenden Teilen des Identicon:Der obere linke Quadrant setzt sich wie folgt zusammen:
Wt
tb
wo
W
stellt 13 Zeilenb
von oben platziertw
. Wir drehen und kehren dann um, um den Rest der Figur zu erhalten.Die Fehler resultieren daraus, wie wir die dünnen weißen Dreiecke erzeugen (zweites Stück oben). Sie sind nicht genau gleich groß - eine hat eine ungerade Anzahl weißer Pixel und die andere eine gerade Anzahl - aber wenn Sie sie als gleich behandeln (ohne die oberste der untersten, insgesamt 25 Zeilen), sparen Sie ein paar Bytes. Hier ist eine 122-Byte-Version, die die geraden und ungeraden Treppenstufen korrekt ausführt (0 Fehler):
Und zum Spaß eine Python-Übersetzung des Originals (ohne Golf):
quelle
Ruby, 324 Bytes, 216 Fehler
Identicon benutzt den String
Ruby
und ich mag ihn irgendwie. Reine Geometrie + Symmetrie. Kantengleichungen für das Dreieck, Drehung um 45 ° für die Rechtecke, um sie auf die Achse auszurichten. Etwa 100 Fehler wurden für ein paar Bytes weniger geopfert.quelle
/// , 1319 Bytes, 0 Fehler
Probieren Sie es online!
Ich brauchte ungefähr 2 Stunden, um das zu machen, weil ich Dinge manuell ersetzte. Das größte was ich in /// gemacht habe.
Wahrscheinlich kann ich ein paar Bytes mehr Golf spielen.
Auch sehen Erik die Antwort der Golfer in /// (4 Byte kürzer als meine).
quelle
Fortran, 214 Bytes, 200 Fehler
Fortran ist vielleicht nicht die erste Wahl für Code Golf, aber sein Identicon sah so einfach aus, dass ich dachte, ich würde es versuchen. In der Tat kann ich nicht mit einigen der terseren Sprachen konkurrieren, sondern implizite Variablen und andere solche Feinheiten verwenden (z. B. Doppelt
-
soxor
), ist es nicht so schlimm - ich habe es auf 214 Bytes nach unten:Hinweis: Dies funktioniert nicht mit
gfortran
. Es kompiliert mit,ifort
wenn Sie der Datei eine.f90
Erweiterung geben (dies aktiviert die Freiformquelle).quelle
Perl -
3244318816091387 Bytes,0136678 FehlerIch habe eine Weile gebraucht, um das zu realisieren, aber das Symbol ist symmetrisch. Außerdem kann ich nur nach jeweils 100 Zeichen eine neue Zeile drucken, anstatt sie fest zu codieren.
Generiert den Text dazu:
quelle
$n=0
nochint()
;if($n>=100){print"\n";$n=0}
→$n>99and$n=!print"\n"
;@p
kann durch ersetzt werden/(.*);(.*)/;$n+=$2;print$1x$2
./// , 1315 Bytes, 0 Fehler
Probieren Sie es online!
Dies ist das Identicon für
///
. Es ist wahrscheinlich die größte Sache, die ich jemals in /// gemacht habe!quelle
IDL 8.4, 333 Bytes, 105 Fehler
Dies ergab ein anderes Identicon, und ich konnte es mit einer völlig anderen Methode wesentlich besser spielen.
Konvertieren Sie zuerst die Zeichen in Zeile 1 in Byte-Werte und subtrahieren Sie 64 (so dass A = 1, B = 2 usw.). Stecken Sie dann diese vielen aufeinander folgenden Einsen und Nullen in ein Array und reformieren Sie es in 50x50 (dh den oberen linken Quadranten, aber transponiert). Dann transponieren und drehen Sie es 4 Mal, nähen Sie sie zusammen und drucken Sie es aus.
quelle
Bubblegum, 535 Bytes, 0 Fehler
Mit zopfli (
--deflate --i10000
) komprimiert . Probieren Sie es online aus.Ziemliech direkt; Ich könnte später mit dem Hinzufügen von Fehlern experimentieren.
quelle
ForceLang,
274924992495 BytesNicht konkurrierende Sprache postdatiert die Frage.
quelle