Pitón, 456 429 381
import turtle as t
L="fl"
R="fr"
d=L*3+R*3
b=(d+R)*3
a=[b,120,L*3+"fflflffflflfrflflfffl"+R*4+"flf",90,b+"ffrfrflffrffrfrfrflflf",120,(R*5+L*5+R+L)*5+"rrfr"+L*5+R*2+L*2+R*4+"f",72,(d+"f")*5+"rfl"+((d+"b")*5)[:-1],120]
l=t.lt
f=t.fd
b=t.bk
r=t.rt
p=input()*2-2
t.setup(.9,.9)
t.goto(-200,150)
t.clear()
for c in a[p]:exec c+"(a[p+1])"
t.getscreen().getcanvas().postscript(file="o")
Implementé un intérprete primitivo con l r f boperadores que mueven el cursor de la tortuga en el ángulo de las formas. Al mismo tiempo, gira solo un ángulo. Comprimí las cadenas reutilizando cadenas (algo así como las subrutinas psuedo), aparte de eso, no verifiqué si estaba usando la mejor ruta. Sale a un archivo postscript.
Una pequeña explicación del código sin golf:
import turtle as t
Left="fl"
Right="fr"
diamond= Left*3 + Right*3
tetrahedron=(d+R)*3 #used to be b
Importa el módulo de tortuga incorporado y define las macros que acortan las cadenas. El módulo de tortuga usa comandos para mover una 'tortuga' por la pantalla (es decir, hacia adelante (100), hacia la izquierda (90))
netList=[
#tetrahedron
tetrahedron,120,
#cube
Left*3+"fflflffflflfrflflfffl"+Right*4+"flf",90,
#octohedron, builds off the tetrahedron
tetrahedron+"ffrfrflffrffrfrfrflflf",120,
#dodecahedron
(Right*5 + Left*5 + Right + Left)*5
+"rrfr"+
Left*5 + Right*2 + Left*2 + Right*4 + "f",72,
#icosahedron
(diamond+"f")*5 +"rfl"+((diamond+"b")*5)[:-1],120
]
Esta lista contiene los ángulos y las secuencias de movimiento. El tetraedro se guardó para reutilizarlo con los octoedros.
l=t.left
f=t.forward
b=t.back
r=t.right
Esta es la parte que me gusta, realiza funciones locales de un solo carácter para que las llamadas se puedan acortar y automatizar a través de cadenas predefinidas.
input=int(raw_input())*2-2
t.setup(.9,.9)
t.goto(-200,150)
t.clear()
Esto comienza tomando la entrada (entre 1 y 5) y convirtiéndola en un índice que apunte a la cadena de forma en netList. Estos configuran tortuga para mostrar toda la red. Estos podrían omitirse si la tarea fuera solo dibujarlos, pero dado que necesitamos una salida de imagen, son necesarios.
for command in netList[input]:
exec command+"(netList[input+1])"
t.getscreen().getcanvas().postscript(file="o")
El bucle for toma los comandos en la cadena de secuencia de comandos y los ejecuta, por lo que para una cadena como "fl", ejecuta "adelante (ángulo); izquierda (ángulo);" llamando a las funciones locales recién creadas. la última línea genera un archivo llamado 'o' que está en formato de formato postscript utilizando la función de tortuga.
Para correr :
Cópielo en un archivo y ejecútelo desde allí. Cuando lo ejecute, esperará una entrada de número entre 1 y 5 (simplemente lo cambié para que pregunte antes de configurar la tortuga). Cuando ingresa un número, aparece una ventana emergente y dibuja la red. si quieres que vaya más rápido, puedes agregar t.speed(200)antes setup.
Puede copiarlo y pegarlo en el intérprete, pero cuando raw_input()se lo llama, consume la siguiente cadena que ingresa en "t.setup(.9,.9)"lugar de un número. Entonces, si hace esto, copie hasta raw_input(), ingrese un número, luego copie y pegue el resto. Está destinado a ejecutarse como un todo. O podría copiarlo en una función y llamarlo.
Aquí están sus salidas (convertidas de postscript):
Nota: la posición de estos en la ventana ha cambiado, pero su forma general es la misma.
Es una pequeña fuerza bruta para el golf de código, pero me cansé de tratar de encontrar un patrón consistente entre las formas.
