পুনরাবৃত্তাকারী অ্যালগরিদমের স্ট্যাক ওভারফ্লো এড়াতে কী কী পদ্ধতি রয়েছে?


44

প্রশ্ন

পুনরাবৃত্তাকারী অ্যালগরিদমের কারণে স্ট্যাক ওভারফ্লো সমাধানের সম্ভাব্য উপায়গুলি কী কী?

উদাহরণ

আমি প্রজেক্ট অলারের সমস্যা 14 সমাধান করার চেষ্টা করছি এবং এটি পুনরাবৃত্ত আলগোরিদিম দিয়ে চেষ্টা করার সিদ্ধান্ত নিয়েছি। তবে প্রোগ্রামটি java.lang.StackOverflowError দিয়ে থামে stop এটা ঠিক যে। অ্যালগরিদম প্রকৃতপক্ষে স্ট্যাকটিকে উপচে ফেলেছে কারণ আমি একটি খুব বড় সংখ্যক জন্য একটি কোলাটজ ক্রম উত্পন্ন করার চেষ্টা করেছি।

সলিউশন

সুতরাং আমি ভাবছিলাম: আপনার পুনরাবৃত্ত আলগোরিদমটি সঠিকভাবে লেখা হয়েছিল এবং এই স্ট্যাকটি সর্বদা উপচে পড়বে তা ধরে নিয়ে কোনও স্ট্যাক ওভারফ্লো সমাধান করার কোন স্ট্যান্ডার্ড উপায় আছে? দুটি ধারণা যে মাথায় আসে সেগুলি হ'ল:

  1. লেজ পুনরাবৃত্তি
  2. পুনরাবৃত্তির

ধারণা (1) এবং (2) সঠিক? অন্য বিকল্প আছে?

সম্পাদন করা

এটি জাভা, সি #, গ্রোভি বা স্কালায় কিছু কোড দেখতে সহায়তা করবে।

সম্ভবত উপরে উল্লিখিত প্রকল্প ইউলার সমস্যাটি ব্যবহার করবেন না যাতে এটি অন্যের জন্য ক্ষতিগ্রস্থ না হয়, তবে অন্য কিছু অ্যালগোরিদম নিন। ফ্যাক্টরিয়াল হতে পারে, বা অনুরূপ কিছু।


3
পুনরাবৃত্তির। স্মৃতিচারণ
জেমস

2
একথাও ঠিক যে, Memoization আছে শুধুমাত্র যখন আসলে কাজ করে হয় হিসাব পুনরাবৃত্তি।
Jörg ডব্লু মিটাগ

2
এছাড়াও লক্ষণীয় যে সমস্ত ভাষা প্রয়োগগুলি যে কোনও উপায়ে লেজ পুনরাবৃত্তি অপ্টিমাইজেশানগুলি করতে পারে না
জে.কে.

2
এটি সম্ভবত পুনরাবৃত্তির চেয়ে কর্সারশন দিয়ে আরও ভাল সমাধান করা হবে।
জার্গ ডব্লু মিটাগ

3
আপনি যদি ১,০০,০০০ এরও কম সংখ্যক থেকে কাজ করছেন এবং ১ এ চলেছেন তবে এই প্রশ্নের উত্তরে ১ টি পৌঁছানোর প্রায় 500 টি পদক্ষেপ জড়িত This --- আপনি যদি 1 থেকে শুরু করে সমাধানের চেষ্টা করছেন, তবে এটি অনুসরণ করে 2, 4, 8, 16, {5,32} এবং সেখান থেকে উপরে যান, আপনি এটি ভুল করছেন।

উত্তর:


35

টেল কল অপ্টিমাইজেশন অনেক ভাষা এবং সংকলক উপস্থিত in এই পরিস্থিতিতে, সংকলক ফর্মের একটি কার্য স্বীকৃতি দেয়:

int foo(n) {
  ...
  return bar(n);
}

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

ক্লাসিক কল্পিত পদ্ধতিটি অনুধাবন করুন:

