Ihr Code wird für immer eine sehr einfache ASCII-artige Darstellung der DNA erzeugen. Es werden zwei Zahlen in einem beliebigen Format als Eingabe verwendet: als Liste, als Argumente für eine Funktion, für stdin usw.

• Ein Gleitkommaintervall Iin Sekunden zwischen 0,0 und 1,0 (einschließlich)
• Eine Zoomstufe Zals Ganzzahl von 1 bis einschließlich 64

Ihr Code druckt jede ISekunde eine Zeile auf stdout oder das Äquivalent davon und erzeugt eine unendliche Ausgabe, die ungefähr so ​​aussieht (für Zoomstufe 4):

    A
 T-----a
G-------c
 G-----c
    g
 t-----A
a-------T
 c-----G
    T
 A-----t
C-------g
...

Genauer gesagt, unsere Darstellung von DNA ist ein Paar von Sinuswellen , die durch Bindestriche verbunden ist , eine aus den Zeichen a, c, g, und t, die andere der Zeichen A, C, G, und T. Wenn xdie 0-indizierten Nummer der Zeile sind wir gerade gedruckt wird , die 0-basierte Position des Zeichens in der Kleinwelle wird durch gegeben (sin(πx / Z) + 1) * Z, und in der Groß Welle ist gegeben durch (-sin(πx / Z) + 1) * Z, die beide abgerundet (nicht platt) zum nächstgelegenen ganze Zahl. Weitere Details:

• In Fällen, in denen sich die beiden Wellen überlappen, müssen Sie abwechseln, welche Welle vorne liegt, beginnend mit der Welle in Großbuchstaben. (Wenn wir mit der Welle in Kleinbuchstaben beginnen, erhalten wir eine Doppelhelix, die es nicht gibt !)
• Ignoriert man den Fall, so paart sich A immer mit T und C immer mit G, wie in der realen DNA. Die Paare selbst sollten zufällig mit einer gleichmäßigen Verteilung über die vier Möglichkeiten ausgewählt werden. Es spielt keine Rolle, ob die Auswahl der Paare bei aufeinanderfolgenden Codeausführungen gleich oder unterschiedlich ist. Die statistische Qualität Ihrer zufälligen Auswahl ist kein Problem, solange die Ausgabe kein offensichtliches Muster und einen Zeitraum von mindestens mehreren Milliarden aufweist (fehlerhafte PRNGs wie RANDU sind in Ordnung).
• Sie dürfen entweder keine nachgestellten Leerzeichen haben oder jede Zeile bis zur maximalen Position der Wellen in dieser Zoomstufe auffüllen (im obigen Beispiel neun Zeichen). Zoomstufe 1 kann aus mathematischen Gründen ein optionales zusätzliches nachgestelltes Leerzeichen enthalten.

Da die DNA klein ist, muss Ihr Code so kurz wie möglich sein.

Mehr Beispiele:

Zoomstufe 8:

        T
     C-----g
  A-----------t
 C-------------g
G---------------c
 T-------------a
  T-----------a
     T-----a
        c
     g-----C
  t-----------A
 g-------------C
a---------------T
...

Zoomstufe 2:

  A
T---a
  c
g---C
  G
A---t
  c
a---T
...

Zoomstufe 1 (beachten Sie das führende Leerzeichen):

 G
 a
 C
 t
...

Ruby, Rev. B 171 161 Bytes

Das Fixieren der Ausgabe für z = 1 kostet 10 Bytes. Es ist ein Sonderfall: Die Helix ist wirklich 3 Zeichen breit, wenn Sie sie bei 90 Grad betrachten, aber wenn wir sie bei 0 Grad betrachten, sieht sie nur 1 Zeichen breit aus. Null führende Leerzeichen auf z = 1 werden nicht mehr benötigt

Einige Einsparungen durch Eliminieren von Klammern und durch Multiplizieren von y.abs mit 2 vor dem Abschneiden bei der Berechnung der Anzahl der benötigten Zeichen.

Schließlich habe ich das include Math(für sinund erforderliche PI) vermieden, indem ich eine komplexe Zahlenarithmetik mit Potenzen der Zahl verwendet habe i. Der Imaginärteil der komplexen Zahl ist äquivalent zu sin x, außer dass er sich mit Periode 4 anstelle von Periode 2 * PI wiederholt. Das Speichern für diese Änderung betrug entweder 1 oder 0 Byte.

