একক ক্রিয়াকলাপে কি সহজ (x == 0 || x == 1) সহজ করা সম্ভব?

Question

সুতরাং আমি ফিবোনাচি সিক্যুয়েশনে n তম সংখ্যাটি যথাসম্ভব কমপ্যাক্টে একটি ক্রিয়াকলাপে লেখার চেষ্টা করছিলাম :

public uint fibn ( uint N ) 
{
   return (N == 0 || N == 1) ? 1 : fibn(N-1) + fibn(N-2);
}

তবে আমি ভাবছি আমি পরিবর্তন করে এটিকে আরও আরও কমপ্যাক্ট এবং দক্ষ করে তুলতে পারি কিনা

(N == 0 || N == 1)

একক তুলনায়। এমন কিছু অভিনব বিট শিফট অপারেশন রয়েছে যা এটি করতে পারে?

Comments

কেন? এটি পাঠযোগ্য, উদ্দেশ্য খুব স্পষ্ট, এবং এটি ব্যয়বহুল নয়। কেন এটি এমন কিছু "চালাক" বিট প্যাটার্ন মেলাতে পরিবর্তন করুন যা বোঝা শক্ত এবং উদ্দেশ্যটি স্পষ্টভাবে সনাক্ত করে না?

— ডি স্ট্যানলে

এটা কি ঠিক ফিবোনাচি নয়?

— n8wrl

ফিবোনাচি পূর্ববর্তী দুটি মান যুক্ত করে। আপনি কি fibn(N-1) + fibn(N-2) পরিবর্তে বোঝাতে চেয়েছিলেন N * fibn(N-1)?

— জুহর

আমি সমস্ত ন্যানোসেকেন্ডগুলি শেভ করার জন্য, তবে যদি আপনি কোনও পদ্ধতিতে পুনরাবৃত্তি ব্যবহারের ক্ষেত্রে একটি সাধারণ তুলনা পেয়ে থাকেন, তবে কেন তুলনাটির দক্ষতার জন্য প্রচেষ্টা ব্যয় করুন এবং সেখানে পুনরাবৃত্তিটি ছেড়ে যাবেন?

— জন হান্না

আপনি ফ্যাবোনচি নম্বর গণনা করার জন্য পুনরাবৃত্ত উপায়টি ব্যবহার করেন, তারপরে আপনি কার্যকারিতাটি উন্নত করতে চান? কেন এটি লুপে পরিবর্তন করবেন না? বা দ্রুত শক্তি ব্যবহার?

— নোটবাদ

Answer 1

এই এক কাজ

Math.Sqrt(N) == N 

0 এবং 1 এর বর্গমূল যথাক্রমে 0 এবং 1 ফিরে আসবে।

Comments

Math.Sqrtএকটি জটিল ভাসমান-পয়েন্ট ফাংশন। এটি পূর্ণসংখ্যার-বিকল্পগুলির সাথে তুলনা করে ধীরে ধীরে চলে!

— নায়ুকি

এটি পরিষ্কার দেখাচ্ছে, তবে এর চেয়ে আরও ভাল উপায় আছে যদি আপনি অন্য উত্তরগুলি পরীক্ষা করেন।

— মাফাই

যদি আমি যে কোডটিতে কাজ করছিলাম আমি যদি এটির সামনে এসে পৌঁছে যাই, তবে আমি সম্ভবত কমপক্ষে সেই ব্যক্তির ডেস্কে যেতে পারি এবং সে সময় তারা কোন পদার্থ গ্রহণ করছিল তা স্পষ্টভাবে তাদের জিজ্ঞাসা করতাম।

— সিভিএন

কে তাদের সঠিক মনে, এটি উত্তর হিসাবে চিহ্নিত করেছেন? নির্বাক।

— স্কোয়াশেড.বাগাবু

Answer 2

বিটওয়াইথ গাণিতিক ব্যবহার করে আপনার গাণিতিক পরীক্ষাটি প্রয়োগ করার বিভিন্ন উপায় রয়েছে। আপনার অভিব্যক্তি:

