मेरा माइक्रोवेव कब तक चलना चाहिए?

33

मुझे भूख लगी है। चलो माइक्रोवेव कुछ। 1 और 4 अंकों के बीच एक संख्यात्मक इनपुट को देखते हुए, माइक्रोवेव चलाने वाले सेकंड की संख्या को आउटपुट करें।

विवरण

यदि उपयोगकर्ता कुछ सेकंड या मिनटों के संयोजन में इनपुट कर रहा है तो चाल का पता चल रहा है। लोगों और दसियों स्थानों को सेकंड के रूप में व्याख्या की जानी चाहिए और सैकड़ों और हजारों स्थानों पर मिनट होने चाहिए। उदाहरण के लिए, मान 1234को 12 मिनट, 34 सेकंड और 987698 मिनट, 76 सेकंड होना चाहिए। टंकण 130और 90दोनों का परिणाम 90 सेकंड के एक कुक समय में होना चाहिए।

यहां कुछ अन्य इनपुट और आउटपुट दिए गए हैं:

  • 1 = 1
  • ११ = ११
  • 111 = 71
  • 1111 = 671
  • 9 = 9
  • 99 = 99
  • 999 = 639
  • 9999 = 6039

नियम

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है। मानक खामियों की अनुमति नहीं है। 1 से 9999 तक किसी भी पूर्णांक इनपुट को दिए जाने पर जीतने वाली प्रविष्टि को सही उत्तर देना होगा।

code-golf  number 
— एंड्रयू ब्रूज़ा
स्रोत
@WheatWizard, मैं इस प्रश्न को संपादित करके खुश हूं। क्या आपके पास विवरण अनुभाग में मुझे क्या कहना चाहिए? शायद मैं इस वाक्य को स्पष्ट कर सकता था: "लोगों और दसियों स्थानों को सेकंड के रूप में व्याख्या की जानी चाहिए और सैकड़ों और हजारों स्थानों पर मिनट होना चाहिए।"
— एंड्रयू ब्रूजा
@WheatWizard मैंने अभी और विवरण जोड़ा है, मुझे पता है कि अगर आपको लगता है कि मुझे और जोड़ना चाहिए।
— एंड्रयू ब्रूजा
उस इनपुट के साथ काम करता है 9876?
— एंड्रयू ब्रूजा
1
अजीब बात है, मैं इस सटीक चुनौती को सैंडबॉक्स करने वाला था
— FlipTack
आउटपुट किसके लिए होगा 190?
— OldBunny2800

जवाबों:

9

जाप , 6 बाइट्स

ìL ì60

इसे ऑनलाइन टेस्ट करें! ìLबेस -100 में ì60धर्मान्तरित , और बेस 60 में वापस धर्मान्तरित, जिसके परिणामस्वरूप floor(n/100)*60 + n%100। इसके अलावा घंटे ( 10000 -> 3600, एक घंटे में सेकंड की संख्या) के साथ काम करता है ।

— ETHproductions
स्रोत
1
वास्तव में मेरे पास क्या था :)
— झबरा
7

सी, सी ++, जावा, सी #, डी: 36 बाइट्स

डी: 35 बाइट्स

C: 28 बाइट्स

पहली बार मैं एक जवाब है कि कम है!

int r(int i){return i/100*60+i%100;}

गोल्फ टेम्प्लेट सिस्टम के कारण D का विशेष अनुकूलन हो सकता है:

T r(T)(T i){return i/100*60+i%100;}

C का निहितार्थ int के साथ एक विशेष अनुकूलन है:

r(i){return i/100*60+i%100;}

परीक्षण करने के लिए कोड

में सी (शामिल करने के लिए है stdio.h):

int main() {
    int testArr[] = {1,11,111,1111,9,99,999,9999};
    for(int i=0;i<8; ++i) {
        printf("%d = %d\n",testArr[i],r(testArr[i]));
    }
    return 0;
}

TIO लिंक

में सी ++ (शामिल करने के लिए है iostream):

int main() {
    std::initializer_list<int> testList{
        1,11,111,1111,9,99,999,9999
    };

    for (auto x : testList) {
        std::cout << r(x) << '\n';
    }
}

इसे ऑनलाइन आज़माएं!

में जावा :

public class MainApp {

    int r(int i){return i/100*60+i%100;}

