Lado a lado, dada a configuração de vértice

11

Tarefa

A tarefa é agrupar polígonos, dada uma configuração de vértice.

Pontuação

Sua pontuação é igual ao "nível de complexidade" atingido pelo seu envio. Os níveis de complexidade são cumulativos, o que significa que, para atingir o número 3, você também deve oferecer suporte aos itens 1 e 2.

Os envios em um nível de complexidade igual são diferenciados pela contagem de bytes; vitórias mais baixas.

Entrada

Entrada é uma sequência que contém uma configuração de vértice, representando uma figura de vértice. Ou seja, uma lista de números inteiros separados por pontos, em que cada número inteiro (n) representa um n-gon regular, conectado por um vértice comum.

As seguintes configurações de vértice devem ser suportadas:

  • 3.3.3.3.3.3
  • 3.3.3.3.6
  • 3.3.3.4.4 (observe que a ordem é refletida na figura do vértice, portanto, a tabela a seguir difere)
  • 3.3.4.3.4
  • 3.12.12
  • 3.4.6.4
  • 3.6.3.6
  • 4.4.4.4
  • 4.6.12
  • 4.8.8
  • 6.6.6

Saída - Nível de complexidade # 1: figura do vértice

Nesse nível de complexidade, a saída é uma imagem que mostra a figura do vértice correspondente à entrada especificada.

A entrada é anexada com um Fpara indicar que a figura do vértice deve ser impressa, e não a peça completa.

Por exemplo, F3.6.3.6fornece esta figura de vértice:

3.6.3.6 figura de vértice

Saída - Nível de complexidade # 2: lado a lado

Nesse nível de complexidade, a saída é uma imagem que mostra um lado a lado uniforme usando a figura de vértice correspondente à entrada especificada.

Por exemplo, 3.6.3.6fornece esse ladrilho:

3.6.3.6 lado a lado

Não há restrições de cor ou formato (exceto brechas).

Saída - Nível de complexidade # 3: ladrilhos duplos

Nesse nível de complexidade, um "lado a lado duplo" pode ser formado a partir de cada lado a lado. Isso é obtido desenhando linhas do centro de cada polígono até o centro de cada polígono de fronteira.

A disposição dupla é especificada anexando a entrada com a V.

Por exemplo, V3.6.3.6esse ladrilho duplo (em vermelho):

V3.6.3.6 lado a lado

code-challenge graphical-output geometry tiling jsh
fonte
Algumas dessas inclinações têm sinônimos. Por exemplo, o seguinte são todos iguais: 3.3.3.4.4 3.3.4.4.3 3.4.4.3.3 4.4.3.3.3 4.3.3.3.4. Temos que apoiar todos os sinônimos, ou apenas o mais baixo lexicamente (conforme indicado na pergunta)? Além disso, 3.3.3.3.6existe em duas formas de imagem invertida. Eu entendo que qualquer um é aceitável.
Level River St
A página que você vinculou não corresponde à lista fornecida. 3.3.3.4.4está faltando, por exemplo. pt.wikipedia.org/wiki/… corresponde exatamente à sua lista. Entendo que o contorno ou polígonos preenchidos são aceitáveis ​​(ou uma combinação dos dois?) Alguns duais já estão na lista. Por exemplo 4.4.4.4é a sua própria dupla e 3.3.3.3.3.3e 6.6.6são mutally dual. Como os duplos são exibidos independentemente de seus pais, entendo que não há necessidade de alinhamento correto com os pais.
Level River St
você deve dar suporte à entrada como ela aparece na lista - você pode dar suporte a sinônimos, mas não precisa - deve dar suporte a todos os duais, até os duplos de si mesmos.
jsh
esboço / preenchido - bem de qualquer maneira. qualquer estilo é permitido além de brechas (deixe tudo branco, diminua a área de desenho etc.). alinhamento não necessário. Eu poderia lhe dizer que você não tem permissão para usar um reflexo, 3.3.3.3.6mas como você saberia qual é? :)
jsh
Agora você mudou a pontuação, qual é o desempate? Esse código ainda é o mais curto? Nesse caso, as configurações de vértices precisam ser delimitadas por pontos ou podemos escolher outro símbolo como vírgula ou espaço?
Level River St

