मैं इस कोड के ब्लॉक को कैसे सुधार और छोटा कर सकता हूं? [बन्द है]

Question

यह फ़ंक्शन डीएनए का एक स्ट्रिंग लेता है जैसे 'GTCA' और एक सरणी देता है जिसमें सही ढंग से मिलान किए गए डीएनए जोड़े होते हैं।

function pairDNA(dna) {

  const pairs = []

  for (let i = 0; i < dna.length; i ++) {

    if (dna[i] === "C" | dna[i] === "c") {
      pairs.push("CG");
    } else if (dna[i] === "G"| dna[i] === "g") {
      pairs.push("GC");
    } else if (dna[i] === "T"| dna[i] === "t") {
    pairs.push("TA");
    } else if (dna[i] === "A"| dna[i] === "a") {
      pairs.push("AT");
    }
  }

return pairs;
}

यह सही है। हालाँकि मैं इसे लिखने का एक छोटा, सरल तरीका खोजने की कोशिश कर रहा हूँ। क्या कोई मेरी मदद कर सकता है जो मुझे उपयोग करना चाहिए?

Comments

आसानी से इस विधि का उपयोग करें dna [i] .LLowerCase ()

— थिएर अल्खतीब

यदि आपका कोड काम करता है और आप सिर्फ सुधार चाहते हैं, तो codereview.stackexchange.com पर

— पीटर

मुझे नहीं लगता है कि यह कोड काम कर रहा है, | तार्किक या जावास्क्रिप्ट में नहीं करता है जैसे||

— रूट

@mamounothman - यह सच है, लेकिन दोनों उस कोड में काम करेंगे ( ||हालांकि, बेहतर होगा)।

— टीजे क्राउडर

Answer 1

आप निम्नलिखित चरणों में कोड में सुधार कर सकते हैं:

• जब कथन कई होते हैं और सभी में समान संरचना होती है, तो आपको संभवतः किसी ऑब्जेक्ट का उपयोग करने की आवश्यकता होती है
• आपको अपरकेस और लोअरकेस दोनों की जांच करने की आवश्यकता है। बस toLowerCase()इनपुट पर उपयोग करें ।
• आप इसे में एक सरणी मान बनाने के बजाय splitस्ट्रिंग और map()यह कर सकते हैं push()।

function pairDNA(dna) {
  const obj = {
    c: 'CG',
    g: 'GC',
    t: 'TA',
    a: "AT"
  }
  return dna.split('').map(x => obj[x.toLowerCase()])

}

यदि स्ट्रिंग में कुछ अन्य विशिष्ट अक्षर हो सकते हैं तो आपको उसके बाद filter()के undefinedमानों की आवश्यकता होगीmap

return dna.split('').map(x => obj[x.toLowerCase()]).filter(x => x !== undefined)

एक और बेहतर @RobG द्वारा टिप्पणियों में उल्लेख किया गया है कि हम इसके माध्यम से लूप से पहले अवांछित पत्रों को स्ट्रिंग से हटा सकते हैं।

return dna
        .toLowerCase()
        .replace(/[^cgta]/g,'')
        .split('')
        .map(x => obj[x])

Comments

यदि dna में एक गैर-सूचीबद्ध वर्ण है, तो undefinedआपके अंतिम सरणी में मान होंगे ।

— ग्रेजोरी NEUT

@ GrégoryNEUT ने मेरे जवाब में उस मामले के लिए एक हल जोड़ा

— माहेर अली

या आप स्ट्रिंग को प्री-प्रोसेस कर सकते हैं dna.toLowerCase().replace(/[^cgta]/g,'')...। ;-)

— रोबगॉन

@RobG वास्तव में पसंद आया। मैंने इसे अपने उत्तर में जोड़ा।

— माहीर अली

मुझे याद आया कि यह एक स्ट्रिंग थी। :-) FWIW, सरणियों में तारों को विभाजित करने का एक और अधिक यूनिकोड-अनुकूल तरीका है [...dna]। यह सरोगेट जोड़े को नहीं तोड़ता है। (या Array.fromहै, जो विशेष रूप से उपयोगी है अगर आप मैप करने के लिए जा रहे हैं यह है: Array.from(dna, mappingFunction)।) (सभी कि यहाँ प्रासंगिक, मुझे लगता है dnaकेवल शामिल c, g, t, और a।)

— टीजे Crowder

Answer 2

मैं शायद:

1. एक for-ofलूप का उपयोग करें (या संभव फ़िल्टरिंग के साथ संभवतः मैपिंग)

2. लुकअप ऑब्जेक्ट या मैप का उपयोग करें

3. स्विचिंग / अप करते समय स्ट्रिंग को कम या ऊपरी स्थिति में बनाएं (लेकिन स्विच / लुकअप कार्य में डुप्लिकेट की गई प्रविष्टियाँ):

यदि आप जानते हैं कि dnaइसमें केवल c/ C, g/ G, t/ T/, या a/ A(जो, जैसा कि मैं समझता हूं, डीएनए; ;-)) का सच है, तो आप Array.fromलुकिंग ऑब्जेक्ट / मैप के साथ इसकी मैपिंग सुविधा के साथ उपयोग कर सकते हैं :

