একটি সাধারণ ডিএনএ সিমুলেটর

Question

আপনার কোড চিরকালের জন্য, ডিএনএর একটি খুব সাধারণ ASCII- শিল্প উপস্থাপনা তৈরি করতে চলেছে। এটি আপনি যে কোনও ফর্ম্যাটে ইনপুট হিসাবে দুটি সংখ্যা নেবেন: একটি তালিকা হিসাবে, কোনও ফাংশনের আর্গুমেন্ট হিসাবে, স্টিডিনে ইত্যাদি etc.

• I0.0 এবং 1.0 এর মধ্যে সেকেন্ডে একটি ভাসমান-পয়েন্ট অন্তর (অন্তর্ভুক্ত)
• Zপূর্ণসংখ্যা হিসাবে একটি জুম স্তর 1 থেকে 64 পর্যন্ত (অন্তর্ভুক্ত)

আপনার কোডটি প্রতি Iসেকেন্ডে এক লাইনে স্টাডাউট বা তার সমতুল্য মুদ্রণ করবে , এমন এক অসীম আউটপুট উত্পাদন করবে যা এর মতো দেখতে (জুম স্তর 4 এর জন্য):

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

বিশেষ করে, ডিএনএ আমাদের উপস্থাপনা, হাইফেন দ্বারা সংযুক্ত সাইন তরঙ্গ একজোড়া হয় অক্ষরের এক গঠিত a, c, g, এবং t, অক্ষরের অন্যান্য A, C, G, এবং T। যদি xবর্তমানে আমরা যে লাইনের মুদ্রণ করছি তার 0-সূচিযুক্ত নম্বরটি হয়, তবে ছোট হাতের তরঙ্গে অক্ষরের 0-ভিত্তিক অবস্থানটি দেওয়া হয় (sin(πx / Z) + 1) * Zএবং বড় হাতের তরঙ্গটি (-sin(πx / Z) + 1) * Zউভয়ই কাছাকাছি ( বৃত্তাকার নয়) দ্বারা প্রদত্ত হয় পূর্ণসংখ্যা। অধিকতর বিস্তারিত:

• দুটি তরঙ্গ ওভারল্যাপ হয় এমন ক্ষেত্রে, বড় হাতের তরঙ্গ দিয়ে শুরু করে আপনার সামনে কোন তরঙ্গটি সামনে রয়েছে তা বিকল্প হতে হবে। (ছোট হাতের তরঙ্গ দিয়ে শুরু করলে আমাদের একটি ডাবল হেলিক্স দেবে যা বিদ্যমান নেই !)
• ক্ষেত্রে অগ্রাহ্য করা, A সর্বদা টি এবং সি এর সাথে সবসময় জুড়ায় জি, যেমন আসল ডিএনএ হিসাবে। জুড়িগুলি এলোমেলোভাবে চারটি সম্ভাবনার উপর অভিন্ন বিতরণের সাথে চয়ন করা উচিত। আপনার কোডটির ক্রমাগত রানগুলির ক্ষেত্রে জোড়ার পছন্দগুলি একই বা আলাদা কিনা তা বিবেচ্য নয়। আপনার র্যান্ডম পছন্দের পরিসংখ্যানগত মানের কোনো সমস্যা যতদিন আউটপুট কোন সুস্পষ্ট প্যাটার্ন এবং কোটি কোটি অন্তত একটি নির্দিষ্ট সময়ের হয়েছে যেমন নয় (মত ত্রুটিপূর্ণ PRNGs RANDU জরিমানা হয়।)
• আপনার জুম স্তরে তরঙ্গগুলির সর্বাধিক অবস্থানের জন্য প্রতিটি লাইনের কোনও চলমান স্থান বা প্যাড প্রতিটি প্যাডের নেই (উপরের উদাহরণে, নয়টি অক্ষর)) জুম স্তর 1 এর গাণিতিক কারণে এক অতিরিক্ত optionচ্ছিক অতিরিক্ত স্থানের স্থান থাকতে পারে।

