डबल हेलिक्स जनरेटिंग एल्गोरिदम

Question

मैं right handed डीएनए स्ट्रिंग का प्रतिनिधित्व करने के लिए एक अच्छा एल्गोरिदम के साथ आने का प्रयास कर रहा हूं, जिसमें अक्षरों की मनमानी संख्या के लिए डैश चरित्र का उपयोग करके प्रमुख और मामूली ग्रूव के साथ डीएनए स्ट्रिंग का प्रतिनिधित्व किया जा रहा है।

यह, मैं वर्तमान क्या है 776 # के उपयोग करते हुए:

#########     ########## 
    #########    ########## 
     #########    ########## 
     #########   ########## 
      ##########  ########## 
      ########## ########## 
       ###### ########## 
       ## ########## 
       ########## # 
       ########## ##### 
      ########## ######### 
      ########## ########## 
     ##########  ########## 
     ##########   ########## 
    ##########    ########## 
    ##########    ########## 
    ##########    ########## 
    ##########    ########## 
    ##########   ########## 
    ##########  ########## 
    ########### ########## 
     ######### ########## 
     ##### ########## 
      # ########## 
      ########## ### 
     ########## ####### 
     ########## ########## 
    ##########  ########## 
    ##########   ########## 
    ##########    ########## 
    ##########    ########## 
    ##########     ########## 
    ##########     ########## 
    ##########    ########## 
     ##########    ########## 
     ##########   ########## 
      ##########  ########## 
      ########## ########## 
       ####### ########## 
       #### ######### 
        ######### # 
        ########## ### 
       ########### ####### 

लेकिन हेलिक्स पूरी तरह से संरेखित नहीं है जब मैं मैन्युअल रूप से प्रतिलिपि करने/चिपकाने के माध्यम से हेलिक्स दोहराने के लिए प्रयास करें।

एक समाधान जिसमें उपरोक्त उदाहरण के समान चौड़ाई है लेकिन बेसपैयर क्रॉसबॉन्ड भी है (जैसे this image या नीचे स्कार्फ पैटर्न में), भी स्वीकार्य है।

Answer 1

इस प्रश्न की कुंजी यह पहचानना है कि आप साइन लहरों के संयोजन के रूप में हेलिक्स पर प्रत्येक स्ट्रैंड का प्रतिनिधित्व कर सकते हैं - आवधिक भाग के लिए एक और पृष्ठ में "गहराई" के लिए। एक बार जब आप समस्या को पैरामीटर कर देते हैं, तो आप अपने हेलिक्स के हर पहलू को नियंत्रित कर सकते हैं। बिंदु को चित्रित करने के लिए अलग-अलग तार दिखाने के लिए नीचे दिया गया उदाहरण * और # का उपयोग करता है। यदि आप तरंग दैर्ध्य के लिए मान चुनते हैं जो पूर्णांक मानों के अनुरूप नहीं होते हैं तो आपको कम से कम इष्टतम परिणाम मिलेंगे - लेकिन अब आप सबसे सौंदर्यपूर्ण रूप से आकर्षक प्रतिनिधित्व पर विचार करने के लिए इनपुट के साथ खेल सकते हैं।

from numpy import * 

amp = 10 
length = 100 
wavelength = 20 

omega = (2*pi)/wavelength 
phi = wavelength*(0.5) 
X = arange(1,length) 
Y1 = round_(amp*(sin(omega*X) + 1)) 
Y2 = round_(amp*(sin(omega*X+phi) + 1)) 

offset = phi/2 
Z1 = sin(omega*X + offset) 
Z2 = sin(omega*X + phi + offset) 

T1 = " ######### " 
T2 = " ********* " 
clen = len(T1) 

H = zeros((length,amp*2+clen),dtype='str') 
H[:,:] = " " 

for n,(y1,y2,z1,z2) in enumerate(zip(Y1,Y2,Z1,Z2)): 
    H[n,y1:y1+clen] = list(T1) 
    H[n,y2:y2+clen] = list(T2) 

    # Overwrite if first helix is on top 
    if z1>z2: H[n,y1:y1+clen] = list(T1) 

for line in H: 
    print "".join(line) 

ये मान दे:

********* #########   
    *********  #########  