int factorial(n) {
  if(n == 0) return 1;
  if(n == 1) return 1;
  return n * factorial(n - 1);
}

হয় না পরিদর্শন আগমন প্রয়োজনীয় কারণ লেজ কল optimizatable। ( উত্স কোড এবং সংকলিত আউটপুট উদাহরণ )

এই লেজ কলটি অনুকূলিত করে তুলতে,

int _fact(int n, int acc) {
    if(n == 1) return acc;
    return _fact(n - 1, acc * n);
}

int factorial(int n) {
    if(n == 0) return 1;
    return _fact(n, 1);
}

এই কোডটি gcc -O2 -S fact.cসংকলন করে (-O2 সংকলকটিতে অপ্টিমাইজেশন সক্ষম করার জন্য প্রয়োজনীয়, তবে -O3 এর আরও অনুকূলিতকরণের সাথে এটি মানুষের পক্ষে পড়া শক্ত হয়ে যায় ...)

_fact(int, int):
    cmpl    $1, %edi
    movl    %esi, %eax
    je  .L2
.L3:
    imull   %edi, %eax
    subl    $1, %edi
    cmpl    $1, %edi
    jne .L3
.L2:
    rep ret

( উত্স কোড এবং সংকলিত আউটপুট উদাহরণ )

একটি অংশ দেখতে পাবেন .L3, jneবরং একটি তুলনায় call(যা একটি নতুন স্ট্যাক ফ্রেম সঙ্গে একটি সাবরুটিন কল না)।

দয়া করে নোট করুন যে এটি সি দ্বারা করা হয়েছিল জাভাতে টেইল কল অপ্টিমাইজেশন হার্ড এবং এটি জেভিএম বাস্তবায়নের উপর নির্ভর করে (এটি বলেছে যে, আমি এটি করে এমন কোনও কিছুই দেখিনি, কারণ এটি স্ট্যাঙ্ক ফ্রেমের জন্য প্রয়োজনীয় জাভা সুরক্ষা মডেলের কঠোর এবং জড়িত বিষয়গুলি) - যা টিসিও এড়িয়ে চলে) - টেল-পুনরাবৃত্তি + জাভা এবং লেজ-পুনরাবৃত্তি + অপ্টিমাইজেশন ব্রাউজ করার জন্য ভাল ট্যাগ সেট। আপনি অন্যান্য জেভিএম ভাষাগুলি লেজ পুনরাবৃত্তিকে আরও অনুকূল করতে সক্ষম হবেন (ক্লোজারটি (যার জন্য টেল কলটি অপ্টিমাইজ করতে পুনরাবৃত্তির প্রয়োজন )) বা স্কালা)।

বলেছিল,

আপনি সঠিক কিছু লিখেছিলেন তা জেনে একটি আনন্দ রয়েছে - আদর্শ উপায়ে এটি করা যায়।
এবং এখন, আমি কিছু স্কচ পেতে যাচ্ছি এবং কিছু জার্মান ইলেক্ট্রনিকা দেব ...


"পুনরাবৃত্তিমূলক অ্যালগরিদমে স্ট্যাকের ওভারফ্লো এড়ানোর জন্য পদ্ধতিগুলির" সাধারণ প্রশ্নের কাছে ...

আর একটি পদ্ধতির পুনরাবৃত্তি কাউন্টার অন্তর্ভুক্ত করা হয়। এটি নিজের নিয়ন্ত্রণের বাইরে অবস্থার কারণে (এবং খারাপ কোডিং) অসীম লুপগুলি সনাক্ত করার জন্য আরও বেশি।

পুনরাবৃত্তি কাউন্টার রূপ নেয়

int foo(arg, counter) {
  if(counter > RECURSION_MAX) { return -1; }
  ...
  return foo(arg, counter + 1);
}