ডিএনএ ছোট হওয়ায় আপনার কোডটি যতটা সম্ভব সংক্ষিপ্ত হওয়া দরকার।

আরও উদাহরণ:

জুম স্তর 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
...

জুম স্তর 2:

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

জুম স্তর 1 (অগ্রণী স্থান নোট করুন):

 G
 a
 C
 t
...

Comments

সম্পর্কিত।

— মার্টিন এন্ডার

"ডিএনএ ছোট হওয়ায় আপনার কোডটি যতটা সম্ভব সংক্ষিপ্ত হওয়া দরকার" " সত্যি?

— তানমাথ

@ ট্যানম্যাথ আপনার কি কোড-গল্ফের সত্যই কারণ দরকার? ব্যাকস্টোরিগুলি প্রায় সর্বদা এর মতো নির্বোধ, কেবল এটির সাথে চলুন।

— প্যাট্রিক রবার্টস

@ পেট্রিকরোবার্টস আমি জানি, তবে আমি কেবল ইঙ্গিত করছিলাম যে কারণটি কী নির্বোধ, অনেকগুলি কোড-গল্ফাররা করেন। খুব সিরিয়াসলি নেবেন না! ;)

— তানমাথ

"এলোমেলোভাবে নির্বাচিত" এর অর্থ কী? RANDU ঠিক আছে? একটি সংক্ষিপ্ত পুনরাবৃত্তি ক্রম সম্পর্কে কি?

— কেএসএফটি

Answer 1

রুবি, রেভ বি 171 161 বাইট

Z = 1 দাম 10 বাইটের জন্য আউটপুট স্থির করে। এটি একটি বিশেষ ক্ষেত্রে: হেলিক্সটি সত্যিকার অর্থে 3 টি অক্ষর প্রশস্ত আপনি যদি 90 ডিগ্রি করে দেখেন তবে আমরা 0 ডিগ্রিতে এটি দেখতে কেবল এটি কেবল 1 টি অক্ষর প্রশস্ত দেখায়। z = 1 এ শূন্যস্থানীয় স্থানগুলির আর প্রয়োজন নেই

প্রয়োজনীয় অক্ষরের সংখ্যা গণনা করার সময় সংক্ষিপ্তকরণের পূর্বে বন্ধনীগুলি মুছে ফেলে এবং y.abs 2 কে গুণ করে কিছু সঞ্চয় করে।

পরিশেষে, আমি সংখ্যার শক্তি সহ জটিল সংখ্যা গাণিতিক ব্যবহার করে include Math(এর জন্য প্রয়োজনীয় sinএবং PI) এড়িয়ে চলেছি i। জটিল সংখ্যার কাল্পনিক অংশটি পাপ x এর সমতুল্য, ব্যতীত এটি 2 * পিআই পিরিয়ডের পরিবর্তে 4 সময়ের সাথে পুনরাবৃত্তি করে। এই পরিবর্তনের জন্য সংরক্ষণ করা হয় 1 বা 0 বাইট ছিল।

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

রুবি, রেভ এ 165 বাইট

এটি প্রত্যাশার চেয়ে দীর্ঘতর। অন্বেষণ করার জন্য কয়েকটি সম্ভাব্য গল্ফিংয়ের সুযোগ রয়েছে।

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

পরীক্ষার প্রোগ্রামে মন্তব্য করা হয়েছে

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]

Comments

সুন্দর লাগছে! একটি ছোটখাটো সমস্যা: জুম স্তর 1 এর জন্য একটি শীর্ষস্থান আছে Also এছাড়াও, আপনার পরীক্ষার প্রোগ্রামটি I=gets.to_iহওয়া উচিত I=gets.to_f।

— লুক