• x == 0 || x == 1

যৌক্তিকভাবে এগুলির প্রতিটিটির সমতুল্য:

• (x & 1) == x
• (x & ~1) == 0
• (x | 1) == 1
• (~x | 1) == (uint)-1
• x >> 1 == 0

বোনাস:

• x * x == x (প্রমাণটি কিছুটা চেষ্টা করে নেয়)

তবে ব্যবহারিকভাবে বলতে গেলে, এই ফর্মগুলি সর্বাধিক পঠনযোগ্য, এবং কার্য সম্পাদনের ক্ষুদ্র পার্থক্যটি বিটওয়াইথ গাণিতিকটি ব্যবহার করার পক্ষে সত্য নয়:

• x == 0 || x == 1
• x <= 1(কারণ xএকটি স্বাক্ষরবিহীন পূর্ণসংখ্যা)
• x < 2(কারণ xএকটি স্বাক্ষরবিহীন পূর্ণসংখ্যা)

Comments

ভুলে যাবেন না(x & ~1) == 0

— লি ড্যানিয়েল ক্রকার

তবে তাদের যে কোনও একটি "আরও দক্ষ" হওয়ার জন্য বাজি ধরবেন না। জিসিসি আসলে বা এর x == 0 || x == 1চেয়ে কম কোড জেনারেট করে । প্রথমটির জন্য এটি যথেষ্ট সমতুল্য হিসাবে এটি স্বীকৃত হিসাবে যথেষ্ট এবং সরল আউটপুট । অন্যরা এটিকে বিভ্রান্ত করে এবং আরও খারাপ কোড তৈরি করে। (x & ~1) == 0(x | 1) == 1x <= 1cmpl; setbe

— hobbs

x <= 1 বা এক্স <2 সহজ।

— gnasher729

@ কেভিন সত্য সত্যই সি ++ এর জন্য, কারণ সেই মানটি সত্যিই চেষ্টা করে, অনুমানযোগ্য কোডটি লেখা অসম্ভবকে শক্ত করে তোলে। ভাগ্যক্রমে এটি সি #;) সম্পর্কে একটি প্রশ্ন

— ভু

সর্বাধিক আধুনিক সংকলকগণ ইতিমধ্যে এর তুলনাগুলি অনুকূল করতে পারেন যদিও আমি জানি না যে স্মার্ট সি # সংকলক এবং নেট জিটটার কতটা স্মার্ট। রিয়েল কোডে কেবলমাত্র একটি একক তুলনা প্রয়োজন

— ফুচলভি

Answer 3

যেহেতু যুক্তি uint( স্বাক্ষরবিহীন ) আপনি রাখতে পারেন

  return (N <= 1) ? 1 : N * fibn(N-1);

কম পাঠযোগ্য (আইএমএইচও) তবে আপনি প্রতিটি অক্ষর গণনা করলে ( কোড গল্ফ বা একই রকম)

  return N < 2 ? 1 : N * fibn(N-1);

সম্পাদনা : আপনার সম্পাদিত প্রশ্নের জন্য :

  return (N <= 1) ? 1 : fibn(N-1) + fibn(N-2);

অথবা

  return N < 2 ? 1 : fibn(N-1) + fibn(N-2);

Comments

যদি এটি কোড গল্ফ হত, এটি হত return N<2?1:f(N-1)+f(n-2)। : পি

— কনর ও'ব্রায়ান

Answer 4

আপনি অন্যান্য সমস্ত বিট 0 টির মতো দেখতেও পরীক্ষা করতে পারেন:

return (N & ~1) == 0 ? 1 : N * fibn(N-1);

সম্পূর্ণ আরও ধন্যবাদ ম্যাটকে আরও ভাল সমাধানের জন্য:

return (N | 1) == 1 ? 1 : N * fibn(N-1);