Respostas:

9

BBC BASIC

Rev 1 Código de golfe, 655 caracteres ASCII, tamanho de arquivo tokenizado 614

Algumas melhorias importantes na tabela de dados, hash da string A.B..Nem um número (1*A+2*B+..n*N)+nantes de procurar e armazenando apenas um vetor de conversão (o outro é gerado pelo código). Mais explicações quando eu terminar o golfe.

t=PI*2DIMm(9)
c=0z=0INPUTz$
FORi=1TOLEN(z$)d%=VAL(MID$(z$,i))IFd%c+=1m(c)=d%i-=d%=12z+=c*d%
NEXTREPEATREADl,e,f
UNTILl=z+c
l=4-3*(m(3)MOD3=0)-8*(l=59)
DATA69,0,70,65,100,35,66,149,0,49,109,0,52,80,0,55,0,189,39,120,0,44,40,40,58,55,95,47,136,0,59,40,0
VDU23,23,3|
FORr=-9TO19FORs=-9TO9a=1+e*(r*2+s)-f*l*s/4b=1+f*(r*2+s)+e*l*s/4p=40q=0FORk=1TOm(c)/2FORj=1TOc
n=m(j)o=TAN(PI/3)IFe=109ANDn<>4o=1
w=-p*COS(t/n)-q*SIN(t/n)q=p*SIN(t/n)-q*COS(t/n)p=w
u=p:v=q
x=a:y=b
MOVEx,y
FORi=1TO14x+=u*2y+=v*2IFVAL(z$)DRAWx,y ELSEGCOL9LINEx-u-v/o,y-v+u/o,x-u+v/TAN(PI/n),y-v-u/TAN(PI/n)
w=v*COS(t/n)-u*SIN(t/n)u=v*SIN(t/n)+u*COS(t/n)v=w
NEXTNEXT
p=u:q=v
a=x:b=y
NEXTNEXTNEXT

Rev 0 Código de golfe, 770 caracteres ASCII, tamanho de arquivo tokenizado 728

Tudo o que fiz aqui foi remover comentários, espaços em branco e aspas desnecessários e colocar tudo DATAem uma linha. Certamente há espaço para mais golfe.

t=PI*2DIMm(9)
c=0INPUTz$
FORi=1TOLEN(z$)d%=VAL(MID$(z$,i))IFd%c+=1:m(c)=d%:i-=d%=12
NEXTREPEATREADl$,e,f,g,h
UNTILMID$(z$,1-(VAL(z$)=0))=l$
DATA3.3.3.3.3.3,240,0,120,70,3.3.3.3.6,200,70,40,210,3.3.3.4.4,80,0,40,150,3.3.4.3.4,-40,150,150,40,3.12.12,300,0,150,260,3.4.6.4,220,0,110,188,3.6.3.6,160,0,80,140,4.4.4.4,80,0,0,80,4.6.12,0,380,330,-190,4.8.8,272,0,136,136,6.6.6,240,0,120,70
VDU23,23,3|
FORr=-9TO19 FORs=0TO9a=1+e*r+g*s
b=1+f*r+h*s
p=40q=0FORk=1TOm(c)/2FORj=1TOc
n=m(j)o=TAN(PI/3):IFe=220ANDn<>4o=1
w=-p*COS(t/n)-q*SIN(t/n)q=p*SIN(t/n)-q*COS(t/n)p=w
u=p:v=q
x=a:y=b
MOVEx,y
FORi=1TO14x+=u*2y+=v*2IFVAL(z$)DRAWx,y ELSEGCOL9LINEx-u-v/o,y-v+u/o,x-u+v/TAN(PI/n),y-v-u/TAN(PI/n)
w=v*COS(t/n)-u*SIN(t/n)u=v*SIN(t/n)+u*COS(t/n)v=w
NEXTNEXT
p=u:q=v
a=x:b=y
NEXTNEXTNEXT

