भोजन की सबसे अधिक कैलोरी-यहां तक ​​कि व्यवस्था को चुनना


9

मान लीजिए मैं एक दिन में पांच भोजन खाता हूं, और चूंकि सप्ताह में सात दिन होते हैं, मेरे पास प्रत्येक भोजन के सात व्यंजनों के लिए, कुल 35 व्यंजनों के लिए व्यंजन हैं। प्रत्येक रेसिपी में कैलोरी की गिनती होती है। प्रत्येक दिन प्रति भोजन एक नुस्खा होना चाहिए, और प्रत्येक नुस्खा एक विशेष भोजन के लिए तय किया गया है (जैसे कि आप रात के खाने के लिए पेनकेक्स नहीं कर सकते हैं)। सभी 35 व्यंजनों को समाधान में होना चाहिए, इसलिए सप्ताह के दौरान एक नुस्खा दोहराया नहीं जा सकता है।

मैं भोजन की व्यवस्था ढूंढना चाहता हूं जो प्रति दिन सबसे अधिक कैलोरी की गिनती देगा - अर्थात, मैं दिन-प्रतिदिन खपत कुल कैलोरी में अंतर को कम करना चाहता हूं।

यह एक होमवर्क समस्या नहीं है - यह वास्तव में सच है! मैं जानवर-बल की तुलना में बेहतर दृष्टिकोण के साथ नहीं आ सकता, और 7! ^ 4 संयोजन हैं, जो बहुत कुछ है।



