As inscrições para este desafio exibirão uma figura Lissajous rotativa e animada . A aparência da rotação 3d ocorre quando o parâmetro x é sucessivamente mudado de fase em cada quadro.

Entrada:

Os parâmetros ae b(conforme o artigo da wikipedia ) serão especificados na linha de comando ou lidos a partir de stdin.

Resultado:

Isso é arte ASCII , portanto, a saída será exibida em uma janela do emulador de terminal ou equivalente. O tamanho da saída pode ser codificado, mas a figura de Lissajous deve ser pelo menos grande o suficiente para preencher uma janela de 80x24.

A taxa de quadros da animação será de aproximadamente 50 qps. Dormir por 20 ms entre cada quadro é bom, desde que o tempo para calcular cada quadro seja pequeno em comparação com o tempo fixo de sono. Se a sua escolha de idioma não puder ser calculada com rapidez suficiente na plataforma escolhida, você precisará calcular o tempo para dormir dinamicamente.

Cada quadro não será exibido até que todo o cálculo desse quadro esteja completo. Não há necessidade de limpar a tela entre cada quadro.

A figura fará uma 2*Pirotação completa aproximadamente a cada 4 segundos.

Para cada quadro, uma curva fechada completa deve ser gerada. Pelo menos 1000 pontos devem ser calculados ao longo da curva. Não é necessário desenhar linhas entre os pontos.

Os pontos da curva serão plotados como #caracteres. O restante da área de exibição ficará em branco / em branco.

Isso é código-golfe , então a resposta mais curta em bytes (considerada aceitável por mim) será o vencedor aceito uma semana após esta postagem.

Resposta de referência não destruída .

Perl - 177

while($d+=.1){print"\e[H\e[2J";$a=0;while(($a+=.01)<4*atan2 1,0){$x=$==40+40*cos$d+$a*$ARGV[0];$y=$==13+13*sin$d+$a*$ARGV[1];print"\e[$y;$x"."H#";}print$/;select($v,$v,$v,.03);}

Os coeficientes são passados ​​através de argumentos. O gif acima é produzido a partir deperl % 2 3

C (resposta de referência - não jogado)

Saída com ./lissajous 2 3:

/*
 * lissajous.c
 *
 * Compile with:
 *   cc lissajous.c -lm -o lissajous
 *
 * Usage:
 *   ./lissajous a b
 *
 * a and b are the parameters as described in:
 * http://en.wikipedia.org/wiki/Lissajous_curve
 */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <unistd.h>

int main (int argc, char **argv) {
    char buffer[25][80];
    double t, p;
    int x, y;
    int a, b;

    if (argc != 3) return 1;

    a = atoi(argv[1]);
    b = atoi(argv[2]);

    for (;;) {
        for (p = 0; p < 2 * M_PI; p += M_PI / 100) {
            memset(buffer, ' ', sizeof(buffer));
            /* Set 1st char of final line to nul.  Then we can printf
             * the whole 2d array as if it were one long 1d buffer.
             * Line wraps at 80 chars are assumed */
            buffer[24][0] = 0;
            for (t = 0; t < 2 * M_PI; t += M_PI / 500) {
                x = 39.5 * (1 + sin(a * t + p));
                y = 11.5 * (1 + sin(b * t)); 
                buffer[y][x] = '#';
            }
            printf("%s\n", &buffer[0][0]);
            usleep(20000);
        }
    }
    return (0);
}

C, 257 bytes

Ok, bem, eu também não pude resistir ao golfe. Eu acho que há muito mais golfe a ser feito sobre isso:

#include<math.h>
main(int a,char**v){char x,y,b,d[25][80];double t,p,q=2*M_PI;a=atoi(v[1]);b=atoi(v[2]);for(p=0;memset(d,32,2000);p+=q/100){p=p<q?p:0;d[24][0]=0;for(t=0;t<q;y=11.5*sin(b*t)+12,d[y][x]=35,t+=q/1e3)x=39.5*sin(a*t+p)+40;puts(d);usleep(20000);}}

Python 3 - 280

Não tenha um desses gifs animados para você, desculpe. O console do Windows está lento na impressão: P

Não tenho certeza se isso atende aos requisitos de 50fps, mas não tenho certeza se é realmente possível com o Python. Você pode ajustar o 1000 na segunda linha para a quantidade de pontos a serem calculados (a lista é largura de saída, altura de saída, pontos a serem encontrados, progressão por quadro (pi * 2 / n) e ponto inicial). Ou você pode removê-los e especificar na entrada também.

