रोजेटा स्टोन चैलेंज का लक्ष्य अधिक से अधिक भाषाओं में समाधान लिखना है। अपनी प्रोग्रामिंग बहुभाषिकता दिखाओ!

चुनौती

आपकी चुनौती एक प्रोग्राम को लागू करना है जो क्रॉस-ओवर फ्रीक्वेंसी का उपयोग करके कुछ जीनों को मैप करेगा, जितनी संभव हो उतनी प्रोग्रामिंग भाषाओं में । आपको किसी भी प्रकार के मानक पुस्तकालय फ़ंक्शन का उपयोग करने की अनुमति है जो आपकी भाषा में है, क्योंकि यह ज्यादातर एक भाषा शोकेस है।

"जीन मैपिंग क्या है?"

जीन मैपिंग गुणसूत्रों पर जीन की सापेक्ष स्थिति का पता लगाने की प्रक्रिया है। यह जीन के जोड़े के क्रॉसिंग-ओवर आवृत्ति को मापने के द्वारा किया जाता है, संतानों के प्रतिशत के बराबर है जिसमें जोड़ी को एक साथ विरासत में नहीं मिला है। दूरी को एक प्रतिशत के बराबर एक मैप यूनिट के साथ मैप इकाइयों में मापा जाता है । उदाहरण के लिए, यदि जीन C & D में 11% की क्रॉस-ओवर आवृत्ति है, तो जीन C, जीन D से 11 मैप यूनिट की दूरी है।

जीन मैपिंग उनके सापेक्ष क्रम को निर्धारित करने के लिए कई जोड़े जीनों के साथ किया जाता है। उदाहरण के लिए, डेटा (A,B,12) (D,B,7) (A,D,5) (D,H,2) (H,B,9)निम्नलिखित मानचित्र बनाता है:

A..H.D......B

आपने देखा होगा कि B......D.H..Aयह एक वैध मानचित्र भी है। यह सच है, क्योंकि दर्पण के विपरीत के बीच अंतर करना संभव नहीं है। आपका प्रोग्राम आउटपुट को चुन सकता है। हालांकि इनपुट में हर संभव जोड़ी शामिल नहीं हो सकती है, लेकिन पूरे नक्शे को फिर से बनाने के लिए हमेशा पर्याप्त जानकारी होगी (इसलिए 2 से अधिक वैध आउटपुट नहीं होंगे)। इसके अलावा, संख्याएं हमेशा (वास्तविक जीव विज्ञान के विपरीत) काम करेंगी, जिसका अर्थ है कि आपके पास सामान नहीं होगा (A,B,3) (B,C,4) (A,C,13)।

इनपुट

इनपुट एक संख्या के साथ शुरू होगा nजिसके बाद जीन की सूची (अपरकेस अक्षर) होगी। उसके बाद nडेटा के ट्रिपल होंगे । प्रत्येक सेट में एक जोड़ी जीन और आवृत्ति (दूरी) पर उनका पार होना शामिल है।

3,P,H,I
P,H,3
H,I,1
P,I,4

7,A,B,G,Q,U
B,Q,4
A,B,10
G,U,13
Q,U,10
A,G,9
G,Q,3
A,Q,6

इनपुट को सख्ती से परिभाषित नहीं किया गया है, क्योंकि अलग-अलग भाषाओं में संभव है पर प्रतिबंध है। उदाहरण के लिए, आप सीमांकक और न्यूलाइन्स के अलावा किसी अन्य के लिए सीमांकक को बदल सकते हैं। इनपुट स्वरूपण काफी हद तक आप पर निर्भर है।

उत्पादन

आउटपुट जीन मैप का एक प्रतिपादन होगा। इसमें उन जीनों (कैपिटल लेटर्स) को शामिल किया जाएगा, जो अवधि के आधार पर अलग-अलग होते हैं ताकि दूरियां सही तरीके से चित्रित की जा सकें। यहाँ उपरोक्त उदाहरणों के लिए आउटपुट हैं।