প্রতিবার আপনি যখন কল করবেন তখন আপনি কাউন্টারটি বাড়িয়ে তুলবেন। যদি কাউন্টারটি খুব বড় হয়ে যায়, আপনি ত্রুটিযুক্ত হয়ে যান (এখানে, -1 এর মাত্র একটি রিটার্ন, যদিও অন্যান্য ভাষায় আপনি ব্যতিক্রম ছুঁড়তে পছন্দ করতে পারেন)। ধারণাটি হ'ল প্রত্যাশার চেয়ে অনেক গভীর এবং সম্ভবত অসীম লুপটি যখন পুনরাবৃত্তি করতে গিয়ে খারাপ জিনিসগুলি ঘটে (স্মৃতি ত্রুটির বাইরে থাকে) না ঘটে।

তত্ত্বীয়ভাবে, আপনার এটির দরকার নেই। অনুশীলনে, আমি দুর্বল লিখিত কোড দেখেছি যা ছোট ত্রুটি এবং খারাপ কোডিং অনুশীলনের আধিক্যের কারণে এটি হিট হয়েছে (বহুবিবাহিত একত্রিত ইস্যু যেখানে পদ্ধতির বাইরে কিছু পরিবর্তিত হয় যা অন্য থ্রেডকে পুনরাবৃত্ত কলগুলির অসীম লুপে ফেলে দেয়)।


সঠিক অ্যালগরিদম ব্যবহার করুন এবং সঠিক সমস্যাটি সমাধান করুন। বিশেষত কোলাটজ কনজেকচারের জন্য, এটি xxcd উপায়ে সমাধান করার চেষ্টা করছেন বলে মনে হয় :

এক্সকেসিডি # 710

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

যদিও পুনরাবৃত্তির সমাধানটি জানা কোনও খারাপ জিনিস নয়, তবে এটিরও বুঝতে হবে যে বহুবার পুনরাবৃত্তি সমাধানটি ভাল । পুনরাবৃত্তির ক্ষেত্রে পুনরাবৃত্তির অ্যালগরিদমকে রূপান্তরিত করার বিভিন্ন উপায়ের পুনরাবৃত্তি থেকে পুনরাবৃত্তিতে যাওয়ার জন্য স্ট্যাক ওভারফ্লোতে দেখা যায় ।


1
ওয়েবে সার্ফ করার সময় আমি আজ সেই এক্সকেসিডি কার্টুনটি পেরিয়ে এসেছি। :-) র‌্যান্ডাল মুনরোর কার্টুনগুলি আনন্দিত।
লার্নকুরভে

@ লার্নকুরভে আমি এটি লেখা (এবং পোস্ট করা) শুরু করার পরে কোড সম্পাদনার সংযোজনটি লক্ষ্য করেছি। এর জন্য আপনার কি অন্যান্য কোডের নমুনার দরকার?

না কোনভাবেই না. এইটা ঠিক আছে. জিজ্ঞাসা করার জন্য একটি গুচ্ছ ধন্যবাদ!
লার্নকুরভে

আমিও এই কার্টুনটি যুক্ত করার পরামর্শ দিতে পারি: imgs.xkcd.com/comics/functional.png
এলেন

