Los identicons son pequeñas imágenes de patrones geométricos que representan el valor hash de una cadena. Stack Exchange utiliza los identicons de Gravatar como imagen de avatar predeterminada de cada usuario.
En este desafío, también usaremos las identificaciones de Gravatar para generar texto para el golf.
Desafío
Este fragmento de pila (una versión reducida de este JSFiddle ) le permite escribir una cadena y le devuelve una versión en blanco y negro de 100 × 100 píxeles del identificador de esa cadena, junto con una versión de texto donde 1
es para negro y 0
es para blanco:
<!-- 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>
(También te permite cargar los estilos Monster, Wavatar y Retro Gravatar, pero son solo por diversión y no están destinados a ser utilizados para este desafío. Desafortunadamente, los Unicornicons faltan debido a las restricciones de XSS .: /)
Su tarea es escribir un programa que genere el bloque de texto de 100 × 100 caracteres de 0
'sy 1
' que se genera cuando coloca el nombre de su lenguaje de programación en el cuadro de entrada del fragmento.
Por ejemplo, si su envío está escrito en Python , escribiría Python
en el fragmento de la pila y vería que
es el identicon para Python, y
es la versión en blanco y negro (binario), y
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
es el resultado textual correspondiente que debe producir su programa Python.
Sin embargo, dado que los identicones pueden tener muchos ángulos incómodos y su rasterización como una imagen en blanco y negro puede dejar irregularidades , su salida puede tener hasta 300 0
's o 1
opuestos de lo que se supone que son. (Eso es el 3% del total de 10000 0
's y 1
' s).
En la parte inferior del fragmento, se puede pegar en la salida de su programa y comprobar cuántos 0
's o 1
' s son diferentes de lo que deberían ser. Cualquier número de diferencias igual o inferior a 300 es válida.
Puntuación
El envío con la menor cantidad de bytes gana. ( Práctico contador de bytes ) .
Tiebreaker va a la presentación con la menor cantidad de 0
'sy' incorrectos 1
.
Si todavía hay un empate, la presentación anterior gana.
Detalles
- La salida va a stdout o una alternativa similar si su idioma no tiene stdout.
- La salida puede tener opcionalmente una nueva línea final.
- Incluya la imagen de identificación de color en su publicación junto con la cadena exacta que la genera. No es necesario desperdiciar espacio y publicar toda su salida de texto.
- Su programa debe ejecutarse sin una conexión a Internet. Debe generar el texto en su código, no consultarlo desde el sitio de Gravatar.
- Use el sentido común al "nombrar" su idioma. Use el nombre del idioma que usaría normalmente en este sitio. No seas molesto y crea un nombre que haga que el identicon sea fácil de jugar al golf. por ejemplo,
Python 2
está bien para Python pero lopython 2.7.2
está estirando ypython 2.7.2 by Guido van Rossum
sería ridículo. - Me doy cuenta de que algunos idiomas son inherentemente más fáciles que otros porque sus formas de identificación son más simples. Así será, no te enojes ni seas tan competitivo con eso. ;)
fuente
Respuestas:
CJam,
92817971 bytes, 120 erroresProbablemente todavía hay espacio para jugar al golf.
Pruébalo aquí.
Explicación
No estoy usando ninguna compresión, sino que en realidad calculo los mosaicos individuales y reconstruyo el resultado a partir de ellos. El mosaico superior izquierdo se aproxima intencionalmente. Algunos otros errores resultan de que la imagen binarizada no es completamente simétrica rotacionalmente. Veamos el código.
El primer mosaico teóricamente debería verse así:
Eso es 12 líneas, a continuación, 13 líneas del punto entre
1
s y0
s del disminuyendo por 2 a la vez. Observe que el primer bloque tiene un número par de0
sy el segundo bloque tiene un número impar. Podemos hacer que el patrón sea aún más regular si sacrificamos la precisión en la fila central y la convertimos en1
seguida por 240
s. Entonces en realidad tenemos una fila para cada número de ceros de 0 a 24, alternando entre las partes superior e inferior. Por lo tanto, podemos generarlos en orden (como un solo triángulo) y luego extraer cualquier otra línea:El siguiente es ese triángulo elegante a la derecha de este mosaico:
Si consideramos un sistema de coordenadas con origen en la esquina superior derecha y
x
va a la derecha yy
bajando, entonces la región de1
s satisface 3: desigualdadesx/y ≥ 1/2
,x/y ≥ 2
,x + y < 38
. Podemos calcularlos por separado y tomar el final lógico. Sin embargo, no guarda ningún carácter, pero limpia ligeramente el código si combinamos las dos primeras desigualdades:Finalmente, guardaremos otro byte verificando lo contrario y usando en
xor
lugar deand
combinar el resultado con la otra desigualdad:Ahora tenemos todo en su lugar: los mosaicos restantes son solo copias y rotaciones de estos, así como el mosaico sólido (aburrido) en el centro. Así que vamos a juntar todo:
Al final del programa, CJam simplemente imprime el contenido de la pila de forma consecutiva, creando el resultado deseado.
fuente
Octave
166164 bytes, 0 ErroresOctave tiene una gran fuerza en el manejo / construcción de matrices. Para los 'diamantes' hice un sistema de coordenadas xy y utilicé la norma de Manhattan para decidir si las entradas serán 1 o 0. Como los diamantes no son completamente simétricos, tuve que jugar con la 'distancia' y el punto central, así que con el punto central (13.1,13.1) funcionó para ambos tipos de formas de 'diamante'.
Después de eso, pude establecer una cuarta parte de esos en cero para obtener esas formas C. Los cuadrados y la concatenación de la matriz fueron fáciles.
Nueva versión -2 caracteres (funciona de la misma manera que la anterior, pero logré abusar de la sintaxis de Octave aún más:
Versión antigua:
Salida
fuente
Brainfuck
94182237 bytes, 88 erroresEditar: como mbomb007 señaló que el nombre 'oficial' parece no estar en mayúscula, esto no se menciona en wikipedia, pero sí en esolangs . Esto me molesta, pero no lo suficiente como para rehacer esto;).
Mi primer programa Brainfuck!
¡Ahora en realidad usa matemáticas, lógica y demás! (por cada píxel decide 0 o 1 dependiendo de algunos condicionales). Esto fue bastante divertido de hacer; Dicho esto, no creo que vaya a codificar de nuevo con Brainfuck durante mucho, mucho tiempo.
produciendo el mapa de bits de la imagen:
Una versión con algunos comentarios (puede que no sea muy útil ya que fueron principalmente para mi propio beneficio):
fuente
Python,
294273239188179170159154 bytesAquí está la versión de 158 bytes :
Este es un programa exclusivo de Python 2, pero estoy usando el identicon para "Python" (es decir, el que está en el OP). La diferencia debe ser de 78 bits.
Al arrojar precisión por la puerta, aquí está la versión de 154 bytes :
que tiene una diferencia de 224 bits en su lugar.
(-4 bytes gracias a Stefan Pochmann)
Explicación
Aquí hay una versión expandida alternativa:
Para esta versión, tratamos el identicon como una cuadrícula de patrones 4x4. Comenzamos con una cuadrícula de ceros de 100x100 y hacemos las siguientes cuatro veces:
La versión original es similar, pero en lugar de rotar después de completar los tres patrones, rotamos cada vez que modificamos una sola celda . Esto hace que el programa tarde unos segundos, pero la salida es la misma.
fuente
J
yr
en una línea usando un punto y coma.~i%12<j/2>i%12
es 3 más corto queabs(i%12-6)+5<j/2
pero conduce a 224 diff, creo.C,
255245237234 bytesEl identicon de C es realmente simétrico.
Golfizado: (nuevas líneas agregadas para "legibilidad")
Esto almacena la mitad de cada línea en la mitad superior en un entero de 64 bits, luego imprime los 50 bits inferiores del entero apropiado en binario dos veces, invirtiendo la segunda impresión.
Se requieren enteros de 64 bits para que esto se ejecute (si su sistema no utiliza enteros de 64 bits, entonces es posible añadir
long
olong long
antesd[50]
, y el(long)
o(long long)
despuéso[i-1]=i<26?
).Ungolfed y comentó:
La salida tiene 291 errores.
Gracias a as por el consejo de usar
puts("")
fuente
putchar(10)
conputs("")
para guardar 3 bytes.C,
224206200176 bytes, 243 erroresPara replicar:
El código anterior genera binarios que se correlacionan con esta imagen, con 243 errores:
Por lo que puedo decir, uso un método bastante diferente de la solución de es1024. Este método probablemente se pueda seguir desarrollando, por lo que esperaré un poco la explicación, pero aquí está en su gloria desvelada:
Básicamente, utiliza un conjunto de desigualdades para definir los polígonos, y depende en gran medida de la simetría.
Actualmente es medianoche, y mi capacidad de leer mi propio código se está deteriorando rápidamente. Probablemente pueda jugar con algunas constantes para reducir los errores, pero solo puedo romper todo constantemente.
Dato curioso, no solo esta es la versión más corta que se me ocurrió, ¡sino que gcc no arroja advertencias !
fuente
for
bucle externofor(;i+1;i+=k=i-50?puts(b),k:-1)
para reducir un punto y coma y dos llaves, ahorrando 3 bytes.k=1
amain(k)
ahorrar 3 bytes.gs2 : 72 bytes, 200 errores
Realmente no he jugado esto todavía, no estoy seguro de si lo haré. Mnemotécnica:
El programa en sí:
fuente
Z80, 194 bytes, 0 errores
Z80, 178 bytes, 80 errores
Los errores se resaltan en verde.
Como se trata de una CPU de la vieja escuela, he usado convenciones de la vieja escuela. He usado & 8000 para valores hexadecimales en lugar del más familiar 0x8000 y he elegido terminar cada línea del patrón con un "\ r" en lugar de un "\ n".
Código fuente codificado HEX
Código fuente explicado
Como el Z80 es una CPU, no tiene salida estándar propia. Como tal, simplemente escribí cada carácter directamente en la memoria, comenzando desde & 4000, y luego MEMDUMP'd los 10,100 bytes para verificar el patrón correcto.
El Z80 tiene registros de la siguiente manera:
El registro especial de la bandera contiene los siguientes indicadores:
SZ-H-VNC
. S ign, Z ero, H alf-carry, O v erflow (también usado como P arity), N egative y C arry. Las posiciones marcadas por-
no se utilizan. Las banderas H alf-carry y N egative solo son utilizadas internamente por la CPU. S ign y O v erflow / P arity requieren bytes adicionales para usar, por lo que solo estoy usando Z ero y C arry que se configuran o restablecen después de cada cálculo, pero no cuando se mueven los valores.Hay otros registros disponibles, pero no son relevantes para un desafío de golf, ya que requieren bytes adicionales para su uso.
LD
l OA d es un valor en un registro o la dirección, por ejemploLD C, 4
esC = 4
. El valor puede ser directo (uno o dos bytes adicionales para un valor de 8 o 16 bits respectivamente) o puede copiarse desde otro registro. Un valor de(HL)
medios copia ao desde la dirección señalada porHL
.PUSH
yPOP
presione (guardar en) y explote (restaure) la pila, que solo puede almacenar valores de 16 bits. Como tal,AF
se trata como un único registro de 16 bits, aunque ninguna otra instrucción lo use así.AND
es bit a bit y . El Z80 no tiene instrucciones lógicas booleanas, pero tiene banderas booleanas.JR
j ump r elative utilizando un desplazamiento con signo de un byte. Esto usa un byte menos que el j um p absolutoJP
, pero tiene menos condiciones que se pueden probar.INC
yDEC
inc Re-Ment y diciembre Re-Ment 8 y 16 registros de bits.DJNZ
d ecrement y j UMP si n situ z ero. Esto hace exactamente lo mismo queDEC B; JR NZ, ##;
en un byte menos, pero solo está disponible para elB
registro.RET
Retirar las urnas a la ubicación de la llamada. Opcionalmente, puede tener condiciones.ADD
ySUB
añadir a y sub tracto ya sea del 8 bitA
registro o la 16 bitHL
de registro.CP
c om p se resta el valor delA
registro, establece las banderas según corresponda pero descarta el resultadoA
sin modificarlo.RRCA
r otate r ight c ircular un ccumulator. Rota todos los bitsA
una vez hacia la derecha, copiando el bit 0 en el bit 7. También copia el bit 0 en elC
indicador Carry ( ), para no confundirlo con elC
registro.Cada patrón de Identicon puede desglosarse así:
donde 0-3 son las esquinas, giradas según corresponda, 4-7 son los mosaicos de bordes, rotados según corresponda y 8 es el mosaico central que es (hasta donde puedo decir) siempre simétrico rotacionalmente.
Afortunadamente, el Z80 Identicon se puede simplificar para:
Puse los "0" en el centro para permitirme verificar eficientemente una condición final. De hecho, para jugar golf el código tenía sentido hacer casi todo al revés.
:Offsets
es un bloque de valores de cuatro bytes que uso como compensaciones del patrón para cada bloque. El programa determina qué bloque ejecutar y luego se altera para saltar al código correcto. ¡Curiosamente, esto parece usar menos bytes que al verificar directamente!:DATA
(¡también llamado datos mágicos en los comentarios!) es el orden codificado en el que se deben representar los bloques. Hay 16 valores, que normalmente requieren 16 bytes, pero como cada valor tiene solo 2 bits, pude poner 4 en un byte, ¡ahorrando 12 bytes! El código para almacenar, restaurar y decodificar estos valores es de 6 bytes. ¡Además, al evitar usar el número 0 en los 2 bits más altos pude duplicar esto como contador, ahorrando al menos 3 bytes (2 para inicializar, 1 para disminuir)! Total de bytes guardados: 12 - 6 + 3 = 9.Los datos de desplazamiento deben almacenarse en una ubicación que termine en 00 hexadecimal para funcionar correctamente. Elegí & 8000 ya que parecía una buena ubicación fuera del camino. Esto significa que el programa comienza en & 8008. Casualmente, Intel produjo una primera CPU llamada 8008 que podría considerarse el abuelo del Z80. Intel también produjo el 8080, en el que Zilog basó su Z80, siendo totalmente compatible. El Z80 tiene una gama de instrucciones extendidas que el 8080 no tiene. ¡He evitado usar estas instrucciones extendidas ya que cada una tiene un prefijo de un byte, lo que significa que este programa también producirá los mismos resultados en el 8080!
Como el patrón para el Bloque-3 es todo "1", lo he incrustado en el bucle principal, por lo que tiene un desplazamiento de 00. ¡Esto ahorra 2 bytes al no tener que regresar del Bloque-3! Afortunadamente pude ajustar las ubicaciones de inicio de los cuatro bloques en menos de 128 bytes. Esto es bueno porque el rango de un salto relativo es -128 a 127 desde la posición actual, calculado después de leer el byte de desplazamiento. Es decir, una
JR
instrucción lee dos bytes y luego realiza el cálculo.JR 00
no hace nada.JR 01
se salta un byte.JR FF
retrocede un byte haciendo que la siguiente instrucción sea el desplazamiento delJR
recién ejecutado, lo cual es realmente malo porque la instrucciónFF
no es para los débiles de corazón.JR FE
retrocede dos bytes causando un bucle infinito, etc. Sin embargo, el salto hacia atrás desde el Bloque-0 está demasiado lejos (menos de -128), así que simplemente salto al bloque anterior, que luego salta nuevamente.Ciertamente hay espacio para jugar al golf un poco más allá. Mi primera versión totalmente funcional fue de 239 bytes. Se pueden guardar 4 bytes eliminando la sección "Extra-1" a expensas de 48 errores y se pueden guardar otros 12 bytes eliminando la sección "Jaggies" a expensas de 32 errores.
fuente
Haskell,
201190 bytes, 44 erroresUtiliza una matriz de funciones para cada forma diferente:
a
(diamante);u
,d
,l
,r
(Triángulos enfrentan cada dirección) yw
(blanco), y se aplica cada uno a una rejilla de 25x25 con coordenadas[-12..12]
. Las formas de diamante y triángulo se calculan utilizando la norma de Manhattan, similar a la solución Octave de flawr .En realidad sólo generan la mitad superior, que sólo necesita
a
,w
,d
, yr
. Produzca la mitad inferior a través del reflejo (map reverse . reverse
).fuente
flip
realmente realiza una rotación geométrica aquí._
enmapM_
. Además, si elimina la definición del
y reemplaza la matriz con:,[[a,r,d,a],[r,w,w,d],[u,w,w,flip u],[a,u,u,a]]
puede guardar un par de bytes y agregar un par de errores.abs j+i+1<13
es soloabs j+i<12
C # - 423 bytes, 237 errores
Simplemente acumulando desigualdades. La mayoría de los errores se deben a que sustituyo t (= 25) en lugares que deberían usar 24.
Aquí hay un intento de visualizar cómo funciona:
Código más legible:
Probablemente podría jugar un poco a los padres y operadores lógicos, pero estoy obteniendo flashbacks de Lisp.
fuente
Perl
186184181151147 bytes, 0 Errores¡El código es
casi tan simple como la imagen! Podría reducirlo en dos bytes más haciendo que el patrón comience con una nueva línea en lugar de terminar con ella, pero técnicamente no se valida sin errores.llegando al punto en que me cuesta entenderlo.fuente
x/99$/
.JavaScript (ES6), 239 bytes, 99 diferentes
Esto usa desigualdades para generar las formas para un cuadrante, y el resto del código gira para llenar los otros.
El texto fue justo
JavaScript
. Este es un identicon bastante simple:Use el fragmento a continuación para verificar, ya que utiliza más JavaScript y salidas más compatibles en una fuente monoespacial. Probablemente tendrá que hacer clic en "Página completa" para verlo todo.
Mostrar fragmento de código
fuente
Python 3,
975963 bytesLa cadena impresa tiene
"Python"
975 bytes con 30 errores.Porque
"Python 3"
yo solíaLo que lo llevaría a 1104 bytes con 124 errores, pero creo que me quedaré solo a
"Python"
menos que OP lo solicite.fuente
J=''.join
y guardar 12 caracteres en la lambda.map
; 2) guardar algunos bytes definiendoR=lambda x:L(Z(*x[::-1]))
; 3) no necesita espacios después de cerrar paréntesis.HTML -
223210193191 bytes, 0 ErroresHTML 100% válido. Tanto HTML como JavaScript son bastante detallados, por lo que, a pesar de la simplicidad del identicon, el código sigue siendo muy largo.
fuente
document.write()
condocument.write(c?2-c/2:+(Math.abs(i)+Math.abs(j)<14)),++x);
. Además, si hace clic en el icono con<>
, puede construir una pila de fichas para mostrar su código.<!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 erroresesto es solo imprimir una línea a la vez, con algunos meta-reemplazo / expresiones elegantes para jugar al golf
sin golf:
Esto es lo que finalmente se canaliza a
iex
:y este que tiene 471 bytes, 104 errores, que usa lógica de rotación
(relativamente) no golfista:
fuente
Python 2,
712711bytesEste programa genera la matriz de bits para 'Python' utilizando la codificación de longitud de ejecución y almacenando ejecuciones como caracteres.
Antes del auto-golfista, se veía (¡bastante similar!) Como:
Este método RLE debería dar como resultado cero errores.
La matriz de identicon para 'python' parece mucho más fácil, pero pensé que sería una trampa si lo usara.
fuente
in
yzip
. Parece haber perdido el espacio entre35
yfor
sin embargo.35 for
secuencias de tipos (teniendo cuidado de mantener el espacio si el siguiente identificador comienza con une
!). Gracias por su consejo.e
. Tal vez intente actualizar y probar? (como referencia probé en 2.7.9)IDL, 472 bytes, 290 errores
Ugh Esto sería mucho más corto si pudiera almacenar funciones como variables o hacer múltiples reemplazos de cadena a la vez, etc.
fuente
PHP -
417414413410 bytes, 0 errores, (20 cuidado!)Requiere PHP> = 5.4.
PHP permite que sus palabras clave sean cualquier caso, por lo que he usado mayúsculas para palabras clave y minúsculas para variables dentro del código de golf.
preg_replace
solo se usa para eliminar el código yeval
ejecutarlo. Eliminé$
todas las variables y las volví a insertar con una expresión regular. También cambié cada instancia de&&
y||
hacia&
y|
y las dupliqué con una expresión regular. No puedo hacer el mismo truco++
porque también uso el+
que no quiero duplicar. Intenté revertir la lógica para deshacerme del-
justo después,echo
pero cambió demasiados99
s en100
s. Sin embargo, ¡logré evitar usar un solo espacio!Pude aplicar la sugerencia de Ismael Miguel al otro conjunto de
{}
llaves para elfor
bucle también, sin embargo, tuve que usar enprint
lugar deecho
.print
yecho
son ambas construcciones de lenguaje (palabras clave "mágicas" que no necesitan paréntesis()
) y, por lo tanto, no están permitidas dentro de unafor
declaración. Sin embargo, dado queprint
tiene un valor de retorno como lo hace una función, está permitido dentro defor
. ¡Al mover las asignaciones variables de la tercera a la segunda sección, también pude eliminar las advertencias!fuente
\r\n
terminaciones de línea, pero lo cambié a solo\n
para guardar un byte como usted sugirió.Pip , 116 bytes (96 errores)
Las líneas nuevas son solo para formatear y no tienen efecto en el código:
Ligeramente descabellado con comentarios:
El código construye el identicon como una lista de cadenas. Una vez que sepa que
X
es la multiplicación de cadenas,RL
es la lista de repetición, laAL
lista de anexos y laJ
unión, es bastante legible (IMHO). Las variablesb
,t
yw
(en la versión sin golf) corresponden a las siguientes partes del identicon:El cuadrante superior izquierdo se junta así:
Wt
tb
donde
W
representa 13 líneas deb
colocado encima dew
. Luego giramos y retrocedemos para obtener el resto de la figura.Los errores son el resultado de cómo generamos los triángulos blancos delgados (segunda pieza arriba). No son exactamente del mismo tamaño, uno tiene números impares de píxeles blancos y el otro tiene números pares, pero tratarlos como iguales (sin la fila superior de la inferior, para un total de 25 filas) ahorra algunos bytes Aquí hay una versión de 122 bytes que hace los pasos pares e impares correctamente (0 errores):
Y, solo por diversión, una traducción de Python del original (no golfizado):
fuente
Ruby, 324 bytes, 216 errores
Identicon usa la cadena
Ruby
, y me gusta. Geometría pura + simetría. Ecuaciones de borde para el triángulo, rotación de 45 ゜ para los rectángulos para alinearlos en el eje. Se han sacrificado unos 100 errores por unos pocos bytes menos.fuente
/// , 1319 bytes, 0 errores
Pruébalo en línea!
Esto me tomó alrededor de 2 horas para hacer, porque estaba reemplazando manualmente las cosas. Lo más grande que hice en ///.
Probablemente pueda jugar unos cuantos bytes más.
Además, vea la respuesta de Erik el golfista en /// (4 bytes más corto que el mío).
fuente
Fortran, 214 bytes, 200 errores
Puede que Fortran no sea la primera opción para el golf de código, pero su identificación se veía tan simple que pensé en probarlo. De hecho, no puedo competir con algunos de los lenguajes terser, pero usando variables implícitas y otras sutilezas (por ejemplo,
-
dobles comoxor
), no es tan malo: lo reduje a 214 bytes:Nota: Esto no funcionará con
gfortran
. Se compila conifort
si le da una.f90
extensión al archivo (esto activa la fuente de forma libre).fuente
Perl -
3244318816091387 bytes,0136678 erroresMe tomó un tiempo darme cuenta, pero el ícono es simétrico. Además, puedo imprimir una nueva línea después de cada 100 caracteres en lugar de codificarla.
Genera el texto para esto:
fuente
$n=0
niint()
;if($n>=100){print"\n";$n=0}
→$n>99and$n=!print"\n"
;@p
puede ser sustituido por/(.*);(.*)/;$n+=$2;print$1x$2
./// , 1315 bytes, 0 errores
Pruébalo en línea!
Este es el identificador para
///
. ¡Es posiblemente la cosa más grande que he hecho en ///!fuente
IDL 8.4, 333 bytes, 105 errores
Esto le dio un identificador diferente, y pude jugar mucho más golf usando un método completamente diferente.
Primero, convierta los caracteres en la línea 1 a valores de bytes y reste 64 (de modo que A = 1, B = 2, etc.). Luego, pegue esos muchos 1s y 0s consecutivos en una matriz y reformúlelos en 50x50 (es decir, el cuadrante superior izquierdo, pero transpuesto). Luego, transponga y gírelo 4 veces, júntelos e imprímalo.
fuente
Chicle, 535 bytes, 0 errores
Comprimido usando zopfli (
--deflate --i10000
). Pruébalo en línea.Bastante sencillo; Podría experimentar añadiendo algunos errores más tarde.
fuente
ForceLang,
274924992495 bytesSin competencia, el lenguaje es posterior a la pregunta.
fuente