->z,i{x=0
loop{y=z*("i".to_c**x).imag
s=(?-*(y.abs*2)).center z*2+1
s[z-y+0.5]='TGAC'[r=rand(4)]
x!=0&&s[z+y+0.5]='actg'[r]
puts s
sleep i
x+=2.0/z
x>3.99&&x=0}}

Ruby, Rev A 165 Bytes

Das ist viel länger als erwartet. Es gibt einige mögliche Golfgelegenheiten, die erforscht werden müssen.

include Math
->z,i{x=0
loop{y=z*sin(x)
s=('--'*(y.abs+h=0.5)).center(z*2+1)
s[z+h-y]='TGAC'[r=rand(4)]
x!=0&&s[z+h+y]='actg'[r]
puts s
sleep(i)
x+=PI/z
x>6.28&&x=0}}

Kommentiert im Testprogramm

include Math
f=->z,i{x=0
  loop{y=z*sin(x)
    s=('--'*(y.abs+h=0.5)).center(z*2+1)  #make a space-padded string of z*2+1 characters, containing enough - signs
    s[z+h-y]='TGAC'[r=rand(4)]            #insert random capital letter, saving index in r
    x!=0&&s[z+h+y]='actg'[r]              #insert small letter. This will normally go on top of the capital as it is done second, but supress for x=0 to make helix
    puts s
    sleep(i)
    x+=PI/z                               #increment x
    x>6.28&&x=0                           #reset x if equal to 2*PI (this proofs against loss of floating point precision, making correct output truly infinite.)
  }
}

Z=gets.to_i
I=gets.to_f
f[Z,I]

C 294 289 285 283 281 270 265 237 218 Bytes

#include<math.h>
o,i,p,r;char*c="acgtTGCA",d[256]={[0 ...254]='-'};P(w,z)float w;{for(;;poll(0,0,r=w*1e3))p=fabs(sinf(M_PI*i++/z))*z+.5,r=rand()&3,o^=4*!p,printf(p?"%*c%s%c\n":"%*c\n",z-p+1,c[r+o],d+256-p*2,c[r+4-o]);}

Oder die längere Version, die Eingaben von main analysiert:

#include<stdlib.h>
#include<math.h>
o,i,p,r;char*c="acgtTGCA",d[256]={[0 ...254]='-'};main(n,v)char**v;{for(;n=strtod(v[2],0);poll(0,0,n=atof(v[1])*1e3))p=fabs(sinf(M_PI*i++/n))*n+.5,r=rand()&3,o^=4*!p,printf(p?"%*c%s%c\n":"%*c\n",n-p+1,c[r+o],d+256-p*2,c[r+4-o]);}

Es ist eine ziemlich blöde Gesamtimplementierung mit ein paar printf-Tricks. Es hat einige fehlende Includes, verwendet K & R-Syntax für die Funktion und stützt sich auf die GCC-Bereichsinitialisierer, daher ist dies nicht sehr Standard. Auch die Funktionsversion verwendet immer noch Globals, so dass sie nur einmal aufgerufen werden kann!

Die Funktionsversion akzeptiert 2 Parameter; Warten Sie (in Sekunden) und zoomen Sie. Hier ist ein Anrufer dafür:

#include <stdlib.h>
int main( int argc, const char *const *argv ) {
    if( argc != 3 ) {
        printf( "Usage: %s <delay> <zoom>\n", argv[0] );
        return EXIT_FAILURE;
    }
    const float delay = atof( argv[1] );
    const int zoom = strtod( argv[2], 0 );
    if( delay < 0 || zoom <= 0 ) {
        printf( "Invalid input.\nUsage: %s <delay> <zoom>\n", argv[0] );
        return EXIT_FAILURE;
    }
    P( delay, zoom );
    return EXIT_SUCCESS;
}

Rennen wie:

./dna <delay> <zoom>
./dna 0.5 8

Nervenzusammenbruch:

// Globals initialise to 0
o,                                 // Ordering (upper/lower first)
i,                                 // Current iteration
p,                                 // Current indent
r;                                 // Current random value
char*c="acgtTGCA",                 // The valid letters
    d[256]={[0 ...254]='-'};       // Line of dashes (for printing)
