सुरक्षित रूप से पारित करने के लिए ट्रोल टोल की गणना करें

12

Https://puzzling.stackexchange.com/q/626 से प्रेरित

अपने कारनामों में आप 7 पुलों की एक श्रृंखला पर पहुंचते हैं जिन्हें आपको पार करना होता है। प्रत्येक पुल के नीचे एक ट्रोल रहता है। पुल को पार करने के लिए, आपको पहले जितने केक ले जा रहे हैं, उसका प्रतिशत के रूप में ट्रोल को कई केक देने चाहिए। क्योंकि ये दयालु ट्रोल हैं, वे आपको निश्चित संख्या में केक वापस देंगे।

प्रत्येक दिन की शुरुआत में, स्थानीय ट्रोल राजा प्रतिशत केक कर निर्धारित करता है जो प्रत्येक यात्री को भुगतान करना होगा, और ट्रोल केक वापसी - प्रत्येक ट्रोल को यात्रियों को वापस देने वाले केक की संख्या।

आपका काम उस दिन दी गई शर्तों के लिए सभी 7 ट्रोल पुलों को पास करने के लिए आवश्यक न्यूनतम केक की गणना करना है।

मान लीजिये:

  1. दो इनपुट पैरामीटर: प्रतिशत केक टैक्स (0 से 100 तक पूर्णांक), और ट्रोल केक रिफंड।
  2. कोई भी नहीं, ट्रोल भी नहीं, एक केक को आंशिक रूप से दूसरे ट्रोल द्वारा खाया जाता है। यदि आप एक केक के एक अंश के साथ छोड़ दिया जाता है तो ट्रोल इसे प्राप्त करता है।
  3. यदि एक ट्रोल एक केक कर स्वीकार करता है, लेकिन फिर आपको सभी केक वापस देना होगा (पहले की तुलना में समान या कम केक के साथ छोड़ दिया जाता है), तो यह नाराज हो जाएगा और आपको और आपके केक खाएगा।
  4. हर ट्रोल को कम से कम एक पूरा केक रखना चाहिए।
  5. आप केवल अधिकतम 100 केक ले जा सकते हैं।
  6. आपको उस दिन को समाप्त करने की आवश्यकता है जहां आप वर्तमान में या सभी 7 पुलों के दूसरी तरफ स्थित हैं।

चुनौती:

वर्तमान दिन या शून्य के लिए यात्रा करने के लिए न्यूनतम संख्या में केक का उत्पादन करने के लिए एक पूरा कार्यक्रम लिखें यदि आज सुरक्षित रूप से यात्रा करना संभव नहीं है - तो आप यह देखने के लिए इंतजार करेंगे कि संख्या कल क्या है।

इनपुट को स्टडिन, कमांड लाइन तर्क या फ़ाइल इनपुट के रूप में पारित किया जाना चाहिए।

सबसे छोटा कोड (बाइट काउंट) जीतता है।

उदाहरण:

25% केक टैक्स, 2 ट्रोल केक रिफंड।


ट्रोल 1: (19 * 0.75) = 14.25 से पहले 19 केक ट्रोल 1 के
बाद शुरू करें: (14 + 2) = 16

ट्रोल 2 से पहले: (16 * 0.75) = 12 के
बाद ट्रोल 2: (12 + 2) = 14

आदि।

19 केक -> 16 -> 14 -> 12 -> 11 -> 10 -> 9 -> 8
18 केक -> 15 -> 13 -> 11 -> 10 -> 9 -> 8 -> 8 (नियम 3)

18 केक के लिए, अंतिम ट्रोल किसी भी केक रखने के लिए नहीं मिलेगा। इसलिए, 25% / 2 दिन के लिए केक की न्यूनतम संख्या 19 है।

input: 25 2
output: 19

उदाहरण 2:

90% केक टैक्स, 1 ट्रोल केक रिफंड

100 केक -> 11 -> 2 -> 1 (नियम 4)

तीसरा ट्रोल किसी भी केक को रखने के लिए नहीं मिला। इसलिए अधिकतम 90 केक के साथ शुरू करके 90% / 1 दिन की यात्रा करना संभव नहीं है।

input: 90 1
output: 0

डेटा

इनपुट और आउटपुट मानों का एक त्वरित ग्राफ एक साथ रखें। मुझे आश्चर्य था कि यह "सुचारू" (घंटी की तरह वक्र या समान) नहीं था; कई ध्यान देने योग्य द्वीप हैं।

डेटा चार्ट