*********   ######### 
*********   ######### 
    *********   ######### 
    *********  ######### 
     ********* ######### 
      ****** #########  
       #########   
      ######### ****  
     ######### ********* 
    #########  ********* 
    #########   ********* 
#########   ********* 
#########   ********* 
#########  *********  
    ######### *********  
    ###### *********   
     *********    
     ********* ####   
    ********* #########   
    *********  #########  
*********   ######### 
*********   ######### 
    *********   ######### 
    *********  ######### 
     ********* ######### 
      ****** #########  
       #########   

Answer 2

    ########## #### 
       ########## ######## 
      ########## ########### 
      ##########  ########## 
     ##########   ########## 
     ##########   ######### 
    ##########    ######### 
    ##########    ########## 
    ##########    ########## 
    ##########    ########## 
    ##########   ########## 
    ##########  ########## 
    ########### ########## 
     ######### ########## 
     ##### ########## 
      # ########## 
      ########## ### 
     ########## ####### 
     ########## ########## 
    ##########  ########## 
    ##########   ########## 
    ##########    ########## 
    ##########    ########## 
    ##########     ########## 
    ##########     ########## 
    ##########    ########## 
     ##########    ########## 
     ##########   ########## 
      ##########  ########## 
      ########## ########## 
       ####### ########## 
       #### ######### 
        ######### # 

। । ।

दुख की बात है कि मैं चाहता था कि यह मेरे उत्तर का कुल योग हो। लेकिन मुझे समझाया जाना चाहिए: जब आप टेस्सेलेशंस में परिवर्तन करते हैं, तो आपको मूल दोहराने वाली इकाई के साथ काम करने की आवश्यकता होती है (और यदि आप जिस तरह से इसे टैसलेट करते हैं, उसे संशोधित करते हैं, तो आपको इसके अन्य हिस्सों को संशोधित करना होगा, लेकिन आप ऐसा नहीं कर रहे हैं)। मैंने आपके पैटर्न को दोहराया जो मैंने सोचा था कि एक दोहराने वाली इकाई की तरह दिखता है, फिर इसे एक बार चिपकाएं; जब मैंने नीचे एक बदलाव किया, तो मैंने शीर्ष पर एक ही बदलाव किया।

< गहरे विचार > कभी-कभी सबसे सरल समाधान बहुत अधिक सोच के बिना पाए जाते हैं। </गहरे विचार >

फिर भी, आप निश्चित रूप से डीएनए की छवि पर पोस्टरराइजेशन एल्गोरिदम निष्पादित कर सकते हैं, इसे बिटमैप में बदल सकते हैं। (आप इसे उस छवि में कर सकते हैं जिस पर आपके पास कॉपीराइट है।) यदि आप एक ही चरित्र का उपयोग करने के लिए नहीं देख रहे हैं, तो आप एसीआईआई आर्ट जनरेटर का भी उपयोग कर सकते हैं, जिसमें से आप वेब पर और ओपन-सोर्स सॉफ़्टवेयर में दर्जनों को पा सकते हैं कुछ Google खोज के माध्यम से। हालांकि, स्टैक ओवरव्लो एफएक्यू के दायरे में नहीं है, इसलिए मैं इस पर विस्तार से नहीं जाऊंगा, इस कंप्यूटर विज्ञान पेपर को वेक्टर-शैली एसीआई-कला रूपांतरण पर जोड़ने के अलावा: http://www.cse.cuhk.edu.hk/~ttwong/papers/asciiart/asciiart.pdf

Answer 3

यह देना चाहिए यदि आप एक अच्छी शुरुआत:

from math import sin, cos, pi 

class RightHelix(object): 
    def __init__(self, maxima, minima, period, offset): 
     self.mid = 0.5 * (maxima + minima) 
     self.mag = 0.5 * (maxima - minima) 
     self.k = 2.0 * pi/period 
     self.offs = self.k * offset 
    def x(self, t): 
     return self.mid + self.mag * sin(self.k*t - self.offs) 
    def y(self, t): 
     return -self.mag * cos(self.k*t - self.offs) 

def main(): 
    rh = RightHelix(33, 7, 20, -2) 

    for t in range(40): 
     x,y = rh.x(t), rh.y(t) 
     print(' '*int(x-0.5) + ('O','X')[y>0]) 

