Identikon adalah gambar kecil dari pola geometris yang mewakili nilai hash string. Stack Exchange menggunakan identicons dari Gravatar sebagai gambar avatar default setiap pengguna.
Dalam tantangan ini, kami akan menggunakan Gravatar identicons juga untuk menghasilkan beberapa teks ke golf.
Tantangan
Cuplikan tumpukan ini (versi yang diperkecil dari JSFiddle ini ) memungkinkan Anda mengetikkan string dan memberikan kembali 100 × 100 piksel versi hitam dan putih dari identitas string itu, bersama dengan versi teks di mana 1
untuk hitam dan 0
untuk putih:
<!-- 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>
(Ini juga memungkinkan Anda memuat gaya Monster, Wegro, dan Retro Gravatar, tetapi itu hanya untuk bersenang-senang dan tidak dimaksudkan untuk digunakan untuk tantangan ini. Sayangnya Unicornicons hilang karena kendala XSS .: /)
Tugas Anda adalah menulis program yang menampilkan blok teks 100 x 100 karakter 0
's dan 1
yang dihasilkan ketika Anda memasukkan nama bahasa pemrograman Anda ke dalam kotak input snippet.
Misalnya, jika kiriman Anda ditulis dengan Python , Anda akan mengetikkan Python
potongan snipet dan melihatnya
adalah identicon untuk Python, dan
adalah versi hitam dan putih (biner), dan
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
adalah output teks yang sesuai yang harus dihasilkan oleh program Python Anda.
Namun, karena identicons dapat memiliki banyak sudut canggung dan rasterisasi sebagai gambar hitam dan putih dapat meninggalkan jaggies , output Anda diperbolehkan untuk memiliki hingga 300 0
-an atau 1
yang merupakan kebalikan dari apa yang seharusnya. (Itu 3% dari total 10.000 0
dan 1
.)
Dekat bagian bawah potongan, Anda dapat menyisipkan dalam output program dan periksa berapa banyak 0
's atau 1
' s yang berbeda dari apa yang mereka harus. Sejumlah perbedaan pada atau di bawah 300 adalah valid.
Mencetak gol
Kiriman dengan byte paling sedikit menang. ( Penghitung byte yang berguna. )
Tiebreaker pergi ke kiriman dengan kesalahan 0
dan kesalahan paling sedikit 1
.
Jika masih ada seri, pengajuan sebelumnya menang.
Detail
- Output menuju ke stdout atau alternatif serupa jika bahasa Anda tidak memiliki stdout.
- Output secara opsional dapat memiliki baris tambahan.
- Harap sertakan gambar identitas warna dalam posting Anda bersama dengan string yang menghasilkannya. Tidak perlu membuang-buang ruang dan memposting seluruh output teks Anda.
- Program Anda harus berjalan tanpa koneksi internet. Anda perlu membuat teks dalam kode Anda, bukan meminta dari situs Gravatar.
- Gunakan akal sehat saat "menyebut" bahasa Anda. Gunakan nama bahasa yang biasanya Anda gunakan di situs ini. Jangan menyebalkan dan membuat nama yang membuat identitasnya mudah untuk golf. eg
Python 2
baik untuk Python tetapipython 2.7.2
merentangkannya danpython 2.7.2 by Guido van Rossum
akan menjadi konyol. - Saya menyadari beberapa bahasa secara inheren lebih mudah daripada yang lain karena bentuk identitasnya lebih sederhana. Begitulah seharusnya, jangan terlalu tidak puas atau kompetitif tentang hal itu. ;)
sumber
Jawaban:
CJam,
92817971 byte, 120 kesalahanMungkin masih ada ruang untuk bermain golf ini.
Uji di sini.
Penjelasan
Saya tidak menggunakan kompresi apa pun, tetapi malah saya benar-benar menghitung ubin individu dan menyatukan hasilnya dari itu. Ubin kiri atas sengaja diperkirakan. Beberapa kesalahan lain dihasilkan dari gambar binaris yang tidak sepenuhnya simetris secara rotasi. Mari kita lihat kodenya.
Ubin pertama secara teoritis akan terlihat seperti ini:
Itu 12 garis, lalu 13 garis titik antara
1
s dan0
menurun 2 pada satu waktu. Perhatikan bahwa blok pertama memiliki angka genap0
dan blok kedua angka ganjil. Kita dapat membuat pola lebih teratur jika kita mengorbankan akurasi di baris tengah dan mengubahnya menjadi1
diikuti oleh 240
detik. Kemudian kita benar-benar memiliki satu baris untuk setiap angka nol dari 0 hingga 24, bergantian antara bagian atas dan bawah. Jadi kita bisa membuatnya secara berurutan (sebagai satu segitiga), dan kemudian menarik setiap baris lainnya:Selanjutnya adalah segitiga mewah di sebelah kanan ubin ini:
Jika kita mempertimbangkan sistem koordinat dengan asal di sudut kanan atas dan
x
akan benar dany
akan turun, maka wilayah1
s memenuhi 3 ketidaksetaraan:x/y ≥ 1/2
,x/y ≥ 2
,x + y < 38
. Kami hanya dapat menghitung ini secara terpisah dan mengambil akhir yang logis. Itu tidak menyimpan karakter apa pun tetapi membersihkan kode sedikit jika kita menggabungkan dua ketidaksetaraan pertama:Pada akhirnya, kami akan menyimpan byte lain dengan memeriksa yang sebaliknya dan menggunakan
xor
alih-alihand
menggabungkan hasilnya dengan ketidaksetaraan lainnya:Kami memiliki semua yang ada sekarang - ubin yang tersisa hanya salinan dan rotasi ini, serta ubin padat (membosankan) di tengah. Jadi mari kita kumpulkan semuanya:
Di akhir program, CJam hanya mencetak isi tumpukan kembali-ke-belakang, menciptakan hasil yang diinginkan.
sumber
Oktaf
166164 byte, 0 kesalahanOktaf memiliki kekuatan besar dalam menangani / membangun matriks. Untuk 'berlian' saya membuat sistem koordinat-xy dan menggunakan norma manhattan untuk memutuskan apakah entri akan 1 atau 0. Karena berlian tidak sepenuhnya simetris, saya harus bermain-main dengan 'jarak' dan titik tengah, jadi dengan titik pusat (13.1,13.1) itu bekerja untuk kedua jenis bentuk 'berlian'.
Setelah itu saya hanya bisa mengatur seperempat dari itu menjadi nol untuk mendapatkan bentuk-C itu. Kuadrat dan gabungan matriksnya mudah.
Versi Baru -2 karakter (bekerja dengan cara yang sama seperti yang lama, tapi saya berhasil menyalahgunakan sintaks Octave bahkan lebih:
Versi lama:
Keluaran
sumber
Brainfuck
94182237 byte, 88 kesalahanSunting: Seperti mbomb007 menunjukkan nama 'resmi' tampaknya tidak dikapitalisasi, ini tidak disebutkan di wikipedia, tetapi pada esolang . Ini mengganggu saya, tetapi hampir tidak cukup untuk mengulang ini;).
Program Brainfuck pertama saya!
Sekarang sebenarnya menggunakan matematika dan logika dan lainnya! (untuk setiap piksel, ia memutuskan 0 atau 1 tergantung pada beberapa persyaratan). Ini cukup menyenangkan untuk dilakukan; itu dikatakan saya tidak berpikir saya akan kode lagi dengan Brainfuck untuk waktu yang lama .
menghasilkan bitmap dari gambar:
Versi dengan beberapa komentar (mungkin tidak terlalu berguna karena sebagian besar untuk keuntungan saya sendiri):
sumber
Python,
294273239188179170159154 byteIni adalah versi 158-byte :
Ini adalah program hanya Python 2, tapi saya menggunakan identicon untuk "Python" (yaitu yang ada di OP). Perbedaannya harus 78 bit.
Dengan mengeluarkan akurasi, inilah versi 154-byte :
yang memiliki perbedaan 224 bit sebagai gantinya.
(-4 byte terima kasih kepada Stefan Pochmann)
Penjelasan
Ini versi alternatif yang diperluas:
Untuk versi ini, kami memperlakukan identitas sebagai kisi pola 4x4. Kami mulai dengan kisi 100x100 0s dan melakukan empat kali berikut:
Versi aslinya serupa, tetapi alih-alih berputar setelah ketiga pola selesai, kami memutar setiap kali kami memodifikasi sel tunggal . Ini membuat program membutuhkan waktu beberapa detik, tetapi hasilnya sama.
sumber
J
danr
ke dalam satu baris menggunakan tanda titik koma.~i%12<j/2>i%12
3 lebih pendek dariabs(i%12-6)+5<j/2
tetapi mengarah ke 224 diff saya pikir.C,
255245237234 byteIdentikon C sangat simetris.
Golfed: (baris baru ditambahkan untuk "keterbacaan")
Ini menyimpan setengah dari setiap baris di bagian atas ke dalam bilangan bulat 64-bit, kemudian mencetak 50 bit lebih rendah dari bilangan bulat yang sesuai dalam biner dua kali, dengan cetakan kedua dibalik.
Diperlukan 64-bit int untuk menjalankan ini (jika sistem Anda tidak menggunakan 64-bit int, maka Anda dapat menambahkan
long
ataulong long
sebelumd[50]
, dan(long)
atau(long long)
setelaho[i-1]=i<26?
).Tidak dikumpulkan dan berkomentar:
Output memiliki 291 kesalahan.
Terima kasih kepada ace untuk tip penggunaannya
puts("")
sumber
putchar(10)
denganputs("")
untuk menyimpan 3 byte.C,
224206200176 byte, 243 kesalahanUntuk mereplikasi:
Kode di atas menghasilkan biner yang berkorelasi dengan gambar ini, dengan 243 kesalahan:
Dari apa yang saya tahu, saya menggunakan metode yang agak berbeda dari solusi es1024. Metode ini mungkin bisa lebih jauh dipagari, jadi saya akan menunda penjelasan sebentar, tapi ini dia dalam kemuliaan terurai:
Ini pada dasarnya menggunakan satu set ketidaksetaraan untuk mendefinisikan poligon, dan sangat bergantung pada simetri.
Saat ini tengah malam, dan kemampuan saya untuk membaca kode saya sendiri memburuk dengan cepat. Anda mungkin dapat mengutak-atik beberapa konstanta untuk menurunkan kesalahan, tetapi saya hanya dapat secara konsisten memecahkan semuanya.
Fakta menyenangkan, bukan saja ini versi terpendek yang saya buat, tetapi gcc tidak memberikan peringatan !
sumber
for
lingkaran luarfor(;i+1;i+=k=i-50?puts(b),k:-1)
untuk mengurangi satu titik koma dan dua kawat gigi, menghemat 3 byte.k=1
kemain(k)
untuk menyimpan 3 byte.gs2 : 72 byte, 200 kesalahan
Belum benar-benar bermain golf ini, tidak yakin apakah saya mau. Ilmu tentang cara menghafal:
Program itu sendiri:
sumber
Z80, 194 byte, 0 kesalahan
Z80, 178 byte, 80 kesalahan
Kesalahan disorot dalam warna hijau.
Karena ini adalah CPU jadul, saya telah menggunakan konvensi jadul. Saya telah menggunakan & 8000 untuk nilai hex alih-alih 0x8000 yang lebih akrab dan saya telah memilih untuk mengakhiri setiap baris pola dengan "\ r", bukan "\ n".
Kode sumber HEX disandikan
Kode sumber dijelaskan
Karena Z80 adalah CPU, Z80 tidak memiliki output standar sendiri. Karena itu, saya hanya menulis setiap karakter langsung ke memori, mulai dari & 4000, dan kemudian MEMDUMP 10.100 byte untuk memverifikasi pola yang benar.
Z80 memiliki register sebagai berikut:
Bendera khusus mendaftar berisi flag berikut:
SZ-H-VNC
. S ign, Z ero, H alf-carry, O v erflow (juga digunakan sebagai P arity), N egative dan C arry. Posisi yang ditandai oleh-
tidak digunakan. The H alf-carry dan N bendera egative hanya digunakan secara internal oleh CPU. S ign dan O v erflow / P arity membutuhkan byte tambahan untuk digunakan, jadi saya hanya menggunakan Z ero dan C arry yang diatur atau diatur ulang setelah setiap perhitungan, tetapi tidak saat memindahkan nilai.Ada register lain yang tersedia tetapi mereka tidak relevan dengan tantangan golf karena mereka membutuhkan byte tambahan untuk digunakan.
LD
l oa d s nilai ke dalam register atau alamat, misalnyaLD C, 4
adalahC = 4
. Nilai dapat langsung (satu atau dua byte tambahan untuk nilai masing-masing 8-bit atau 16-bit) atau dapat disalin dari register lain. Nilai(HL)
sarana menyalin ke atau dari alamat yang ditunjuk olehHL
.PUSH
danPOP
tekan (save to) dan pop (restore from) stack, yang hanya bisa menyimpan nilai 16-bit. Dengan demikian,AF
diperlakukan sebagai register 16-bit tunggal meskipun tidak ada instruksi lain yang menggunakannya seperti itu.AND
bitwise dan . Z80 tidak memiliki instruksi logika boolean, tetapi memiliki flag boolean.JR
j UMP r elative menggunakan satu byte ditandatangani offset. Ini menggunakan satu byte kurang dari mutlak j um pJP
, namun memiliki kondisi lebih sedikit yang dapat diuji untuk.INC
danDEC
inc Re-Ment dan Desember Re-Ment 8 dan 16 bit register.DJNZ
d ecrement dan j UMP jika n on z ero. Ini melakukan persis sama sepertiDEC B; JR NZ, ##;
dalam satu byte kurang tetapi hanya tersedia untukB
register.RET
ret guci ke lokasi panggilan. Secara opsional dapat memiliki kondisi di atasnya.ADD
danSUB
tambahkan ke dan sub- saluran dariA
register 8 bit atau register 16 bitHL
.CP
c om p mengurangkan nilai dariA
register, menetapkan flag yang sesuai tetapi membuang hasilnyaA
tanpa perubahan.RRCA
r otate r ight c mengitari sebuah ccumulator. Putar semua bitA
sekali ke kanan, menyalin bit 0 ke bit 7. Ini juga menyalin bit 0 keC
bendera Carry ( ), jangan bingung denganC
register.Setiap pola Identicon dapat diuraikan seperti ini:
di mana 0-3 adalah sudut, diputar sebagaimana mestinya, 4-7 adalah ubin tepi, diputar sesuai kebutuhan dan 8 adalah ubin tengah yang (sejauh yang saya tahu) selalu simetris secara rotasi.
Untungnya, Z80 Identicon dapat disederhanakan menjadi:
Saya meletakkan "0" di tengah untuk memungkinkan saya memeriksa kondisi akhir secara efisien. Bahkan, untuk bermain golf kode itu masuk akal untuk melakukan hampir semuanya mundur!
:Offsets
adalah blok nilai empat byte yang saya gunakan sebagai offset dengan pola untuk setiap blok. Program ini bekerja di mana blok untuk dijalankan kemudian mengubah dirinya untuk melompat ke kode yang tepat. Anehnya, ini tampaknya menggunakan byte lebih sedikit daripada dengan memeriksa secara langsung!:DATA
(juga disebut data ajaib dalam komentar!) adalah urutan yang dikodekan di mana blok perlu dirender. Ada 16 nilai, biasanya membutuhkan 16 byte tetapi karena setiap nilai hanya 2 bit, saya bisa memasukkan 4 menjadi satu byte, menghemat 12 byte! Kode untuk menyimpan, mengembalikan, dan mendekode nilai-nilai ini adalah 6 byte. Selain itu, dengan menghindari penggunaan angka 0 dalam 2 bit tertinggi, saya dapat menggandakan ini sebagai penghitung, menghemat setidaknya 3 byte (2 untuk menginisialisasi, 1 ke penurunan)! Total byte yang disimpan: 12 - 6 + 3 = 9.Data offset harus disimpan di lokasi yang diakhiri dengan hex 00 agar berfungsi dengan baik. Saya memilih & 8000 karena sepertinya lokasi out-of-the-way yang bagus. Ini berarti program dimulai pada & 8008. Secara kebetulan, Intel memproduksi CPU awal yang disebut 8008 yang dapat dianggap sebagai kakek Z80! Intel juga memproduksi 8080, yang menjadi dasar Zilog Z80 mereka, sepenuhnya kompatibel dengan. Z80 memiliki serangkaian instruksi tambahan yang tidak dimiliki 8080. Saya telah menghindari menggunakan instruksi yang diperluas ini karena masing-masing memiliki awalan satu byte, yang berarti bahwa program ini juga akan menghasilkan hasil yang sama pada 8080!
Karena pola untuk Blok-3 adalah semua "1", saya telah menyematkannya ke loop utama, itulah sebabnya ia memiliki offset 00. Ini menghemat 2 byte dengan tidak harus kembali dari Blok-3! Untungnya saya dapat menyesuaikan lokasi awal untuk keempat blok menjadi kurang dari 128 byte. Ini bagus karena kisaran lompatan relatif adalah -128 hingga 127 dari posisi saat ini, dihitung setelah membaca byte offset. Yaitu sebuah
JR
instruksi membaca dua byte kemudian melakukan perhitungan.JR 00
tidak melakukan apa-apa.JR 01
melompati satu byte.JR FF
kembali dengan satu byte yang menyebabkan instruksi berikutnya menjadi offset dari yangJR
baru saja dieksekusi, yang benar-benar buruk karena instruksiFF
tidak untuk yang lemah hati!JR FE
kembali oleh dua byte yang menyebabkan loop tak terbatas, dll. Namun, lompatan kembali dari Blok-0 terlalu jauh (kurang dari -128) jadi saya hanya melompat kembali ke blok sebelumnya, yang kemudian melompat lagi!Pasti ada ruang untuk bermain golf ini sedikit lebih jauh. Versi sepenuhnya berfungsi pertama saya adalah 239 byte. 4 byte dapat disimpan dengan menghapus bagian "Extra-1s" dengan mengorbankan 48 kesalahan dan 12 byte selanjutnya dapat disimpan dengan menghapus bagian "Jaggies" dengan mengorbankan 32 kesalahan.
sumber
Haskell,
201190 byte, 44 kesalahanMenggunakan matriks fungsi untuk setiap bentuk yang berbeda:
a
(berlian);u
,d
,l
,r
(Segitiga menghadap setiap arah) danw
(putih), dan berlaku masing-masing untuk grid 25x25 dengan koordinat[-12..12]
. Bentuk berlian dan segitiga dihitung menggunakan norma Manhattan, mirip dengan solusi Octave dari flawr .Sebenarnya hanya menghasilkan setengah bagian atas, yang hanya membutuhkan
a
,w
,d
, danr
. Hasilkan setengah bagian bawah melalui mirroring (map reverse . reverse
).sumber
flip
sebenarnya melakukan rotasi geometris di sini._
dimapM_
. Juga, jika Anda menghapus definisil
dan mengganti matriks dengan:,[[a,r,d,a],[r,w,w,d],[u,w,w,flip u],[a,u,u,a]]
Anda dapat menyimpan beberapa byte dan menambahkan beberapa kesalahan.abs j+i+1<13
hanyaabs j+i<12
C # - 423 byte, 237 kesalahan
Hanya menumpuk ketidaksetaraan. Sebagian besar kesalahan adalah karena saya mengganti t (= 25) di tempat yang seharusnya menggunakan 24.
Berikut adalah upaya untuk memvisualisasikan cara kerjanya:
Kode lebih mudah dibaca:
Mungkin bisa bermain golf parens dan operator logis sedikit, tapi saya mendapat kilas balik Lisp.
sumber
Perl
186184181151147 byte, 0 kesalahanKode ini
hampir sesederhana seperti gambar! Saya bisa menguranginya dengan dua byte lagi dengan memiliki pola yang dimulai dengan baris baru alih-alih diakhiri dengan itu tetapi secara teknis itu tidak valid tanpa kesalahan.sampai pada titik di mana saya mengalami kesulitan memahaminya!sumber
x/99$/
.JavaScript (ES6), 239 byte, 99 berbeda
Ini menggunakan ketidaksetaraan untuk menghasilkan bentuk untuk satu kuadran, dan sisa kode memutar itu untuk mengisi yang lain.
Teksnya adil
JavaScript
. Ini adalah identitas yang cukup sederhana:Gunakan cuplikan di bawah untuk memverifikasi, karena menggunakan JavaScript yang lebih baik dan hasil dalam font monospace. Anda mungkin harus mengklik "Halaman penuh" untuk melihat semua itu.
Tampilkan cuplikan kode
sumber
Python 3,
975963 byteString yang dicetak berukuran
"Python"
975 byte dengan 30 kesalahan.Karena
"Python 3"
saya duluYang akan membawanya hingga 1104 byte dengan 124 kesalahan, tapi saya pikir saya akan tetap dengan
"Python"
kecuali diminta oleh OP.sumber
J=''.join
dan menyimpan 12 karakter di lambda.map
; 2) simpan beberapa byte dengan mendefinisikanR=lambda x:L(Z(*x[::-1]))
; 3) tidak perlu spasi setelah tanda kurung ditutup.HTML -
223210193191 byte, 0 kesalahan100% HTML yang valid. Baik HTML dan JavaScript cukup bertele-tele sehingga meskipun kesederhanaan identitasnya, kode ini masih sangat panjang.
sumber
document.write()
dengandocument.write(c?2-c/2:+(Math.abs(i)+Math.abs(j)<14)),++x);
. Juga, jika Anda mengklik ikon dengan<>
, Anda dapat membuat stacksnippet untuk menampilkan kode Anda.<!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 byte, 49 kesalahanini hanya mencetak satu baris pada satu waktu, dengan beberapa penggantian / ekspresi meta mewah untuk bermain golf
ungolfed:
inilah yang akhirnya disalurkan ke
iex
:dan yang ini adalah 471 byte, 104 kesalahan, yang menggunakan logika rotasi
(relatif) tidak berbulu:
sumber
Python 2,
712711 byteProgram ini menghasilkan bit array untuk 'Python' dengan menggunakan enkode panjang run dan menyimpan run sebagai karakter.
Sebelum pegolf otomatis, terlihat (sangat mirip!) Seperti:
Metode RLE ini akan menghasilkan nol kesalahan.
Array identicon untuk 'python' terlihat jauh lebih mudah, tapi saya pikir akan curang jika saya menggunakannya.
sumber
in
danzip
. Tampaknya telah melewatkan ruang di antara35
danfor
meskipun.35 for
urutan jenis (berhati-hati untuk menjaga ruang jika pengidentifikasi berikut dimulai dengane
!). Terima kasih atas saranmu.e
. Mungkin mencoba memperbarui dan menguji? (untuk referensi saya mencoba pada 2.7.9)IDL, 472 byte, 290 kesalahan
Ugh. Ini akan jauh lebih pendek jika saya bisa menyimpan fungsi sebagai variabel, atau melakukan penggantian string sekaligus, dll.
sumber
PHP -
417414413410 byte, 0 kesalahan, (20 peringatan!)Membutuhkan PHP> = 5.4.
PHP memungkinkan kata kunci untuk kasus apa pun jadi saya telah menggunakan huruf besar untuk kata kunci dan huruf kecil untuk variabel dalam kode golf.
preg_replace
hanya digunakan untuk ungolf kode daneval
untuk menjalankannya. Saya dihapus$
dari semua variabel dan dimasukkan kembali dengan regex. Saya juga mengubah setiap contoh&&
dan||
untuk&
dan|
dan dua kali lipat mereka dengan regex. Saya tidak dapat melakukan trik yang sama++
karena saya juga menggunakan+
yang saya tidak ingin berlipat ganda. Saya mencoba membalikkan logika untuk menghilangkan-
setelahecho
tapi itu berubah terlalu banyak99
menjadi100
. Namun, saya berhasil menghindari menggunakan satu ruang!Saya bisa menerapkan saran Ismael Miguel ke set
{}
kawat gigi lain untukfor
loop juga, namun, saya harus menggunakanprint
bukanecho
.print
danecho
keduanya merupakan konstruksi bahasa (kata kunci "ajaib" yang tidak membutuhkan tanda kurung()
) dan karenanya tidak diizinkan di dalamfor
deklarasi. Namun, karenaprint
memiliki nilai pengembalian seperti fungsi, itu diizinkan di dalamfor
. Dengan memindahkan tugas variabel dari bagian ketiga ke bagian kedua saya juga bisa menghilangkan peringatan!sumber
\r\n
akhir baris tetapi saya mengubahnya hanya\n
untuk menyimpan satu byte seperti yang Anda sarankan.Pip , 116 byte (96 kesalahan)
Baris baru hanya untuk keperluan memformat dan tidak berpengaruh pada kode:
Sedikit tidak menyukai komentar:
Kode membangun identitas sebagai daftar string. Setelah Anda tahu bahwa
X
ini adalah perkalian string,RL
daftar berulang,AL
tambahkan daftar, danJ
bergabung, itu cukup mudah dibaca (IMHO). Variabelb
,,t
danw
(dalam versi yang tidak disatukan) berhubungan dengan bagian-bagian dari identitas berikut:Kuadran kiri atas disatukan seperti ini:
Wt
tb
dimana
W
mewakili 13 garisb
ditempatkan di atasw
. Kami kemudian memutar dan mundur untuk mendapatkan sisa gambar.Kesalahan dihasilkan dari bagaimana kita menghasilkan segitiga putih kurus (bagian kedua di atas). Mereka tidak persis ukuran yang sama - satu memiliki jumlah ganjil piksel putih dan yang lainnya memiliki angka genap - tetapi memperlakukan mereka sebagai sama (tanpa baris paling atas, untuk total 25 baris) menghemat beberapa byte. Berikut adalah versi 122-byte yang melakukan tangga genap-aneh dengan benar (0 kesalahan):
Dan, hanya untuk bersenang-senang, terjemahan Python yang asli (bukan golf):
sumber
Ruby, 324 byte, 216 kesalahan
Identicon menggunakan string
Ruby
, dan saya menyukainya. Geometri murni + simetri. Persamaan tepi untuk segitiga, rotasi 45 ゜ untuk persegi panjang untuk membuat mereka sejajar. Sekitar 100 kesalahan telah dikorbankan untuk beberapa byte lebih sedikit.sumber
/// , 1319 byte, 0 kesalahan
Cobalah online!
Ini membuat saya sekitar 2 jam untuk membuat, karena saya secara manual mengganti barang. Hal terbesar yang saya buat di ///.
Mungkin saya bisa bermain golf beberapa byte lagi.
Juga, lihat jawaban Erik the Golfer di /// (4 byte lebih pendek dari milik saya).
sumber
Fortran, 214 byte, 200 kesalahan
Fortran mungkin bukan pilihan pertama untuk kode golf, tetapi identitasnya terlihat sangat sederhana sehingga saya pikir saya akan mencobanya. Sebenarnya saya tidak bisa bersaing dengan beberapa bahasa terser, tetapi menggunakan variabel implisit dan kualitas lain seperti itu (misalnya,
-
ganda sebagaixor
), itu tidak begitu buruk - saya turun ke 214 byte:Catatan: Ini tidak akan bekerja dengan
gfortran
. Ini dikompilasi denganifort
jika Anda memberikan.f90
ekstensi file (ini mengaktifkan sumber formulir gratis).sumber
Perl -
3244318816091387 byte,0136678 kesalahanButuh beberapa saat untuk menyadarinya, tetapi ikonnya simetris. Juga, saya bisa mencetak baris baru setelah setiap 100 karakter daripada mengkodekannya.
Buat teks untuk ini:
sumber
$n=0
jugaint()
;if($n>=100){print"\n";$n=0}
→$n>99and$n=!print"\n"
;@p
dapat digantikan oleh/(.*);(.*)/;$n+=$2;print$1x$2
./// , 1315 byte, 0 kesalahan
Cobalah online!
Ini adalah identitas untuk
///
. Mungkin hal terbesar yang pernah saya lakukan di ///!sumber
IDL 8.4, 333 byte, 105 kesalahan
Ini memberikan identitas yang berbeda, dan saya bisa bermain golf lebih banyak menggunakan metode yang sama sekali berbeda.
Pertama, konversikan karakter di baris 1 ke nilai byte dan kurangi 64 (sehingga A = 1, B = 2, dll.). Kemudian, tempelkan banyak angka 1 dan 0 yang berurutan ke dalam array, dan ubah menjadi 50x50 (yaitu, kuadran kiri atas, tetapi ditransformasikan). Kemudian, transpos & putar 4 kali, jahit bersama, dan cetak.
sumber
Bubblegum, 535 byte, 0 kesalahan
Dikompresi menggunakan zopfli (
--deflate --i10000
). Cobalah online.Cukup mudah; Saya mungkin bereksperimen dengan menambahkan beberapa kesalahan nanti.
sumber
ForceLang,
274924992495 byteTidak bersaing, bahasa memposting pertanyaan.
sumber