रुचि रखने वालों के लिए डेटा। कॉलम को 5% अंतराल में विभाजित किया जाता है, पंक्तियाँ 1 केक रिफंड अंतराल की इकाइयां होती हैं (एक्सेल ने छवि को घुमाया)। आप देख सकते हैं कि 28 केक से अधिक धनवापसी नहीं हो सकती है।

27, 17, 13, 14, 15, 18, 20, 24, 53, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
47, 27, 20, 19, 19, 19, 24, 39, 48, 68, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0
67, 37, 28, 24, 23, 28, 27, 29, 50, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
87, 47, 33, 29, 27, 28, 31, 44, 37, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 57, 40, 34, 31, 29, 34, 34, 62, 74, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
0, 67, 48, 39, 35, 38, 37, 49, 57, 76, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 77, 53, 44, 39, 38, 47, 39, 59, 78, 94, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 87, 60, 49, 43, 39, 40, 54, 46, 80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 97, 68, 54, 47, 48, 44, 44, 71, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 73, 59, 51, 48, 47, 59, 73, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 80, 64, 55, 49, 51, 49, 68, 86, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 88, 69, 59, 58, 54, 64, 70, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 93, 74, 63, 58, 57, 54, 57, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 100, 79, 67, 59, 67, 69, 82, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 84, 71, 68, 60, 59, 77, 94, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 89, 75, 68, 64, 74, 79, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 94, 79, 69, 67, 64, 66, 98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 99, 83, 78, 71, 79, 91, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 87, 78, 74, 69, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 91, 79, 77, 84, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 95, 88, 87, 74, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 99, 88, 80, 89, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 89, 84, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 98, 87, 94, 97, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 98, 91, 84, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 99, 94, 99, 86, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 97, 89, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
code-golf 
— समुदाय
स्रोत
अच्छी बात। इसे सरलता के लिए पूरा कार्यक्रम बनाएं। इनपुट तब तक निर्दिष्ट किया जा सकता है जब तक आप उसे तब तक फिट देखते हैं जब तक वह हार्ड-कोडेड (अपडेटेड चुनौती) न हो।
CJam में ब्रूट-फोर्स के लिए यह एक अच्छी पहेली है। मैं कल के आसपास ऐसा करूँगा
bah, यही कारण है कि c # में अच्छी चीजें नहीं हो सकती हैं
नियम 2 एक केक के केवल एक अंश को प्राप्त करने वाले ट्रोल की संभावना को बाहर करने के लिए लगता है, जिसे धारणा को 4 निरर्थक बनाना चाहिए। फिर भी आप उदाहरण 2 में कहते हैं कि तीसरे ट्रोल में केवल 0.8 केक मिलेंगे।
— डेनिस
कल्पना में झमेले हैं। में 25 211 केक मामला है, आप ट्रोल 2.75 केक देने के लिए और वापस 2 मिलता है तो ट्रोल रहता है .75 (+। 25) और तुम जीवित रहते हैं। में 90 12 केक मामला है, आप ट्रोल 1.8 देने के लिए और इसलिए ट्रोल रहता है .8 वापस 1 मिलता है (+। 2) लेकिन आप मर जाते हैं।
— ट्विनइट

जवाबों:

6

CJam, 46 43 41 39 38 36 33 बाइट्स

100:H,{)_7{ea:i~H@m2$*H/+@;}*>}#)

ARGV के माध्यम से इनपुट।

एक ऑनलाइन दुभाषिया है, लेकिन दुर्भाग्य से यह कमांड-लाइन तर्कों का समर्थन नहीं करता है। परीक्षण के लिए, आप इसे इस संस्करण के साथ STDIN से नकल कर सकते हैं:

rr]:A;
100:H,{)_7{A:i~H@m2$*H/+@;}*>}#)

ARGV- आधारित संस्करण की व्याख्या:

100:H                                  "Push a 100 and save it in H.";
     ,                                 "Create a range (as an array) from 0 to 99.";
      {                       }#       "Find the first index in [0,1,2,...,99] for which the
                                        block produces a truthy (non-zero) value.";
       )_                              "Increment and duplicate the current array element.";
         7{                }*          "Execute the block seven times.";
           ea:i                        "Push the command-line arguments as an array of strings
                                        and convert each element to an integer";
               ~                       "Unwrap the array.";
                H@                     "Push a 100 and rotate the stack to pull up
                                        the first command line argument.";
                  m                    "Subtract (from 100).";
                   2$                  "Copy the last iterations result.";
                     *H/               "Multiply and divide by 100, deducting tax.";
                        +              "Add the refund.";
                         @;            "Rotate top three stack elements, and discard the one that 
                                        has been pulled to the top. This always leaves the last 
                                        two results on the stack.";

                             >         "Make sure that the last result was less than the second 
                                        to last. Yields 0 or 1.";
                                )      "After the # search completes, we'll get -1 if no such 
                                        index exists, or one less than the desired number if it 
                                        does, so we can just increment.";