উভয় ক্ষেত্রে আপনাকে প্রথম বন্ধনীর যত্ন নেওয়া প্রয়োজন কারণ বিটওয়াইজ অপারেটরগুলির তুলনায় কম অগ্রাধিকার রয়েছে ==।

Comments

আমি এটা পছন্দ করি! ধন্যবাদ।

— ব্যবহারকারী 6048670

1 (N|1)==1

— ম্যাট

@atk 3 | 1 টি 3 কারণ b0011 | b0001 is b0011

— রেনা ভোগ্ট

@ এটাক এটি কিছুটা দিক থেকে বা যৌক্তিক নয়। কোনও শর্টকিউটিং নেই।

— isaacg

@ হটেন সঠিক, তবে ম্যাট বলেছেন 1 টি কম চরিত্র , 1 টি অপারেশন নয় ।

— ইভান স্টয়েভ

Answer 5

আপনি যদি যা করতে চান তা হ'ল ফাংশনটি আরও দক্ষ করে তোলা, তবে একটি সারণী ব্যবহার করুন। অনুসন্ধানের টেবিলটি কেবল 47 টি এন্ট্রিগুলিতে আশ্চর্যজনকভাবে ছোট - পরের এন্ট্রিটি 32-বিট স্বাক্ষরযুক্ত পূর্ণসংখ্যাকে উপচে ফেলবে। এটি অবশ্যই লিখতে ফাংশনকে তুচ্ছ করে তোলে।

class Sequences
{
    // Store the complete list of values that will fit in a 32-bit unsigned integer without overflow.
    private static readonly uint[] FibonacciSequence = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,
        233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418,
        317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169,
        63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073
    };

    public uint fibn(uint N)
    {
        return FibonacciSequence[N];
    }
}

আপনি অবশ্যই ঘটনাচক্রে একই জিনিস করতে পারেন।

Answer 6

কীভাবে এটি বিটশিট দিয়ে করবেন

আপনি যদি বিটশিফ্ট ব্যবহার করতে চান এবং কোডটি কিছুটা অস্পষ্ট করতে চান (তবে সংক্ষিপ্ত) আপনি করতে পারেন:

public uint fibn ( uint N ) {
   return N >> 1 != 0? fibn(N-1) + finb(N-2): 1;
}

Nভাষার সি তে স্বাক্ষরিত পূর্ণসংখ্যার জন্য , N>>1লো অর্ডার বিটটি টস করে দেয়। যদি ফলাফলটি শূন্য নয় তবে এটি সূচিত করে যে এন 1 এর চেয়ে বড়।

দ্রষ্টব্য: এই অ্যালগরিদম মারাত্মকভাবে অক্ষম কারণ এটি অকারণে ক্রমটির মানগুলি পূর্বে গণনা করা হয়েছে বলে পুনরায় গণনা করে।

কিছু ওয়ে ওয়ে ওয়ে

সুস্পষ্টভাবে একটি ফিবোনাচি (এন) আকারের গাছ তৈরির পরিবর্তে এটি একটি পাস গণনা করুন:

uint faster_fibn(uint N) { //requires N > 1 to work
  uint a = 1, b = 1, c = 1;
  while(--N != 0) {
    c = b + a;
    a = b;
    b = c;
  }
  return c;
}

কিছু লোক যেমন উল্লেখ করেছেন, a৪ বিটের স্বাক্ষরবিহীন পূর্ণসংখ্যার পূর্ণ উপায়েও সময় লাগে না। আপনি কতটা বড় হওয়ার চেষ্টা করছেন তার উপর নির্ভর করে আপনার স্বেচ্ছাচারিত নির্ভুলতা পূর্ণসংখ্যা ব্যবহার করতে হবে।

Comments

কেবল ক্ষতিকারক ক্রমবর্ধমান গাছকে এড়ানো নয়, আপনি আধুনিক সিপিইউ পাইপলাইনগুলিকে আটকে রাখতে পারে এমন টের্নারি অপারেটরের সম্ভাব্য শাখাটি এড়াতে পারবেন।

