कुशल त्रुटि मुक्त * एन्कोडिंग [बंद कर दिया]

Question

मिशन

जैसा कि सर्वविदित है, पृथ्वी पर सभी ज्ञात प्राणियों की आनुवंशिक सामग्री डीएनए में एन्कोडेड है; चार न्यूक्लियोटाइड्स एडेनिन, थाइमिन, साइटोसिन और गुआनिन का उपयोग करना। (आमतौर पर ATGC द्वारा प्रतिनिधित्व)।

एक bioinformaticist एक पूरे जीनोम स्टोर करने के लिए बधाई देने के लिए बिल्कुल नहीं, ASCII के रूप में इस स्टोर करने के लिए है क्योंकि प्रत्येक विकल्प मात्र दो बिट्स द्वारा दर्शाया जा सकता चाहेगा!

विशेष विवरण

आपका मिशन, आप इसे स्वीकार करने के लिए चुनना चाहिए, एक द्विआधारी प्रतिनिधित्व और वापस करने के लिए एक ASCII प्रतिनिधित्व कन्वर्ट करने के लिए कार्यक्रम, कार्य या तरीकों की एक जोड़ी लिखने के लिए है, का प्रतिनिधित्व Aके रूप में b00, Tके रूप में b01, Gके रूप में b10, और Cके रूप में b11(इसके बाद से "इकाइयों")।

इसके अलावा, प्रत्येक बाइट के उच्च बिट बाइट में इकाइयों की गिनती को शामिल करना चाहिए, प्रत्येक बाइट एक त्रिक प्रतिनिधित्व करते हैं बना रही है।

उदाहरण के लिए: "GATTACCA"हो जाता है b11 100001 b11 010011 b10 1100xx।

ASCII में बाइनरी इनपुट, स्पेस, टैब और न्यूलाइन्स को नजरअंदाज करना चाहिए। किसी भी वर्ण के सेट में [ \r\n\tATGC]कोई त्रुटि नहीं है और या तो अनदेखा किया जा सकता है या प्रसंस्करण को समाप्त कर सकता है।

ASCII इनपुट के लिए बाइनरी में, बाइट्स जिनके दो उच्च बिट्स को b00अनदेखा किया जा सकता है।

ASCII उत्पादन खाली स्थान के हो सकती है; लेकिन प्लस द्विआधारी इनपुट से अधिक 4 बार आकार में लंबे समय के एक बाइट कभी नहीं होना चाहिए, और एक नई पंक्ति के साथ समाप्त होना चाहिए।

बाइनरी आउटपुट में b00xxxxxx"नियंत्रण" बाइट्स की एक मनमानी संख्या हो सकती है ; लेकिन ASCII इनपुट से अधिक समय कभी नहीं होना चाहिए।

प्रत्येक रूपांतरण कार्यक्रम मनमाना लंबाई के इनपुट का समर्थन करना चाहिए; और एन्कोडिंग या लगभग रैखिक समय में डिकोडिंग पूरा करना चाहिए।

ट्विस्ट

जिसे आप इस कार्य प्रदर्शन कर रहे हैं के लिए bioinformaticist के लिए दुर्भाग्य से, वह है किसी तरह से आप, गलत एक व्यक्तिगत अभी तक शायद क्षुद्र स्तर पर।

शायद वह एक बार अपनी बहन के साथ बाहर गया, और कभी उसे फिर से बुलाया। शायद वह अपने कुत्ते की पूंछ पर कदम रखा। बारीकियों वास्तव में महत्वपूर्ण नहीं हैं।

क्या महत्वपूर्ण है कि आप कर्ज उतारने के लिए एक मौका है कि है!

विवरण

प्रत्येक रूपांतरण को एक छोटी त्रुटि दर पेश करनी चाहिए; संसाधित की गई दस हजार प्रति दस हजार में से एक त्रुटि के आदेश पर।

एक त्रुटि निम्नलिखित में से एक हो सकती है:

• डुप्लीकेशन एरर: "GAT TAC CA"बन जाता है"GAT TAA CCA"
• विलोपन त्रुटियां: "GAT TAC CA"बन जाती हैं"GAT TAC A"
• अनुवाद त्रुटियाँ: "GAT TAC CA"बन जाता है"GTA TAC CA"
• ट्रिपल दोहराव: "GAT TAC CA"बन जाता है"GAT TAC TAC CA"
• ट्रिपल स्लिपज: "GAT TAC CA"बन जाता है"TAC GAT CA"
• ट्रिपल रिवर्सल: "GAT TAC CA"बन जाता है"GAT CAT CA"