Explicação

Esta é uma continuação da minha resposta anterior de nível 1, mas decidi publicá-la separadamente, porque é bastante longa.

Nível 2

Isto é conseguido através da tradução dos meus modelos "nível 1.5" da minha resposta anterior. Os dois vetores de conversão para cada lado a lado são codificados. Aproveito o fato de que um triângulo isósceles de base 80 e altura 70 é uma aproximação muito boa de um triângulo equilátero, e um triângulo retângulo com vetor de hipotenusa (56,56)tem um comprimento de hipotenusa muito próximo de 80.

Nível 3

Para plotar os duais, em vez de plotar uma aresta do polígono, plotamos um raio do meio dessa aresta até o centro do polígono. Está em ângulo reto com a aresta e possui comprimento de 1/TAN/(PI/n)vezes do vetor (u, v) que, por sua vez, é metade do comprimento da aresta.

Infelizmente, como certos polígonos em inclinações 3.3.3.3.6e 3.4.6.4não são plotados explicitamente, eles não seriam plotados se fizéssemos isso. Portanto, o raio também se estende para fora do polígono. A extensão externa é controlada pela variável o.

Por padrão, a extensão é suficiente para alcançar o centro de um triângulo, mas 3.4.6.4precisa ser estendida mais para desenhar os duplos dos quadrados que não são plotados explicitamente. Portanto, a extensão suficiente para preencher os quadrados ausentes é aplicada quando hexágonos e triângulos são plotados explicitamente, mas a extensão normal é aplicada quando quadrados são plotados explicitamente, para evitar linhas espúrias nos triângulos adjacentes.

Aqui está a aparência deles sem as extensões spoke. Os furos no padrão duplo podem ser vistos claramente. A saída correta pode ser vista na figura principal, na parte inferior da resposta.

insira a descrição da imagem aqui

Código comentado