main(n,v)char**v;{                 // K&R-style main definition (saves 2 bytes)
    // n will be used for Zoom, random number & casting delay
    for(
        ;n=strtod(v[2],0);         // Store zoom
        poll(0,0,n=atof(v[1])*1e3) // After each loop, use poll to delay
                                   // (Use variable to cast delay to int)
    )
        p=fabs(sinf(M_PI*i++/n))*n+.5,   // Calculate separation / 2
        r=rand()&3,                      // Pick random number [0-4)
        o^=4*!p,                         // Reverse order if crossing
        printf(p                         // Print... if not crossing:
                ?"%*c%s%c\n"             //  indent+character+dashes+character
                :"%*c\n",                //  Else indent+character
                n-p+1,                   // Width of indent + 1 for char
                c[r+o],                  // First character
                d+256-p*2,               // Dashes
                c[r+4-o]                 // Second character
        );
}

C 569 402 361 Bytes

#include<stdlib.h>
u,l,r,m,n,Z,I,y=0,x=0;main(c,char**v){Z = atoi(v[1]);I=atof(v[2])*1000000;srand(time(0));char *a="ACGTtgca";while(1){r=rand()%4;usleep(I);double s=sin(3.14*x++/Z);u=floor(((-1*s+1)*Z)+0.5);l=floor(((s+1)*Z)+0.5);m=(u<l)?u:l;n=u<l?l:u;char z[n+1];memset(z,' ',n);z[l]=a[r+4];z[u]=a[r];for(y=m+1;y<n;y++)z[y]='-';z[n+1]='\0';printf("%s\n",z);}}

Ich habe das ziemlich schnell durchgearbeitet und bin mir sicher, dass ich noch einige andere Dinge tun kann, um meine Punktzahl zu senken, aber ich bin einfach froh, dass ich dieses Programm beim ersten Versuch richtig kompilieren und ausführen konnte.

De-Golf-Version:

#include<stdio.h>
#include<math.h>
#include<unistd.h>
#include<time.h>
#include<stdlib.h>
u,l,r,m,n,Z,I,y=0,x=0;
main(c,char**v){
   Z = atoi(v[1]);
   I=atof(v[2])*1000000;
   srand(time(0));
   char *a="ACGTtgca";
   while(1){
      r=rand()%4;
      usleep(I);
      double s=sin(3.14*x++/Z);
      u=floor(((-1*s+1)*Z)+0.5);
      l=floor(((s+1)*Z)+0.5);
      m=(u<l)?u:l;
      n=u<l?l:u;
      char z[n+1];
      memset(z,' ',n);
      z[l]=a[r+4];
      z[u]=a[r];
      for(y=m+1;y<n;y++)z[y]='-';
      z[n+1]='\0';
      printf("%s\n",z);
   }
}

UPDATE: Ich habe die Schleife so angepasst, dass alles in einer print-Anweisung gedruckt wird, und habe die Tatsache verwendet, dass Variablen standardmäßig als int definiert sind, um einige Bytes zu sparen. UPDATE2: Einige Var-Umbenennungen und einige Logik-Kürzungen, um ein paar Bytes mehr zu sparen.

JavaScript (ES6) 241 244 227 222 231 Byte

Das sah interessant aus - ich liebe ASCII-Kunst!
Gerade erst angefangen, noch dabei, Golf zu spielen ...

(I,Z)=>{c=i=0,setInterval(_=>{with(Math)m=sin(PI*i++/Z),a=round(++m*Z),b=round((2-m)*Z),r=random()*4|0,D="TGAC"[r],d="actg"[r],e=a-b,c^=!e,p=" ".repeat(a>b?b:a)+(c?D:d)+"-".repeat(e?abs(e)-1:0)+(e?a>b?d:D:""),console.log(p)},I*1e3)

--- EDIT: stellt sich heraus, dass ich es nicht in eval () schreiben kann - ansonsten kann es nicht auf die Vars I und Z zugreifen (fügt also 9 Bytes hinzu)

- 6 Bytes dank user81655
gespart - 5 Bytes dank Dave gespart

Erläuterung

(I,Z)=>{
  c=i=0,                                // clear vars
  setInterval(_=>{                      // repeat

    with(Math)                         
      m=sin(PI*i++ / Z),                // calculate waves
      a=round(++m * Z),
      b=round((2-m) * Z),
      r=random()*4|0,                   // get random amino-acids
      D="TGAC"[r],
      d="actg"[r],
      e=a-b,
      c^=!e,                            // alternate upper/lowercase
      p=                                // prepare output
        " ".repeat(
          a>b ? b : a
        )+(
          c ? D : d
        )+

        "-".repeat(
          e ? abs(e)-1 : 0
        )+(
          e ? a>b ? d : D : ""
        ),

      console.log(p)                    // return output
  },I*1e3)                              // repeat for every 'I' seconds
}