P..HI  *or*  IH..P

BG..Q.....A...U  *or*  U...A.....Q..GB

यह भी पूरी तरह से कठोर आवश्यकता नहीं है। उदाहरण के लिए आप पीरियड्स के अलावा कुछ और इस्तेमाल कर सकते हैं, जैसे कॉमा या स्पेस।

उद्देश्य जीत का मानदंड

एक उद्देश्य जीतने वाली कसौटी के रूप में, यहाँ यह है: प्रत्येक भाषा एक अलग प्रतियोगिता है जो सबसे छोटी प्रविष्टि लिख सकती है, लेकिन समग्र विजेता वह व्यक्ति होगा जो इन उप-प्रतियोगिताओं में सबसे अधिक जीतता है। इसका मतलब यह है कि कई असामान्य भाषाओं में जवाब देने वाला व्यक्ति लाभ प्राप्त कर सकता है। किसी भाषा में एक से अधिक समाधान होने पर कोड-गोल्फ ज्यादातर एक टाईब्रेकर होता है: सबसे छोटे कार्यक्रम वाले व्यक्ति को उस भाषा का श्रेय जाता है।

नियम, प्रतिबंध और नोट्स

आपका कार्यक्रम 20 दिसंबर, 2013 से पहले मौजूद किसी भी भाषा में लिखा जा सकता है। मुझे कुछ अधिक असामान्य / गूढ़ भाषाओं में लिखी गई कुछ प्रतिक्रियाओं को मान्य करने के लिए समुदाय पर निर्भर रहना होगा, क्योंकि मैं परीक्षण करने में सक्षम नहीं हूं। उन्हें।

वर्तमान लीडरबोर्ड

यह अनुभाग समय-समय पर भाषाओं की संख्या दिखाने के लिए अद्यतन किया जाएगा और प्रत्येक में कौन अग्रणी है।

ऑटोहॉटकी (632) - एवी
dj (579) - रूबिक

वर्तमान उपयोगकर्ता रैंकिंग

एवी (1): ऑटोहॉटकी (632)
रुबिक (1): डीजे (579)

code-golf rosetta-stone

— PhiNotPi
स्रोत

क्या हमें इनपुट पढ़ने के लिए कोड शामिल करना चाहिए? या क्या हमें यह मान लेना चाहिए कि इनपुट को फ़ंक्शन का पहला तर्क माना जाता है?

— जूता

@ जेफ्री मुझे लगता है या तो एक ठीक है।

— PhiNotPi

.. लीडरबोर्ड? :-)

— एवीआई

1

इनपुट सीमा क्या हैं? इतना अधिक नहीं है n, लेकिन मुख्य रूप से आवृत्ति (दूरी) पर क्रॉसिंग के लिए सीमा। क्या हम यह मान सकते हैं कि यह हमेशा, कम से कम होगा 1000?

— रबिक

@PhiNotPi: क्या आप कुछ और परीक्षण मामले प्रदान कर सकते हैं? मैंने अपना काम लगभग पूरा कर लिया है और मैं इसका और अधिक परीक्षण करना चाहता हूं।

— रुबिक

2

ऑटोहॉटकी (632)