— ম্যাথ্রেডলার

আপনার 'উপায় দ্রুত' কোডটি সি # তে কাজ করবে না কারণ uintএটি স্পষ্টতই কাস্টেবলযোগ্য নয় boolএবং প্রশ্নটি বিশেষত সি # হিসাবে ট্যাগ করা হয়েছে।

— ফারাপ

@ ফারাপ এর --N != 0পরিবর্তে করুন। মুল বক্তব্যটি হ'ল ও (এন) এর কিছু ও (ফিবন (এন)) এর চেয়ে ভাল।

— ম্যাথু গুন

@ ম্যাথুগান এর পয়েন্টটি প্রসারিত করতে, ও (ফাইব (এন)) হ'ল হ'ল (ফাই ^ n) (এই উত্সটি দেখুন স্ট্যাকওভারফ্লো.com/ a/ 360773/2788187 )

— কনার ক্লার্ক

@ রেনোভোগ আমি এসি # বিকাশকারী নই। আমি বেশিরভাগই একটি হে (ফাইবএন (এন)) অ্যালগরিদমের সম্পূর্ণ অযৌক্তিকতা সম্পর্কে মন্তব্য করার চেষ্টা করছিলাম। এটি কি এখন সংকলন করে? (আমি যুক্ত করেছি! = 0 যেহেতু সি # অ-শূন্য ফলাফলগুলিকে সত্য হিসাবে বিবেচনা করে না)) আপনি যদি uint64_t এর মতো মানদণ্ডের সাথে uint প্রতিস্থাপন করেন তবে এটি সোজা সিতে কাজ করে (এবং কাজ করেছে)।

— ম্যাথু গন

Answer 7

আপনি যেমন একটি ইউন্ট ব্যবহার করেন, যা নেতিবাচক পেতে পারে না, আপনি তা পরীক্ষা করে দেখতে পারেন n < 2

সম্পাদনা

বা বিশেষ ফাংশনের ক্ষেত্রে আপনি নীচে এটি লিখতে পারেন:

public uint fibn(uint N)
    return (N == 0) ? 1 : N * fibn(N-1);
}

যা অবশ্যই অতিরিক্ত পুনরাবৃত্তির পদক্ষেপ ব্যয় করে একই ফলাফলের দিকে নিয়ে যায়।

Comments

@ ক্যাথলএমএফ: তবে ফলাফলটি একই রকম, কারণ1 * fibn(0) = 1 * 1 = 1

— ডের্পিয়ার্সার

আপনার ফাংশনটি ফ্যাকোরিয়াল গণনা করছে না, ফিবোনাচি নয়?

— বার্মার

@ বার্মার হ্যাঁ, প্রকৃতপক্ষে এটি ঘটনাবাদী, কারণ এটিই আসল প্রশ্ন ছিল

— ডের্পিয়ার্সার

fibnএরপরে কল না করাই ভাল হতে পারে

— পাই3636

@ পাই36366 আমি এটি ফিবন বলেছি কারণ এটিই মূল প্রশ্নে এটি বলা হয়েছিল এবং আমি পরে উত্তরটি আপডেট করিনি

— ডের্পিয়ার্সার

Answer 8

কেবলমাত্র N<= 1 আছে কিনা তা পরীক্ষা করে দেখুন যেহেতু আপনি জানেন যে এন স্বাক্ষরিত রয়েছে সেখানে কেবলমাত্র 2 টি শর্ত থাকতে পারে N <= 1যা ফলাফল TRUE: 0 এবং 1

public uint fibn ( uint N ) 
{
   return (N <= 1) ? 1 : fibn(N-1) + finb(N-2);
}

Comments

