Como elaborar um algoritmo para gerar um layout de trilhos de trem aleatório, mas válido?
https://cs.stackexchange.com/questions/117972
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Estou me perguntando se tenho a quantidade C de trilhas curvas e a quantidade S de trilhas retas, como eu poderia elaborar um algoritmo, (assistido por computador ou não), para projetar um layout "aleatório" usando todas essas trilhas, de modo que as seguintes regras estão satisfeitos:
1) Os trilhos, quando todos conectados, formam um circuito fechado (contínuo) para o trem circular.
2) Rampas, curvas de trilhos, batidas de trilhos, cruzamentos de trilhos não são permitidos.
3) C e S serão números pares.Um exemplo seria C=20 e S=10.Observe que são necessárias 12 curvas na mesma orientação para formar um círculo completo de 360 graus, portanto, pelo menos 12 dessas curvas precisam ser orientadas da mesma maneira para completar os 360 graus.Os outros podem "ziguezaguear" desde que o resultado líquido seja 360 graus para que o trem dê uma volta completa.
As trilhas retas têm cerca de 10 polegadas (25,4 cm) de comprimento e as curvas têm cerca de 12,4 polegadas (31,6 cm) de comprimento (no centro, seguindo a curva) e curvam 30 graus.Os "laços" nos trilhos têm largura máxima de 9,2 cm (3 5/8 polegadas).Coloquei uma pista reta e uma curva uma sobre a outra e medi que a curva de 12,4" (31,6 cm) tem 12" (30,5 cm) de comprimento linear (na mesma direção da reta) e 3" (7,6 cm) da curva (na direção perpendicular da reta).Um círculo 12C tem diâmetro de 47,5" (120,6 cm) de centro a centro dos trilhos em lados opostos.
Todas as medidas são aproximadas.
ATUALIZAR
Medi novamente as pistas usando muito mais delas para ajudar a eliminar erros e, para minha surpresa, o comprimento das retas NÃO é de 10 polegadas, elas parecem ter cerca de 9,78 polegadas.Isto tem um impacto significativo na correspondência entre curvas em zigue-zague e retas.Originalmente pensei que 4 curvas em zigue-zague = 5 retas, mas isso não está totalmente correto.4 curvas têm cerca de 47 "de distância linear, então 5 retas de 9,78" cada seriam 48,9 ", quase 2 polegadas a mais.Então o truque é encontrar o MMC (mínimo múltiplo comum) de 47 e 9,78.Acontece que é 235.235 = 47*5 e 235/9,78 = 24,028...(perto o suficiente).Isso significa que 20 curvas em zigue-zague são praticamente iguais a 24 retas em comprimento linear.Felizmente, tenho 26 sequências, então mal consegui.As 2 sobras podem ser facilmente posicionadas em outro lugar do layout.
Outra coisa que descobri é que se eu ziguezaguear as curvas 2 na mesma orientação de cada vez (OOCCCCOO), então 8 delas terão uma distância linear de apenas 83 polegadas, e não 94 polegadas como se eu alternasse as curvas (OCCOOCCO).O MMC de 83 e 9,78 é cerca de 166.Portanto, 16 dessas curvas têm o mesmo comprimento linear que 17 retas.É útil saber isso porque tenho 44 curvas e apenas 26 retas, mas se eu fizer essa substituição, posso ajudar a compensar isso.
Se eu ziguezaguear as curvas 3 de cada vez (OOOCCCCCCOOO) e dobrá-las levemente, posso obter o comprimento linear exato de 10 retas (cerca de 97,8 polegadas).
FIM DA ATUALIZAÇÃO
Então o programa de computador teria que criar um modelo geométrico e lembrar as posições exatas de cada trilha ou existe alguma maneira mais simples de codificar isso?Quero poder "apertar um botão" e o computador "cospe" um "novo" layout válido para mim.
Quero dar esse algoritmo funcional às crianças que usam os trens, para que não fiquem frustradas ao tentar um layout que não funciona e depois tentem dobrar os trilhos para fazê-lo funcionar ou tenham que deixar de fora algumas peças dos trilhos porque eles não cabem.Um computador pode criar um layout válido usando todas as trilhas e se o algoritmo for bom, talvez em alguns segundos.Isso ajuda a evitar frustrações para eles.
Tenho algumas habilidades de codificação, mas preciso conhecer um algoritmo antes de poder codificar algo significativo (além de apenas testar algumas partes de um algoritmo candidato)
O que estou pensando é que eu poderia fazer com que o computador modelasse as trilhas usando uma representação menor (em escala reduzida).Eu acho que ele poderia simplesmente "colocar" as trilhas no layout candidato e verificar se há colisões com outras trilhas já existentes.
Estou pensando que provavelmente existem maneiras melhores de fazer isso, e é por isso que estou pedindo aqui algumas ajudas/ideias.Eu realmente quero que isso funcione e tenho as trilhas aqui para poder usá-las para ajudar a verificar se o algoritmo está funcionando.
Podemos usar C=20 e S=10 como parâmetros para tentar resolver isso porque é um número razoavelmente pequeno de trilhas (30 no total).Presumo que se o algoritmo for robusto o suficiente, os valores C e S podem ser alterados à vontade e ainda funcionará.Por exemplo, eventualmente quero tentar C=44 e S=26.
Palavra final
Obrigado a todos por seus comentários e sugestões sobre esta questão.Eu aprendi muito também.Quando criança, nunca pensei muito sobre trilhos de trem e como eles se encaixam, mas como adulto, posso ver que é um problema geométrico fascinante e um problema de contagem matemática muito difícil para gerar/descobrir quantos layouts de trilhos diferentes (únicos). há.Espero que você tenha gostado deste exercício tanto quanto eu.As crianças também apreciam.
Fim Palavra final
Solução
Pensei em oferecer a solução de força bruta.
A ideia é testar cada layout de pista por vez.Ao construir um layout, existem apenas três peças que precisam ser levadas em consideração:uma curva para canhotos, uma curva para destros e uma reta.
Você pode codificar o layout da trilha como um número base 3 com largura correspondente ao número de peças no layout.Para enumerar todos os layouts das trilhas basta contar na base 3, onde a codificação é 0=direto, 1=esquerda e 2=direita.
A próxima etapa é verificar se o layout se une nas duas extremidades.A primeira verificação é ter certeza de que há curvas suficientes para percorrer um circuito completo.Se escolhermos um sentido anti-horário para um circuito, serão necessárias 12 curvas à esquerda.Para cada curva extra à direita, precisamos adicionar uma curva extra à esquerda.Portanto, para verificar se o layout específico funciona, basta adicionar o número de curvas à esquerda e subtrair o número de curvas à direita - deve ser igual a 12.
Por último, precisamos verificar se os objetivos realmente são alcançados.Simplesmente traçamos a pista em uma grade cartesiana.Começamos a origem em [0,0] e se terminar em [0,0], então ela se junta.
A maneira mais simples de traçar a trilha é LOGOTIPO estilo.Em outras palavras, mantemos um vetor de direção que aponta na direção da última peça de pista colocada.Se encontrarmos uma curva à esquerda, gire a direção em 30 graus e, para uma curva à direita, gire em -30 graus - uma reta não afeta a direção.
Para realmente traçar as curvas e retas, aumentamos o vetor de direção pelo tamanho da peça, ou seja,10 unidades para uma reta e 12,4 x 12/2 x pi (raio da pista circular completa) unidades para uma curva.
RESSALVAS
Devido a erros de arredondamento na soma dos números de ponto flutuante, a plotagem não é exata.E na vida real podemos deixar alguma margem de manobra para que os objetivos sejam alcançados, então isso precisa ser atendido.
Muitos layouts serão iguais, mas deslocados em uma posição.Não consigo ver uma maneira de excluir layouts duplicados alterados, a não ser manter os anteriores e verificá-los.
O algoritmo não exclui layouts onde as peças se cruzam.Para fazer isso, você teria que verificar se cada peça em um layout não cruza outra peça no layout (isso é O(n^2)).E teria que haver verificações para cruzamentos curva-curva, curva-reta e reta-reta, e isso começa a ficar muito complexo.
O tempo de execução do algoritmo é obviamente O(3^N), que é exponencial - e provavelmente impraticável para layouts muito grandes.
Abaixo está um código VBA que você pode colar no Excel para fornecer uma prova de conceito.Tentei deliberadamente manter o código o mais simples possível para ajudar na conversão para sua linguagem favorita.Qualquer dúvida, por favor sinta se à vontade para perguntar.
Option Explicit
Type Vector
X As Double
Y As Double
End Type
Sub GenerateTrackLayout()
Dim lCounts(40) As Long
Dim lColumn As Long
Dim lTrackLength As Long
Dim lCurveSum As Long
Dim lIndex As Long
Dim lIndex2 As Long
Dim vDirection As Vector
Dim vBase As Vector
Dim vTrackPosition As Vector
Dim fPI As Double
Dim fCurveRadius As Double
Dim fStraightLength As Double
Dim sPath As String
Dim lOutputRow As Long
Const TOLERANCE = 0.5 'inch
lOutputRow = 1
vBase.X = Sqr(3) / 2 ' 30 degrees
vBase.Y = 1 / 2 ' 30 degrees
fPI = 4 * Atn(1)
fCurveRadius = 12.4 * 12 / (2 * fPI)
fStraightLength = 10
lTrackLength = 12 ' initial track length
Application.ScreenUpdating = False
Do
' Check for closed track
lCurveSum = 0
For lIndex = 0 To lTrackLength - 1
If lCounts(lIndex) = 1 Then
lCurveSum = lCurveSum + 1
ElseIf lCounts(lIndex) = 2 Then
lCurveSum = lCurveSum - 1
End If
Next
If lCurveSum = 12 Then ' one 360 degree rotation anti-clockwise
vDirection.X = 0
vDirection.Y = 1
vTrackPosition.X = 0
vTrackPosition.Y = 0
' Plot the track and ensure that ends meet
For lIndex = 0 To lTrackLength - 1
Select Case lCounts(lIndex)
Case 0 ' straight
vTrackPosition = AddVectors(vTrackPosition, ScaleVector(vDirection, fStraightLength))
Case 1 ' left curve
vDirection = MultiplyVectors(vDirection, vBase, 1)
vTrackPosition = AddVectors(vTrackPosition, ScaleVector(vDirection, fCurveRadius))
Case 2 ' right curve
vDirection = MultiplyVectors(vDirection, vBase, -1)
vTrackPosition = AddVectors(vTrackPosition, ScaleVector(vDirection, fCurveRadius))
End Select
' If ends meet within tolerance then output the track
If Abs(vTrackPosition.X) < TOLERANCE Then
If Abs(vTrackPosition.Y) < TOLERANCE Then
If lIndex = (lTrackLength - 1) Then
sPath = ""
For lIndex2 = 0 To lIndex
Select Case lCounts(lIndex2)
Case 0 ' straight
sPath = sPath & "S"
Case 1 ' left
sPath = sPath & "L"
Case 2 ' right
sPath = sPath & "R"
End Select
Next
Application.ScreenUpdating = True
Cells(lOutputRow, 1).Value = sPath
Application.ScreenUpdating = False
lOutputRow = lOutputRow + 1
End If
End If
End If
Next
End If
' Count in base 3 where number width is Track Length
lColumn = 0
Do
lCounts(lColumn) = lCounts(lColumn) + 1
If lCounts(lColumn) = 3 Then
lCounts(lColumn) = 0
lColumn = lColumn + 1
Else
Exit Do
End If
Loop Until lColumn = lTrackLength
' We've tried all tracks of this length, next one up...
If lColumn = lTrackLength Then
Erase lCounts ' reset all columns to zero
lTrackLength = lTrackLength + 1
End If
DoEvents
Loop
End Sub
' Vector maths
Function MultiplyVectors(vVectorA As Vector, vVectorB As Vector, ByVal fConjugate As Double) As Vector
MultiplyVectors.X = vVectorA.X * vVectorB.X - fConjugate * vVectorA.Y * vVectorB.Y
MultiplyVectors.Y = vVectorA.Y * vVectorB.X + fConjugate * vVectorA.X * vVectorB.Y
End Function
Function AddVectors(vVectorA As Vector, vVectorB As Vector) As Vector
AddVectors.X = vVectorA.X + vVectorB.X
AddVectors.Y = vVectorA.Y + vVectorB.Y
End Function
Function ScaleVector(vVector As Vector, ByVal fScale As Double) As Vector
ScaleVector.X = vVector.X * fScale
ScaleVector.Y = vVector.Y * fScale
End Function
Outras dicas
Em primeiro lugar, um desafio de quadro:
Um computador pode criar um layout válido usando todas as trilhas e se o algoritmo for bom, talvez em alguns segundos
Você não precisa que o algoritmo seja executado em alguns segundos.Você precisa de saída em alguns segundos.Não vejo nada que impeça você de configurar um triturador de layout de força bruta em execução em um computador no canto e armazenar soluções em um banco de dados a partir do qual a interface do usuário pode selecionar layouts aleatórios.
Em termos de geração, existem várias abordagens semipadrão.O espaço de estados é bastante grande, portanto uma busca exaustiva pode não ser viável.Mas qualquer um dos seguintes pode valer a pena tentar:
- Embaralhamento aleatório puro de uma lista de retas e números iguais de curvas esquerda e direita, seguido de teste de "bondade".
- Escalada:comece com uma permutação aleatória e, em seguida, teste trocas simples para ver se elas melhoram a "bondade".Se o fizerem, faça a troca e repita.
- Recozimento simulado:semelhante, mas às vezes permite mudanças que diminuem a “bondade” na esperança de chegar a um morro melhor.
- Algoritmo genético:gere muitas permutações aleatórias e misture-as repetidamente e mantenha os melhores resultados.No entanto, não está totalmente claro como misturá-los.
- Os três últimos poderiam começar com curvas "boas conhecidas" geradas por inserções em um círculo.
- Explore opções de encontro intermediário.Por exemplo.gere todas as curvas com um ângulo total de +90 graus, indexe-as por vetor 2D entre os pontos finais e, se houver muito menos vetores do que curvas, você poderá considerar exaustivamente quádruplos deles para encontrar aqueles que formam um quadrilátero fechado .
Para testes de “bondade”, obviamente é necessário haver uma grande penalidade se a curva não for fechada.Também é necessário que haja uma grande penalidade para auto-sobreposições.Eu estaria inclinado a testar aqueles que usam uma árvore quádrupla para encontrar segmentos que não são consecutivos, mas estão próximos uns dos outros e, em seguida, testes de arco-arco, arco-linha e linha-linha para ver se alguma aresta delimita um segmento sobrepõe uma aresta que limita outra.
Outra estratégia que poderia ser capaz de forçar completamente o caso menor, mas não o maior, seria adotar uma abordagem algébrica para o vetor total.Seja o comprimento da peça reta $2\el$ e o raio da peça curva é $2r$.Como as orientações são todas múltiplas de 30 graus, o vetor entre as extremidades de uma peça reta está em $$(0, \pm 2\ell), (\pm 2\ell, 0), (\pm \ell, \pm \sqrt3 \ell), (\pm \sqrt3 \ell, \pm \ell)$ $ e da mesma forma o vetor entre as extremidades de uma peça curva está em $$(\pm r, \pm \sqrt3 r), (\pm \sqrt3 r, \pm r), (\pm (\sqrt3 - 1)r, \pm (\sqrt3 - 1)r))$$
A menos que um dos $\frac\ell r$, $\frac {\sqrt 3 \ell} r$, ou $\frac \ell {\sqrt 3 r}$ é uma fração com um numerador pequeno e um denominador pequeno, curvas e retas são independentes, então você pode encontrar conjuntos de curvas funcionais (a força bruta é suficiente para 20 curvas, das quais 16 estão em uma direção e 4 estão na outra;para 44 curvas divididas em 28-16, você precisa de uma abordagem melhor;Eu não trabalhei nas implicações de exigir o $+\quadrado 3$s para ter um número correspondente de $-\sqrt 3$s, mas eles podem permitir alguma filtragem pesada) e depois inserir retas em pares.Aplicar isso com força bruta para um pequeno número de curvas permitiria avaliar quantos layouts você está potencialmente perdendo com a abordagem simétrica.
Uma solução possível tornar isso o mais simples possível para obter rapidamente um algoritmo funcional seria o seguinte.O layout mais simples é, obviamente, 12C (12 trilhas curvas, todas com a mesma orientação (uma em relação à outra) e formando um círculo simples.Esta será a base sobre a qual poderemos construir.
Portanto, o algoritmo básico será manter o layout de loop contínuo de 360 graus em cada etapa ao adicionar faixas.Podemos fazer isso examinando quantas trilhas curvas ainda restam e adicionando-as ao layout em grupos de modo que a propriedade de 360 graus seja mantida.Por exemplo, comece com nosso layout 12C (um círculo simples).Sabemos que temos 20C no total, então temos 8C restantes.A adição mais simples de algumas daquelas que manteriam a propriedade de 360 graus seria adicionar uma curva de orientação reversa e uma mesma curva de orientação (igual ao círculo principal com o qual começamos).Faríamos então o mesmo no lado oposto do layout.Neste exemplo simples, teríamos adicionado mais 4 curvas ao layout do círculo para que 12C se tornasse 16C (com 4C sobrando).Continuaríamos colocando curvas até que todas as 20 (neste exemplo) estivessem posicionadas corretamente.Observe que este layout que consiste em todas as curvas é um layout de circuito fechado válido.O trem pode usar esse layout, no entanto, ele consiste em trilhos curvos, portanto ainda não terminamos.
As trilhas retas seriam então inseridas da mesma maneira, exceto que podem ser adicionadas em pares (2 trilhas), uma vez que não alteram a propriedade de 360 graus.Eles podem ser inseridos em qualquer lugar, então acho que seria melhor colocar primeiro TODAS as trilhas curvas, depois voltar e fazer uma segunda passagem para colocar as retas aleatoriamente (mas simetricamente).
Este é o algoritmo mais simples que consigo pensar no momento.É garantido produzir um loop fechado de 360 graus, uma pista simétrica, e assumindo que o número de curvas é um múltiplo de 4, e o número de retas é um múltiplo de 2, ele usará cada pista.
Porém, uma coisa a considerar (ao usar esse algoritmo em um computador ou apenas em sua mente enquanto você constrói o layout) é que pode haver restrições de espaço mais em uma direção do que na outra.Por exemplo, em um pátio longo, mas não tão largo.Ao usar o algoritmo, ele deve ser mais direcionado para a dimensão longa de onde o layout será montado.
Se alguém conseguir descobrir um algoritmo para formar um layout assimétrico usando todas as faixas, isso seria ainda mais impressionante.
A diferença de complexidade entre a solução mais simples e a mais complicada é impressionante.Começar com um círculo (12C) é o mais simples possível para este problema e é razoável para crianças, porém é muito interessante analisar uma solução genérica que possa produzir QUALQUER layout válido (incluindo os assimétricos).
Na realidade, um algoritmo que não seja de computador seria apenas adicionar algumas formas "legais" ao layout e aproximá-lo da conexão, depois voltar e ajustá-lo para que ele realmente se conecte (para um circuito fechado).Com um total de 70 pistas (44C e 26S), é possível um layout enorme.Calculei um total de cerca de 67 pés de pista, o que equivale a cerca de 20 metros.O trem deve levar cerca de 1 minuto para percorrer todo o layout uma vez.
Outra solução candidata seria tomar as medidas reais de cada pista e lembrar a borda direita do layout.Ao construir o layout, você pode começar com uma trilha reta ou com uma curva à esquerda (sentido anti-horário), acumulando a distância da última trilha adicionada daquela borda mais à direita, e depois ao adicionar outras trilhas, nunca permitindo uma combinação de trilhas que irá bata ou cruze a borda mais à direita ou talvez nem chegue perto.Assim, por exemplo, comece com uma trilha reta (sem círculo inicial 12C nesta solução candidata) e, em seguida, escolha aleatoriamente outra trilha.Observe desde o início que NÃO permitiríamos uma curva à direita (sentido horário), pois isso quebraria a regra de "cruzar" a borda mais à direita.Após a primeira reta, nossas únicas opções são outra reta ou uma curva à esquerda (sentido anti-horário).Outra regra a ser aplicada seria após uma reta, não podemos adicionar mais de 9 curvas de orientação iguais seguidas, caso contrário, será provável que colida/cruze algumas outras pistas já instaladas.Esse limite poderia até ser reduzido para 8 para obter mais folga, e se isso ocorrer, a próxima pista DEVE ser uma curva com orientação reversa (já que uma reta pode causar problemas).
Este algoritmo precisaria de ajuda para voltar e se conectar ao outro lado da primeira faixa adicionada.Podemos fazer isso insistindo que as curvas no sentido anti-horário contam como +1 e as curvas no sentido horário contam como -1, e essas devem somar 12 na última curva adicionada.Podemos ajudar nisso polarizando as curvas CC (sentido anti-horário) em uma proporção de 4:1 com curvas no sentido horário, de modo que provavelmente obteremos 16 CC e 4 no sentido horário, o que resultará efetivamente em um círculo de 360 graus.Se o algoritmo tentar adicionar uma curva CC, mas esbarrar nas trilhas existentes, temos 2 opções nesse ponto: tentar uma curva de orientação oposta ou abandonar o layout e começar de novo.Eu acho que em um computador rápido, eventualmente ele terá um bom layout.
Ainda não tenho certeza se esse método produziria os mesmos layouts do início com 12C, mas talvez seja mais fácil de implementar em um computador, já que existem apenas algumas regras a serem aplicadas e estamos construindo o layout em uma faixa de uma vez.
Na verdade, acabei de pensar em um 3ª possível solução candidata isso deve funcionar e não é muito difícil de implementar.É o seguinte.
Use a técnica descrita acima, mas faça apenas meio traçado (utilizando metade das pistas de cada tipo, ou seja, 10 curvas e 5 retas).Fazemos com que o computador escolha trilhas aleatórias, mas só aceitamos layouts que terminem com uma rede de 180 graus de curva à esquerda (porque estamos impondo uma borda direita que nenhuma trilha pode tocar ou cruzar.Ok, então suponha que o computador encontre rapidamente um "meio layout" válido.Então o que fazemos é simplesmente fazer um inventário de quantas curvas no sentido horário e no sentido anti-horário existem, e duplicar isso na outra metade da pista (mas não necessariamente simetricamente).Para as retas, temos que registrar em que ângulo elas foram inseridas e depois combiná-las na outra metade da pista, mas novamente, não necessariamente de forma simétrica.
Vamos tentar um exemplo usando S para reta, O para curva no sentido anti-horário e C para curva no sentido horário.Concentrando-se primeiro no meio layout.
A primeira linha reta vai se afastar de nós e isso define nossa borda mais à direita que não podemos cruzar.
SOOSOCSOOSSOOOC - Este é um meio layout válido, pois possui 5 retas e 10 curvas com uma rede de 6 curvas no sentido anti-horário (2 das 8 foram "anuladas por 2 curvas no sentido horário).
Agora precisamos "manter o controle" sobre o ângulo em que as retas foram inseridas e combinar aquelas com o mesmo ângulo (mas direção oposta) para "cancelá-las".
1:Retas de ângulo de 0 graus
0:Retas em ângulo de 30 graus
2:Retas em ângulo de 60 graus
0:Retas em ângulo de 90 graus
2:Retas em ângulo de 120 graus
0:Retas em ângulo de 150 graus
0:Retas em ângulo de 180 graus
Então, para "combinar" isso com a outra metade do layout e fazer com que ele se conecte à trilha reta inicial única, só precisamos combinar o mesmo número de Os e Cs, mas também combinar o mesmo número de retas no + Ângulo de "retorno" de 180 graus.Por exemplo, é melhor que uma reta de 60 graus tenha uma reta de 240 graus do outro lado do layout em algum lugar, não necessariamente exatamente oposto.Isso ocorre porque a reta de 60 graus irá principalmente para a esquerda e um pouco para cima (usando este esquema) e a reta de 240 graus a trará de volta para a direita e para baixo na mesma quantidade para efetivamente "cancelar" essas contribuições de 2 faixas para desviando-se da posição inicial da pista.
Então agora tudo o que precisamos fazer para criar a "metade que falta" do layout é pegar as trilhas conhecidas que precisamos (e saber em quais ângulos as retas devem estar) e apenas "embaralhá-las" em qualquer ordem.
Pode haver uma maneira de NÃO ter que combinar exatamente metade do layout com faixas "complementares" do outro lado, mas isso envolveria matemática mais complexa e provavelmente não há tempo suficiente para resolver isso no tempo o bounty está ativo para.Há também uma chance de que nem todos os trilhos sejam usados dessa maneira e seja necessária uma ligeira curvatura dos trilhos.Podemos ignorar esta propriedade especial para esta questão.
Na verdade, fiz uma trilha assimétrica para ver se funcionaria e parece que funcionou.Usando S para linha reta, O para curva no sentido anti-horário e C para curva no sentido horário, mais o ângulo (em graus) relativo à linha reta inicial, obtive o seguinte para a metade superior:
S0, O30, O60, S60, O90, C60, S60, O90, O120, S120, S120, O150, O180, O210, C180
Para a metade inferior da pista obtive:
O210, O240, S240, C210, O240, S240, O270, O300, S300, S300, O330, O360, O390, C360, S360
Na verdade, a foto foi tirada do lado errado, então a parte superior e inferior estão invertidas.A primeira trilha traçada foi a reta próxima à lixeira azul e vindo em direção ao espectador da foto e a 2ª trilha é a curva no sentido anti-horário.
Parece que esta técnica funcionaria para um número par de curvas e um número par de retas, incluindo 44C e 26S, que é meu objetivo final.Isso é realmente encorajador, já que um computador eletrônico não é realmente necessário para resolver isso, posso apenas fazer com que as crianças construam qualquer forma de semicírculo que quiserem com metade das pistas (22C e 13S) e depois "corrijam" seu design para que que seja 180 graus, então "combine" com o outro lado da pista, não necessariamente simetricamente.
Você teria que ter cuidado se criasse um meio layout de 180 graus onde a trilha inicial e a trilha final estivessem muito próximas.Por exemplo, a forma da parte superior de um ponto de interrogação "?" (sem o ponto), mas continue a curva superior, para que ele apareça mais e uma reta descendo disso seria muito próxima da reta que está acima de onde estava o ponto.Então, para a metade inferior, você NÃO seria capaz de fazer mais curvas no sentido anti-horário imediatamente, pois existem outras retas a partir da "metade superior".A imagem do meu layout de circuito fechado funcionou porque não tive "gargalos" na metade "superior", mas é claro que isso é possível, como acabei de descrever.
O layout "problemático" do trem ocorre quando metade dos trilhos tem o formato de uma ampulheta com um meio estreito.Nesse caso, você quase tem que “espelhar” a parte superior porque certas curvas não podem ser feitas porque as trilhas estão muito próximas umas das outras.Aqui está um exemplo...
Outra observação interessante é que 4 trilhas curvas em zigue-zague são quase uma substituição exata (no que diz respeito à distância linear percorrida) para 5 retas.No entanto, muitos deles criarão uma diferença significativa no comprimento.Conforme declarado na seção ATUALIZADO acima, 20 curvas em zigue-zague são quase uma correspondência exata (para distância linear) de 24 retas.
Usando esta técnica, um layout gigante pode ser feito com todas as 70 peças da pista.Começaria com um círculo de 12c e, em seguida, de um lado, eu poderia inserir 24 retas (240 polegadas de comprimento).No lado oposto do layout (para quase corresponder ao comprimento do lado reto), eu usaria 20 curvas em zigue-zague (também com cerca de 240 polegadas de comprimento).Eles devem estar quase alinhados e uma ligeira curvatura deve fazer funcionar.As pistas restantes (2 retas e 12 curvas) poderiam ser facilmente posicionadas para manter o layout "equilibrado" (e conectado).
Suponha que você comece no ponto (0, 0) indo direto para a direita.Você precisa adicionar trilhas até chegar ao ponto (0, 0) novamente, desta vez direto da esquerda.Existem dois problemas aqui:Uma é chegar ao ponto (0, 0) vindo da esquerda exatamente.A outra é não ter sobreposições.
Para formar um círculo no sentido anti-horário você precisará de 12 peças curvas virando para a esquerda.Eles formam um círculo exato.Com 0, 24 ou 36 peças curvas você teria um oito, dois ou três círculos, nenhum dos quais pode ser feito sem cruzamento.
E é claro que você pode adicionar faixas adicionais, e estas devem seguir certas regras:Você pode adicionar peças curvadas à esquerda, retas e curvas à direita em pares, começando em ângulos de x graus ex+30 graus, para retornar a 0,0.E o número de peças curvadas à esquerda além das 12 primeiras deve corresponder ao número de peças curvadas à direita, de modo que as peças correspondam no ângulo reto em 0,0.
Então essas são as peças que você pode usar.Você precisa verificar se não há cruzamentos, obviamente.
Se os comprimentos estiverem exatamente corretos, então pode ser que, por exemplo, uma combinação esquerda/direita/direita/esquerda cubra exatamente a mesma distância que quatro ou cinco retas, então algumas outras combinações podem ser permitidas.
E, claro, faixas são flexível, o que pode produzir muito mais possibilidades.