कार्यक्रम के अंत में स्टैक की सामग्री स्वचालित रूप से मुद्रित होती है।

— मार्टिन एंडर
स्रोत
आपका कोड 55 2(के 0बजाय 100) और 56 5(के 98बजाय ) के लिए गलत परिणाम प्रस्तुत करता है 94। इसका कारण यह है है 100_0.55*-iऔर 25_0.56*-iचल बिन्दु अस्पष्टता को गिरावट शिकार। जहाँ तक मैं बता सकता हूँ, जोड़े 31 24, 31 25, 33 21, 33 22, 33 23, 35 10, 35 12, 35 15, 35 16, 35 27, 56 1, 57 4गलत परिणाम भी देते हैं।
— डेनिस
1
@ डेनिस तय, धन्यवाद!
— मार्टिन एंडर
@ डेनिस कि वास्तव में एक बाइट को बचाया। मेरी इच्छा है कि सीजेएम के पास क्लोजर थे, तो मैं शुरुआत में एक ब्लॉक को परिभाषित कर सकता था जो कर कटौती करता है, और इसका उपयोग दो चर का उपयोग करने के बजाय करता है। शायद मैं STDIN के बजाय ARGV का उपयोग करके कुछ बचा सकता हूं, मुझे देखने दें।
— मार्टिन एंडर
5

CJam, 44 40 38 37 35 बाइट्स

l~U100:M),{{_M5$-*M/3$+_@<*}7*}=]W=

या कमांड लाइन तर्कों और {}#चाल का उपयोग करते समय , 33 बाइट्स :

100:M,{){_ea:i~M@-@*M/+_@<*}7*}#)

इस एक को अपने मुख्य के रूप में नहीं रखना {}#दृष्टिकोण के रूप में मार्टिन के जवाब से प्रेरित है।

उदाहरण रन:

इनपुट:

25 2

आउटपुट:

19

एक और:

इनपुट:

15 14

आउटपुट:

100

यह काम किस प्रकार करता है

l~                       "Read the two numbers, swap and convert tax to double";
  U100:M),               "Push 0 and [0, 1, ... 100] to stack, storing 100 in M";
          {  ...  }=     "Run this code for each element until top stack element is 1";
           {...}7*       "Run this code block 7 times";
_                        "Copy the array element";
  M5$                    "Push 100 and a copy tax % to stack";
     -*                  "Number = (100 - tax %) * Number";
       M/                "Integer divide the number by 100";          
         3$+             "Add refund";
            _@<*         "Convert to 0 if refunded number > before tax one";
                    ]W=  "Take the last element of the stack";

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत
और अब जो बचा है वह डेनिस के साथ आने और हम दोनों को हरा देने के लिए इंतजार करने का है। ;)
— मार्टिन एंडर
CJam में नहीं;) (उम्मीद है)
— ऑप्टिमाइज़र
मुझे वास्तव में यह ]W=ट्रिक पसंद है , लेकिन अब तक, हर तरह से मैं इसे इस्तेमाल करने की कोशिश करता हूं, मैं एक ही कैरेक्टर काउंट को खत्म करता हूं।
— मार्टिन एंडर
@ मार्टिनबटनर - हाँ, मुझे भी।
— ऑप्टिमाइज़र
1
@ डेनिस - 2 बाइट्स छोटे कोड के अतिरिक्त लाभ के साथ अब काम करना चाहिए: डी
— ऑप्टिमाइज़र
4

एपीएल (39)

T R←⎕⋄⊃Z/⍨{⍵(⊢×>)R+⌊⍵×1-T÷M}⍣7¨Z←⍳M←100

स्पष्टीकरण:

  • T R←⎕: कीबोर्ड से दो नंबर पढ़ें और उन्हें T(कर) और R(वापसी) में स्टोर करें ।
  • Z←⍳M←100: नंबर को 100इन Mमें और सभी नंबरों 1को 100अंदर से स्टोर करें Z।
  • {... }⍣7¨: प्रत्येक तत्व के लिए Z, निम्न फ़ंक्शन को 7 बार चलाएं:
    • R+⌊1-T÷M: गणना करें कि कितने केक का भुगतान करने की आवश्यकता है,
    • ⍵(⊢×>): उस राशि को 1 से गुणा करें यदि ट्रोल शुरू होने से अधिक केक के साथ समाप्त होता है, या नहीं तो 0 से।
  • ⊃Z/⍨: प्रत्येक तत्व के लिए Z, उस फ़ंक्शन द्वारा दी गई संख्या से इसे दोहराएं। (इसलिए सभी नंबर जिसके लिए फ़ंक्शन 0गायब हो गया है।) फिर उस सूची से पहले आइटम का चयन करें। यदि सूची खाली हो गई, तो यह देता है 0।