এটি স্বাক্ষরিত বা স্বাক্ষরবিহীন হলেও তা কী গুরুত্বপূর্ণ? অ্যালগরিদম নেতিবাচক ইনপুটগুলির সাথে অসীম পুনরাবৃত্তি উত্পাদন করে, তাই 0 বা 1 সমতুল্য তাদের চিকিত্সা করার কোনও ক্ষতি নেই

— বার্মার

@ বারমার নিশ্চিত হন যে এটি গুরুত্বপূর্ণ, বিশেষত এই নির্দিষ্ট ক্ষেত্রে। ওপি জিজ্ঞাসা করেছিল যে তিনি ঠিক কী সরল করতে পারবেন কিনা (N == 0 || N == 1)। আপনি জানেন যে এটি 0 এর চেয়ে কম হবে না (কারণ এরপরে এটি স্বাক্ষরিত হবে!) এবং সর্বোচ্চটি 1 হতে পারে N <= 1simp আমি অনুমান করি যে স্বাক্ষরবিহীন প্রকারটি গ্যারান্টিযুক্ত নয় তবে এটি অন্য কোথাও পরিচালনা করা উচিত, আমি বলব।

— জেমস

আমার বক্তব্যটি হ'ল যদি এটি ঘোষিত হয় int Nএবং আপনি যদি মূল শর্তটি রেখেছিলেন তবে এন তার আসল অবস্থার সাথে নেতিবাচক হলে তা অসীম পুনরাবৃত্তি হবে। যেহেতু এটি অপরিজ্ঞাত আচরণ, তাই আমাদের আসলে এটি নিয়ে চিন্তা করার দরকার নেই। সুতরাং আমরা ধরে নিতে পারি যে এন ঘোষণাটি নির্বিশেষে অ-নেতিবাচক।

— বর্মার

বা নেতিবাচক ইনপুটগুলির সাথে আমরা যা চাই তা করতে পারি, সেগুলি পুনরাবৃত্তির বেস কেস হিসাবে বিবেচনা করে।

— বর্মার

@ বারমার বেশ নিশ্চিত যে আপনি যদি নেতিবাচক হিসাবে সেট করার চেষ্টা করেন তবে ইউন্ট সর্বদা স্বাক্ষরবিহীন হয়ে যাবে

— জেমস

Answer 9

দাবি অস্বীকার: আমি সি # জানি না, এবং এই কোডটি পরীক্ষা করিনি:

তবে আমি ভাবছি যে আমি [...] কে একক তুলনায় রূপান্তর করে এটিকে আরও কমপ্যাক্ট এবং দক্ষ করে তুলতে পারি কিনা ...

বিটশিফিং বা এ জাতীয় প্রয়োজন নেই, এটি কেবল একটি তুলনা ব্যবহার করে এবং এটি অনেক বেশি দক্ষ হওয়া উচিত (ও (এন) বনাম ও (2 ^ n) আমি মনে করি?)। ফাংশনটির দেহটি আরও কমপ্যাক্ট , যদিও এটি ঘোষণার সাথে কিছুটা দীর্ঘ হয়।

(পুনরাবৃত্তি থেকে ওভারহেড অপসারণ করতে, ম্যাথিউ গানের উত্তরের মতো পুনরাবৃত্ত সংস্করণ রয়েছে )

public uint fibn ( uint N, uint B=1, uint A=0 ) 
{
    return N == 0 ? A : fibn( N--, A+B, B );
}

                     fibn( 5 ) =
                     fibn( 5,   1,   0 ) =
return 5  == 0 ? 0 : fibn( 5--, 0+1, 1 ) =
                     fibn( 4,   1,   1 ) =
return 4  == 0 ? 1 : fibn( 4--, 1+1, 1 ) =
                     fibn( 3,   2,   1 ) =
return 3  == 0 ? 1 : fibn( 3--, 1+2, 2 ) =
                     fibn( 2,   3,   2 ) =
return 2  == 0 ? 2 : fibn( 2--, 2+3, 3 ) =
                     fibn( 1,   5,   3 ) =
