Les entrées pour ce défi afficheront une figure animée Lissajous en rotation . L'apparition d'une rotation 3D se produit lorsque le paramètre x est successivement déphasé dans chaque image.

Contribution:

Les paramètres aet b(selon l' article de wikipedia ) seront spécifiés sur la ligne de commande, ou lus depuis stdin.

Production:

C'est ascii-art , donc la sortie sera affichée dans une fenêtre d'émulateur de terminal ou équivalent. La taille de sortie peut être codée en dur, mais le chiffre Lissajous doit être au moins assez grand pour remplir une fenêtre de 80x24.

La fréquence d'images d'animation sera d'environ 50 images par seconde. Dormir pendant 20 ms entre chaque image est bien, tant que le temps de calcul de chaque image est petit par rapport au temps de sommeil fixe. Si votre choix de langue ne peut pas calculer assez rapidement sur la plate-forme que vous avez choisie, vous devrez calculer le temps de sommeil de manière dynamique.

Chaque cadre ne sera affiché que lorsque tous les calculs pour ce cadre seront terminés. Il n'est pas nécessaire d'effacer l'écran entre chaque image.

La figurine effectuera une 2*Pirotation complète toutes les 4 secondes environ.

Pour chaque image, une courbe fermée complète doit être générée. Au moins 1 000 points doivent être calculés le long de la courbe. Le dessin au trait entre les points n'est pas nécessaire.

Les points de la courbe seront tracés sous forme de #caractères. Le reste de la zone d'affichage sera vide / blanc.

Il s'agit de code-golf , donc la réponse la plus courte en octets (jugée acceptable par moi) sera le gagnant accepté une semaine après cette publication.

Réponse de référence non golfée .

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);}

Les coefficients sont transmis via des arguments. Le gif ci-dessus est produit à partir deperl % 2 3

C (réponse de référence - pas joué au golf)

Sortie avec ./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 octets

D'accord, je n'ai pas pu résister un peu au golf moi-même. Je pense qu'il y a encore beaucoup de golf à faire à ce sujet:

#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'ayez pas l'un de ces gifs animés fantaisie pour vous, désolé. La console Windows est lente à imprimer: P

Je ne suis pas sûr que cela réponde à l'exigence de 50 images par seconde, mais je ne suis pas sûr que ce soit vraiment possible avec Python. Vous pouvez ajuster le 1000 sur la deuxième ligne pour la quantité de points à calculer (la liste est la largeur de sortie, la hauteur de sortie, les points à trouver, la progression par image (pi * 2 / n) et le point de départ). Vous pouvez également les supprimer et les spécifier également dans l'entrée.

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

MODIFICATION PLUS IMPORTANTE: Entrée via stdin, espace séparé, fin de ligne. Attendra votre entrée.

EDIT: Capture d'écran. Changé la hauteur à 40 pour celui-ci.

C # - 360 352 (multiplateforme - 332 pour Windows uniquement)

Modifié après correction d'un bug de micro-golf et d'arrondi + suggestion par Ypnypn

Pas exactement un concurrent à cette longueur - et c'est à peu près une copie textuelle de la référence - mais eh bien. :)

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 mémoire, créant un nouveau tableau pour chaque rafraîchissement - à l'origine (ré) utilisé un StringBuilder, mais sacrifié pour la brièveté. Mais au moins le rafraîchissement prend moins de 1 ms sur mon ancien Core2.

Après avoir supprimé un peu de golf ancien - qui fait mal à la longueur, le réduisant ainsi de 8 caractères, j'ai essayé de le ramener au 360 "poétique" en revenant au double plutôt qu'à l'analyse syntaxique, et en revenant à 80 * 24 au lieu de 1920. Ce n'est toujours que 359, cependant - et aucun autre ajout de caractère unique auquel je peux penser n'apporte vraiment de valeur au code. Nous allons donc nous contenter de 352. :-)

Déroulé (perdu le code pré-golf):

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);
                }
            }
        }
    }
}

La console Windows accepte en fait la sortie d'un grand nombre de caractères nuls, ce qui donne une sortie (graphiquement) identique à l'utilisation d'un caractère d'espace réel - ce qui permet à quelques caractères de moins d'initialiser le tableau de caractères.

Python 2.7 - 214

Je pense que je vais revoir cela. J'ai le sentiment que cela peut être réduit encore plus, mais il sera difficile d'atteindre le nombre d'octets Perl. Les mathématiques semblent être ma plus grande limitation ici.

Avertissement: peut planter le terminal que vous utilisez. J'ai testé cela sur l'invite de commande Windows avec lissajous.py 2 3. En raison de l'écriture rapide dans l'invite de commandes, attendez-vous à ce que les cadres sautent un peu. Cela peut être principalement résolu (au prix de la vitesse) en utilisant un plus grand sdans le range(s)et t=2*pi*i.

Je n'utilise pas \rou \bici à dessein parce que je l'exécute sur Windows et cela coûterait des caractères supplémentaires.

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