Una serpiente de flujo, también conocida como curva de Gosper , es una curva fractal, que crece exponencialmente en tamaño con cada orden / iteración de un proceso simple. A continuación se detallan los detalles de la construcción y algunos ejemplos de varios pedidos:
Pedido 1 serpiente de flujo :
____
\__ \
__/
Orden 2 serpiente de flujo :
____
____ \__ \
\__ \__/ / __
__/ ____ \ \ \
/ __ \__ \ \/
\ \ \__/ / __
\/ ____ \/ /
\__ \__/
__/
Orden 3 serpiente de flujo :
____
____ \__ \
\__ \__/ / __
__/ ____ \ \ \ ____
/ __ \__ \ \/ / __ \__ \
____ \ \ \__/ / __ \/ / __/ / __
____ \__ \ \/ ____ \/ / __/ / __ \ \ \
\__ \__/ / __ \__ \__/ / __ \ \ \ \/
__/ ____ \ \ \__/ ____ \ \ \ \/ / __
/ __ \__ \ \/ ____ \__ \ \/ / __ \/ /
\ \ \__/ / __ \__ \__/ / __ \ \ \__/
\/ ____ \/ / __/ ____ \ \ \ \/ ____
\__ \__/ / __ \__ \ \/ / __ \__ \
__/ ____ \ \ \__/ / __ \/ / __/ / __
/ __ \__ \ \/ ____ \/ / __/ / __ \/ /
\/ / __/ / __ \__ \__/ / __ \/ / __/
__/ / __ \ \ \__/ ____ \ \ \__/ / __
/ __ \ \ \ \/ ____ \__ \ \/ ____ \/ /
\ \ \ \/ / __ \__ \__/ / __ \__ \__/
\/ / __ \/ / __/ ____ \ \ \__/
\ \ \__/ / __ \__ \ \/
\/ \ \ \__/ / __
\/ ____ \/ /
\__ \__/
__/
Construcción
Considere el orden 1 Flow Snake que se construirá a partir de una ruta que contiene 7 bordes y 8 vértices (etiquetados a continuación. Ampliado para mayor factibilidad):
4____5____6
\ \
3\____2 7\
/
0____1/
Ahora, para cada orden siguiente, simplemente reemplace los bordes con una versión girada de este patrón de orden 1 original. Use las siguientes 3 reglas para reemplazar los bordes:
1 Para un borde horizontal, reemplácelo con la forma original como está:
________
\ \
\____ \
/
____/
2 Para un /
borde ( 12
en la construcción anterior), reemplácelo con la siguiente versión girada:
/
/ ____
\ / /
\/ /
/
____/
3 Para un \
borde ( 34
y 67
superior), reemplácelo con la siguiente versión girada:
/
/ ____
\ \ \
\ \ \
\ /
\/
Entonces, por ejemplo, el orden 2 con vértices del orden 1 etiquetado se verá como
________
\ \
________ \____ \6
\ \ / /
\____ \5___/ / ____
/ \ \ \
4___/ ________ \ \ \7
/ \ \ \ /
/ ____ \____ \2 \/
\ \ \ / /
\ \ \3___/ / ____
\ / \ / /
\/ ________ \/ /
\ \ /
\____ \1___/
/
0___/
Ahora, para cualquier orden superior, simplemente divida el nivel actual en bordes de longitudes 1 /
, 1 \
o 2 _
y repita el proceso. Tenga en cuenta que incluso después de la sustitución, los vértices comunes entre dos bordes consecutivos siguen coincidiendo.
Reto
N
Debe escribir una función de un programa completo que reciba un número entero único a través del argumento STDIN / ARGV / function o el equivalente más cercano e imprima la ordenN
Flow Snake en STDOUT.- El entero de entrada siempre es mayor que
0
. - No debe haber espacios iniciales que no sean parte del patrón.
- No debe haber espacios finales o suficientes espacios finales para rellenar el patrón para llenar completamente el rectángulo límite mínimo.
- La nueva línea final es opcional.
Hechos graciosos
- Flow Snakes es un juego de palabras de Snow Flakes, que este patrón se asemeja al orden 2 y superior
- El flujo y las serpientes realmente juegan un papel en el patrón, ya que el patrón se compone de un solo camino que fluye a lo largo.
- Si observa con cuidado, el patrón de orden 2 (y también superior) se compone de rotaciones del patrón de orden 1 pivotado en el vértice común del borde actual y el borde anterior.
- Hay una variante no ASCII de Flow Snakes que se puede encontrar aquí y en varios otros lugares.
Este es el código de golf, ¡el código más corto en bytes gana!
Tabla de clasificación
La primera publicación de la serie genera una tabla de clasificación.
Para asegurarse de que sus respuestas aparezcan, comience cada respuesta con un título, utilizando la siguiente plantilla de Markdown:
# Language Name, N bytes
¿Dónde N
está el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:
# Ruby, <s>104</s> <s>101</s> 96 bytes
Respuestas:
CJam, 144 bytes
Nueva línea agregada para evitar el desplazamiento. Pruébalo en línea
El programa funciona en varios pasos:
fuente
Python 2,
428411388 bytesEste fue bastante complicado. Los patrones no conservan sus proporciones después de cada paso, lo que significa que es muy difícil producir procesalmente una imagen de su predecesor. Lo que hace este código, aunque es bastante ilegible después de un intenso golf matemático, es dibujar la línea de principio a fin utilizando la
D
función definida recursivamente .El tamaño también fue un problema, y terminé comenzando en el medio de un
5*3**n
cuadrado echado a un lado y recortando cosas después, aunque si puedo pensar en una mejor manera de calcular el tamaño, podría cambiarlo.fuente
r=[s*[" "]for i in range(s)]
->r=[[" "]*s]*s]
afeitará algunos bytes*
repiten los objetos mutables .l
, cambiandoprint'\n'.join()
a la impresión dentro de un bucle for, usandoreturn[...][t]+x,
y eliminando los paréntesis(t%2)
. Además, podría usarlomin(c.find('\\')%s for c in S)
si cambia el nombre de la listaS
para que no sobrescriba el valor inicial des
.JavaScript ( ES6 ),
356362 370Esa es una difícil ...
Cada forma se almacena como una ruta. Hay 6 bloques de construcción básicos (3 + 3 hacia atrás)
0
diagonal arriba izquierda a abajo derecha (4
hacia atrás)1
diagonal inferior izquierda a arriba derecha (5
hacia atrás)2
horizontal de izquierda a derecha (6
hacia atrás)Para cada uno, hay un paso de reemplazo que se aplicará al aumentar el orden:
0
->0645001
(hacia atrás4
->5441024
)1
->2116501
(hacia atrás5
->5412556
)2
->2160224
(hacia atrás6
->0664256
)valores prellenados en la
h
matriz, incluso si los elementos 4..6 se pueden obtener de 0..2 usandoPara obtener la forma para el orden dado, la ruta se construye en la variable p aplicando las sustituciones repetidamente. Luego, el bucle principal itera en la variable p y dibuja la forma dentro de la matriz g [], donde cada elemento es una fila.
Comenzando en la posición (0,0), cada índice puede volverse negativo (índice y en órdenes altas). Evito que los índices negativos y cambien toda la matriz g cada vez que encuentro un valor negativo de y. No me importa si el índice x se vuelve negativo, ya que en JS se permiten índices negativos, solo que es un poco más difícil de administrar.
En el último paso, escaneo la matriz principal usando .map, pero para cada fila necesito usar un bucle explícito para (;;) usando la
b
variable que contiene el menor índice x alcanzado (que será <0).En el
console.log
En la versión hay una práctica nueva línea principal, que se puede convertir fácilmente en una nueva línea final intercambiando 2 filas, como en la versión de fragmento.Fragmento práctico para probar (en Firefox):
fuente
Haskell, 265 bytes
(Nota: en GHC antes de 7.10, deberá agregar
import Control.Applicative
o reemplazarabs<$>
conmap abs$
).Corre en línea en Ideone.com
f n :: Int -> IO ()
dibuja lan
serpiente de flujo de nivel . El dibujo se calcula en orden de mapa de bits en lugar de a lo largo de la curva, lo que permite que el algoritmo se ejecute en el espacio O (n) (es decir, logarítmico en el tamaño del dibujo). ¡Casi la mitad de mis bytes se gastan calculando qué rectángulo dibujar!fuente
Perl,
334 316309Parámetro tomado en la entrada estándar. Ponme a prueba .
fuente
Haskell,
469419390385365 bytesla función f :: Int-> IO () toma un entero como entrada e imprime la serpiente de flujo
fuente
$
en la definición dek
, y reemplazar(!!)a
con el(a!!)
cual puede deshacerse de algunos paréntesis. Aparte de eso, parece que conoces muchos trucos por ti mismo. NizaC,
479474468427 bytesSupongo que no hay que vencer a los chicos de Perl y Haskell, pero dado que todavía no hay una presentación de C aquí:
Para ahorrar espacio en una llamada atoi (), el número de argumentos pasados al programa se utiliza para el nivel.
El programa se ejecuta en O (n ^ 3) o peor; primero, la ruta se calcula una vez para encontrar las coordenadas mín. / máx., luego, para cada par (x, y), se calcula una vez para encontrar el carácter en esa ubicación específica. Terriblemente lento, pero ahorra en la administración de memoria.
Ejemplo ejecutado en http://codepad.org/ZGc648Xi
fuente
X,Y,K,L,M,N,i,j,c;
lugar deint X,Y,K,L,M,N,i,j,c;
y enmain(l)
lugar devoid main(int l)
Python 2,
523502475473467450437 bytesPffft, me costó unas 3 horas, ¡pero fue divertido hacerlo!
La idea es dividir la tarea en múltiples pasos:
Aquí está el código en forma no golfizada:
Editar: cambié el idioma a python 2, para que sea compatible con mi respuesta para el n. ° 3 (y también ahorra 6 bytes más)
fuente
l.extend(x)
al+=x
. También es probable que pueda usar codegolf.stackexchange.com/questions/54/… en lugar del.split()
que usa (hice algo similar en mi respuesta)extend
Pari / GP, 395
Recorriendo las posiciones de los caracteres x, y y calculando qué caracteres imprimir. Intentos moderados de minimizar, puntuado con espacios en blanco y comentarios despojados.
Cada personaje es el primero o el segundo de una celda hexagonal. Una ubicación de celda es un número complejo z dividido en base b = 2 + w con dígitos 0, 1, w ^ 2, ..., w ^ 5, donde w = e ^ (2pi / 6) sexta raíz de la unidad. Esos dígitos se mantienen como un distintivo de 1 a 7 y luego se toman de mayor a menor a través de una tabla de estado para la rotación neta. Esto está en el estilo del código de serpiente de flujo por Ed Shouten (
xytoi
) pero solo para la rotación neta, sin convertir los dígitos en un índice "N" a lo largo de la ruta. Las extensiones son relativas a un origen 0 en el centro de la forma. Mientras el límite no sea un punto final, estos son el medio de un hexágono de 2 caracteres y solo se necesita 1 de esos caracteres. Pero cuando el inicio y / o final de la serpiente son el límite X, se necesitan 2 caracteres, que es k = 0 inicio yk <3 final. Pari tiene "quads" como sqrt (-3) incorporado, pero lo mismo se puede hacer con partes reales e imaginarias por separado.fuente