As diferenças da minha resposta anterior são indicadas em linha

  t=PI*2                                          :REM constant Tau = PI*2

  DIMm(9)                                         :REM declare array for the numbers in the input
  c=0                                             :REM number of polygons in the list

  INPUTz$
  FORi=1TOLEN(z$)                                 :REM for each character in the input
    d%=VAL(MID$(z$,i))                            :REM use VAL to return the numeric value of the substring to the right and store to integer variable
    IF d% c+=1 :m(c)=d%: i-=d%=12                 :REM if the last character read was a number, d% contains it, otherwise 0. Advance c and store to m. If it is 12, increment i to skip a character.
  NEXT

  REM BLOCK OF NEW CODE to define vectors (e,f) and (g,h) for each possible tiling

  REPEAT
    READ l$,e,f,g,h                               :REM read an entire line of the data below
  UNTIL MID$(z$,1-(VAL(z$)=0))=l$                 :REM abort the loop when l$ coincides with the input. the MID$ strips off the 'V' from the input where necessary.

  DATA"3.3.3.3.3.3",240,0,120,70
  DATA"3.3.3.3.6",200,70,40,210
  DATA"3.3.3.4.4",80,0,40,150
  DATA"3.3.4.3.4",-40,150,150,40
  DATA"3.12.12",300,0,150,260
  DATA"3.4.6.4",220,0,110,188
  DATA"3.6.3.6",160,0,80,140
  DATA"4.4.4.4",80,0,0,80
  DATA"4.6.12",0,380,330,-190
  DATA"4.8.8",272,0,136,136
  DATA"6.6.6",240,0,120,70

  VDU23,23,3|                                           :REM change linewidth to 3 (default is 1)

  REM END BLOCK OF NEW CODE

  FORr=-9TO19 FORs=0TO9                                 :REM two new loops for translations

      a=1+e*r+g*s                                       :REM modified code for
      b=1+f*r+h*s                                       :REM coordinates to start drawing at


      p=40:q=0                                          :REM vector of first line

      FORk=1TOm(c)/2                                    :REM draw half as many vertex figures as there are sides on the last polygon in the list

        FORj=1TOc                                       :REM for each polygon on the list
          n=m(j)                                        :REM n=number of sides
          o=TAN(PI/3): IF e=220 AND n<>4 o=1            :REM new code for the spoke extension 1/o. 

          w=-p*COS(t/n)-q*SIN(t/n)                      :REM rotate the starting vector anticlockwise by the internal angle of the current polygon
          q=p*SIN(t/n)-q*COS(t/n)                       :REM to avoid overlapping the previous one, if any.
          p=w

          u=p:v=q                                       :REM make a local copy of the vector and coordinates
          x=a:y=b                                       :REM to avoid corruption of p,q,a,b during the drawing of the polygon
          MOVE x,y                                      :REM move the graphics cursor to the start without drawing
          FORi=1TO14                                    :REM do 14 iterations regardless of the number of sides on the polygon
            x+=u*2                                      :REM increment x and y by the vector representing the side
            y+=v*2                                      :REM the value is double (u,v) to facilitate drawing duals later

            REM if z$ begins with a numeric character, draw an edge. If not, change to red and draw a spoke.
            IFVAL(z$) DRAW x,y ELSE GCOL9: LINEx-u-v/o,y-v+u/o,x-u+v/TAN(PI/n),y-v-u/TAN(PI/n)             

            w=v*COS(t/n)-u*SIN(t/n)                     :REM rotate the vector clockwise
            u=v*SIN(t/n)+u*COS(t/n)                     :REM through the external angle of the polygon
            v=w
          NEXT                                          :REM draw next edge of the current polygon
        NEXT                                            :REM draw next polygon of the current vertex

        p=u:q=v                                         :REM once the vertex is finished, we will be two sides around the perimeter of the last polygon.
        a=x:b=y                                         :REM copy the position and direction data into p,q,a,b.
      NEXT                                              :REM draw next vertex figure

    NEXT                                                :REM close the two new translation loops
  NEXT

Resultado

O programa executa apenas um lado a lado ou duplo para cada execução. No entanto, traça os duplos em vermelho. Para economizar espaço, executei o programa duas vezes sem limpar a tela, a fim de sobrepor o dual em cima dos ladrilhos comuns.

insira a descrição da imagem aqui

Level River St
fonte
8

Mathematica

O nível 1 contém os modelos básicos de bloco que são estampados repetidamente para colocar um plano em bloco.

O nível 2 faz a telha.

Ainda existem 2 inclinações que não consegui alcançar. Eles parecem exigir rotação e translação.

Nível 1: Figura do vértice (559 bytes)