f(i){
o:={},f:={},n:=0
loop,parse,i,`n
{
a:=A_LoopField
if A_index!=1
{
@:=Substr(a,1,1),#:=Substr(a,3,1),n+=($:=Substr(a,5))
if !IsObject(o[@])
o[@]:={}
if !IsObject(o[#])
o[#]:={}
o[@][#]:=o[#][@]:=$
}
}
f[n+1]:=@,f[@]:=n+1,a:=""
while !a
{
a:=0
for k,v in o
{
if !f[k]
{
c1:=c2:=s:=0
for k1,v1 in v
{
if f[k1]
if s
{
if (r1==f[k1]-v1)or(r1==f[k1]+v1)
c1:=r1
else r1:=c1:=""
if (r2==f[k1]-v1)or(r2==f[k1]+v1)
c2:=r2
else r2:=c2:=""
}
else
c1:=r1:=f[k1]+v1,c2:=r2:=f[k1]-v1,s:=1
}
if c1
f[c1]:=k,f[k]:=c1,a:=1
else if c2
f[c2]:=k,f[k]:=c2,a:=1
}
} 
}
loop % 2*n+1
{
v:=f[A_index]
if v
z:=1
r.=z?(!v?".":v):v
}
return Rtrim(r,".")
}

सभी वर्णों को 1 वर्ण में बदलकर कोड को और छोटा किया जा सकता है .. यह तब लगभग 610 वर्ण होना चाहिए।

परीक्षण के मामलों

v := "
(7,A,B,G,Q,U
B,Q,4
A,B,10
G,U,13
Q,U,10
A,G,9
G,Q,3
A,Q,6 
)"

msgbox % f(v)
msgbox % f("3,P,H,I`nP,H,3`nH,I,1`nP,I,4")

— एवी
स्रोत

1

अजगर 311

import sys,random
d=sys.stdin.readlines()
u=[]
r=g=0
m={}
l=d[0].split()[1:]
for a in l:m[a]=g;g+=1
for v in d[1:]:i=v.split();u+=[i];r+=int(i[2])
j=len(l)
y=range(j)
while any(abs(y[m[t]]-y[m[w]])!=int(p) for t,w,p in u):y=random.sample(range(r),j)
o=["."]*r
for a in m:o[y[m[a]]]=a
print "".join(o).strip(".")

मेरा पहला कोड-गोल्फ: डी

(मैं गिनती के साथ यकीन नहीं है, मैं इसे एक चरित्र गणना में ऑनलाइन पोस्ट करता हूं)

एल्गोरिथ्म का विचार बहुत बुरा है, लेकिन यह छोटा है। जब तक वे सभी बाधाओं को पूरा नहीं करते, तब तक प्रतीकों के लिए सभी पदों की कोशिश करें। उदाहरण के लिए इनपुट व्हॉट्सएप के साथ है

3 P H I
P H 3
H I 1
P I 4

पढ़ने को समाप्त करने के लिए कंसोल में CTRL + D के बाद मारो।

यहाँ मूल कोड है जो अभी भी ',' सीमांकक के रूप में उपयोग करता है।

import sys, random
#data = sys.stdin.readlines()
data = [
"3,P,H,I",
"P,H,3",
"H,I,1",
"P,I,4"
]
container = []
max_range = 0
map = {}
map_counter = 0

line_split = data[0].split(',')[1:]
count = len(line_split) # Number of genes
for symbol in line_split:
    map[symbol] = map_counter
    map_counter += 1

for line in data[1:]:
    line_split = line.split(',')
    container.append(line.split(','))
    max_range += int(line_split[2])

restart = True
while restart == True:
    positions = random.sample(range(max_range), count) # Since this loop will take like forever, but some day it will produce the correct positions
    restart = False
    for symbol1, symbol2, distance in container:
        if abs(positions[map[symbol1]] - positions[map[symbol2]]) != int(distance):
            restart = True
            break

output = ["."] * max_range
for symbol in map:
    output[positions[map[symbol]]] = symbol
print "".join(output).strip(".") # Strip . to make it more pretty

— NVIDIA
स्रोत

0

dg - 717 579 बाइट्स

एक पायथन एक आने वाली है।

import '/sys'
w,o=list,tuple
p=g a b m->
 b in g=>a,b=b,a
 i,l,k=g.index a,w$g,w$g
 l!!(i+m),k!!(i-m)=b,b
 g!!(i+m)=='.'=>yield$o$l
 g!!(i-m)=='.'=>yield$o$k
g=t->
 d=sorted key:(i->snd i)$map((a,b,i)->((a,b),int i))$filter fst$map(i->i.split ',')$t.split '\n'
 (a,b),i=d.pop!
 g=w$('.',)*i*4
 g!!i,g!!(i+i)=a,b
 s=set'$o g
 while d=>
  d.sort key:((k,v)->set k&(set$fst$w s))
  n,(a,b),i=set! :+d.pop!
  for r in s=>
   if(a in r and b in r=>i==abs(r.index a-r.index b)=>n.add r)(1=>n.update$p r a b i)
   s = n
 '\n'.join$map(l->(''.join l).strip '.')s
print$g sys.stdin.read!

उदाहरण:

$ echo """P,H,3
H,I,1
P,I,4""" | dg dna.dg
P..HI
$ echo """B,Q,4
A,B,10
G,U,13              
Q,U,10
A,G,9
G,Q,3
A,Q,6""" | dg dna.dg
BG..Q.....A...U

— रूबिक
स्रोत

0

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <malloc.h>

struct Gene
{
    char a1 , a2 ;
    int d ;
};
typedef struct Gene gene ;

struct Set
{
    int appr_id ;
    char CMN_char ;
};
typedef struct Set set ;

gene *stack;
int cp_id1 , cp_id2 , N=0 , cid , *used , n ;
char ucmn_char , *cmp1 , *cmp2 , *base , ep[15] ;                       
set ap_set ;


void randomize(void)
{   int i;
    Set temp;
    for(i=0;i<(n-1);i++)
    {
        temp=stack[i];
        stack[i]=stack[i+1];
        stack[i+1]=temp;
    }

    return;

}
void populate_ep ( char ucmn_char )
{
    int i;
    for ( i=0 ; ep[i] != '\0' ; i ++ );
        ep[ i ] = ucmn_char ;
}

set find_appr ( void )
{
    int i , j ;
    set s ;
    for ( i = 0 ; i < n ; i++ )
    {
        if ( used[ i ] == 1 )
            continue ;
        else
        {
            for ( j = 0 ; ep[ j ] != '\0' ; j++ )
            {
                if ( ep[ j ] == stack[ i ].a1 || ep[ j ] == stack[ i ].a2 )
                {
                    s.appr_id = i ;
                    s.CMN_char = ep[ j ] ;
                    return s ;
                }
            }
        }
    }
}

void destroy ( int id )
{
    used[ id ] = 1 ;
}

int get_center_id ( char a )
{
    int i ;
    for ( i = 0 ; i < N * 2 ; i++ )
        if ( base[ i ] == a )
            return i ;
}

int get_comparer ( void )
{
    int i , j , k ;
    for ( i = 0 ; i < n ; i ++ )
    {
        if ( used[ i ] == 0 )
        for ( j = 0 ; ep[ j ] != '\0' ; j ++ )
            if ( stack[ i ].a1 == ep[ j ])
                for ( k = 0 ; k < 15 ; k ++ )
                    if ( stack[ i ].a2 == ep[ k ] )
                        return i ;
    }
    printf ( "\nWrong set of genes....\n" ) ;
    exit ( 0 ) ;
}

void compare_and_merge ( int cid, int cp_id1, int cp_id2 )
{
    int base_cp_id , i ;
    char temp = ( ucmn_char == stack[ cid ].a1 ) ? stack[ cid ].a2 : stack[ cid ].a1 ;
    for ( i = 0 ; i < N * 2 ; i ++ )
        if ( base[ i ] == temp )
            base_cp_id = i ;
    if ( stack[ cid ].d == ( sqrt ( pow ( ( cp_id1 - base_cp_id ) , 2 ) ) ) )
    {   
        base[ cp_id1 ] = cmp1[ cp_id1 ] ;
        return ;
    }
    else
    {
        base[ cp_id2 ] = cmp2[ cp_id2 ] ;
        return ;
    }
}

void show_stack ( void )
{
    int i ;
    printf ( "The gene sets you entered are: \n" ) ;
    printf ( "____________\n" ) ;
    for ( i = 0 ; i < n ; i ++ )
        if ( used[ i ] == 0 )
            printf ( "%c %c %d\n" , stack[i].a1, stack[i].a2, stack[i].d ) ;
    printf ( "____________\n" ) ;
}

int main ( void )
{
    printf ( "Enter number of gene sets: " ) ;
    scanf ( "%d" , &n ) ;
    stack = ( gene* ) calloc ( n , sizeof ( gene ) ) ;
    used = ( int* ) calloc ( n , sizeof ( int ) ) ;
    int i ;
    N = 0 ;
    for ( i = 0 ; i < n ; i ++ )
    {
        char y[ 2 ] ;
        scanf ( "%s" , y ) ;
        stack[ i ].a1 = y[ 0 ] ;
        scanf ( "%s" , y ) ;
        stack[ i ].a2 = y[ 0 ] ;
        scanf ( "%d" , &stack[ i ].d ) ;
        N += stack[ i ].d ;
        used[ i ] = 0 ;
        fflush ( stdin ) ;
    }   
    randomize();
    show_stack ( ) ;
    int ff ;
    strcpy ( ep , " " ) ;
    cmp1 = ( char* ) calloc ( N * 2 , sizeof ( char ) ) ;
    cmp2 = ( char* ) calloc ( N * 2 , sizeof ( char ) ) ;
    base = ( char* ) calloc ( N * 2 , sizeof ( char ) ) ;
    for ( i = 0 ; i < N * 2 ; i ++ )
        base[ i ] = cmp1[ i ] = cmp2[ i ] = '=' ;
    base[ N ] = stack[ 0 ].a1 ;
    base[ N + stack[ 0 ].d ] = stack[ 0 ].a2 ;
    destroy ( 0 ) ;
    ep[ 0 ] = stack[ 0 ].a1 ;
    ep[ 1 ] = stack[ 0 ].a2 ;
    for ( ff = 0 ; ff < n / 2  ; ff ++ )
    {
        ap_set = find_appr ( ) ;
        cmp1[ get_center_id ( ap_set.CMN_char ) ] = ap_set.CMN_char ;
        cmp2[ get_center_id ( ap_set.CMN_char ) ] = ap_set.CMN_char ;
        ucmn_char = ( stack[ ap_set.appr_id ].a1 == ap_set.CMN_char ) ? stack[ ap_set.appr_id ].a2 : stack[ ap_set.appr_id ].a1;
        cmp1[ cp_id1 = get_center_id ( ap_set.CMN_char ) + stack[ ap_set.appr_id ].d ] = ucmn_char ;
        cmp2[ cp_id2 = get_center_id ( ap_set.CMN_char ) - stack[ ap_set.appr_id ].d ] = ucmn_char ;
        populate_ep ( ucmn_char ) ;
        destroy ( ap_set.appr_id ) ;
        cid = get_comparer ( ) ;
        compare_and_merge ( cid , cp_id1 , cp_id2 ) ;
        destroy ( cid ) ;
    }
    int start , end ;
    for ( i = 0 ; i < N * 2 ; i ++ )
        if ( base[ i ] != '=' )
        {
            start = i ;
            break ;
        }
    for ( i = N * 2 - 1 ; i >= 0 ; i -- )
        if ( base[ i ] != '=' )
        {
            end = i ;
            break ;
        }
        for ( i = start ; i <= end ; i ++ )
            printf( "%c" , base[ i ] ) ;
    printf( "\n\n" ) ;
}

— अंकित कुमार
स्रोत

3

PPCG में आपका स्वागत है! यह कोड गोल्फ है, इसलिए कृपया कोड की न्यूनतम राशि में समस्या को हल करने के लिए कुछ प्रयास दिखाएं। एक शुरुआत के लिए आप सभी अनावश्यक व्हाट्सएप को हटा सकते हैं और एकल-अक्षर चर, संरचना और फ़ंक्शन नामों का उपयोग कर सकते हैं। कृपया अपने उत्तर के शीर्ष पर भाषा और कुल बाइट-गिनती भी शामिल करें।

— मार्टिन एंडर

रोसेटा स्टोन चैलेंज: जीन मैपिंग