import math as m
a,b,w,h,p,r,t=list(map(int,input().split()))+[79,24,1000,100,0]
while 1:v,z=w/2,h/2;d=[[int(m.sin(a*k+t)*v+v),int(m.sin(b*k)*z+z)]for k in[m.pi*2/p*l for l in range(p)]];print('\n'.join(''.join([' ','#'][[i,j]in d]for i in range(w))for j in range(h)));t+=m.pi*2/r

EDIÇÃO MAIS IMPORTANTE: Entrada via stdin, separada por espaço, nova linha terminada. Vai aguardar a sua entrada.

Edição: Screenshot. Altura alterada para 40 para este.

C # - 360 352 (plataforma cruzada - 332 apenas para Windows)

Editado após correção de bug de micro-golfe e arredondamento + sugestão de Ypnypn

Não é exatamente um candidato nesse sentido - e é praticamente uma cópia literal da referência - mas tudo bem. :)

namespace System{class P{static int Main(string[]m){double p=Math.PI*2,a=int.Parse(m[0]),b=int.Parse(m[1]),q,t;for(;;)for(q=0;q<p;q+=p/200){var s=new string(' ',1920).ToCharArray();for(t=0;t<p;t+=p/1000)s[(int)(39.5*Math.Sin(a*t+q)+40)+(int)(11.5*Math.Sin(b*t)+12)*80]='#';Console.SetCursorPosition(0,0);Console.Write(s);Threading.Thread.Sleep(20);}}}}

Hog de memória, criando uma nova matriz para cada atualização - originalmente (re) usava um StringBuilder, mas o sacrificava por falta de tempo. Mas pelo menos a atualização leva menos de 1 ms no meu antigo Core2.

Depois de remover um pouco do golfe antigo, que agora prejudica o comprimento, reduzindo-o em 8 caracteres, tentei devolvê-lo ao 360 "poético", revertendo para o dobro em vez da análise int e retornando para 80 * 24 em vez de 1920. No entanto, ainda são apenas 359 - e nenhuma outra adição de caractere em que eu consigo pensar realmente agrega valor ao código. Então, vamos ficar com 352. :-)

Desenrolado (perdeu o código de pré-golfe):

namespace System
{
    class P
    {
        static int Main(string[] m)
        {
            double p = Math.PI * 2,
                   a = int.Parse(m[0]),
                   b = int.Parse(m[1]),
                   q, t;

            for (;;)
            {
                for (q = 0; q < p; q += p/200)
                {
                    var s = new string(' ', 1920).ToCharArray();
                    // Alternative - Windows console only:
                    // var s = new char[1920];

                    for (t = 0; t < p; t += p/1000)
                    {
                        s[
                            (int) (39.5*Math.Sin(a * t + q) + 40)
                          + (int) (11.5*Math.Sin(b * t) + 12) * 80
                        ] = '#';
                    }
                    Console.SetCursorPosition(0, 0);
                    Console.Write(s);
                    Threading.Thread.Sleep(20);
                }
            }
        }
    }
}

O console do Windows realmente aceita a saída de muitos caracteres nulos, resultando em uma saída (graficamente) idêntica ao uso de um caractere de espaço real - o que permite que alguns caracteres a menos inicializem a matriz de caracteres.

Python 2.7 - 214

Eu acho que vou dar outra olhada nisso. Tenho a sensação de que isso pode ser reduzido ainda mais, mas será difícil atingir a contagem de bytes do Perl. A matemática parece ser minha maior limitação aqui.

Aviso: pode travar qualquer terminal que você estiver usando. Eu testei isso no prompt de comando do Windows com lissajous.py 2 3. Devido à rápida gravação no prompt de comando, espere que os quadros pulem um pouco. Isso pode ser resolvido principalmente (ao custo da velocidade) usando um valor maior sno range(s)e t=2*pi*i.

Eu não uso \r ou \baqui intencionalmente porque estou executando no Windows e isso custaria caracteres extras.

from math import*;import sys;a,b=sys.argv[1:];p=s=1920
while p:
 c = [" "]*s
 for i in range(s):
    t=2*pi*i/s;c[int(round((39.5*(1+sin(eval(a)*t+p))))+round(11.5*(1+sin(eval(b)*t)))*80)]="#"
 print ''.join(c)
 p+=.1