@ এস্পার্টাস আপনাকে ধন্যবাদ আমি এটি যুক্ত করেছি (কিছু উত্স

17

মনে রাখবেন যে ভাষা প্রয়োগের অবশ্যই লেজ পুনরাবৃত্তি অপ্টিমাইজেশন সমর্থন করে। আমি মনে করি না যে বড় জাভা সংকলকগুলি করে।

স্মৃতিচারণের অর্থ হ'ল আপনি কোনও গণনার ফলাফল প্রতিবার পুনরায় গণনার চেয়ে মনে রাখবেন, যেমন:

collatz(i):
    if i in memoized:
        return memoized[i]

    if i == 1:
        memoized[i] = 1
    else if odd(i):
        memoized[i] = 1 + collatz(3*i + 1)
    else
        memoized[i] = 1 + collatz(i / 2)

    return memoized[i]

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


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

10

আমি অবাক হয়েছি যে এখনও কেউ ট্রামোলিনিংয়ের কথা উল্লেখ করেনি। ট্রামপোলিন (এই অর্থে) এমন একটি লুপ যা পুনরাবৃত্তভাবে থাঙ্ক-রিটার্নিং ফাংশনগুলি (ধারাবাহিকতা পাস করার শৈলী )কে আহ্বান করে এবং স্ট্যাক-ওরিয়েন্টেড প্রোগ্রামিং ল্যাংগুলিতে লেজ-পুনরাবৃত্তি ফাংশন কলগুলি প্রয়োগ করতে ব্যবহার করা যেতে পারে।

এই স্ট্যাকওভারফ্লো প্রশ্নটি জাভাতে ট্রামপোলিনিংয়ের বিভিন্ন বাস্তবায়ন সম্পর্কে আরও কিছুটা বিশদে যায়: ট্রামপোলিনের জন্য জাভাতে স্ট্যাক ওভারফ্লো পরিচালনা


আমি এই মুহুর্তে পাশাপাশি চিন্তা করেছিলাম। ট্রাম্পোলাইনগুলি টেল কল অপ্টিমাইজেশান সম্পাদনের জন্য একটি পদ্ধতি, তাই লোকেরা এটি বলছে (প্রায়-সম্ভবত-সম্ভবত)। নির্দিষ্ট রেফারেন্সের জন্য +1।
স্টিভেন এভার্স

6

আপনি যদি এমন ভাষা এবং সংকলক ব্যবহার করছেন যা লেজ পুনরাবৃত্ত ফাংশনগুলি স্বীকৃতি দেয় এবং সেগুলি সঠিকভাবে পরিচালনা করে (যেমন "কলারটির পরিবর্তে কলারকে প্রতিস্থাপন করে") তবে হ্যাঁ, স্ট্যাকটি নিয়ন্ত্রণের বাইরে না বাড়ানো উচিত। এই অপ্টিমাইজেশানটি মূলত পুনরাবৃত্ত পদ্ধতিতে একটি পুনরাবৃত্তি পদ্ধতি হ্রাস করে। আমি মনে করি জাভা এটি করে না, তবে আমি জানি যে র্যাকেট এটি করে।

যদি আপনি পুনরাবৃত্তির পদ্ধতির পরিবর্তে পুনরাবৃত্ত পদ্ধতির সাথে যান, আপনি কলগুলি কোথা থেকে আসছে তা স্মরণ করার প্রয়োজনীয়তাটি বেশিরভাগ সরিয়ে ফেলছেন এবং স্ট্যাকের ওভারফ্লো হওয়ার সম্ভাবনাটি কার্যত নিরসন করছেন (যাইহোক পুনরাবৃত্তি কলগুলি থেকে)।

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


1
স্মৃতিচারণের প্রতিশ্রুতি দেওয়ার জন্য +1 পুনরাবৃত্ত পদ্ধতির ক্ষেত্রেও কার্যকর।
কার্ল বিলেফেল্ট

সমস্ত কার্যনির্বাহী প্রোগ্রামিং ভাষাতে টেল কল অপ্টিমাইজেশন রয়েছে।

3

আপনি এমন একটি গণনা তৈরি করতে পারেন যা পুনরাবৃত্তিটি প্রতিস্থাপন করবে ... অনুষদগুলি এটি করার জন্য একটি উদাহরণ রয়েছে ... (আমি কেবল উদাহরণের মধ্যে দীর্ঘকাল ব্যবহার করেছি বলে বড় সংখ্যার জন্য কাজ হবে না :-))

public class Faculty
{

    public static IEnumerable<long> Faculties(long n)
    {
        long stopat = n;

        long x = 1;
        long result = 1;

        while (x <= n)
        {
            result = result * x;
            yield return result;
            x++;
        }
    }
}

এমনকি এটি স্মৃতিচারণ না হলেও এইভাবে আপনি স্ট্যাকের ওভারফ্লো বাতিল করে দেবেন


সম্পাদনা


আমি আপনারা কারও মন খারাপ করে দিলে দুঃখিত। আমার একমাত্র উদ্দেশ্য ছিল কীভাবে কোনও স্ট্যাকের ওভারফ্লো এড়ানো যায় তার উপায় দেখানো। আমার সম্ভবত একটি দ্রুত লিখিত এবং রুক্ষ কোডের অংশের কেবল একটি ছোট্ট টুকরোটির পরিবর্তে একটি পূর্ণ কোড উদাহরণ লেখা উচিত ছিল।

