Essa espiral geométrica parece complicada, mas é bastante simples de desenhar; pegue a seguinte caixa:

Desenhe uma linha reta entre o canto da caixa e uma certa distância acima do próximo canto no sentido anti-horário.

Continue esse padrão para dentro, sempre mantendo essa distância definida no canto da próxima linha. Aqui estão mais algumas linhas.

Como você pode ver, à medida que o padrão continua, a espiral se aproxima do centro e as caixas que você desenha começam a girar. Observe que a distância permanece constante, independentemente do ângulo.

O desafio

A inspiração (e também graças à pessoa maravilhosa que me apresentou esse conceito <3)

Dada uma entrada numérica (possivelmente fracionária) de 1 a 25, escreva uma imagem no disco que use esse padrão ou exiba a saída na tela, onde a distância de cada canto é a distância de um lado inicial da caixa dividido pela entrada . Continue o padrão para dentro até que a distância do canto especificado seja maior que o comprimento do lado seguinte.

Regras

• Você não pode usar internos para esta criação em espiral, mas pode usar internos de processamento de imagem.
• Se você gravar no disco, deverá gerar uma imagem em qualquer um dos formatos .jpg, .gif, .tiff, .pbm, .ppm e .png.
• O comprimento inicial do lado deve ser de pelo menos 500 pixels.
• O canto inicial pode ser o que você escolher.
• Como sempre, as brechas padrão não são permitidas.

Sapatos (Ruby) 163 bytes

Shoes é um kit de ferramentas GUI baseado em rubi.

Shoes.app{n=ask('').to_f
r=s=5E2
a=[0,s*i="i".to_c,s*i+s,s,0]
(q=a[-3]-a[-4]
r=q.abs/s*n
a<<a[-4]+q/r)while r>1
1.upto(a.size-1){|j|line *(a[j-1].rect+a[j].rect)}}

Ungolfed

Shoes.app{ 
  n=ask('').to_f                 #Open a dialog box with no message, get n from user
  r=s=5E2                        #Initialize s to sidelength=500. r can be initialized to any vale, we use the same one for convenience.
  a=[0,s*i="i".to_c,s*i+s,s,0]   #intialize array a with 5 points needed to draw a square, in complex number format (first point=0 is duplicated.)

  (
    q=a[-3]-a[-4]                #find the vector from point plotted 4 before to the following point (plotted 3 before)
    r=q.abs/s*n                  #r is the scale factor
    a<<a[-4]+q/r                 #add a new point derived from a[-4] by moving toward a[-3] by a distance s/n 
  )while r>1                     #break loop when length of line is less than s/n

  1.upto(a.size-1){|j|           #for all points except 1st and last one
    line *(a[j-1].rect+a[j].rect)#take the two complex numbers correspondimg to the current and previous point,
  }                              #convert to 2-element arrays (rectangular coordinates
}                                #combine to make a 4-element array, use * to splat into 4 parameters, and draw using the line method.

Saídas n = 4 en = 25

Observe que a forma sempre termina em um triângulo, que recolhe ainda mais uma linha. Substituir size-1por sizenão faz diferença na aparência da saída e economizaria 2 bytes, mas deixei para a correção teórica.

Saída n = 300

Inspirados por um comentário do OP, os números mais altos parecem ótimos!

Java, 1056 1005 985 948 522 508 507 504 502 501 493 492 488 474 465 458 bytes

import java.awt.*;interface G{static void main(String[]a){new Frame(){int s=499,o=s,e,i,x,y;{o/=new Float(a[0]);add(new Component(){public void paint(Graphics g){g.drawRect(0,0,s,s);int[]p={s,s,s,0,0,0,0,s};for(double d=s,t;d>o;t=o/d,i=e*2,x=(int)((1-t)*p[i]+t*p[(2+i)%8]+.5),y=(int)((1-t)*p[1+i]+t*p[(3+i)%8]+.5),g.drawLine(p[(6+i)%8],p[(7+i)%8],x,y),p[i]=x,p[1+i]=y,e=++e%4,i=e*2,x=p[(2+i)%8]-p[i],y=p[(3+i)%8]-p[1+i],d=Math.sqrt(x*x+y*y));}});show();}};}}

Obrigado ao CoolestVeto e ECS por outras formas de reduzir o tamanho. :-)

Groovy, 412 411 403 398 bytes

import java.awt.*
new Frame(){
def s=499,o=s/(args[0]as float),e=0,i,a,b,d,t
{add new Component(){void paint(Graphics g){g.drawRect 0,0,s,s
p=[s,s,s,0,0,0,0,s]
for(d=s;d>o;d=Math.sqrt(a*a+b*b)){t=o/d
i=e*2
a=(int)((1-t)*p[i]+t*p[(2+i)%8]+0.5)
b=(int)((1-t)*p[1+i]+t*p[(3+i)%8]+0.5)
g.drawLine p[(6+i)%8],p[(7+i)%8],a,b
p[i]=a
p[1+i]=b
e=++e%4
i=e*2
a=p[(2+i)%8]-p[i]
b=p[(3+i)%8]-p[1+i]}}}
show()}}