return 1  == 0 ? 3 : fibn( 1--, 3+5, 5 ) =
                     fibn( 0,   8,   5 ) =
return 0  == 0 ? 5 : fibn( 0--, 5+8, 8 ) =
                 5
fibn(5)=5

পিএস: এটি সঞ্চয়ীগুলির সাথে পুনরাবৃত্তির জন্য একটি সাধারণ ক্রিয়ামূলক প্যাটার্ন। যদি আপনি এর সাথে প্রতিস্থাপন N--করেন N-1আপনি কার্যকরভাবে কোনও রূপান্তর ব্যবহার করছেন না, যা এটি একটি বিশুদ্ধ কার্যকরী পদ্ধতির জন্য ব্যবহারযোগ্য করে তোলে।

Answer 10

এখানে আমার সমাধানটি রয়েছে, এই সাধারণ ফাংশনটি অনুকূলকরণের পক্ষে খুব বেশি কিছু নেই, অন্যদিকে আমি এখানে যা দিচ্ছি তা হ'ল পুনরাবৃত্তি ফাংশনের গাণিতিক সংজ্ঞা হিসাবে পাঠযোগ্যতা।

public uint fibn(uint N) 
{
    switch(N)
    {
        case  0: return 1;

        case  1: return 1;

        default: return fibn(N-1) + fibn(N-2);
    }
}

একই ধরণের ফিবোনাচি সংখ্যার গাণিতিক সংজ্ঞা ..

স্যুইচ কেসটিকে দেখার টেবিল তৈরি করতে বাধ্য করার জন্য আরও এগিয়ে নেওয়া Taking

public uint fibn(uint N) 
{
    switch(N)
    {
        case  0: return 1;
        case  1: return 1;
        case  2: return 2;
        case  3: return 3;
        case  4: return 5;
        case  5: return 8;
        case  6: return 13;
        case  7: return 21;
        case  8: return 34;
        case  9: return 55;
        case 10: return 89;
        case 11: return 144;
        case 12: return 233;
        case 13: return 377;
        case 14: return 610;
        case 15: return 987;
        case 16: return 1597;
        case 17: return 2584;
        case 18: return 4181;
        case 19: return 6765;
        case 20: return 10946;
        case 21: return 17711;
        case 22: return 28657;
        case 23: return 46368;
        case 24: return 75025;
        case 25: return 121393;
        case 26: return 196418;
        case 27: return 317811;
        case 28: return 514229;
        case 29: return 832040;
        case 30: return 1346269;
        case 31: return 2178309;
        case 32: return 3524578;
        case 33: return 5702887;
        case 34: return 9227465;
        case 35: return 14930352;
        case 36: return 24157817;
        case 37: return 39088169;
        case 38: return 63245986;
        case 39: return 102334155;
        case 40: return 165580141;
        case 41: return 267914296;
        case 42: return 433494437;
        case 43: return 701408733;
        case 44: return 1134903170;
        case 45: return 1836311903;
        case 46: return 2971215073;

        default: return fibn(N-1) + fibn(N-2);
    }
}

Comments

আপনার সমাধানটির সুবিধাটি হ'ল এটি যখন প্রয়োজন হয় কেবল তখনই গণনা করা হয়। সেরা একটি সারণী হবে। বিকল্প বোনাস: f (n-1) = someCalcOf (f (n-2)), তাই সম্পূর্ণ পুনরায় রান প্রয়োজন হয় না।

— কার্স্টেন

@ কার্সটেন আমি স্যুইচটির জন্য এটির জন্য একটি সারণী তৈরি করতে যথেষ্ট মান যুক্ত করেছি। বিকল্প বোনাস কীভাবে কাজ করে তা সম্পর্কে আমি নিশ্চিত নই।

— খালেদ.কে

কিভাবে এই প্রশ্নের উত্তর দেয়?

— ক্লার্ক কেন্ট