    public static void main(String[]a) {
        MainApp m = new MainApp();
        int testArr[] = new int[]{
                1,11,111,1111,9,99,999,9999
        };

        for (int v : testArr) {
            System.out.println(v + " = " + m.r(v));
        }
    }
}

इसे ऑनलाइन आज़माएं!

में सी #

class Program {
    int r(int i){return i/100*60+i%100;}
    static void Main(string[] args) {
        var p = new Program();
        int[] testArr = new int[8]
        {
            1,11,111,1111,9,99,999,9999
        };
        foreach(int a in testArr) {
            Console.WriteLine(a + " = " + p.r(a));
        }
    }
}

में डी (आयात करने के लिए है std.stdio) (वास्तव में, मैं पता नहीं कैसे डी में सरणियों का उपयोग करना):

void main() {
    int[] arr = [1,11,111,1111,9,9,999,9999];
    for(int i = 0; i < arr.length; i++)
        writeln(arr[i]," = ",r(arr[i]));
}

TIO लिंक

— HatsuPointerKun
स्रोत
D परीक्षण कोड इस TIO का पाद हो: tio.run/… , और मुझे लगता है कि आपने टेम्पलेट प्रणाली सीख ली है :)। ( foreachडी में एक है, मैं सिर्फ यह भूल गया कि इसे
— दु: ख के साथ
C को C89 इम्प्लांट -इंट का उपयोग करके 28 बाइट्स के लिए गोल्फ किया जा सकता है ।
— pizzapants184
आपको इन सभी को अलग-अलग उत्तरों के रूप में पोस्ट करना चाहिए।
— एमडी एक्सएफ
6

पायथ - 9 8 बाइट्स

इनपुट को बेस 100 में परिवर्तित करता है, फिर इंटरप्रिट करता है कि बेस 60 नंबर है।

ijQ*TT60

टेस्ट सूट ।

— Maltysen
स्रोत
6

टीआई-बेसिक (83 श्रृंखला), 8 बाइट्स

Ans-40int(sub(Ans

OS संस्करण 1.15 या उच्चतर की आवश्यकता है।

— मिशा लावरोव
स्रोत
6

डीसी , 10 बाइट्स

?9A~r60*+p

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण: डीसी में जब आप sth धक्का। ढेर पर यह शीर्ष पर चला जाता है

?         # read and push the input number on the stack
9A        # push 100: 9 * 10^1 + A[10] * 10^0 :D
~         # divide 2nd nr. by the top nr., push quotient, then remainder
r60*      # swap top 2 nr., then multiply the top by 60
+p        # add top 2 nr., then print result
— seshoumara
स्रोत
5

बैश बीसी + सेड, 30 28 बाइट्स

-2 बाइट्स @seshoumara को धन्यवाद ।

bc<<<0`sed 's/..\?$/*60+&/'`

इसे ऑनलाइन आज़माएं!

स्टड से इनपुट लेता है। अधिक रचनात्मक दृष्टिकोण के लिए चला गया: *60+अंतिम 1 या 2 अंकों से पहले आवेषण , और 0केवल 1 या 2 अंकों के साथ इनपुट के लिए खाते की शुरुआत के लिए प्रीपेन्ड करता है। परिणाम फिर पास किया जाता है bc।

— जस्टिन मेरिनर
स्रोत
1
यदि आप हटाते हैं -rऔर उपयोग करते हैं \?, तो आप 2 बाइट्स को ढीला कर सकते हैं।
— शीशमारा
3

सी (जीसीसी) , 50 बाइट्स

t;f(){scanf("%d",&t);printf("%d",t%100+t/100*60);}

इसे ऑनलाइन आज़माएं!

— gastropner
स्रोत
2
— स्टीडबॉक्स
25 बाइट्स f(i,x){x=i/100*60+i%100;}
— जियाको गारबेलो
21 बाइट्स f(i,x){x=i-i/100*40;}
— केविन क्रूज़सेन
2

जावास्क्रिप्ट, 21 बाइट्स

a=>(a/100^0)*60+a%100

इसे ऑनलाइन आज़माएं!

अंडा की चाल का उपयोग करके 4 बाइट्स बचाएं - a- (a / 100 ^ 0) * 40
— IanF1
1
@ IanF1। धन्यवाद, लेकिन मुझे लगता है कि यह सचमुच उनके विचार को चुरा रहा होगा।
हां आप ठीक हैं। बहुत उत्साही, माफ करना।
— IanF1
3
@ ThePirateBay आप वास्तव में तब तक आपके नाम पर नहीं रहते हैं;)
— kamoroso94
2

जे , 12 बाइट्स

-40*&<.%&100

यह ओव्स पायथन 2 समाधान जे में व्यक्त किया गया है। इसमें एक हुक और एक कांटा शामिल है:

┌─┬───────────────────────┐
│-│┌──┬────────┬─────────┐│
│ ││40│┌─┬─┬──┐│┌─┬─┬───┐││
│ ││  ││*│&│<.│││%│&│100│││
│ ││  │└─┴─┴──┘│└─┴─┴───┘││
│ │└──┴────────┴─────────┘│
└─┴───────────────────────┘

       %&100  - divides the number by 100
   *&<.       - finds the floor of the left argument and multiplies it to the left arg.
 40           - 
-             - subtracts the result of the above fork from the input

इसे ऑनलाइन आज़माएं!

— गैलेन इवानोव
स्रोत
1
के रूप में ही बाइट गिनती 60#.0 100#:]।
— फ्राउनफ्रॉग
@FrownyFrog - आपका समाधान प्रेटियर, चीयर्स दिखता है!
— गैलेन इवानोव
2

भूलभुलैया , 19 बाइट्स

?:_100%}#00/_60*{+!

इसे ऑनलाइन आज़माएं!

व्याख्या

?      Read input.
:      Duplicate.
_100%  Mod 100.
}      Move off to auxiliary stack.
#00/   Divide by 100, using the stack depth to get a 1, instead of _1.
_60*   Multiply by 60.
{+     Retrieve the earlier result and add it.
!      Print.

आईपी ​​तब एक मृत अंत मारता है और पीछे की ओर बढ़ना शुरू कर देता है। जब यह पहुंचता है तो /यह शून्य से एक विभाजन का प्रयास करता है जो कार्यक्रम को समाप्त करता है।

— मार्टिन एंडर
स्रोत
2

जेली , 5 बाइट्स

एक राक्षसी लिंक के रूप में (हेड-अप, केर्ड के लिए धन्यवाद!):

b³ḅ60

इसे ऑनलाइन आज़माएं!

... या एक पूर्ण कार्यक्रम के रूप में:

bȷ2ḅ60

इसे आसानी से 05AB1E पर पोर्ट किया जा सकता है, इसलिए:

05AB1E , 5 बाइट्स

тв60β

इसे ऑनलाइन आज़माएं!

बस इनपुट पूर्णांक को आधार 100 में परिवर्तित करता है और फिर परिणाम को आधार 60 से पूर्णांक में परिवर्तित करता है । इसलिए, यह इनपुट% 100 + 60 * ⌋Input / 100 equivalent के बराबर है

— मिस्टर एक्सकोडर
स्रोत
— caird coinheringaahing
@cairdcoinheringaahing मुझे लगता है कि आप का मतलब यह है, लेकिन के लिए धन्यवाद सिर-अप वैसे भी
— श्री Xcoder
2

एक्सेल VBA, 29 बाइट्स

बेनामी VBE तत्काल विंडो फ़ंक्शन जो रेंज से इनपुट लेता है [A1]और VBE तत्काल विंडो में आउटपुट करता है।

?[A1]Mod 1E2+60*[Int(A1/100)]
— टेलर स्कॉट
स्रोत
2

PARI / GP , 16 बाइट्स

सीधा:

n->n\100*60+n%100

दुर्भाग्य से इस अच्छी विधि का उपयोग करने के लिए बस बहुत लंबा है:

n->[60,1]*divrem(n,100)
— चार्ल्स
स्रोत
2

पुष्य , 10 9 बाइट्स

केविन ने मुझे अपनी भाषा में समझा ... ( ovs के उत्तर से दृष्टिकोण का उपयोग करके )

2dH/40*-#

इसे ऑनलाइन आज़माएं!

10 बाइट्स

sjvj60*^+#

इसे ऑनलाइन आज़माएं!

s             \ Split input into digits
 jvj          \ Join the first two and the last two
    60*       \ Multiply the first by 60
       ^+     \ Add the values
         #    \ Print

11 बाइट्स

एक बाइट के लिए अधिक हम Input % 100 + 60 * ⌊Input / 100⌋दृष्टिकोण का उपयोग कर सकते हैं :

H2d%}/60*+#