nGon[n_]:=
{ColorData[46,"ColorList"][[n]],Polygon@Switch[n,
3,{{0,0},{-1/2,.866},{-1,0},{0,0}},
4,{{0,0},{0,1},{-1,1},{-1,0},{0,0}},
6,Table[{Cos[i 2Pi/n],Sin[i 2Pi/n]}+{-.5,.866},{i,0,n}],
8,Table[1.31{Cos[i Pi/4],Sin[i Pi/4]}+{-0.5`,1.207},{i,1/2,9}],
_,Table[2{Cos[i 2Pi/n],Sin[i 2Pi/n]}+{-0.5176,1.932},{i,1/2,13}]]}
innerAngle[n_]:=180-360/n
g[{}]=0;
g[a_]:=-(Plus@@innerAngle/@a)

h[{{},__,out_}]:=out
h[{list_,angles_,out_}]:=(
z=GeometricTransformation[nGon[l=list[[1]]],RotationTransform[g[angles] Degree]];
h[{Rest@list,Append[angles,l],Append[out,z]}])

Teste

Row[Graphics[{EdgeForm[{Blue}], #}, 
      ImageSize -> 70] & @@ {h[{#, {}, {}}]} & /@ {{3, 3, 3, 3, 3, 
    3}, {3, 3, 3, 3, 6}, {3, 3, 3, 4, 4}, {3, 3, 4, 3, 4}, {3, 12, 
    12}, {3, 4, 6, 4}, {3, 6, 3, 6}, {4, 4, 4, 4}, {4, 6, 12}, {4, 8, 
    8}, {6, 6, 6}}]

selos

Nível 2: lado a lado (690 bytes adicionais)

As regras retornam compensações e recuos lado a lado para cada configuração.

r é a função básica que gera as inclinações.

pmostra o modelo e o respectivo ladrilho. Os espaços em branco correspondem àqueles não cobertos pelo modelo.

rules={
{3,6,3,6}-> {2,3.47,0,0},
{4,4,4,4}-> {1,1,0,0},
{6,6,6}-> {3,2.6,1.5,0},
{3,3,3,3,3,3}-> {1.5,1.74,0,.9},
{3,3,3,3,6}-> {2,2.6,-0.4,1.8},

{4,6,12}->{4.2,4.9,0,2.5},
{3,3,4,3,4}-> {1.87,1.86,-.5,-0.5},
{4,8,8}-> {3.4,3.4,0,0},
{3,3,3,4,4}-> {2,1.87,.52,0},
{3,12,12}-> {3.82,6.73,0,0},
{3,4,6,4}-> {1.4,4.3,0(*1.375*)-1,-2.4}};


r[nGons_]:=
Module[{horizHop,vertHop,indent,downIndent},
{horizHop,vertHop,indent,downIndent}=(nGons/.rules);
Graphics[{EdgeForm[{Blue}],Table[GeometricTransformation[h[{#,{},{}}]&/@{nGons},
TranslationTransform[{
If[MemberQ[{{3,3,4,3,4},{3,3,3,3,6},{3,4,6,4}},nGons],indent *row,indent Boole[OddQ[row]]]+col horizHop,
If[MemberQ[{{3,3,4,3,4},{3,3,3,3,6},{3,4,6,4}},nGons],downIndent *col,downIndent Boole[OddQ[col]]]-row vertHop}]],
{col,0,5},{row,0,4}]},ImageSize-> 250]]

p[nGon_]:=Row[{Graphics[{EdgeForm[{Blue}],h[{nGon,{},{}}]},ImageSize->70],r@nGon}];

Teste

Mosaico triangular

p[{3, 3, 3, 3, 3, 3}]

triangular

hexagonal

p[{6, 6, 6}]

hexagonal

quadrado

p[{4, 4, 4, 4}]

quadrado

desconhecido

p[{3, 3, 4, 3, 4}]

archimedes1

quadrado truncado

p[{4, 8, 8}]

quadrado truncado

trihexagonal

p[{3, 6, 3, 6}]

trihexagonal

hexagonal truncado

p[{3, 12, 12}]

hexagonal truncado

sem nome

p[{3, 3, 3, 3, 6}]

inclinado

triangular alongado

p[{3, 3, 3, 4, 4}]

triangular alongado

Inclinações para descobrir

esquerda

DavidC
fonte
Estou praticamente no mesmo estágio que você. Posso criar os ladrilhos, mas trabalhar com os ladrilhos vai demorar um pouco. O steveverill wiki publicado em seus comentários meio que faz parecer que vários esquemas criados precisam ser suportados. Precisa fazer um pouco de estudo :)
MickyT
Micky, O deslocamento vertical e horizontal de um ladrilho dependerá do número da linha, do número da coluna. usando compensações exclusivas para o caso em questão. Estou trabalhando um por um e depois generalizarei.
21414
@DavidCarraher ótimo começo. Fiz uma alteração nos critérios de pontuação que podem afetar você.
jsh
Bom até agora! Se você reduzir sua tradução horizontal 3.3.3.3.3.3pela metade, para que as unidades se sobreponham, você poderá se livrar desses diamantes e corrigir o ladrilho. Você ainda tem mais o que fazer e 3.3.3.3.6, no entanto. 3.4.6.44.6.12
Level River St
Re 4.6.12 anyone know what it should look like?- Todas as inclinações necessárias estão em en.wikipedia.org/wiki/… . Veja meu comentário sobre a questão. Esta é uma página diferente da mencionada na pergunta. Mas 4.6.12também é mostrado nessa página de qualquer maneira.
Level River St
6

R

Passo 1

Aqui está o meu esforço na construção dos ladrilhos. Lado a lado para vir em seguida. Isso não valida a entrada; portanto, os inválidos desenharão alguns blocos estranhos. A entrada é digitada após a primeira linha

i=as.numeric(unlist(strsplit(readline(),"[.]")))
e=c()
for(n in 1:length(i)){
    o=sum(c(0,180-360/i[1:n-1]))
    for(z in 1:i[n]){
        e=c(e,(360/i[n])*(z-1)+o)
    }
}
f=pi/180
plot(c(0,cumsum(sin(e*f))),c(0,cumsum(cos(e*f))),type="l")

insira a descrição da imagem aqui

Etapa 1, 2 e 3: 1898

Finalmente voltei a isso. A maior parte disso é resolvida com compensações e tratamento de casos especiais :). Edit: V flag para duals agora são manipulados

O processo geral é:

  • Pegue a entrada e faça uma lista
  • Crie uma lista de ângulos para desenhar o bloco inicial
  • Calcule os centros de cada polígono, o ladrilho e os vetores a partir deles para dividir as arestas
  • Determine o conjunto de blocos que está sendo desenhado e faça uma lista de desvios angulares. Alguns ladrilhos têm polígonos adicionais adicionados a eles para ajudar no preenchimento de orifícios.
  • Desenhe os azulejos
  • Desenhe os duplos

Provavelmente ainda posso jogar isso um pouco mais.

##Get input (Enter by itself then type in the tile scheme)
i=strsplit(readline(),"[.]")[[1]]
## Run once i is set
q=0
if(substr(i[1],1,1)=="V"){q=1;i[1]=substr(i[1],2,9)}
i=as.numeric(i)
f=pi/180
e=x=y=q=p=c()
l=length(i)
d=1/(2*tan(pi/3))
g=1/(2*sin(pi/3))
for(n in 1:l){o=sum(c(0,180-360/i[1:n-1]))
r=1/(2*sin(pi/i[n]))
a=o+(180-360/i[n])/2
b=1/(2*tan(pi/i[n]))+d
for(z in 1:i[n]){x=c(x,r*sin(a*f))
y=c(y,r*cos(a*f))
q=c(q,b)
p=c(p,(360/i[n])*(z-1)+o-90)
e=c(e,(360/i[n])*(z-1)+o)}}
if(sum(i)==18&l==6){h=c(60,0);w=c(60,120)}
if(sum(i)==18&l==5){h=c(0,0,60);w=c(60,120,60)
e=c(e,0,-60,60,180,60,180)
x=c(x,g*sin(-30*f),g*sin(-30*f),g*sin(90*f))
y=c(y,1+g*cos(-30*f),1+g*cos(-30*f),1)
q=c(q,d+d,d+d,d+d)
p=c(p,-30,90,-30)}
if(sum(i)==17&l==5&sum(abs(diff(c(i,i[1]),1)))==2){h=c(0,0);w=c(90,60)}
if(sum(i)==17&l==5&sum(abs(diff(c(i,i[1]),1)))==4){h=c(0,30);w=c(270,300)}
if(sum(i)==17&l==4){h=c(0,30,-30);w=c(60,30,90)
e=c(e,150,120,210,300)
x=c(x,sin(150*f)+g*sin(90*f),sin(150*f)+sin(210*f)/2)
y=c(y,cos(150*f)+(1/(2*cos(pi/3)))*cos(90*f),cos(150*f)+cos(210*f)/2)
q=c(q,1,1)
p=c(p,210,120)}
if(sum(i)==18&l==4){h=c(0,0);w=c(120,120)}
if(sum(i)==16&l==4){h=c(0,0);w=c(90,90)}
if(sum(i)==27&l==3){h=c(0,-30,0,30);w=c(60,90,120,150,180)}
if(sum(i)==22&l==3){h=c(0,-30,30,90,60,30)
w=c(90,150,120,90,60,30)
e=c(e,0,-30,-60,30,120,210,30,90,150)
q=q-d+1/(2*tan(pi/4));q[13]=q[17]=q[21]=q[21]+3}
if(sum(i)==20&l==3){h=c(0,-45,-90);w=c(90,0,45)}
if(sum(i)==18&l==3){h=c(0,60,0,-60);w=c(0,60,120,60)}
hx=sum(sin(h*f))
hy=sum(cos(h*f))
wx=sum(sin(w*f))
wy=sum(cos(w*f))
plot(0,0,type="n")
par(pin=c(5,5),usr=c(0,20,0,20))
for(c in -20:20){for(j in -20:20){lines(c((c*hx)+(j*wx)+0,(c*hx)+(j*wx)+cumsum(sin(e*f))),c((c*hy)+(j*wy)+0,(c*hy)+(j*wy)+cumsum(cos(e*f))),type="l")
if(q){for(n in 1:length(x)){lines(c((c*hx)+(j*wx)+x[n],(c*hx)+(j*wx)+x[n]+q[n]*sin(p[n]*f)),c((c*hy)+(j*wy)+y[n],(c*hy)+(j*wy)+y[n]+q[n]*cos(p[n]*f)),col="RED")}}}}

insira a descrição da imagem aqui insira a descrição da imagem aqui insira a descrição da imagem aqui

MickyT
fonte
Uau, apenas 4 horas atrás de mim. E eles também são bonitos, +1! Você já tem todos os casos trabalhando?
Level River St
@steveverrill Obrigado e funciona em todos os casos da pergunta.
MickyT
4

BBC BASIC

Faça o download do emulador em http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

Nível 1

insira a descrição da imagem aqui

Nível 1.5

O nível 1.5 é minha própria designação, mas é um marco importante no meu método.

Traduzir as figuras do vértice nem sempre leva à colocação correta. Em alguns casos, faltam linhas.

Minha solução para isso é contornar o maior polígono, desenhando a figura do vértice para cada segundo vértice desse polígono. Esta é uma solução geral para todos os casos. Observe que o maior polígono sempre tem um número par de lados e a figura do vértice geralmente alterna no sentido horário / anti-horário à medida que você percorre o polígono. Isso pode ser visto com mais clareza 4.6.12, mas também é verdade para 4.8.8e 3.12.12: quando vistos de qualquer 8-gon ou 12-gon em particular, os vértices alternados são imagens em espelho um do outro. É também o que está acontecendo, um pouco menos obviamente, com 3.3.3.4.4e 3.3.4.3.4: quando vistos de um quadrado em particular, os vértices alternados são imagens espelhadas um do outro.

O algoritmo que eu uso para mover dois lados do polígono é sempre fazer 14 iterações do loop de desenho de arestas, independentemente de quantas arestas o polígono possui. 8 é um fator de 16, portanto, ao desenhar octógonos, o cursor gráfico termina 16-14 = 2 vértices atrás de onde começou. 3- 4- 6- e 12-gons têm lados que são fatores de 12; portanto, o cursor gráfico termina 14-12 = 2 vértices à frente de onde começou.

As figuras podem ser vistas abaixo. Amanhã espero elaborar as traduções corretas para completar a lista. Em todos os casos, linhas suficientes são desenhadas para concluir o nível 2 apenas com traduções. Em alguns casos, é desenhado muito mais do que o mínimo necessário, mas não há problema com sobreposição: as regras não dizem nada sobre o desenho de linhas apenas uma vez :-)

Em geral, o maior polígono é o último da lista. Infelizmente, há um caso em que não é assim: 3.4.6.4Portanto, a figura desenhada neste caso é centrada em um quadrado e não em um hexágono. Existem linhas suficientes para concluir o nível 2 usando apenas traduções, embora existam certos quadrados que não são desenhados explicitamente. Isso apresentará alguns problemas no nível 3 (felizmente acho que sei como resolver isso.) Da mesma forma, 3.3.3.3.6há linhas suficientes para concluir o nível 2 usando apenas traduções, mas haverá certos triângulos que não são desenhados explicitamente.

insira a descrição da imagem aqui

Código

O código para o nível 1.5 é comentado, apenas o código para o nível 1 é ativado. Existem quatro linhas começando com a REM. Remova estes REMs para ativar o nível 1.5.

  t=PI*2                                          :REM constant Tau = PI*2
  DIMm(9)                                         :REM declare array for the numbers in the input
  c=0                                             :REM number of polygons in the list

  INPUTz$
  FORi=1TOLEN(z$)                                 :REM for each character in the input
    d%=VAL(MID$(z$,i))                            :REM use VAL to return the numeric value of the substring to the right and store to integer variable
    IF d% c+=1 :m(c)=d%: i-=d%=12                 :REM if the last character read was a number, d% contains it, otherwise 0. Advance c and store to m. If it is 12, increment i to skip a character.
  NEXT

  FORi=1TOc PRINTm(i),:NEXT                       :REM parsing check for debugging.


  a=601:b=601                                     :REM coordinates to start drawing at
  p=40:q=0                                        :REM vector of first line

  REM FORk=1TOm(c)/2                              :REM draw half as many vertex figures as there are sides on the last polygon in the list

  FORj=1TOc                                       :REM for each polygon on the list
    n=m(j)                                        :REM n=number of sides

    w=-p*COS(t/n)-q*SIN(t/n)                      :REM rotate the starting vector anticlockwise by the internal angle of the current polygon
    q=p*SIN(t/n)-q*COS(t/n)                       :REM to avoid overlapping the previous one, if any.
    p=w

    u=p:v=q                                       :REM make a local copy of the vector and coordinates
    x=a:y=b                                       :REM to avoid corruption of p,q,a,b during the drawing of the polygon
    MOVE x,y                                      :REM move the graphics cursor to the start without drawing
    FORi=1TO14                                    :REM do 14 iterations regardless of the number of sides on the polygon
      x+=u*2                                      :REM increment x and y by the vector representing the side
      y+=v*2                                      :REM the value is double (u,v) to facilitate drawing duals later
      IFVAL(z$) DRAW x,y ELSE LINEx-u,y-v,x-u,y-v :REM if the first character of the input is a number, draw the side of the polygon. The ELSE part is unfinished and will be for drawing duals.
      w=v*COS(t/n)-u*SIN(t/n)                     :REM rotate the vector clockwise
      u=v*SIN(t/n)+u*COS(t/n)                     :REM through the external angle of the polygon
      v=w
    NEXT                                          :REM draw next edge of the current polygon
  NEXT                                            :REM draw next polygon of the current vertex

  REM p=u:q=v                                     :REM once the vertex is finished, we will be two sides around the perimeter of the last polygon.
  REM a=x:b=y                                     :REM copy the position and direction data into p,q,a,b.
  REM NEXT                                        :REM draw next vertex figure

Níveis 2 e 3

Veja minha outra resposta.

Level River St
fonte