@ সাভিউরসেফ এটি একটি অনুসন্ধানের টেবিলে নেমে আসে এবং উত্তরে চাক্ষুষ দিকটি ব্যাখ্যা করা আছে। stackoverflow.com/a/395965/2128327

— Khaled.K

আপনি switchযখন উত্তরগুলির একটি অ্যারে রাখতে পারেন তখন কেন আপনি এমনটি ব্যবহার করবেন ?

— নায়ুকি

Answer 11

এন ইউন্ট হয়, শুধু ব্যবহার করুন

N <= 1

Comments

ঠিক আমি কী ভাবছিলাম; এন ইউিন্ট! সত্যই উত্তর হওয়া উচিত।

— স্কোয়াশড.বাগাবু

Answer 12

দিমিত্রি এর উত্তর সবচেয়ে ভাল তবে যদি এটি একটি ইন্টার 32 রিটার্ন টাইপ হত এবং আপনার কাছ থেকে বেছে নিতে আপনার সংখ্যার বৃহত সংখ্যক এটি করতে পারে।

return new List<int>() { -1, 0, 1, 2 }.Contains(N) ? 1 : N * fibn(N-1);

Comments

আসলটির চেয়ে ছোটটি কেমন?

— এমসিমিস্ট্রি

@ এমসিমিস্ট্রি এটি খাটো নয়। যেমন আমি এটির আরও ভাল উল্লেখ করেছি যদি মূল রিটার্ন টাইপটি একটি ইন্ট 32 হয় এবং সে বৈধ সংখ্যার একটি বড় সেট থেকে নির্বাচন করে is লিখতে থাকার Insead (এন == -1 || এন == 0 || এন == 1 || এন == 2)

— CathalMF

ওপির কারণগুলি অপ্টিমাইজেশনের সাথে সম্পর্কিত বলে মনে হচ্ছে। এটি বিভিন্ন কারণে একটি খারাপ ধারণা: 1) প্রতিটি পুনরাবৃত্তির কলের অভ্যন্তরে কোনও নতুন অবজেক্ট ইনস্ট্যান্ট করা সত্যিই খারাপ ধারণা, 2) List.Containsও (এন), 3) পরিবর্তে দুটি তুলনা করা ( N > -3 && N < 3) কম এবং আরও পঠনযোগ্য কোড দেয় would

— গ্রো

@ গ্রু এবং মানগুলি কী -10, -২, 5, 7, 13 হলে

— হত

ওপি যা বলেছিল তা নয়। তবে যাইহোক, আপনি এখনও 1) প্রতিটি কলটিতে একটি নতুন উদাহরণ তৈরি করতে চান না, 2) নির্দিষ্ট সমস্যার জন্য পরিবর্তে একটি (একক) হ্যাশসেট ব্যবহার করা উচিত, 3) আপনি হ্যাশ ফাংশনটিকে আরও অনুকূলিত করতে সক্ষম হবেন খাঁটি হতে, বা এমনকি অন্যান্য উত্তরের মত প্রস্তাবিত চালাকিভাবে ব্যবস্থা করা বিটওয়াইজ অপারেশন ব্যবহার করুন।

— গ্রো

Answer 13

ফিবোনাচি সিকোয়েন্সটি এমন একটি সংখ্যার সিরিজ যেখানে দুটি নম্বর আগে যুক্ত করে একটি সংখ্যা পাওয়া যায়। দুটি প্রারম্ভিক পয়েন্ট রয়েছে: ( 0,1 , 1,2, ..) এবং ( 1,1 , 2,3)।

-----------------------------------------
Position(N)| Value type 1 | Value type 2
-----------------------------------------  
1          |  0           |   1
2          |  1           |   1
3          |  1           |   2
4          |  2           |   3
5          |  3           |   5
6          |  5           |   8
7          |  8           |   13
-----------------------------------------

Nএই ক্ষেত্রে অবস্থানটি শুরু হয় 1, এটি 0-basedঅ্যারে সূচক হিসাবে নয় ।