इसे ऑनलाइन आज़माएं!

— FlipTack
स्रोत
1
9 के एक बंदरगाह बनाने के द्वारा बाइट्स @ovs 'अजगर 2 जवाब : 2dH/40*-#। पुसी में पहले कभी भी प्रोग्राम नहीं किया गया था, लेकिन यह एक बहुत अच्छी भाषा है। :)
— केविन क्रूज़सेन
1
@KevinCruijssen यह काफी सामान्य स्टैक आधारित भाषा है, मुझे लगता है कि मेज पर लाए जाने वाली एकमात्र अलग चीज डबल स्टैक है ... लेकिन धन्यवाद, और गोल्फ के लिए धन्यवाद :)
— FlipTack
1

05AB1E , 9 बाइट्स

т÷60*¹т%+

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

т÷60*¹т%+

т         // Push number 100
 ÷        // Integer division with the input
  60      // Push number 60
    *     // Multiply with the previous result
     ¹    // Push input
      т   // Push 100 again
       %  // Modulo
        + // Add the first and the second result

संभवतः आधार रूपांतरण के साथ कुछ तरकीबें हैं जिन्हें 05AB1E में प्राप्त किया जा सकता है, लेकिन मुझे यह नहीं मिला।

1

रेटिना , 11 बाइट्स