स्पष्ट करने के लिए - आपके पास "दिन के पहले भोजन" के लिए 7 रेसिपी, "2 भोजन के लिए", "3" भोजन के लिए 7 और इसी तरह के अन्य 7 व्यंजन हैं? क्या आप कभी "दिन के अंतिम भोजन" के लिए एक "पहला भोजन" नुस्खा प्रदान करेंगे? (एक और तरीका रखो, क्या आप रात के खाने के लिए पेनकेक्स
परोसेंगे

सही बात; तुम नहीं करोगे।
डेफुलकेन

2
क्या सभी 35 व्यंजनों में अलग-अलग कैलोरी मायने रखती है? ! आप पास 10 या 50 कैलोरी कैलोरी की गिनती के दौर करना हो तो 7 ^ 4 आसानी से 3 हो सकता है ^ 4 - जो जानवर बल के माध्यम से आसानी गणना कर सका है
दान Pichelman

2
यार, तुम बहुत ज्यादा खाते हो, 5 भोजन / दिन खाने से तुम्हारा वजन अधिक हो जाएगा।
पीटर बी

जवाबों:


1

अपनी समस्या के लिए अधिक औपचारिक दृष्टिकोण बनाने के लिए:

आपके पास प्रत्येक 7 संख्याओं की 5 सूचियाँ हैं। आपको प्रत्येक 5 संख्या की 7 सूचियों का निर्माण करने की आवश्यकता है, और उस समाधान को ढूंढें जिसमें सूची के बीच न्यूनतम अंतर हो, जिसमें संख्याओं का सबसे बड़ा योग हो और सबसे छोटा।

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

जो भी समाधान आप पाते हैं, जब आप इसे "अब तक का सबसे अच्छा पाया" के रूप में पंजीकृत करते हैं, तो अपने मीट्रिक के बारे में उसके प्रदर्शन को दर्ज करें (मेरा मानना ​​है कि यह न्यूनतम-अधिकतम है)। फिर, यदि कोई समाधान शाखा स्पष्ट रूप से सड़क से दूर है, तो इसे रोकना बंद करें। प्रोटिप: गैर-निर्मित दिनों में कम से कम कैलोरी की मात्रा होगी जो सभी शेष भोजन का औसत है। तो, कल्पना कीजिए कि आपके पास ऐसी सूचियां हैं जो [10, 2, 2, 1, 1, 0, 0]सभी 5 भोजन के लिए हैं, और आपने दिन के लिए प्रत्येक भोजन पर समाधान 10 का निर्माण किया है। आप जानते हैं कि शेष दिन प्रति दिन औसतन 5 कैलोरी होंगे, इसलिए अंतर कम से कम 45 होगा और इसलिए यदि आपने पहले कहा था, का कहना है max - min = 10, आप किसी भी आगे जाने की जरूरत नहीं है। आप सीधे दिन 1 के लिए एक और मेनू आज़माएंगे।


यह कोई बिन समस्या नहीं है। एक बिन समस्या डिब्बे की निश्चित संख्या नहीं है और प्रति बिन वस्तुओं की निश्चित संख्या नहीं है।
पापाराज़ो

हाँ आप सही है। ठीक है कि ठीक है।
आर्थर हैवेलिस

0

यह सिर्फ एक हैक है, लेकिन यह आपको
केवल 3 भोजन बंद कर देगा
आप मूल रूप से भोजन को फ्लॉप करते हैं यदि यह दो दिन औसत C # के करीब बनाता है

एक बेहतर तरीका यह होगा कि फ्लॉप पर एक बुलियन को लौटाया जाए और पूरा होने तक इसे पुन: व्यवस्थित किया जाए।

फ्लॉप हो सकता है होशियार। आप लंच और डिनर को फ्लॉप करने के लिए नाश्ता नहीं करने की स्थिति में हो सकते हैं। शायद हार्ड कोड क्रमपरिवर्तन हो। यह एक तरह की तरह है जहां सॉर्ट के बजाय फ्लॉप मान है।

public static void MealEven()
{
    List<Day> Days = new List<Day>();
    Random rnd = new Random();
    decimal sum = 0;
    for(int i = 0; i<7; i ++)
    {
        int b = rnd.Next(100) + 40;
        int l = rnd.Next(100) + 60;
        int d = rnd.Next(100) + 80;
        Meal br = new Meal(enumMeal.b, b);
        Meal lu = new Meal(enumMeal.l, l);
        Meal di = new Meal(enumMeal.d, d);
        Day day = new Day(br, lu, di);
        Days.Add(day);
        sum += day.Calories;
    }
    decimal avg = sum / 7;
    foreach (Day d in Days.OrderBy(x => x.Calories))
        System.Diagnostics.Debug.WriteLine(d.Calories);
    System.Diagnostics.Debug.WriteLine("");

    Day low;
    Day high;
    Day lowLast = null;
    Day highLast = null;
    int count = 0;
    while (true)
    {   // first do high and low
        low = Days.OrderBy(x => x.Calories).FirstOrDefault();
        high = Days.OrderByDescending(x => x.Calories).FirstOrDefault();
        if (lowLast != null && lowLast == low && highLast == high)
            break;
        if (count > 1000)
            break;
        lowLast = low;
        highLast = high;
        count++;               
        Flop(ref high, ref low);
    }
    foreach (Day d in Days.OrderBy(x => x.Calories))
        System.Diagnostics.Debug.WriteLine("{0} {1} {2} {3}", d.Calories, d.B.Calories, d.L.Calories, d.D.Calories);
    System.Diagnostics.Debug.WriteLine("");

    // day a one on one pass
    for (int i = 0; i < 7; i ++)
    {
        for (int j = 0; j < 7; j++)
        {
            if (i == j)
                continue;
            Day d1 = Days[i];
            Day d2 = Days[j];
            Flop(ref d1, ref d2);
        }
    }

    foreach (Day d in Days.OrderBy(x => x.Calories))
        System.Diagnostics.Debug.WriteLine("{0} {1} {2} {3}", d.Calories, d.B.Calories, d.L.Calories, d.D.Calories);
    System.Diagnostics.Debug.WriteLine("");
}
public static void Flop (ref Day high, ref Day low)
{
    if(low.Calories > high.Calories)
    {
        int hold = low.B.Calories;
        low.B.Calories = high.B.Calories;
        high.B.Calories = hold;

        hold = low.L.Calories;
        low.L.Calories = high.L.Calories;
        high.L.Calories = hold;

        hold = low.D.Calories;
        low.D.Calories = high.D.Calories;
        high.D.Calories = hold;

    }
    decimal avg = (low.Calories + high.Calories) / (decimal)2;
    int bDiff = (high.B.Calories - low.B.Calories) < 0 ? 0 : (high.B.Calories - low.B.Calories);
    int lDiff = high.L.Calories - low.L.Calories < 0 ? 0 : (high.L.Calories - low.L.Calories);
    int dDiff = high.D.Calories - low.D.Calories < 0 ? 0 : (high.D.Calories - low.D.Calories);
    // only flop is one does not go past the average  
    if (bDiff > 0 && ((low.Calories + bDiff) < avg || (high.Calories - bDiff) > avg))
    {
        int hold = low.B.Calories;
        low.B.Calories = high.B.Calories;
        high.B.Calories = hold;
    }
    if (lDiff > 0 && ((low.Calories + lDiff) < avg || (high.Calories - lDiff) > avg))
    {
        int hold = low.L.Calories;
        low.L.Calories = high.L.Calories;
        high.L.Calories = hold;
    }
    if (dDiff > 0 && ((low.Calories + dDiff) < avg || (high.Calories - dDiff) > avg))
    {
        int hold = low.D.Calories;
        low.D.Calories = high.D.Calories;
        high.D.Calories = hold;
    }
}
public enum enumMeal {b, l, d};
public class Day
{
    public Meal B { get; set; }
    public Meal L { get; set; }
    public Meal D { get; set; }
    public Decimal Calories { get { return (Decimal)(B.Calories + L.Calories + D.Calories); } }
    public Day (Meal b, Meal l, Meal d )
    {
        B = b;
        L = l;
        D = d;
    }
}
public class Meal
{
    public enumMeal Type { get; set; }
    public int  Calories { get; set; }
    public Meal (enumMeal meal, int calories)
    {
        Type = meal;
        Calories = calories;
    }
}   

1
क्या कोई ऐसा तरीका है जिससे आप अधिक उपयोगी / प्रबुद्ध होने का उत्तर प्राप्त करने के लिए कोड में स्पष्टीकरण या कुछ टिप्पणी जोड़ सकते हैं? मुझे लगता है कि मैं समझता हूं कि वहां क्या चल रहा है लेकिन मुझे यकीन नहीं हो रहा है।
एडम वेल्स

@AdamWells मैंने कुछ टिप्पणियां जोड़ीं। आपको क्या समझ नहीं आया?
पेपराराज़ो

यह सिर्फ फ्लॉप के साथ क्लिक नहीं किया। अब समझ में आता है, धन्यवाद!
एडम वेल्स

मैं यह भी नहीं बता सकता कि क्या यह जावा कोड है। क्या यह ? क्षमा करें, मेरे जावा और Cx दिन मुझसे बहुत पीछे हैं। वैसे भी मुख्य कहाँ है?
आर्थर हैवेलिस

@ArthurHavlicek कोड C #। वे एक समान दिखते हैं।
पापाराजो

0

पहले प्रति भोजन औसत कैलोरी की गणना करें। फिर प्रति दिन औसत रंगीन गणना करें। ये ऐसे मेट्रिक्स होंगे जिन्हें कोई भी माप सकता है। अगला भोजन छांटें।

अब केवल उच्चतम और सबसे कम भोजन को छाँट से बाहर निकालें। यदि कोई भोजन उसी समय स्लॉट में होता है, तो आपको अगले समय तक या उच्चतम पर जाना होगा जब तक कि आप उस समय स्लॉट (रात के खाने, आदि) में भोजन नहीं पाते हैं। इसे पहले 4 भोजन (हाय / कम) के लिए करें। 5 वें भोजन पर, एक ऐसा भोजन चुनें जो आपको औसत से सबसे अधिक मिलता है। 5 वीं भोजन को एक अलग बाल्टी में सहेजें। कुल्ला और 7 बार दोहराएं।

यह आपके भोजन का प्रारंभिक सेट होगा। यह सुंदर भी होगा। यदि आप इष्टतम वितरण चाहते हैं तो 5 वें भोजन के साथ कुछ और परिशोधन किया जा सकता है।

5 वीं भोजन की बाल्टी के माध्यम से जाओ और भोजन को 5 दिनों के बीच अदला-बदली करके देखें कि क्या भोजन आगे भी चलता है। आपको अभी भी एक ही नियम (प्रति समय एक से अधिक भोजन नहीं) लागू करना होगा। एक या अधिक सेट भी हो सकता है और नहीं भी। पहले गणना औसत का उपयोग करके देखें कि सुधार हुआ है या नहीं। पहले 4 भोजन उच्च / निम्न के आधार पर तय किए जाने के बाद से बहुत कम संयोजन होंगे।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.