ব্যবহার C # এর 6 এক্সপ্রেশন শরীরের বৈশিষ্ট্য এবং প্রায় দিমিত্রি এর পরামর্শ তিন অপারেটর আমরা টাইপ 1 জন্য সঠিক হিসাব সাথে একটি এক লাইন ফাংশন লিখতে পারেন:

public uint fibn(uint N) => N<3? N-1: fibn(N-1)+fibn(N-2);

এবং টাইপ 2 জন্য:

public uint fibn(uint N) => N<3? 1: fibn(N-1)+fibn(N-2);

Answer 14

পার্টিতে দেরি হলেও আপনারা তাও করতে পারেন (x==!!x)

!!xমানটি 1যদি তা না হয় তবে তা রূপান্তর করে এবং যদি তা থাকে তবে তা 0ছেড়ে দেয় 0।
আমি এই ধরণের জিনিসটি প্রচুর অবহেলায় ব্যবহার করি।

দ্রষ্টব্য: এটি সি, এটি সি # তে কাজ করে কিনা তা নিশ্চিত নন

Comments

কেন এটি উপকৃত হয়েছে তা নিশ্চিত নয়। এমনকি C # তে যেমন uint n = 1; if (n == !!n) { }দেয় তেমন কার্সারিও চেষ্টা Operator '!' cannot be applied to operand of type 'uint'করে !n। কিছু কিছু সি-তে কাজ করার অর্থ এই নয় যে এটি সি # তে কাজ করে; এমনকি #include <stdio.h>সি # তেও কাজ করে না, কারণ সি # এর "অন্তর্ভুক্ত" প্রিপ্রোসেসর নির্দেশিকা নেই। ভাষা সি এবং সি ++ এর চেয়ে আলাদা।

— একটি সিভিএন

উহু. ঠিক আছে. আমি দুঃখিত :(

— এক সাধারণ রাত

@ একনর্মালনাট (এক্স == !! এক্স) এটি কীভাবে কাজ করবে। আমার ইনপুটটি 5 হিসাবে বিবেচনা করুন (5 == !! 5)। এটি সত্য হিসাবে ফলাফল দেবে

— ভিনথ এনারজিটিক

@ উইনোথকুমার !! 5 টি 1 টি মূল্যায়ন করে (

— এক সাধারণ রাত

@ অমনর্মালাইট হ্যাঁ আমি এখন এটি পেয়েছি। (5) আবার 1 প্রয়োগ করে এটি 0 দেয় gives। 1 নয়

— ভিনথ এনারজিটিক

Answer 15

সুতরাং আমি Listএইগুলির মধ্যে একটি বিশেষ পূর্ণসংখ্যার তৈরি করেছি এবং Nএটির সাথে সম্পর্কিত কিনা তা পরীক্ষা করেছি।

static List<uint> ints = new List<uint> { 0, 1 };

public uint fibn(uint N) 
{
   return ints.Contains(N) ? 1 : fibn(N-1) + fibn(N-2);
}

আপনি বিভিন্ন উদ্দেশ্যে একটি এক্সটেনশন পদ্ধতিও ব্যবহার করতে পারেন যেখানে Containsকেবল একবার ডাকা হয় (যেমন আপনার অ্যাপ্লিকেশনটি ডেটা শুরু এবং ডেটা লোড করা হয়) এটি একটি পরিষ্কার শৈলী সরবরাহ করে এবং আপনার মান ( N) এর সাথে প্রাথমিক সম্পর্কটি স্পষ্ট করে :

static class ObjectHelper
{
    public static bool PertainsTo<T>(this T obj, IEnumerable<T> enumerable)
    {
        return (enumerable is List<T> ? (List<T>) enumerable : enumerable.ToList()).Contains(obj);
    }
}

এটি প্রয়োগ করুন:

N.PertainsTo(ints)

এটি করার দ্রুততম উপায় এটি নাও হতে পারে তবে আমার কাছে এটি আরও ভাল শৈলী বলে মনে হয়।