if __name__=="__main__": 
    main() 

के रूप में दिया, पैदा करता है

      O 
           O 
           O 
           O 
           X 
           X 
          X 
         X 
        X 
       X 
      X 
     X 
     X 
     X 
     O 
     O 
      O 
       O 
        O 
         O 
          O 
           O 
           O 
           O 
           X 
           X 
          X 
         X 
        X 
       X 
      X 
     X 
     X 
     X 
     O 
     O 
      O 
       O 
        O 
         O 

(Xs और ओएस को दिखाने के लिए है कि यह है, वास्तव में, एक दाएं हाथ सर्पिल बस कर रहे हैं)।

Answer 4

यह कैसे एक के बारे में:

import math 

phaseA = math.pi/1.5 
phaseB = 0 
step = math.pi/20 
width = 30 # screen size 
breadth = 8 # breadth of DNA single string 

x = 0.0 
while True: 
    x += step 
    if x > 30.0: break 
    yA = math.sin(x + phaseA) 
    zA = math.cos(x + phaseA) 
    yB = math.sin(x + phaseB) 
    zB = math.cos(x + phaseB) 
    if zA > zB: # which is in front? 
    yTop, yBottom = yA, yB 
    else: 
    yTop, yBottom = yB, yA 
    # screenify values: 
    yTop = 1 + int((1.0 + yTop) /2.0 * (width-breadth)) 
    yBottom = 1 + int((1.0 + yBottom)/2.0 * (width-breadth)) 
    line = ' ' * yBottom + '#' * breadth + ' ' * (width-yBottom) 
    line = list(line) # make mutable 
    line[yTop-1] = ' ' 
    line[yTop+breadth+1] = ' ' 
    for i in range(breadth): 
    line[yTop+i] = '#' 
    print ''.join(line) 

यह उत्पादन के लिए हैश की एक विशिष्ट संख्या है, हालांकि उपयोग नहीं करता। हो सकता है कि यह आपकी आवश्यकताओं में से एक था, पता नहीं ...

इसे step मान math.pi का एक पूर्ण-क्रमांकित अंश होने तक एक दोहराव पैटर्न बनाना चाहिए।

Answer 5

मेरा दृष्टिकोण यहां है। यह शायद किसी और की तुलना में भौतिक रूप से अलग नहीं है, लेकिन मैंने इसे लिखा है, इसलिए यहां यह जाता है:

शीर्ष आधा कॉन्फ़िगरेशन है। नीचे आधा कार्रवाई है।

from math import cos, sin, pi 

length = 50 
width = 30 
thickness = 10 
rotation = 0.15 
strands = [0, 2 * pi/3] 
strand_char = "#" 

radius = width/2 
for line in range(length): 
    output = [" "] * (width + thickness + 2) 
    total_rotation = -line * rotation 
    sorted_strands = sorted(strands, key=lambda s: cos(total_rotation + s)) 
    for strand_offset in sorted_strands: 
     pos = int(radius * sin(total_rotation + strand_offset) + radius) 
     output[pos : pos + thickness + 2] = " " + strand_char * thickness + " " 
    print("".join(output)) 

आउटपुट:

   ########## ##########  
      ##########  ########## 
      ##########   ########## 
     ##########   ########## 
     ##########    ########## 
    ##########    ########## 
    ##########    ########## 
    ##########    ##########  
    ##########    ##########  
##########    ##########  
##########    ##########   
##########   ##########   
##########   ##########    
    ##########  ##########    
    ########## ##########     
    ######## ##########     
    ##### ##########      
     # ##########      
     ########## #      
    ########## #####      
    ########## ########     
    ########## ##########     
##########  ##########    
##########   ##########    
##########   ##########   
##########    ##########   
##########    ##########  
    ##########    ##########  
    ##########    ########## 
    ##########    ########## 
    ##########    ########## 
     ##########    ########## 
     ##########   ########## 
      ##########   ########## 
      ##########  ########## 
       ########## ##########  
        ######## ##########  
        ##### ##########  
         # ##########   
         ########## #   
        ########## #####  
       ########## #########  
       ########## ########## 
      ##########  ########## 
      ##########   ########## 
     ##########   ########## 
     ##########    ########## 
    ##########    ########## 
    ##########    ########## 
    ##########    ##########