.{100}
60$*

इसे ऑनलाइन आज़माएं!

इनपुट और आउटपुट अनरी में । परीक्षण सूट सुविधा के लिए और दशमलव से परिवर्तित करता है।

इस तरह के आधार रूपांतरण को केवल दो अंकों तक करना आश्चर्यजनक रूप से एकरी में करना सरल है। हम सिर्फ 100 के रन बनाते हैं 1और उनकी जगह 60 1एस लगाते हैं । जो कुछ भी बचा है वह दशमलव प्रतिनिधित्व में अंतिम दो अंकों के अनुरूप होगा और अपरिवर्तित रहेगा।

— मार्टिन एंडर
स्रोत
1

एलिस , 19 बाइट्स

/o
\i@/.'d%~'d:'<*+

इसे ऑनलाइन आज़माएं!

व्याख्या

बहुत बुरा मैंने भाषा से divmod हटा दिया , मुझे लगता है ...

/o
\i@/...

यह कार्डिनल (अंकगणितीय) मोड में दशमलव I / O के साथ रैखिक कार्यक्रमों के लिए सिर्फ सामान्य रूपरेखा है।

.     Duplicate input.
'd%   Mod 100.
~     Swap with other copy.
'd:   Divide by 100.
'<*   Multiply by 60.
+     Add.
— मार्टिन एंडर
स्रोत
1

मिल्की वे , 10 बाइट्स

':Z/v40*-!

उपयोग: ./mw code.mwg -i 9999

स्पष्टीकरण:

code       explanation                          stack

'          push input to stack                  [input]
 :         duplicate ToS                        [input, input]
  Z        push 100                             [input, input, 100]
   /v      integer division (divide and floor)  [input, ⌊input/100⌋]
     40    push 40                              [input, ⌊input/100⌋, 40]
       *   multiply                             [input, ⌊input/100⌋*40]
        -  subtract                             [input - ⌊input/100⌋*40]
         ! print
— OVS
स्रोत
1

आर , 21 बाइट्स

x=scan();x-x%/%100*40

इसे ऑनलाइन आज़माएं!

— निशान
स्रोत
1
मैंने आर में अपना समाधान बनाया और यह इससे कहीं कम सुरुचिपूर्ण था।
— एंड्रयू ब्रूजा
आप scanअधिकतर उत्तरों को काट सकते हैं क्योंकि मान लें कि चर पहले से ही परिभाषित है।
— एंड्रयू ब्रूजा
उस संबंध में नियम बहुत असंगत हैं। एक अन्य सबसे अधिक चुनौतियां आपके पास मूल्य को पकड़ने के लिए एक फ़ंक्शन या स्कैन करने की है।
— मार्क
1

आरईएक्सएक्स, 25 बाइट्स

arg t
say t%100*60+t//100

(@Ovs का सिर्फ एक और अनुवाद)

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