कि त्रुटियों को पेश किया जाएगा बेशक कोड से तुरंत स्पष्ट नहीं होना चाहिए; और इनपुट की लंबाई के बावजूद; रूपांतरण में कम से कम एक त्रुटि होनी चाहिए।

समान इनपुट के साथ दो रन जरूरी समान आउटपुट का उत्पादन नहीं करना चाहिए ।

चाल

वाइल बायोइनफॉरमैटिस्टिक एक मामूली सक्षम कोडर है; और जैसे कि, कुछ निर्माणों को स्वचालित रूप से खोजा जाएगा, और इस तरह के प्रतिबंधित हैं:

• वह स्वत: ही किसी)) इस तरह रैंड (के रूप में प्रणाली यादृच्छिक संख्या जनरेटर के लिए कॉल, यादृच्छिक (, खोज, या से पढ़ने जाएगा / dev / urandom या / dev / यादृच्छिक (या जो भी भाषा बराबर है)।
• वह किसी भी शानदार चर, काउंटर या लूप को भी नोटिस करेगा।

स्कोरिंग

एनकोडर और डिकोडर को अलग-अलग स्कोर किया जाएगा।

प्रत्येक को 100 बेतरतीब ढंग से उत्पन्न इनपुट फ़ाइलों के एक सेट के खिलाफ 3 बार चलाया जाएगा, प्रत्येक फ़ाइल 3 मिलियन इकाइयों के आदेश पर आकार के साथ होगी।

एनकोडर परीक्षण मामलों के लिए डेटा लगभग बनाया जाएगा:

for (l = 1 => bigNum)
  for (t = 1 => 20)
    random_pick(3,ATGC)
    t == 20 ? newline : space

विकोडक परीक्षण मामलों का डेटा लगभग इस प्रकार बनाया जाएगा:

for (u = 1 => bigNum)
  for (t = 1 => 20)
    random_byte() | 0b11000000
   0x00

एनकोडर

• प्रत्येक बाइट वास्तविक लंबाई में उम्मीद की न्यूनतम लंबाई से लापता स्कोर -1 अंक, ऊपर -1000 की एक अधिकतम करने के लिए। (उम्मीद कम से कम लंबाई है ceil(count(ATGC) / 3)।)

विकोडक

• वास्तविक लंबाई में उम्मीद की अधिकतम लंबाई से अधिक प्रत्येक बाइट स्कोर -1 अंक, ऊपर -1000 की एक अधिकतम करने के लिए। (उम्मीद अधिकतम लंबाई है size(input) * 4 + 1।)

दोनों

• त्रुटि है कि 100 अंक स्कोर होगा उत्पादन किया जा सकता से प्रत्येक प्रकार; प्रत्येक के लिए 600 अंक संभव हो, कुल 1200 के एक कुल के लिए।
• प्रत्येक परीक्षा मामले जिसके लिए एनकोडर की तुलना में अधिक 30% कम या ज्यादा त्रुटियों से अपने स्वयं के औसत -5 अंक दंडित नहीं किया जाएगा पैदा करता है।
• प्रत्येक परीक्षा मामले जिसके लिए एनकोडर अपने स्वयं के औसत की तुलना में 15% से कम और अधिक या कम त्रुटियों का उत्पादन 5 अंक दिया जाएगा।
• प्रत्येक परीक्षा मामले में जहां सभी तीन रन समान आउटपुट उत्पादन -10 अंक दंडित किये जाएँगे।

हार्ड आवश्यकताओं

एक प्रविष्टि को अयोग्य ठहराया जाएगा यदि:

• एक त्रिक से अधिक समय किसी भी मान्य इनपुट के लिए यह भी एक त्रुटि का उत्पादन करने में विफल रहता है।
• इसके प्रदर्शन को ऐसी है कि वह लगभग एक घंटे के भीतर परीक्षण चुनौती पूर्ण नहीं कर सकता है।
• यह औसतन हर दस हजार इकाइयों में एक से अधिक त्रुटि पैदा करता है।
• यह औसतन हर मिलियन यूनिट में एक से कम त्रुटि पैदा करता है।

अंतरपटल

नवागंतुकों मानक आउटपुट में मानक इनपुट पर इनपुट, और उत्पादन को स्वीकार करना चाहिए।

यदि प्रविष्टि दोहरे फ़ंक्शन के साथ एक कार्यक्रम है; स्विच -eऔर -dएन्कोडिंग और डिकोडिंग, क्रमशः के लिए कार्यक्रम निर्धारित करना चाहिए।

उदाहरण के चालान:

$ encoder <infile.txt >outfile.bin
$ decoder <infile.bin >outfile.txt
$ recoder -e <infile.txt >outfile.bin

विजेता

विजेता उच्चतम स्कोर के साथ प्रविष्टि है; सैद्धांतिक अधिकतम त्रुटि पीढ़ी दर में स्थिरता के लिए त्रुटि प्रकार के लिए 1200 से अधिक 3000 अंक की जा रही है।

एक ड्रॉ की अप्रत्याशित घटना में; विजेता वोट गिनती द्वारा निर्धारित किया जाएगा।

अतिरिक्त नोट्स

परीक्षण गौंटलेट चलाने के प्रयोजनों के लिए, प्रत्येक प्रविष्टि में रन या संकलन निर्देश शामिल होना चाहिए।

सभी प्रविष्टियों अधिमानतः एक्स के बिना एक Linux मशीन पर runnable होना चाहिए

Comments

टैग बदल दिया है। Koth चुनौतियों जहां प्रस्तुतियाँ एक दूसरे के साथ बातचीत के लिए है। इसके अलावा मुझे डर है कि यह निष्पक्ष "गुप्त" घटक लागू करने के लिए असंभव मुश्किल हो जाएगा।

— मार्टिन Ender

मैं @ m.buettner की टिप्पणी से सहमत है कि गुप्त हिस्सा जज करना मुश्किल है। दूसरी ओर मुझे लगता है कि इस चुनौती में केवल दिलचस्प हिस्सा है। मैं गारंटी ले सकते हैं कि त्रुटि पीढ़ी और दर वास्तव में विनिर्देशों के भीतर होते हैं और इसलिए अधिक से अधिक अंक है। या मैं कल्पना से कुछ याद करते हैं? इसके अलावा, त्रुटि के एक अतिरिक्त तरह स्वीकार किया जाता है, तो यह ऊपर की सूची में जोड़ दिया जाएगा; और सभी उत्तर उस पर स्कोर किया जाएगा। आप की तरह लगता है चुनौती को बदलने के लिए जा रहे हैं के बाद लोगों को काम करने या समाधान जो मुझे लगता है कि एक अच्छा विचार नहीं है प्रस्तुत करने शुरू कर दिया।

— हावर्ड

@Howard: प्रसिद्घ। नियम विशिष्ट underhandedness मापदंड के साथ अद्यतन कर रहे हैं; और उत्परिवर्तनीय पहलू WRT। त्रुटियों निकाल दिया जाता है।

— Williham Totland

मैं अपने जवाब देने के लिए जा रहा हूँ .. लेकिन मैं दो वाक्यों लगता है "प्रत्येक रूपांतरण एक छोटी सी त्रुटि दर को लागू करना चाहिए, एक लाख यूनिट संसाधित करने के लिए दस हजार प्रति एक त्रुटि के आदेश पर।" और "एक प्रविष्टि अगर अयोग्य घोषित कर दिया जाएगा: यह औसत हर दस हजार इकाइयों में एक से अधिक त्रुटि पैदा करता है पर।" असंगत हैं। एक ही के बीच "प्रत्येक रूपांतरण एक छोटी सी त्रुटि दर को लागू करना चाहिए;। एक लाख यूनिट संसाधित करने के लिए दस हजार प्रति एक त्रुटि के आदेश पर" और ": औसतन यह हर लाख यूनिट में कम से कम एक त्रुटि पैदा करता है एक प्रविष्टि अगर अयोग्य घोषित कर दिया जाएगा।"

— Mattsteel

मैं इस प्रश्न को ऑफ-टॉपिक के रूप में बंद करने के लिए मतदान कर रहा हूं क्योंकि इस साइट पर अंडरहैंड चुनौतियां अब विषय पर नहीं हैं। meta.codegolf.stackexchange.com/a/8326/20469

— बिल्ली

Answer 1

पर्ल 5.10

मैं पर्ल में अपना समाधान प्रस्तुत करने में प्रसन्न हूं।

जब मैं चुनौती शुरू कर दिया मैं काफी यकीन है कि पर्ल अच्छी तरह से 1 घंटे की सीमा से नीचे रहना होता था।

उद्देश्य के परीक्षण के लिए मैं एक सादे नमूना जनरेटर और एक कोडित नमूना जनरेटर का विकास किया।

तब मैं एनकोडर कि एक बड़ा प्रयास ले लिया और एक लंबे समय तक कोड का उत्पादन विकसित की है। एनकोडर निम्नानुसार काम करता है:

1. पहले पाश पूरी फ़ाइल और विभाजन डेटा पढ़ता है सभी तीन की एक सरणी के लिए
2. दूसरे लूप सरणी और प्रत्येक तत्व उसकी अवधि से आगे जोड़ते को पार करता
3. तीसरे पाश फिर से पार करता है और प्रत्येक चरित्र उत्पादन देने के लिए मैप करता है।

कोडित द्विआधारी उत्पादन ताकि नए-लाइन समाप्त 20 ओक्टेट्स की "लाइनों" के रूप में स्वरूपित किया गया है, जहां प्रत्येक ओकटेट कोड एक त्रिक, उपसर्ग के दो पात्रों के साथ (एक चक्रीय लाइन नंबर की तरह)।

उदाहरण के लिए, कम से कम तीन बाइट इनपुट:

AAA

तीन बाइट्स के साथ साथ नए-लाइन के कम से कम उत्पादन देना चाहिए।

00ÿ

अर्थात्

30 30 FF 0A

तथा

AGG CGC AAC GGC TAA ATC GTT TTC ACA CCA CGT TTG AAA CGG GTG ACA CGA GAT TTA GTC
TAT GGT ACT AGG TAC GCC GTG GTG CGT GCG GAG TTA CTA GAT GTG TTA GTA CGC CAT CGT

निम्नलिखित द्विआधारी देना चाहिए।

01ÊûÃëÐÇå×ÌüùÖÀúæÌøáÔç
00ÑéÍÊÓïææùîâÔôáæÔäûñù

चाहिए छोटी से छोटी इनपुट के लिए, स्क्रिप्ट द्वारा प्रस्तुत किया 1 त्रुटि: छोटे त्रुटि दर की वजह से।

एक 3 लाख तीन फ़ाइल रन के लिए, एनकोडर 11 त्रुटियों परिचय देता है।

बशर्ते कि स्क्रिप्ट dnacodec3.pl है, रन कमांड हमेशा की तरह प्रॉम्प्ट पर शुरू हो जाती है:

$> perl dnacodec3.pl -e < plain.txt > coded.txt

डिकोडर निम्नानुसार काम करता है:

1. पहले पाश पूरी फ़ाइल पढ़ता है और डेटा विभाजन सभी ओक्टेट्स की एक सरणी है। यह हर नई-लाइन का ट्रैक रखता है।
2. दूसरी पाश प्रत्येक ओकटेट की जांच करता है, नहीं के साथ 00 और उपेक्षा बाकी शुरु होने वाले को बनाए रखना। सादे ASCII उत्पादन स्वरूपित है नई लाइन के रूप में एक अंतरिक्ष से अलग कर दिया तीनो की तर्ज समाप्त हो गया। नई-लाइन उसी स्थिति में हैं जैसे वे इनपुट में थे।

मैं एक 3 लाख तीन नमूना परीक्षण फ़ाइल (12MByte के बारे में) तैयार और समय के लिए परीक्षण किया गया। 2.6 गीगाहर्ट्ज़ पर Intel Core i5 vPro के साथ मेरे लैपटॉप का उपयोग करते हुए, 3M एनकोडर रन हमेशा 20 सेकंड से कम समय लेता है। रन के दौरान इसमें 200-220 MByte RAM लगता है। कितना बेकार है!

डिकोड रन में 10 सेकंड से कम समय लगता है। यह त्रुटियों को प्रस्तुत नहीं कर सकता ... अभी के लिए।

फिर से, डिकोडिंग रन के लिए

$> perl dnacodec3.pl -d < coded.txt > plain.txt

यहाँ कोड है

#!/usr/bin/perl
use strict ;
use warnings ;
my $switch = shift || die "usage $0 [-e|-d]\n";
my %map = qw( x 10  X 11  c 0b  ? 00
              A 00  T 01  G 10  C 11  
              0 00  1 01  2 10  3 11  
              00 A  01 T  10 G  11 C  ) ;
my $r = 20 ;
my @dummy = unpack ( '(A4)*', '0xxx' x $r ) ;
my $map = oct( $map{ c } . ($map{ C } x 9) ) ;
my $t = time() ;
my @inp = () ;
my @out = () ;
my @buf = () ;
my $n ;

sub arch {
    push @buf, @dummy[ 0 .. $r - $#buf - 2 ] ;
    push @out, "@buf" ;
    @buf = () ;
}

sub encode {
    my $mask = '(A3)*' ;
    while ( my $row = <STDIN> ) {
        chomp $row ;
        $row =~ s/\s+//g ;
        $row =~ s/[^\r\n\tATGC]//g ;
        next unless $row ;
        my @row = unpack( $mask, $row ) ;
        push @inp, @row if $row ;
    }
    $n = scalar @inp ;
    $r = $n if $r > $n ;
    for ( my $i = $n - 1 ; $i >= 0 ; --$i ) {
        my $e = $inp[$n-$i-1] ;
        my $l = length( $e ) ;
        my $d = $e =~ /\?/? 0: $l ;
        push @buf, ( $d -((($i-($n>>1))&$map)?0:1) )
           . $e . 'x'x(3-$l) ;
        arch unless $i % $r ;
    }
    arch if scalar @buf ;
    my $m = scalar @out ;
    for ( my $j = $m - 1 ; $j >= 0; --$j ) {
        my @ary = () ;
        my $e = $out[$m-$j-1] ;
        for my $byte ( split / /, $e ) {
            my @byte = split ( //, $byte ) ;
            my @trad = map { $map{ $_ } } @byte ;
            my $byte = join( '', @trad ) ;
            push @ary, $byte ;
        };
        my $row = sprintf( '%02d', $j % $r) ;
        $row .= pack( '(B8)*', @ary ) ;
        print "$row\n" ;
    }
}

sub decode {
    my $mask = '(B8)*' ;
    while ( my $row = <STDIN> ) {
        chomp $row ;
        next unless $row ;
        my @row = unpack( $mask, $row ) ;
        push @inp, @row[0..$#row], '?' if $row ;
    }
    $n = scalar @inp ;
    my @ary = () ;
    for ( my $i = $n - 1 ; $i >= 0 ; --$i ) {
        my $e = $inp[$n-$i-1] ;
        if ( $e ne '?' ) {
            my $u = oct( '0b'. substr($e,0,2) ) ;
            my $a = '' ;
            for my $j ( 1 .. $u ) {
                $a .= $map{ substr($e,$j+$j,2) } ;
            }
            push @ary, $a if $u ;
        }
        else {
            my $row = "@ary" ;
            $row =~ s/\s{2,}//g ;
            print "$row\n" if $row ;
            @ary =() ;
        }
    }
}

decode if $switch eq '-d' ;
encode if $switch eq '-e' ;

और यहाँ नमूना जनरेटर है:

sub test_coder {
    my $n = shift || 1000 ;
    my @b = qw( A C G T ) ;
    for (my $l = 0; $l < $n; $l++) {
        my @ary = () ;
        for (my $t = 0; $t < 20; $t++) {
            push @ary, $b[ int(rand(4)) ] . $b[ int(rand(4)) ] . $b[ int(rand(4)) ] ;
        }
        print "@ary\n" ;
    }
    1;
}

sub test_decoder {
    my $n = shift || 1000;
    for (my $l = 0; $l < $n; $l++) {
        my @ary = () ;
        for (my $t = 0; $t < 20; $t++) {
            push @ary, int(rand(256)) | 0b11000000 ;
        }
        my $row = pack( 'C*', @ary ) ;
        print "$row\000" ;
    }
    1;
}


test_coder( @ARGV ) if $switch eq '-g' ;
test_decoder( @ARGV )  if $switch eq '-h' ;

Comments

दूसरी पाश में धक्का @buf काम कर देता है: मैं जहां त्रुटि इंजेक्ट किया जाता है को दिखाने के लिए भूल गए।

— मटकास्टाइल

यह सूक्ष्म है, मैं तुम्हें दे दूँगा। मैं पूर्ण पैमाने पर परीक्षण चल नहीं किया जाएगा जब तक वहाँ एक से अधिक एक प्रतियोगी है, लेकिन यह अच्छा सामान है। :)

— Williham Totland

धन्यवाद। मुझे पता है कि यह अन्य दोस्तों के लिए एक सुझाव है ... मैं (अभी भी अप्रयुक्त) समय की

— फ़ोक