নিম্নলিখিত কোড

  • পুনরাবৃত্তি এড়ানোর কারণে আমি প্রয়োজনীয় মানগুলি পুনরাবৃত্তভাবে গণনা করি।
  • ইতিমধ্যে গণনা করা মানগুলি সঞ্চিত এবং ইতিমধ্যে গণনা করা থাকলে পুনরুদ্ধার করা মেমোয়েজেশন অন্তর্ভুক্ত করে
  • এছাড়াও একটি স্টপওয়াচ অন্তর্ভুক্ত, যাতে আপনি দেখতে পারেন যে মেমোয়েজেশন সঠিকভাবে কাজ করে

... উম্ম ... আপনি এটি চালান তা নিশ্চিত করে নিন যে আপনি আপনার কমান্ড শেল উইন্ডোটি 9999 লাইনের একটি বাফার স্থাপন করেছেন ... সাধারণ 300 টি নীচের প্রোগ্রামের ফলাফলগুলি চালানোর পক্ষে যথেষ্ট হবে না ...

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;
using System.Timers;

namespace ConsoleApplication1
{
    class Program
    {
        static Stopwatch w = new Stopwatch();
        static Faculty f = Faculty.GetInstance();

        static void Main(string[] args)
        {
            Out(5);
            Out(10);
            Out(-5);
            Out(0);
            Out(1);
            Out(4);
            Out(29);
            Out(30);
            Out(20);
            Out(10000);
            Out(20000);
            Out(19999);
            Console.ReadKey();
        }

        static void Out(BigInteger n)
        {
             try
            {
                w.Reset();
                w.Start();
                var x = f.Calculate(n);
                w.Stop();
                var time = w.ElapsedMilliseconds;
                Console.WriteLine(String.Format("{0} ({2}ms): {1}", n, x, time));
            }
            catch (ArgumentException e)
            {
                Console.WriteLine(e.Message);
            }

            Console.WriteLine("\n\n");
       }
    }

আমি ফ্যাকাল্টি ক্লাসে * 1 স্ট্যাটিক ভ্যারিয়েবল "উদাহরণ" ঘোষণা করে একটি স্টোরকে একটি সিঙ্গলটন করে। আপনার প্রোগ্রামটি যতক্ষণ চলমান থাকবে ততক্ষণ আপনি যখনই ক্লাসের "গেটইনস্ট্যান্স ()" পাবেন তখনই উদাহরণটি পাবেন যা ইতিমধ্যে গণনা করা সমস্ত মান সঞ্চিত করেছে। * 1 স্থিতিশীল সাজানো তালিকা যা ইতিমধ্যে গণনা করা সমস্ত মান ধরে রাখবে

কনস্ট্রাক্টরে আমি ইনপুট 0 এবং 1 এর জন্য তালিকার 1 এর 2 টি বিশেষ মানও যুক্ত করব।

    public class Faculty
    {
        private static SortedList<BigInteger, BigInteger> _values; 
        private static Faculty _faculty {get; set;}

        private Faculty ()
        {
            _values = new SortedList<BigInteger, BigInteger>();
            _values.Add(0, 1);
            _values.Add(1, 1);
        }

        public static Faculty GetInstance() {
            _faculty = _faculty ?? new Faculty();
            return _faculty;
        }

        public BigInteger Calculate(BigInteger n) 
        {
            // check if input is smaller 0
            if (n < 0)
                throw new ArgumentException(" !!! Faculty is not defined for values < 0 !!!");

            // if value is not already calculated => do so
            if(!_values.ContainsKey(n))
                Faculties(n);

            // retrieve n! from Sorted List
            return _values[n];
        }

        private static void Faculties(BigInteger n)
        {
            // get the last calculated values and continue calculating if the calculation for a bigger n is required
            BigInteger i = _values.Max(x => x.Key),
                           result = _values[i];

            while (++i <= n)
            {
                CalculateNext(ref result, i);
                // add value to the SortedList if not already done
                if (!_values.ContainsKey(i))
                    _values.Add(i, result);
            }
        }

