O modelo de tráfego Biham-Middleton-Levine é um autômato celular de auto-organização que os modelos simplificados de trânsito.

Consiste em vários carros representados por pontos em uma treliça com uma posição inicial aleatória, onde cada carro pode ser de dois tipos: aqueles que apenas se movem para baixo (mostrados em azul neste artigo) e aqueles que apenas se movem em direção à direita (mostrada em vermelho neste artigo). Os dois tipos de carros se revezam para se mover. Durante cada turno, todos os carros do tipo correspondente avançam um passo se não forem bloqueados por outro carro.

Sua tarefa é visualizar esse modelo como uma animação. Aqui estão algumas boas demonstrações.

Entrada

Um número de ponto flutuante entre 0 e 1 representando densidade e dois números inteiros representando a altura e a largura da grade exibidas. Suponha que as entradas sejam válidas e que os parâmetros para uma função ou leitura da entrada do usuário estejam corretos.

Exemplo: 0.38 144 89(corresponde à imagem acima)

Resultado

Uma grade, pelo menos 80x80, que exibe a animação desse modelo em execução. No início, os carros são colocados aleatoriamente na grade até que a grade atinja a densidade de entrada, com meio vermelho e meio azul (ou seja, densidade vezes o número total de quadrados da grade, arredondados da maneira que você desejar). A densidade deve ser esse valor, o que significa que você não pode preencher cada célula com densidade como uma probabilidade. Para cada etapa, um tipo de carro se move para baixo ou para a direita, contornando se ultrapassarem a borda. O tipo de carro que se move alterna cada etapa. Para tornar a animação visível, deve haver pelo menos 10 ms entre cada etapa.

Regras

• Os carros podem ter qualquer cor ou símbolo, desde que sejam distinguíveis entre si e com o plano de fundo, e cada tipo de carro tenha a mesma cor ou símbolo.

• Console e saída gráfica são permitidos. Para a saída do console, qualquer símbolo imprimível é bom, mas a saída deve ser como uma grade de caracteres.

• Especifique que tipo de saída você produziu se não tiver uma captura de tela ou gif.

• A simulação deve ser executada para sempre.

A saída é um pouco complexa, portanto, se você tiver alguma dúvida, comente.

R, 350 338 293 291 273 268 264 bytes

function(d,x,y){f=function(w){v=length(w);for(j in which(w>0&!w[c(2:v,1)]))w[c(j,j%%v+1)]=0:1;w};m=matrix(sample(c(rep(1,q<-floor(d*y*x/2)),rep(-1,q),rep(0,x*y-2*q))),x);p=animation::ani.pause;o=image;a=apply;repeat{o(m<-t(a(m,1,f)));p();o(m<--1*a(-1*m,2,f));p()}}

Ungolfed:

function(d,x,y){
  q=floor(d*y*x/2)

  m=matrix(sample(c(rep(1,q),rep(-1,q),rep(0,x*y-2*q))),x)

  f=function(w){
    v=length(w)
    for(j in which(w>0&!w[c(2:v,1)])){
      w[c(j,j%%v+1)]=0:1
    }
    w
  }


  library(animation)
  repeat{
    m=t(apply(m,1,f))
    image(m)
    m=-1*apply(-1*t(m),2,f))
    ani.pause()
    image(m)  
    ani.pause()
  }
}

Função que recebe 3 argumentos: dcomo densidade e dimensões x,y. qé o número de carros em cada cor. mé a matriz com carros, que é preenchida inicialmente tomando um tipo aleatório do número de carros e espaços vazios. Os carros são 1ou -1, o espaço vazio é 0.

fé uma função que move os carros uma linha, olhando para os carros codificados como 1. Ele verifica se o carro pode se mover verificando 1s seguidos por 0. Costumamos applycorrer fem todas as linhas ou colunas, dependendo de quais carros.

flida com o movimento dos 1carros, para mover os -1carros, transpomos a matriz, seguindo a direção do movimento, multiplicando a matriz por -1, para que os -1carros se tornem 1carros, e vv e a matriz resultante é transformada novamente.

Isso é usado imagepara criar a plotagem, usando três cores padrão para os três valores. Usa o animationpacote para manipular as animações usando as opções padrão, que são 1 fps.

0.38, 144, 89:

0.2, 144, 89:

0.53, 144, 89:

Mathematica, 237 228 203 198 181 bytes

