A simple DNA simulator
Ruby, Rev B 171 161 bytes
Fixing the output for z=1 cost 10 bytes. It's a special case: the helix is really 3 characters wide if you looked at it at 90 degrees, but as we look at it at 0 degrees it looks only 1 character wide. zero leading spaces on z=1 no longer required
Some savings by eliminating brackets and by multiplying y.abs by 2 before truncation when calculating the number of - characters needed.
Finally, I avoided the include Math (required for sin and PI) by using complex number arithmetic with powers of the number i. The imaginary part of the complex number is equivalent to sin x, except that it repeats with period 4 instead of period 2*PI. Saving for this change was either 1 or 0 bytes.
->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
This is way longer than expected. There are a few potential golfing opportunities to be explored.
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}}
Commented in test program
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, 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);}}
Whipped this up pretty quick so I am sure there are some other things I could do to decrease my score but I am just happy I got this program to compile and run properly on the first attempt.
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: I adjusted the loop to print everything in one print statement and used the fact that variables are defined as int by default to shave some bytes. UPDATE2: Some var renaming and some logic shortening to shave a few more bytes.
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]);}
Or the longer version which parses input from main:
#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]);}
It's a pretty dumb overall implementation, with some printf tricks thrown in. It has some missing includes, uses K&R syntax for the function, and relies on GCC's range initialisers, so this isn't very standard. Also the function version still uses globals, so it can only be called once!
The function version takes 2 parameters; wait (in seconds) and zoom. Here's a caller for it:
#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;
}
Run as:
./dna <delay> <zoom>
./dna 0.5 8
Breakdown:
// 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
);
}