const table = {
    c: "CG",
    g: "GC",
    t: "TA",
    a: "AT"
};

function pairDNA(dna) {
  return Array.from(dna, entry => table[entry.toLowerCase()]);
}                                                                                                                           

मैं उपयोग कर रहा हूं Array.fromक्योंकि यह कोड बिंदुओं पर स्ट्रिंग को विभाजित करेगा , न कि केवल कोड इकाइयां (सरोगेट जोड़े को नहीं तोड़ता है) और एक मैपिंग सुविधा है यदि आप एक मैपिंग फ़ंक्शन प्रदान करते हैं। (मूल रूप से, Array.from(str, mappingFunction)है [...str].map(mappingFunction)शायद बिल्कुल नहीं है कि यहां प्रासंगिक अपने स्ट्रिंग की सामग्री दी है, लेकिन अगर आपके स्ट्रिंग सरोगेट जोड़े हो सकती है बात कर सकते हैं लेकिन मध्यवर्ती सरणी के बिना।)।

या एक के साथ Map:

const table = new Map([
  [c, "CG"],
  [g, "GC"],
  [t, "TA"],
  [a, "AT"]
]);

function pairDNA(dna) {
  return Array.from(dna, entry => table.get(entry.toLowerCase()));
}                                                                                                                           

यदि आप उस धारणा को नहीं बना सकते हैं, .filterतो उन लोगों को फ़िल्टर करने के लिए जोड़ें जिनके पास मैच नहीं था:

function pairDNA(dna) {
  return Array.from(dna, entry => table.get(entry.toLowerCase())).filter(Boolean);
  // or if using an object: return dna.map(entry => table[entry.toLowerCase()]).filter(Boolean);
}

या यदि आप अतिरिक्त सरणी बनाने से बचना filterचाहते हैं, तो for-of(या यहां तक ​​कि for) के साथ रहें :

const table = {
    c: "CG",
    g: "GC",
    t: "TA",
    a: "AT"
};

function pairDNA(dna) {
  const pairs = [];

  for (const entry of dna) {
    const value = table[entry.toLowerCase()];
    if (value) {
      pairs.push(value);
    }
  }
  return pairs;
}

Answer 3

लूप को सरल बनाने के लिए आप लुकअप मैपिंग का उपयोग कर सकते हैं:

function pairDNA(dna) {

  const pairs = [], key = { G: "GC", C: "CG", A: "AT", T: "TA" };

  for (let i = 0; i < dna.length; i ++)
    pairs.push(key[dna[i].toUpperCase()]);
  return pairs;
}

Comments

यह दिलचस्प है कि मैंने इसे इस तरह से करने के बारे में नहीं सोचा था, धन्यवाद!

— CocoFlade

Answer 4

शायद छोटा न हो लेकिन निश्चित रूप से अधिक रखरखाव योग्य है।

function pairDNA(dna) {
  const map = {
    C: 'CG',
    c: 'CG',
    G: 'GC',
    g: 'GC',
    T: 'TA',
    t: 'TA',
    A: 'AT',
    a: 'AT',
  };

  return dna.split('').reduce((tmp, x) => {
    if (map[x]) {
      tmp.push(map[x]);
    }

    return tmp;
  }, []);
}

आप भी कर सकते हैं:

function pairDNA(dna) {
  const map = {
    c: 'CG',
    g: 'GC',
    t: 'TA',
    a: 'AT',
  };

  return dna.split('').reduce((tmp, x) => {
    if (map[x].toLowerCase()) {
      tmp.push(map[x]);
    }

    return tmp;
  }, []);
}

Answer 5

आप इस तरह एक switch caseऔर एक forEachकवक का उपयोग करने की कोशिश कर सकते हैं :

function pairDNA(dna) {
  let pairs = [];

  dna.forEach( dnaValue => {
    switch (dnaValue.toLowerCase()) {
      case "c":
        pairs.push("CG");
        break;
      case "g":
        pairs.push("GC");
        break;
      case "t":
        pairs.push("TA");
        break;
      case "a":
        pairs.push("AT");
        break;
    }
  })

  return pairs;
}

Answer 6

आप स्ट्रिंग को कम कर सकते हैं जो आपको कैपिटल स्ट्रिंग की जाँच को हटाने की अनुमति देगा:

function pairDNA(dna) {
  dna = dna.toLowerCase();
  const pairs = []
  for (let i = 0; i < dna.length; i ++) {
   if (dna[i]=== "c") {
     pairs.push("CG");
   } else if (dna[i]dna[i] === "g") {
     pairs.push("GC");
   } else if (dna[i] === "t") {
     pairs.push("TA");
   } else if (dna[i] === "a") {
     pairs.push("AT");
   }
 }

 return p;
}

Answer 7

const lookup = {
    c: "CG", 
    g: "GC", 
    t: "TA", 
    a: "AT"
};

function pairDNA(dna) {  

  const pairs = [];

  for (let i = 0; i < dna.length; i ++) {
     pairs.push( lookup[dna[i].toLowerCase()] );
  }

  return pairs;

}