El desafío: mostrar este arte ASCII exacto de una telaraña en una ventana:
_______________________________
|\_____________________________/|
|| \ | / ||
|| \ /|\ / ||
|| /\'.__.' : '.__.'/\ ||
|| __.' \ | / '.__ ||
||'. /\'---':'---'/\ .'||
||\ '. /' \__ _|_ __/ '\ .' /||
|| | /. /\ ' : ' /\ .\ | ||
|| | | './ \ _|_ / \.' | | ||
||/ '/. /'. // : \\ .'\ .\' \||
||__/___/___/_\(+)/_\___\___\__||
|| \ \ \ /(O)\ / / / ||
||\ .\' \.' \\_:_// './ '/. /||
|| | | .'\ / | \ /'. | | ||
|| | \' \/_._:_._\/ '/ | ||
||/ .' \ / | \ / '. \||
||.'_ '\/.---.:.---.\/' _'.||
|| '. / __ | __ \ .' ||
|| \/.' '. : .' '.\/ ||
|| / \|/ \ ||
||____/_________|_________\____||
|/_____________________________\|
Fuente: Joan Stark (araña y marco ligeramente modificados, y eliminar las iniciales por el bien del desafío).
Caracteres requeridos: _|\/'.:-(+)O(12) + espacio y nueva línea (2)
Reglas de desafío:
- Se permiten uno o varios espacios finales y / o nuevas líneas.
Reglas generales:
- Este es el código de golf , por lo que la respuesta más corta en bytes gana.
No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación. - Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
- Las lagunas predeterminadas están prohibidas.
- Si es posible, agregue un enlace con una prueba para su código.
- Además, agregue una explicación si es necesario.
code-golf
ascii-art
kolmogorov-complexity
Kevin Cruijssen
fuente
fuente
.7 caracteres antes de laO. ¿Se supone que debe haber un 7 caracteres después también?Respuestas:
SOGL V0.12 , 141 bytes
Explicación:
Pruébalo aquí! (el programa contiene pestañas, así que aquí hay una mejor representación del programa)
fuente
Arnold C,
1257 1261 12561233 bytesEste es mi primer intento de programación en el lenguaje supremo, así que me comeré mis votos negativos ya que no ofrezco una solución inteligente a este problema, aunque la programación en el lenguaje descendió de los cielos.
Aquí hay un compilador si alguien por casualidad cuestiona este algoritmo.
Quedarse.
fuente
TALK TO THE HAND!vim,
373371 bytes<ESC>Es un sustituto de 0x1B.Sin golf
Pruébalo en línea!
Y para aclarar la explicación que le dieron cuando era niño: si bien es cierto que la única emoción que las arañas sienten personalmente es el odio, son capaces de sentir miedo a una distancia de más de 50 metros.
fuente
<CR>pero ¿las líneas que terminan con<CR>media presionan la tecla dos veces? La respuesta parece ser no en las dos instancias anteriores, pero luego, las líneas cons/ /_/gytrno terminan,<CR>pero no puedo hacer que funcione sin presionar Enter.<CR>s fueron un error, y el avance de línea también funciona. (Ingresé las líneas usando<C-v><ENTER>, lo que genera<CR>; por eso aparece como en^Mlugar de una nueva línea). Modifiqué el código para eliminar esos dos duplicados y reemplazar los retornos de carro con saltos de línea / saltos de línea normales. Todas las nuevas líneas restantes deben ingresarse con precisión una vez. (La versión no golfizada todavía tiene algunas líneas en blanco adicionales; esas no corresponden a las pulsaciones de teclas reales. La versión golfizada es exactamente lo que debe teclearse, excepto el<ESC>s.){ cat foo.vim; echo ':wq'; } | vim a.txtmodo que no esté atascado en vim sin teclado conectado a stdin. La ventaja es que puedo ejecutar el programa directamente desde un archivo en lugar de intentar escribirlo exactamente cada vez que hago un cambio. Para este programa, los bytes y las pulsaciones de teclas son equivalentes, pero ese no es siempre el caso. por ejemplo,<C-v><ENTER>es tres pulsaciones de teclas, pero produce un byte,\r.Gelatina ,
206205 bytesUn enlace niládico que devuelve una lista de caracteres, o un programa completo que imprime el arte.
Pruébalo en línea!
¿Se podría utilizar la simetría vertical aproximada?
¿Cómo?
Los primeros 158 bytes son un número muy grande escrito en la base biyectiva 250 que usa los primeros 250 bytes de la página de códigos de Jelly:
Este número (del orden de 10 372 se convierte en una lista de sus dígitos en base-9 (391 números entre 0 y 8) y luego se agrega tres a los dígitos 203 rd , 204 th , 220 th y 221 st ( que será el cuerpo de las arañas):
El resultado luego se convierte a los 12 caracteres del lado izquierdo (hasta la columna central) que incluye el arte:
Las filas completas se construyen haciendo rebotar cada fila del lado izquierdo (es decir, reflejándola como si su último carácter fuera un espejo), cambiando todos los
(to), the\to/y/to\, y luego solo usando los nuevos valores a la derecha de la mano usando un vectorizadoandcon el lado izquierdo de antes. El resultado finalmente se une con nuevas líneas para crear el arte:fuente
Carbón ,
239238 bytesPruébalo en línea! El enlace es a la versión detallada del código. La mayor parte de esto es simplemente imprimir una cadena comprimida grande, pero las partes repetitivas se han codificado por separado para reducir la longitud de la cadena; en particular,
Rectangleahorra una cantidad de bytes al evitar que el relleno de espacio llegue a la columna 17 e incluso las líneas diagonales guardan un byte cada una.Editar: el carbón de leña ya no parece reconocer la cadena comprimida, y su compresión actual genera una cadena más corta que ahorra 51 bytes, y permite que una de las líneas diagonales se mueva de nuevo a la cadena para un ahorro adicional de 2 bytes. (Tenga en cuenta que estos no son los recuentos que se muestran
-sl; de hecho, incluso el recuento original parece haberse apagado en 1.) Sin embargo, hay tres ahorros adicionales que también se habrían aplicado al código original: ¡ Pruébelo en línea!Ｂ(Box) en lugar deＵＲ(Rectangle).↙Ｐ×_¹⁶←/lugar de↓Ｐ×_¹⁵←_/.×_¹⁶Ｊ⁵¦¹lugar deＰ×_¹⁶Ｍ⁵¦².fuente
PHP , 380 bytes
Pruébalo en línea!
PHP , 494 bytes
Pruébalo en línea!
fuente
brainfuck , 4086 bytes
Pruébalo en línea!
Este es solo un método de búsqueda y selección para generar la cadena.
Nuevas líneas agregadas para mayor legibilidad:
fuente
---------------------------------------------------------------lugar de algo así>++++++++[-<-------->]<+?>s y<s aparecería más adelante en el código. No sé cuántos bytes (si alguno) ahorra mi enfoque. Examinaré el uso de más células.>>>secuencias más adelante, ya que solo se usan como espacio temporal para las factorizaciones. En particular, si llena las celdas de izquierda a derecha, puede usar, por ejemplo, la celda 5 como espacio temporal para configurar la celda 4 y luego (dado que la celda 5 se pone a cero en el proceso de configuración de la celda 4), almacene un nuevo valor en la celda 5 mientras se usa la celda 6 como espacio temporal. Siempre que los valores finales de las celdas no cambien, puede modificar cualquier cosa antes de la primera.sin necesidad de modificar el código posterior.JavaScript (ES6), 471 bytes
Equipado con una variante ES6 de RegPack .
fuente
Java (JDK) , 494 bytes
Pruébalo en línea!
Gracias Kevin Cruijssen por jugar unos pocos bytes, más 6 bytes cambiando
Windows-1252acp1252, y solo a ASCII para comprimir un poco la cadena :)Nota: el archivo debe estar codificado como Windows-1252 para el recuento de bytes, ¡pero se puede copiar / pegar de forma segura en UTF-8 para probarlo!
La cadena larga es en realidad la cadena, tal como está, con sus caracteres asignados a un codificador de caracteres flexible (por una vez, estoy feliz de usar CP-1252). El resto es solo el método de desasignación.
El mapeo se encontró usando una permutación, primero inicializada a la frecuencia de cada carácter en el arte ascii. Las asignaciones que dan como resultado los caracteres
'"'y'\\'se descartaron explícitamente para ser la cadena válida más corta posible.Sin golf
Descubrimiento de mapeo
fuente
()a un carácter aleatorio. Nunca he dicho nada sobre ninguna entrada, por lo que puede usar una no utilizadaObjectque esnullcomo entrada. Meta-post relevante. . Ah, y puede guardar otro byte cambiandobyteainten el ciclo for-each.r+=a;es equivalenter = r + (a)y con caracteres, eso significa que se agregan entre sí antes de concatenarse, por lo que ahora se consideran comoints, y la cadena resultante es similar a127190190190190190190190190190.... Escribí un comentar sobre eso en la versión sin código de código;)Windows-1252se puede jugar golfcp1252. Explicación aquí.b>>4no necesita parens, recuerde que los bits son muy, muy baja precedenciaRetina ,
465463425 bytesPruébalo en línea!
fuente
C # (.NET Core) ,
935 676 636627 bytesPruébalo en línea!
Quería probar otro enfoque y RLE'd el dibujo. Terminé con un código que tenía más bytes que el dibujo en sí (782 bytes). Luego comprimí la cadena RLE'd creando un diccionario con los grupos más utilizados, y después de comprimirla, creé más diccionarios y comprimí nuevamente hasta que la cadena no pudiera reducirse más. El dibujo se crea expandiendo primero esos grupos y luego descomprimiendo con RLE.
fuente
Python 2.7,
414405401bytesSimplemente descomprime la cadena e imprime. :)
fuente
Z_FILTERED) que evita encabezados y sumas de verificación. Lo baja a 401 bytes.print zlib.decompress('fY9BauhADEP3OcXbueUz1j6X6AUEuogP/xeTpCmUGgxK5iFZ5O85xn++a44ZAHPPPEoAcxMPovEbeBFyddLFyRbyi0i6Hpd5HKqTTVTfLmutOmutdTt0zRwzphoVOCETEkGZLrRTBtSATHFSyEAbhocYqgUmEwTu2r9njhlRalA1Eic2XYZ24ZljJlHu9ce/T8XJvTsFc68+vj6Ndl0EV5d27Wg7Z6R9VKlfXWZHC7alql+XMuACrHTOdCyg9OrSha9ohusoUX116QpQVq+1+uy1VlsFpPrqQjWI5PJIMHRxdQHA6oJqTraw4Aexv8HzqG8iSZR75lFOkpljvh9/G89/'.decode('base64'),-9)compress[obj]() takes no keyword argumentscompressno lo hace, perocompressobjtoma argumentos adicionales (aunque no como palabras clave anteriores a 3.3, debe pasar los argumentos posicionalmente). Crear un compresor, llamarcompressor.compress(thedata)y luego hacercompresseddata = compressor.flush()es equivalente a tres pasoszlib.compress, pero puede configurarlocompressobjmás finamente. El único inconveniente es que el uso dewbits=-9medios que debe pasar-9adecompress(por lo que sabe que no debe buscarse un encabezado o suma de comprobación).Python 3 ,
404398 bytesPruébalo en línea!
El mismo truco que la versión Python 2.7 , solo ajustado para Py3 requiere conversión
bytes<->str. Aún más pequeño que el código 2.7 a pesar de las importaciones adicionales y la decodificación requerida en virtud de que Python 3 proporciona codificación base85 como una función incorporada, reduciendo el tamaño requerido para representar los datos comprimidos en formato imprimible ASCII en 28 bytes.Editar: Afeitó seis bytes más volviendo a comprimir
wbits=-9para que no se coloque ningún encabezado o suma de verificación en los datos (a cambio de la necesidad de agregar,-9arg azlib.decompress).fuente
Java 8, 719 bytes
Definitivamente se puede jugar al golf, pero es solo un comienzo y algo que otros golfistas de Java pueden (intentar) vencer. ;)
Explicación:
Pruébalo aquí
fuente
brainfuck , 5173 bytes
Pruébalo en línea!
Cómo funciona
En pocas palabras: encuentra el índice ascii de cada carácter en la línea; Luego lo imprime. Luego encuentre el índice ASCII para una nueva línea e imprima eso. Enjuaga y repite a mi hijo.
fuente
256 bytes, código de máquina (16 bits x86)
Esperaba poder superar al menos la solución de carbón, pero no he logrado sacar más provecho de esto (hasta ahora).
En ejecución: guarde en codegolf.com, dosbox para ver el resultado en el que necesita establecer el punto de interrupción
cs:200y volcar la memoria en lads:400parte inferior30e... o puede agregar la siguiente pieza, que lo volcará en stdoutEste es mi tercer código de entrada de golf. El anterior fue el cifrado xor .
De nuevo: hecho usando HT hexeditor , sin compilador , pero usando Ctrl-a
assemble instruction.Cómo
Este tardó un poco en hacerlo ...
Comencé con un enfoque simple, con un cuadrante y tratando de reflejarlo. Eso resultó en ~ 250 bytes y solo tenía 2 de 4 cuadrantes. Gran parte de eso fue el primer cuadrante, que tomó 204 bytes.
Sabía que esto puede ser mejor.
Rápidamente verifiqué que lz4 produce un archivo con 144 bytes (omitiendo los encabezados). GZ da como resultado ~ 120 bytes, pero claramente no podría crear descompresor en aproximadamente 30 bytes.
Entonces, otro intento fue elaborar a mano el primer cuadrante dibujándolo (incluyendo omisión, codificación de 4 bits y demás). Eso junto con el código resultó en 164 bytes (solo el primer cuadrante), bueno, pero estaba bastante convencido de que podría hacerlo mejor.
Se me ocurrió algo de codificación, que termina en 85 bytes para datos. Junto con la tabla de traducción (que aún no se usa) y el decodificador, terminé con 144 bytes. NOICE, soy = lz4 y ya tengo decodificador.
El siguiente paso fue fusionar la duplicación inicial de ~ 250 intentos a este, esto requirió algunos ajustes de datos, pero fue más fácil de lo esperado y resultó en 184bytes.
Me di cuenta de que necesitaré algunos marcadores adicionales para hacer un espejo horizontal, que extendió los datos a 91b y el código a 190bytes (que luego se tiraron a la basura).
Junto con el espejo horizontal y la traducción final, terminé con ~ 250 bytes.
Me las arreglé para comer algunos bytes aquí y allá, pero tuve que agregar esos caracteres feos, que se reflejan incorrectamente. Eso produjo 259 bytes ... Eso es malo, porque estaba usando memoria comenzando en 0x200 y no quería rehacer eso.
He reemplazado las condiciones en espejo horizontal, para hacer un bucle con la tabla de traducción, que en sí mismo no ahorró mucho, pero combinado con el cambio de caracteres ofensivos a espacios y la fijación posterior, ahorró algunos bytes, lo que resultó en 256 bytes finales .
Puedes ver una bonita galería, que he hecho, mientras hago esto aquí
Disección
Como entradas anteriores, esta también se basa en valores iniciales , aunque no tanto como los anteriores:
saltar datos, hay 3 tablas siguientes:
La tabla de traducción se usará para la duplicación horizontal
La tabla de traducción se utilizará para la sustitución final, para convertir códigos a ascii reales
Datos codificados, la codificación es bastante simple:
llenar 12 * 17 bytes con lo que se convertirá en espacio (8)
"Descomprima" los datos como se describe en la tabla 3. Tenga en cuenta el uso de la querida instrucción AAM y el abuso de scasb para omitir bytes.
Esta parte es bastante fea, establece el destino en 0x400:
Tenga en cuenta que el espejo se realiza mediante el abuso de std / cld, para ir a la
SIinversa. Solo los\/()caracteres deben reflejarse, eso lo hace xor a 0x1BF.Esto hace un espejo horizontal usando la tabla 1 y usando el maravilloso XLAT de 1 byte
Luego viene la parte aburrida que arregla 4 "píxeles", lo omitiré desde aquí es aburrido
Paso final de traducir a ascii.
¡UF! Eso fue divertido.
fuente
JavaScript (ES6),
517...459457456433431418409397392 bytesIncluye una línea final de espacios más un espacio final en la primera línea. Algo de esto todavía no se juega de manera óptima: dedico mucho tiempo a que todo funcione.
Originalmente basado en Traktor53 desde la solución abandonada de 556 bytes . Publicado con permiso .
Lista de quehaceres
Encuentre una forma menos costosa de palindromizar las cuerdas.Intenta mejorar el reemplazo de RLE.Vea si los últimos 4 reemplazos se pueden reducir de alguna manera.Investigue si construir la imagen en trimestres generaría ahorros significativos. ¡Sospecho que no!fuente
string1[string2.indexOf( char) ]|| chares una construcción que probé pero con la que no pude reducir bytes. ¡Bien hecho!JavaScript
556468462448438387379 bytesMenos golf
Compresión
La publicación original (556 bytes) utilizaba dígitos decimales para indicar la repetición de un carácter anterior en la telaraña. Las versiones más recientes comprimen la mitad izquierda de la red en caracteres de 7 bits, donde el mordisco menos significativo es un índice en un conjunto de caracteres, y tres bits de orden superior especifican el número de caracteres a emitir más 1: valores
000y001no se utilizan,010significa 1 personaje y111significa seis. Esta construcción evita la producción de personajes de control.Gracias a @Shaggy por consejos y trucos útiles en la reescritura.
Cómo funciona
El cuadrante superior izquierdo se reescribió para incluir marcadores de posición para las mitades superior e inferior de la web:
dando:
que fue comprimido usando
Descompresión
La descompresión asigna caracteres codificados a caracteres reales para cada cuadrante. En codigo,
Xes una lista de caracteres indexados que varía entre las secciones web superior e inferior. Proporciona valores para marcadores de posición "suqh" y reflexiones de caracteres duros, como entre '+' y 'O'.Codificación
La codificación del carácter central está limitada a usar una expansión de un solo carácter. El orden del juego de caracteres está restringido para no producir caracteres DEL (0x7F), Grave (0x60) o barra invertida (0x5C) durante la compresión.
Esta es una actualización tardía en respuesta a la actividad en la pregunta.
fuente
.reducey.mapqué no pude. Mientras tanto, he cambiado el algoritmo para obtener 468 bytes. Feliz fin de semana./// , 463 bytes
Pruébalo en línea!
fuente
Bash, 391 bytes
Pruébalo en línea!
Felicitaciones a todos los que pudieron superar la compresión fuera de la clavija: ¡soy yo tirando la toalla! Reconozco a la gente de Python que entró primero con el enfoque zlib / gzip.
fuente
Perl 5
439402 bytesEn lugar de usar base64 / gzip, este enfoque es reflejar y voltear el cuadrante superior izquierdo, con las sustituciones apropiadas
Pruébalo en línea
Para aquellos interesados, una versión comentada:
fuente
C #, 484 bytes
Nota: no estoy 100% en cómo calificar estos. Con el encabezado y pie de página son 544 bytes.
Sin golf:
¡Pruébelo en línea!
fuente
Ruby 1.9.3,
1102763 bytes¡Pruébelo en línea!
fuente
putsy una cadena multilínea debería tomar ~ 790 bytes. Su enorme cadena para escanear y el código para procesarlo termina siendo más largo que la solución ingenua ...C #,
401 399 397 396389 bytesEscribió esta como una excusa para probar la codificación de Huffman
Sin golf:
Versión anterior sin comentarios:
¡Pruébelo en línea!
fuente
while(v>0){a afor, y colocando los enteros yv/=2dentro de él:for(int p=0,l=0;v>0;v/=2){whileocupe el mismo espacio que unafor, ahora.for(;someCondition;someAction);vsfor(;someCondition;)someAction;vswhile(someCondition)someAction;. Pero en generalfores más corto quewhile, por lo que casi siempre lo uso yoformismo.Python 2 , 395 bytes
Pruébalo en línea!
fuente
Espacio en blanco ,
47234584 bytesSe agregaron letras
S(espacio),T(tabulación) yN(nueva línea) solo como resaltado.Pruébalo en línea .
Explicación:
Utilizo el enfoque explicado en este consejo de Whitespace . El enfoque descrito es el siguiente:
El valor constante ideal fue el
94que he generado con este programa Java . El uso94daría un programa de espacios en blanco con una longitud total de 7508 bytes (7481 + 27 bytes para el bucle), o 5791 bytes (5764 + 27) si ya implementamos Duplicate Top (SNS) donde dos de los mismos caracteres son adyacentes.Después de eso, utilicé manualmente Copy 1st (
STSSTN), Copy 2nd (STSSTSN) y Copy 3rd (STSSTTN) (1-indexado) donde sea que ahorre bytes. Que también se puede encontrar en los consejos de espacios en blanco. Lo que en total resultó en el programa de 4584 bytes que ves aquí.fuente
05AB1E , 204 bytes
Pruébalo en línea.
Verifica que sea correcto.
Explicación:
fuente