        private static void CalculateNext(ref BigInteger lastresult, BigInteger i) {

            // put in whatever iterative calculation step you want to do
            lastresult = lastresult * i;

        }
    }
}

5
প্রযুক্তিগতভাবে এটি পুনরাবৃত্তি হ'ল আপনি সম্পূর্ণ কোনও পুনরাবৃত্তি সরিয়ে নিলেন
রাচেট ফ্রিক

এটা যে :-) এবং এটি প্রতিটি হিসাব পদক্ষেপ মধ্যে পদ্ধতি ভেরিয়েবল মধ্যে ফলাফল memoizes
ইঙ্গো

2
আমি মনে করি আপনি স্মৃতিচারণকে ভুল বুঝেছেন, যখন অনুষদগুলি (100) কে প্রথমবার বলা হয় ফলাফলটি গণনা করে এটি একটি হ্যাশে সঞ্চয় করে ফিরে আসে, তারপরে আবার যখন বলা হয় তখন সঞ্চিত ফলাফলটি ফিরে আসে
ratchet freak

@jk। তার কৃতিত্বের জন্য, তিনি আসলে কখনও বলে না যে এটি পুনরাবৃত্ত হয়।
নীল

এটি স্মৃতিচারণ না হলেও এইভাবে আপনি স্ট্যাকের ওভারফ্লো বাতিল করে দেবেন
ইনগো

2

স্কেল হিসাবে, আপনি @tailrecএকটি পুনরাবৃত্ত পদ্ধতিতে টীকা যোগ করতে পারেন । এইভাবে সংকলকটি নিশ্চিত করে যে টেল কল অপ্টিমাইজেশনটি আসলে ঘটেছে:

সুতরাং এটি সংকলন করবে না (ঘটনামূলক):

@tailrec
def fak1(n: Int): Int = {
  n match {
    case 0 => 1
    case _ => n * fak1(n - 1)
  }
}

ত্রুটি বার্তাটি হ'ল:

স্কেল: @ টেইল্যারাক টীকাযুক্ত পদ্ধতি fak1 অনুকূল করতে পারেনি: এটিতে পুনরাবৃত্ত কল রয়েছে যা পুচ্ছ অবস্থানে নেই

অন্য দিকে:

def fak3(n: Int): Int = {
  @tailrec
  def fak3(n: Int, result: Int): Int = {
    n match {
      case 0 => result
      case _ => fak3(n - 1, n * result)
    }
  }

  fak3(n, 1)
}

সংকলন, এবং লেজ কল অপ্টিমাইজেশন স্থান গ্রহণ।


1

একটি সম্ভাবনা যা এখনও উল্লেখ করা হয়নি তা হ'ল পুনরাবৃত্তি হওয়া, কিন্তু সিস্টেম স্ট্যাক ব্যবহার না করেই। অবশ্যই আপনি নিজের গাদাটিও উপচে ফেলতে পারেন, তবে যদি আপনার অ্যালগরিদমকে সত্যিই কোনও ফর্ম বা অন্য কোনও আকারে ব্যাকট্র্যাকিংয়ের প্রয়োজন হয় (অন্যথায় কেন পুনরাবৃত্তি ব্যবহার করছেন?), আপনার কোনও বিকল্প নেই got

কিছু ভাষার স্ট্যাকলেস বাস্তবায়ন রয়েছে, যেমন স্ট্যাকলেস পাইথন


0

আরেকটি সমাধান হ'ল আপনার নিজের স্ট্যাকের অনুকরণ এবং সংকলক + রানটাইম বাস্তবায়নের উপর নির্ভর না করা। এটি কোনও সহজ সমাধান বা একটি দ্রুত সমাধান নয় তবে তাত্ত্বিকভাবে আপনি কেবল স্মৃতিশক্তি থেকে বাইরে থাকলে স্ট্যাকওভারফ্লো পাবেন।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.