উপস! আপনি ঠিক বলেছেন যে জেড = 1 একটি বিশেষ কেস। এটি উদ্দেশ্যমূলক ছিল না এবং এটি আসলে আমার দেওয়া গণিতের দেওয়া বিধিগুলির একটি দ্বন্দ্ব। আমি গণিতকে সামঞ্জস্য করার জন্য জেড = 1 এর শীর্ষস্থানীয় স্থান যুক্ত করতে যাচ্ছি।

— লুক

@ সাধারণ নিয়মে লুককে পরিবর্তন করা উচিত নয়, তবে প্রকৃতপক্ষে একটি বৈপরীত্য ছিল। আমি যতদূর বলতে পারি, অন্যান্য উত্তরগুলিও এটি বিবেচনা করে না। আমি আমার উত্তরটি পরে আপডেট করব, তবে এটি যেভাবে ছোট হবে।

— স্তরের নদী সেন্ট

@ লুক আপডেট হয়েছে, তবে এর অর্থ আমার কাছে জেড = 1 এ একটি শীর্ষস্থান এবং একটি চলমান স্থান উভয়ই রয়েছে। আমি বুঝতে পারি যে এটি আপনি যা চান তার স্পিরিট অনুসারে এবং তাই ঠিক আছে, যদিও এটি স্পেসিংয়ে ফাঁকা জায়গাগুলি এবং জেড = 1 এর উদাহরণ হিসাবে সারণী অনুসারে নয়।

— স্তরের নদী সেন্ট

উফফফফফ, হ্যাঁ ঠিক আছে। বিভ্রান্তির জন্য দুঃখিত.

— লুক

Answer 2

সি, 294 289 285 283 281 270 265 237 218 বাইট

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

বা লম্বা সংস্করণ যা মূল থেকে ইনপুট পার্স করে:

#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 এতে কিছু অনুপস্থিত রয়েছে, ফাংশনটির জন্য কেঅ্যান্ডআর সিনট্যাক্স ব্যবহার করে এবং জিসিসির রেঞ্জ ইনিশিয়ালাইজারগুলির উপর নির্ভর করে, সুতরাং এটি খুব স্ট্যান্ডার্ড নয়। এছাড়াও ফাংশন সংস্করণ এখনও গ্লোবাল ব্যবহার করে, তাই এটি শুধুমাত্র একবার বলা যেতে পারে!

ফাংশন সংস্করণ 2 পরামিতি লাগে; অপেক্ষা করুন (সেকেন্ডে) এবং জুম করুন। এর জন্য এখানে একজন কলার রয়েছে:

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

হিসাবে চালান:

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

ভাঙ্গন:

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

Comments

আপনি প্রধান (), যা আপনি এর বাইট সংরক্ষণ করতে হবে পরিবর্তে একটি ফাংশন ব্যবহার করার অনুমতি দেওয়া করছি strtodএবং atof।

— লুক

@ লুক আঃ শীতল; আমি এটি কতটা সঞ্চয় করে তা দেখতে পাচ্ছি ...

— ডেভ

Answer 3

সি, 569 402 361 বাইট

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

এটি বেশ তাড়াতাড়ি মেরে ফেলা হয়েছে তাই আমি নিশ্চিত যে আমার স্কোর হ্রাস করার জন্য আমি আরও কিছু কিছু করতে পারি তবে আমি খুব খুশি যে আমি এই প্রোগ্রামটি প্রথম প্রচেষ্টাটিতে সংকলন এবং সঠিকভাবে চালানোর জন্য পেয়েছি।

ডি-গল্ফ সংস্করণ:

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

আপডেট: আমি একটি মুদ্রণ বিবৃতিতে সবকিছু মুদ্রণের জন্য লুপটি সামঞ্জস্য করেছি এবং কিছু বাইট শেভ করার জন্য ভেরিয়েবলগুলি ডিফল্ট হিসাবে int হিসাবে সংজ্ঞায়িত করা হয় তা ব্যবহার করেছিলাম। আপডেট 2: আরও কিছু বাইট শেভ করার জন্য কিছু ভের নাম পরিবর্তন করা এবং কিছু যুক্তি সংক্ষিপ্ত করা।