(b=RandomSample@ArrayReshape[Table[{0,i=2},##/2],{1##2},1]~Partition~#2;Dynamic@Colorize[i=-i;b=CellularAutomaton[{193973693,{3,{a=0{,,},{3,9,1},a}},{1,1}},b];If[i>0,b,2-b]])&

A saída é uma dinâmica Image. O fundo é verde claro e os carros são pretos ou magenta, dependendo da direção.

Explicação

b=RandomSample@ArrayReshape[Table[{i=1,2},##/2],{1##2},1]~Partition~#2

Crie o quadro inicial:

Table[{0,i=2},##/2]

Defina icomo 2. Crie um Listde {0, 2}, cujo comprimento seja piso (densidade * largura * altura / 2) (dividido por dois porque {0, 2}é comprimento-2).

ArrayReshape[ ... ,{1##2},1]

Remodelar o 2-D resultante List(2 x algo) em 1-D List(comprimento = largura * altura). Almofada 1se não houver valores suficientes.

RandomSample@ ...

(Pseudo-) classifica aleatoriamente o resultado.

... ~Partition~#2

Partição que resulta em comprimento (largura).

b= ...

Armazene isso em b .

Dynamic@Colorize[i=-i;b=CellularAutomaton[{193973693,{3,{a=0{,,},{3,9,1},a}},{1,1}},b];If[i>0,b,2-b]]

Crie um Dynamic Image:

i=-i;

Vire o sinal de i.

b=CellularAutomaton[{193973693,{3,{a=0{,,},{3,9,1},a}},{1,1}},b]

Aplique o autômato celular com 193973693pesos de regra e vizinhos {{0, 0, 0}, {3, 9, 1}, {0, 0, 0}}para btranspor. Conjuntob igual a isso.

If[i>0,b,2-b]

Se ifor positivo, deixe em bpaz. Caso contrário, transponha o b( 2-existe porque eu joguei CellularAutomatonum pouco). Essencialmente, isso transpõeb todas as outras iterações (para desfazer a transposição)

Colorize[ ... ]

Converta a matriz em um colorido Image .

Dynamic@ ...

Faça a expressão Dynamic. ou seja, as funções acima são executadas repetidamente.

Resultado

Aqui está uma saída de amostra (entradas :) 0.35, 192, 108para 2000 quadros (ampliada 2x).

https://i.imgur.com/zmSyRut.mp4

Dyalog APL , 190 108 115 112 bytes

Solução

S←{⍉⍣⍺⊢d[⍺]↑d[⍺]↓⍉↑(⍺⊃'(↓+) ' '(→+) ')⎕R' \1'↓(,⍨,⊢)⍉⍣⍺⍉⎕←⍵⊣⎕DL÷4}
{1S 0S⍵}⍣≡' ↓→'[d⍴{⍵[?⍨⍴⍵]}c↑1 2⍴⍨⌊⎕×c←×/d←⎕]

TryAPL online (ligeiramente modificado devido a restrições online):

1. Conjunto ⎕IO←0, definir a função S , e, em seguida, definir e exibir um aleatória 38% 14 × 29 grelha, L .

2. Faça um movimento para baixo.

3. Faça um movimento para a direita.

4. Vá para o passo 2.

   
   ^{Animação do algoritmo anterior, que não garantiu densidade.}

Explicação

S←{defina a função direta S (explicada aqui da direita para a esquerda):

 ÷4 recíproco de 4 (0,25)

 ⎕DL aguarde alguns segundos (retorna o tempo decorrido real)

 ⍵⊣ descartar isso em favor de ⍵ (o argumento certo; a grade)

 ⎕← saída que

 ⍉ transpor

 ⍉⍣⍺ transponha novamente se ⍺ (o argumento da esquerda; 0 = baixo, 1 = direita)

 ( aplique o trem de funções (explicado aqui da esquerda para a direita):

  ,⍨ o argumento anexado a si mesmo

  , anexado a

  ⊢ em si

 )

 ↓ dividir matriz em lista de listas

 ( regex de pesquisa (explicado aqui da esquerda para a direita):

  ⍺⊃ escolha uma das duas seguintes com base em ⍺ (0 = para baixo / primeiro, 1 = para direita / segundo)

  '(↓+) ' '(→+) ' seqüências de seta para baixo e esquerda, seguidas por um espaço

 )⎕R' \1' substitua por um espaço seguido pela sequência encontrada

 ↑ misturar lista de listas em matriz

 ⍉ transpor

 d[⍺]↓ solte as linhas "altura" se ⍺ (argumento à esquerda) for 0 (para baixo) ou as linhas "largura" se ⍺ for 1 (à direita)

 d[⍺]↑ então pegue tantas linhas

 ⊢ passagem (serve como separador)

 ⍉⍣⍺ transpõe se ⍺ (o argumento da esquerda; 0 = baixo, 1 = direita)

}

' ↓→'[ indexe a string com (explicada aqui da direita para a esquerda):

 ⎕ entrada numérica (dimensões)

 d← atribuir isso a d

 ×/ multiplique as dimensões (encontra contagem de células)

 c← atribua isso a c

 ⎕× multiplique isso com entrada numérica (a densidade)

 ⌊ arredondar para baixo

 1 2⍴⍨ repetir ciclicamente um e dois até esse comprimento

 c↑ estenda isso até o comprimento c , preenchendo com zeros

 d⍴ use d (as dimensões) para remodelar

 { aplique esta função anônima a isso (explicada aqui da esquerda para a direita):

  ⍵[ o argumento correto (a lista de zeros, uns e dois) indexados por

   ?⍨ os índices embaralhados até

   ⍴⍵ o comprimento do argumento

  ]

 }

]

{ aplique a seguinte função anônima (explicada da direita para a esquerda):

 0S⍵ aplique S com 0 (para baixo) como argumento à esquerda e a grade como argumento à direita

 1S com isso como argumento certo, aplique S com 1 (direito) como argumento esquerdo

}⍣≡ até que duas iterações sucessivas sejam idênticas (um engarrafamento)

Notas

1. Requer ⎕IO←0, que é padrão em muitos sistemas.

2. Solicita (altura, largura) e, em seguida, densidade.

3. Não usa nenhum autômato interno.

4. Usa suporte a regex interno.

5. Pára se houver um engarrafamento (nenhum carro pode se mover).

6. Produz matrizes de caracteres onde →representa carros se movendo para a direita, ↓representa carros se movendo para baixo e espaços são estradas vazias.

7. Como acima, ele envia para a sessão em 4 Hz, mas a frequência pode ser ajustada alterando ÷4; por exemplo, ÷3é 3 Hz e .3é ³⁄₁₀ Hz.

8. É mais fácil ver o que está acontecendo se for executado ]Box on -s=max -f=onprimeiro.

9. A distribuição necessária agora está garantida e os dois tipos de carros ocorrem exatamente em 50 a 50, exceto o arredondamento.

Java (624 bytes + 18 bytes para Java.awt. * = 642 bytes)

static void k(double b,final int c,final int d){final int[][]a=new int[c+1][d+1];int i=0,j;for(;i<c;i++){for(j=0;j<d;j++){a[i][j]=Math.random()<b?Math.random()<0.5?1:2:0;}}Frame e=new Frame(){public void paint(Graphics g){setVisible(1>0);int i=0,j;for(;i<c;i++){for(j=0;j<d;j++){g.setColor(a[i][j]==2?Color.BLUE:a[i][j]==1?Color.RED:Color.WHITE);g.drawLine(i,j,i,j);}}for(i=c-1;i>=0;i--){for(j=d-1;j>=0;j--){if(a[i][j]==1&&a[i][(j+1)%d]==0){a[i][(j+1)%d]=1;a[i][j]=0;}else if(a[i][j]>1&&a[(i+1)%c][j]==0){a[(i+1)%c][j]=2;a[i][j]=0;}}}}};e.show();while(1>0){e.setSize(c,d+i++%2);try{Thread.sleep(400L);}catch(Exception f){}}}

Ungolfed:

static void k(double b,final int c,final int d){
        final int[][]a=new int[c+1][d+1];
        int i=0,j;
        for(;i<c;i++) {
            for(j=0;j<d;j++) {
                a[i][j]=Math.random()<b?Math.random()<0.5?1:2:0;
            }
        }

        Frame e=new Frame(){
            public void paint(Graphics g){
                setVisible(1>0);
                int i=0,j;
                for(;i<c;i++) {
                    for(j=0;j<d;j++) {
                        g.setColor(a[i][j]==2?Color.BLUE:a[i][j]==1?Color.RED:Color.WHITE);
                        g.drawLine(i,j,i,j);
                    }
                }
                for(i=c-1;i>=0;i--) {
                    for(j=d-1;j>=0;j--) {
                        if(a[i][j]==1&&a[i][(j+1)%d]==0){
                            a[i][(j+1)%d]=1;a[i][j]=0;
                        }else if(a[i][j]>1&&a[(i+1)%c][j]==0){
                            a[(i+1)%c][j]=2;a[i][j]=0;
                        }
                    }
                }
            }
        };
        e.show();
        while(1>0){e.setSize(c,d+i++%2);try{Thread.sleep(400L);}catch(Exception f){}}
    }

Cenário: