আমি কীভাবে কোডের এই ব্লকটিকে উন্নত ও সংক্ষিপ্ত করতে পারি? [বন্ধ]

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

এই পদ্ধতিটি সহজেই ব্যবহার করুন ডিএনএ [i] .toLowerCase ()

— থায়ার আলখতিব

যদি আপনার কোডটি কাজ করে এবং আপনি কেবল উন্নতি করতে চান, কোডরেভিউ.সটাকেক্সচেঞ্জ.কম

— পিটার কলিংগ্রিজ

আমি মনে করি না এই কোড কাজ হিসাবে উদ্দীষ্ট, | যৌক্তিক করে না অথবা Javascript মত||

— রুট

@ মামুনোথম্যান - এটি সত্য, তবে উভয়ই সেই কোডটিতে কাজ করবে ( ||যদিও আরও ভাল হবে)।

— টিজে ক্রাউডার

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

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

@ আরবজি দ্বারা মন্তব্যে আরও একটি ভাল উল্লেখ করা হয়েছে যে আমরা অযাচিত অক্ষরগুলি লুপিংয়ের আগে স্ট্রিং থেকে অপসারণ করতে পারি।

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

Comments

যদি ডিএনএতে একটি তালিকাভুক্ত অক্ষর undefinedথাকে তবে আপনার চূড়ান্ত অ্যারেতে মান থাকবে ।

— গ্রেগরি

@ GrégoryNEUT যোগ করা হয়েছে আমার উত্তর যে ক্ষেত্রে জন্য একটি ফিক্স

— Maheer আলী

অথবা আপনি স্ট্রিংটি প্রি-প্রসেস করতে পারেন dna.toLowerCase().replace(/[^cgta]/g,'')...। ;-)

— রবিজি

@ রবজি সত্যিই এটি পছন্দ করেছে। আমি এটি আমার উত্তর যোগ।

— মাহির আলী

আমি মিস করেছি যে এটি একটি স্ট্রিং ছিল। :-) 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-offor

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

এটি আকর্ষণীয় আমি এইভাবে এটি করার কথা ভাবি নি, ধন্যবাদ!

— কোকোফ্লেড

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;

}