Comments

আপনার জিসিসি ধরে রাখা দরকার। এটি লিনাক্স তবে আপনি এটিকে সাইগউইনের সাহায্যে উইন্ডোতে চালাতে পারেন। ভেরিয়েবলগুলি (যদি প্রোগ্রামের শুরুতে বা ফাংশন আর্গুমেন্ট হিসাবে ঘোষিত হয়) কোনও ধরণের প্রয়োজন হয় না, সেগুলি অনুমান করা হয়। ফাংশন সঙ্গে একই। এবং আমি নিশ্চিত যে আপনার এর অন্তর্ভুক্তগুলির প্রয়োজন হবে না।

— স্তর নদী সেন্ট

এছাড়াও আপনার অনেকগুলি প্রিন্টফেস রয়েছে :- ডি। হয় ১. একবারে একটি অক্ষর মুদ্রণ করতে পুতচর ব্যবহার করুন বা ২. আপনি যা মুদ্রণ করতে চান তা নিয়ে কাজ করুন এবং তারপরে এটি পুটগুলি দিয়ে মুদ্রণ করুন। 3. এটিতে একটি বৃহত জটিল এক্সপ্রেশন সহ কীভাবে একটি একক মুদ্রণযন্ত্র ব্যবহার করবেন তা নিয়ে কাজ করুন। যাইহোক, +1।

— স্তর নদী সেন্ট

ঠিক আছে পরামর্শের জন্য ধন্যবাদ! আমি চেষ্টা করব এবং একটি একক মুদ্রণ বিবৃতি করব। এটি একটি ভাল ধারণা এবং আমি নিশ্চিত এটি আমার স্কোরের উন্নতি করবে। আজ আমার কিছুটা সময় থাকলে আমি এটিকে পুনরায় শুরু করব। ধন্যবাদ @ স্টেভেভারিল

— দানওয়াকিম

Answer 4

জাভাস্ক্রিপ্ট (ES6) 241 244 227 222 231 বাইট

এটি আকর্ষণীয় দেখায় - আমি ASCII শিল্প ভালবাসি!
সবে শুরু হয়েছে, এখনও এটি গল্ফ করার প্রক্রিয়াতে রয়েছে ...

(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)

--- সম্পাদনা: দেখা যাচ্ছে আমি আসলে এটি এভাল () এ রাখতে পারি না - অন্যথায় এটি আমার এবং জেড ভার্সে অ্যাক্সেস করতে পারে না (সুতরাং 9 বাইট যুক্ত করা হয়)

- ব্যবহারকারী 81655 ধন্যবাদ 6 বাইট
সংরক্ষণ - ডেভ ধন্যবাদ 5 বাইট সংরক্ষণ

ব্যাখ্যা

(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
}

Comments

ব্যবহার করে আপনি অন্য 4 বাইট বাঁচাতে পারে c^=!eপরিবর্তে c+=a==b(যদি আপনি অপসারণ দেয় %2চেক পরে)। এছাড়াও -m+2হতে পারে 2-m!

— ডেভ

@ ডেভ - ধন্যবাদ! আপনি কি সি ^ =! ই আসলে কি তা বোঝাতে আপত্তি করবেন? আমি এর আগে কখনও দেখিনি :)

— এᴄʜᴇʀᴏɴғᴀɪʟ

এটা যেমন একই c=c^(e==0); এটি আপনার আগে যেমন একটি সংযোজন করেছিল ঠিক তেমনই একটি এক্সওআর প্রয়োগ করে। আপনি যদি এক্সওআর সম্পর্কে অপরিচিত হন তবে এটি কিছুটা অপারেশন: এক্সক্লুসিভ বা (উইকিপিডিয়া এটি সঠিকভাবে ব্যাখ্যা করতে পারে)

— ডেভ