— मारीनस
स्रोत
3

सी, 83 बाइट्स

int cake(int perc_taken, int given_back)
{
    int startcake = floor(100.f/perc_taken*given_back+1);
    for(int i = 0; i < 6; i++)
    {
        startcake = ceil((startcake-given_back) * 100.f/(100 - perc_taken));
    }
    return startcake;
}

यदि यह काम करता है, तो यह केवल 1 से 100 तक ही नहीं, सभी संभव शुरुआत के लिए काम करता है।

संपादित करें: यह काम करता है। golfed:

n(int p,int g) {int s=100./p*g+1,i=0;for(;i++<6;){s=ceil((s-g)*100./(100-p));}return s;}

'अधिकतम 100 केक' की सीमा के साथ:

n(int p,int g) {int s=100./p*g+1,i=0;for(;i++<6;){s=ceil((s-g)*100./(100-p));}return s>100?0:s;}

91 बाइट्स।

— Gerwin
स्रोत
मुझे लगता है कि यह कल्पना का एक महत्वपूर्ण हिस्सा है कि समाधान शून्य हो जाता है यदि आपको शुरुआत में 100 से अधिक केक चाहिए।
— मार्टिन एंडर
1

सी ++ - 202 चार्ट

हमेशा की तरह, मेरे C ++ ने सबसे बुरा किया:

#include<iostream>
int main(){double p,g,c=1,i,r,t;std::cin>>p>>g;for(;c<101;c++){r=c;for(i=0;i<7;i++){t=(int)(r*(1-(p/100))+g);if(t>=r){r=-1;break;}r=t;}if(r!=-1)break;}r!=-1?std::cout<<c:std::cout<<0;}
1

एपीएल, ३६

x y←⎕⋄101|1⍳⍨y<x×{y+⍵-⌈⍵×x}⍣6⍳x÷←100

व्याख्या

ध्यान दें कि "केक थ्रेसहोल्ड" है। कर की दर xऔर धनवापसी के लिए y, आपको y÷xअगले पुल को पारित करने के लिए कड़ाई से अधिक की आवश्यकता होगी ।

x y←⎕इनपुट लें और x(टैक्स) को असाइन करें और y(वापसी) 100 से
⍳x÷←100विभाजित करें x, और फिर 1 से 100 की एक सरणी उत्पन्न करें

{y+⍵-⌈⍵×x}⍣66 बार "पास ब्रिज" फ़ंक्शन को कॉल करें:
⌈⍵×xआपके पास जितने केक हैं, उतनी बार टैक्स दर, राउंड अप (आपके द्वारा भुगतान की गई राशि)
⍵-आपके द्वारा दिए गए केक की संख्या से घटाएं।
y+धनवापसी जोड़ें

यदि आप 1 ~ 100 केक के साथ शुरू करते हैं तो 6 पुलों को पार करने के बाद आपके द्वारा छोड़े गए केक की संख्या दिखाते हुए आपको 100-तत्व की सरणी मिलती है। यह देखने के लिए कि क्या आप पिछले पुल को पार कर सकते हैं, जाँच करें कि क्या आप दहलीज से ऊपर हैं y÷x। वैकल्पिक रूप से:
x×सरणी को x
y<चेक से गुणा करें यदि अधिक से अधिक होy

अंत में, (सत्य)
1⍳⍨की पहली घटना के सूचकांक का पता लगाएं 1, 101अगर
101|मॉड 101 नहीं मिला है

— TwiNight
स्रोत
1

सी 128

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

t,r,j,k,l,p;main(i){for(scanf("%d%d",&t,&r),i=101;k=--i;){for(j=8;--j>0;)(p=r+k*(100-t)/100)<k?k=p:j=0;j?0:l=i;}printf("%d",l);}

Ungolfed

int t,r,j,k,l,p;
main(int i)
{
    for(scanf("%d%d",&t,&r),i=101;k=--i;)
    {
        for(j=8;--j>0;)
        {
            if((p=r+k*(100-t)/100)<k)
                k=p;
            else
                j=0;
        }
        j?0:l=i;
    }
    printf("%d",l);
}
— Alchymist
स्रोत
आप क्या संकलक का उपयोग कर रहे हैं?
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.