IOS 11 कैलकुलेटर को लागू करें

43

iOS 11 में एक बग है जो 1 + 2 + 3 का परिणाम 24 बनाता है । यह एनीमेशन गति से संबंधित है, लेकिन फिर भी:

कार्य बनाना है 1 + 2 + 3 == 24। लेकिन केवल इतना ही। तो आपको एक फ़ंक्शन प्रदान करना चाहिए जो सही ढंग से अधिकांश अनुक्रमों को बताता है लेकिन 24जब तर्क होते हैं 1, 2और 3किसी भी क्रम में वापस लौटता है ।

उदाहरण इनपुट:

1 2 => 3
3 4 => 7
1 2 3 4 5 6 7 8 9 => 45
3 2 1 => 24
2 1 3 => 24
1 1 => 2
1 2 3 => 24
40 2 => 42
1 2 2 4 => 9
1 2 3 4 1 2 3 => 16
1 => 1
1 23 => 24
0 1 2 => 3
3 2 3 => 8

जब तक आपका कोड किसी भी तर्क को स्वीकार करता है तब तक इनपुट किसी भी प्रारूप में हो सकता है।

  • नकारात्मक संख्याओं के लिए समर्थन की आवश्यकता नहीं है (सभी गैर नकारात्मक संख्याओं को काम करने के लिए आवश्यक है, जिसमें 0 शामिल हैं)
  • हम सही इनपुट मानते हैं

से मतभेद एक और इसी तरह प्रश्न: "क्या आप जब आप गुणा 6 से 9 से मिलता है (42)?" :

  • इस मामले में आपके फ़ंक्शन को किसी भी तर्क को स्वीकार करने की आवश्यकता है । पुराना प्रश्न ठीक 2 निर्दिष्ट करता है।
  • इस मामले में आदेश मायने नहीं रखता है, जबकि पुराने प्रश्न में निर्दिष्ट किया गया है कि आदेश 6 9की आवश्यकता है और 9 6सही तरीके से मूल्यांकन किया जाना चाहिए।
code-golf  math  number 
— Hauleth
स्रोत
23
इसके अलावा, iOS 11 ऐसा काम नहीं करता है। यह होना चाहिए इस तरह के बजाय। ( कोड स्पष्टीकरण )
— user202729
3
@ user202729 यह सवाल शायद iOS 11 से प्रेरित है। मुझे नहीं लगता कि ओपी आपको इसे पूरी तरह से दोहराने के लिए कह रहा है।
— ओकेक्स
2
@ ओकेएक्स बिल्कुल। यह मज़ेदार है, इसे 1 से 1. लागू करने के लिए नहीं। बेशक इसे उपयोगकर्ता 202729 के प्रस्ताव में बदला जा सकता है, लेकिन यदि वह चाहे तो ऐसे कार्य के साथ नई चुनौती पैदा कर सकता है।
— हौलेथ
3
क्या इनपुट पूर्णांक हैं?
— xnor
9
एक कारण यह एक सुंदर चुनौती है क्योंकि संपत्ति के साथ जुड़ा हुआ है, जिसमें संख्याओं का यह संयोजन बहुत विशेष है। दूसरी वजह यह है कि यह एक खूबसूरत चुनौती है कि यह कार्यक्षमता पर UX को प्राथमिकता देने (उनके विचार) के लिए मजेदार है।
— एनएच।

जवाबों:

11

MATL , 11 10 बाइट्स

St3:X=6*+s

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

व्याख्या

        % implicit input [3,1,2]
S       % sort
        % STACK: [1,2,3]
t       % duplicate elements
3:      % push range 1..3
        % STACK: [1,2,3], [1,2,3], [1,2,3]
X=      % true if arrays are numerically equal
        % STACK: [1,2,3], 1
6*+     % multiply result of comparison by 6 and add to the original array
        % STACK: [7,8,9]
s       % sum
        % (implicit) convert to string and display
— Cinaski
स्रोत
11

जावा 8, 109 106 101 90 75 74 71 66 बाइट्स

a->{int s=0,p=0;for(int i:a){s+=i;p|=1<<i;}return s<7&p==14?24:s;}

-12 बाइट्स की बदौलत @ OlivierGrégoire ।
-31 बाइट्स @ थैंक्स टू थैंक्स ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

a->{                  // Method with integer-array parameter and boolean return-type
  int s=0,            //  Sum-integer, starting at 0
      p=1;            //  Product-integer, starting at 1
  for(int i:a){       //  Loop over the input-array
    s+=i;             //   Add current item to sum
    p|=1<<i;          //   Take 1 bitwise left-shifted with `i`, and bitwise-OR it with `p`
  }                   //  End of loop
  return p==14        //  If `p` is now exactly 14 (`0b1110`)
    &s<7?             //  and the sum is 6 or lower:
     24               //   Return 24
    :                 //  Else:
     s;               //   Return the sum
}                     // End of method

(अकुशल) सबूत है कि केवल [1,2,3](किसी भी क्रम में) संभव परिणाम होगा जब pहै 0b1110( p==14) और योग नीचे 6 या कम (है s<7): इसे यहाँ की कोशिश करो।

p==14( 0b1110) सही मानों का मूल्यांकन करता है यदि इनपुट मान मोडुलो 32 मानों को कवर करते हैं 1, 2और 3कोई अन्य मान नहीं होते हैं ( p|=1<<i) (प्रत्येक मान 1+ बार घटित होता है)। मेल करने वाले इनपुट का योग किसी भी इनपुट को छोड़कर ( साथ ) p==14से बड़ा होगा । @Nevay61,2,3s=a*1+b*2+c*3+u*32a>0,b>0,c>0,u>=0

पुराने 71 बाइट्स उत्तर:

a->{int s=0,p=1;for(int i:a){s+=i;p*=i;}return a.length==3&p==s?s*4:s;}

सबूत है कि किसी भी तीन दिए गए गैर-शून्य प्राकृतिक संख्याओं के लिए, केवल [1,2,3](किसी भी क्रम में) इसके उत्पाद के बराबर राशि होगी ( 1+2+3 == 1*2*3) (एक सकारात्मक राशि के साथ):
जब यह राशि लियो कुरलैंडिक और एंड्रीज नाउकी द्वारा उत्पाद के बराबर होती है

(अकुशल) सबूत जो केवल [1,2,3](किसी भी क्रम में) और [0,0,0]गैर-नकारात्मक संख्या और 3 की लंबाई के साथ संभावित परिणाम होंगे: यहां प्रयास करें।
तो s*4इच्छा हो जाता है 6*4 = 24के लिए [1,2,3], और 0*4 = 0के लिए [0,0,0]।

— केविन क्रूज़सेन
स्रोत
7

MATL , 13 बाइट्स

stGp=18*Gda*+

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

यह अन्य MATL उत्तर की तुलना में दो बाइट्स लंबा है, लेकिन यह पूरी तरह से अलग (और IMO अधिक दिलचस्प) दृष्टिकोण का उपयोग करता है, इसलिए मुझे लगा कि यह पोस्ट करने लायक है।

स्पष्टीकरण:

यह समाधान इस तथ्य का उपयोग करता है कि:

तीन तत्वों के साथ एक सरणी का योग और उत्पाद केवल समान हैं यदि सरणी का क्रमपरिवर्तन है 1,2,3।

यह इनपुट लेता है, योग की गणना करता है s, और इसे डुप्लिकेट करता है t। यह तब जांचता है कि क्या राशि उत्पाद के बराबर है Gp=। हम बूलियन 1/0को 18 से गुणा करते हैं 18*, और जांचते हैं कि क्या वेक्टर में गैर-समान मूल्य हैं da*(फिर से, एक बूलियन से any(diff(x))गुणा करें। हम फिर दोनों को मूल संख्या में अंतिम संख्या जोड़ते हैं।

एक कदम से कदम स्पष्टीकरण:

इनपुट मानें [1, 2, 3]:

s                              % Implicit input, calculate the sum
                               % 6
 t                             % Duplicate the sum:
                               % 6, 6
  G                            % Grab input
                               % 6, 6, [1,2,3]
   p                           % Calculate the product
                               % 6, 6, 6
    =                          % Check if the last two elements are equal
                               % 6, 1 (true)
     18*                       % Push 18, multiply by the last number
                               % 6, 18
        G                      % Grab input
                               % 6, 18, [1,2,3]
         d                     % Calculate the difference between each element
                               % 6, 18, [1,1]
          a                    % any non zero elements?
                               % 6, 18, 1 (true)
           *                   % Multiply last two numbers
                               % 6, 18
            +                  % Add numbers. Result: 24
— स्टीवी ग्रिफिन
स्रोत
6

पायथन 2 , 39 बाइट्स

lambda*a:sum(a)+18*(sorted(a)==[1,2,3])

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

18 को जोड़ने की एक वैकल्पिक विधि का उपयोग करता है यदि सॉर्ट किया गया इनपुट अन्य पायथन उत्तर को बाइट [1, 2, 3]से हरा देता है ।

— FlipTack
स्रोत
sorted(a)==[1,2,3]set(a)=={1,2,3}3 बाइट्स बचाने के लिए बन सकता है ।
— 19
1
@mypetlion दुर्भाग्य से जो डुप्लिकेट के साथ सूचियों के लिए सही होगा जैसे कि[1, 2, 3, 3]
— FlipTack
ओह। हालाँकि हम 3 इनपुट तक ही सीमित थे।
— म्य्प्टेलियन
6

हास्केल , 37 बाइट्स

f[a,b,c]|2^a+2^b+2^c==14=24
f l=sum l

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

हम असाधारण मामले को पकड़ने के लिए पैटर्न मिलान का उपयोग करते हैं।

हास्केल में बिल्ट-इन छँटाई नहीं है। गैर-नकारात्मक पूर्णांकों के बीच क्रमबद्धता 2^a+2^b+2^c==14से ही समानता संतुष्ट होती है । एक छोटा लगभग काम करता है, लेकिन द्वारा संतुष्ट है , और चेक को जोड़कर यह 1 बाइट को लंबा बनाता है।[a,b,c][1,2,3]a+b+c=a*b*c[0,0,0],a>0

— XNOR
स्रोत
4

ऑक्टेव , 34 बाइट्स

@(x)sum(x)+isequal(sort(x),1:3)*18

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

या 

@(x)(s=sum(x))+18*~(s-6|prod(x)-6)

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

या

@(x)(s=sum(x))+18*~(s-prod(x)|s-6)

दूसरों द्वारा उपयोग किए जाने वाले दृष्टिकोण से यह छोटा है @(x){24,sum(x)}{2-isequal(sort(x),1:3)}:।

स्पष्टीकरण:

यह सदिश का योग लेता है, और 18 को जोड़ता है यदि छांटे गए सदिश के बराबर है 1,2,3। इस दे देंगे 6+18=24अगर वेक्टर का क्रमपरिवर्तन है 1,2,3, और सिर्फ वेक्टर का योग नहीं तो।

— स्टीवी ग्रिफिन
स्रोत
4

PHP, 116 बाइट्स

यह एक गोल्फ चुनौती पर मेरा पहला प्रयास है, और यह PHP, एक भाषा है जो जाहिरा तौर पर गोल्फ में बेकार है क्योंकि मैं शायद ही कभी इसे यहाँ देखता हूं, इसलिए ... उह, मैंने कोशिश की?

<?php
//call as var/www/html/cg_ios.php --'1 2 3 4 5'
$i=$argv[1];$a=(explode(' ',$i));echo((($b=array_sum($a))==6&&count($a)==3&&in_array(3,$a)&&!in_array(0,$a)?24:$b));

नोट: मैंने टिप्पणी को बाइटकाउंट में शामिल नहीं किया।

Ungolfed

यह कुछ खास नहीं है:

$i=$argv[1];             //Read the input from the command line
$a=array_filter($c=explode(' ',$i)) //Split the input string into an array, use Whitespace as delimiter
                         //also, remove all 0 from the array, since they are not important at all
echo(                    //print the result
    ($b=array_sum($a) == 6  //If The SUM of the Array is 6 ...
        &&               //... AND ...
    (count($c) == 3)     //... the array has exactly 3 values ...
        &&               //... AND ...
    in_array(3,$a)       // ... the array contains the value 3 ...
        &&               // ... AND ...  
    !in_array(0,$a)      //... the array contains no zeros
        ?
    24                   //print 24
        :
    $b));     //print the sum of the array values we saved earlier

यदि आप इसे PHPFiddle में परीक्षण करना चाहते हैं और कंसोल पर नहीं, तो आप स्पष्ट रूप से $iअपनी पसंद की किसी भी चीज़ को बदल सकते हैं।

ओलिवियर ग्रेगोइरे के लिए धन्यवाद जिन्होंने मुझे स्ट्रिंग संयोजन के बारे में अवगत कराया [0,3,3]जो 24 से पहले लौट आए और उन्होंने मुझे array_sumफिर से काम करने से रोकने और वापस करने के बजाय कुछ चार्ट सहेजने में मदद की ।

— यू नो वर्क
स्रोत
साइट पर आपका स्वागत है, और अच्छी पहली पोस्ट!
— caird coinheringaahing
इनपुट मूल्यों के बारे में क्या [0, 3, 3]? इसके अलावा, क्या आप array_sum($a)एक चर के परिणाम को नहीं बचा सकते हैं और इसका पुन: उपयोग कर सकते हैं?
— ओलिवियर ग्रेगोइरे
@ ओलिवियरग्रैगोयर अब भी तय हो गया है, मैं स्पष्ट रूप से उस मामले को याद कर रहा हूं। मैं शायद एक बेहतर समाधान के बारे में सोच सकता था, यह है - मेरे मानकों के लिए भी - वास्तव में ... गन्दा।
— YU NO WORK
गोल्फ कोड $ Argv पर गायब है [1]
— manassehkatz
4

आर, 47 बाइट्स 34 बाइट्स 36 बाइट्स

x=scan();all(sort(x)==1:3)*18+sum(x)

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

इनपुट को जोड़ो और 18 जोड़ें यदि इनपुट सेट 1: 3 है।
11 बाइट बंद करने के लिए @mlt को धन्यवाद। Overgolfed कोड के साथ त्रुटि की पहचान करने के लिए @ Ayb4btu को धन्यवाद

— निशान
स्रोत
3

जावास्क्रिप्ट ईएस 6, 39 बाइट्स

@Herman Lauenstein को धन्यवाद

a=>a.sort()=="1,2,3"?24:eval(a.join`+`)


f=a=>a.sort()=="1,2,3"?24:eval(a.join`+`)

console.log(f([1,2,3]));
console.log(f([1,2,3,4]));
स्निपेट का विस्तार करें

पिछला उत्तर

जावास्क्रिप्ट ईएस 6, 66 बाइट्स

a=>(n=[1,2,3],a.every(_=>n.includes(_))?24:a.reduce((x,y)=>x+y,0))

कोशिश करो

f=a=>(n=[1,2,3],a.every(_=>n.includes(_))?24:a.reduce((x,y)=>x+y,0))

console.log(f([1,2,3]));
console.log(f([1,3,2]));
console.log(f([1,2,3,4]));
स्निपेट का विस्तार करें

— Weedoze
स्रोत
58 बाइट्स:a=>(Array.sort(a).join()=="1,2,3"?24:a.reduce((x,y)=>x+y))
— ओकेक्स
a.sort()=="1,2,3"काम करता है।
— नील
39 बाइट्स: a=>a.sort()=="1,2,3"?24:eval(a.joinBT+BT)(बीटी को बैकटीक्स से बदलें)
— हरमन एल
3

स्विफ्ट, 67 बाइट्स

func z(i: [Int])->Int{return i.sorted()==[1,2,3] ?24:i.reduce(0,+)}

[इंट] पर एक्सटेंशन के साथ 27 बाइट्स तक बना सकता है, लेकिन यह धोखा होगा :(

— डोमिनिक बुचर
स्रोत
1
साइट पर आपका स्वागत है! यह एक कोड गोल्फ प्रतियोगिता है, कृपया आप जितनी संभव हो उतनी जगहों पर गोल्फ को हटा सकते हैं, जैसे कि रिक्त स्थान को हटाकर। इसके अलावा, मैं स्विफ्ट को नहीं जानता, लेकिन अगर मैं सही हूं, तो यह एक चर में इनपुट को बचाता है, जिसकी अनुमति नहीं है। हालाँकि, आपको इसे फ़ंक्शन में बदलने की अनुमति है।
— caird coinheringaahing
1
नीचे golfed एक छोटे से: func z(i:[Int]){print(i.sorted()==[1,2,3] ?24:i.reduce(0,+))}।
— मिस्टर एक्सकोडर
1
या 55 बाइट्स (-12):, {$0.sorted()==[1,2,3] ?24:$0.reduce(0,+)}as([Int])->Intअनाम कार्यों के रूप में हमारे मानक नियमों की अनुमति है। आप देख सकते हैं कि यह यहाँ कैसे काम करता है ।
— मिस्टर एक्सकोडर
@ Mr.Xcoder आप कास्टिंग को छोड़ सकते हैं और इसे f निरंतर में जोड़ सकते हैं जिसे आप घोषित कर रहे हैं। या क्लोजर के अंदर टाइप करें और आप से छुटकारा पाएं as:)
— डॉमिनिक बुचर
2
स्विफ्ट के लिए +1। क्या यह iOS कैलकुलेटर का मूल स्रोत कोड है?
— जीबी
2

जे, 17 बाइट्स

-6 बाइट्स फ्रोबी फ्रॉग के लिए धन्यवाद

+/*1+3*1 2 3-:/:~

सभी संख्याओं +/को जोड़ो और परिणाम (pseudocode) से गुणा करें 1 + 3*(is123 ? 1 : 0)। यह है कि परिणाम को अपरिवर्तित लौटाएं जब तक कि सॉर्ट की गई सूची उस स्थिति में नहीं है जब 1 2 3हम परिणाम को 4 से गुणा करते हैं।

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

मूल उत्तर

+/`(24"_)@.(1 2 3-:/:~)

अगर सॉर्ट किए गए इनपुट की जाँच करें 1 2 3- यदि हाँ, तो निरंतर फंक्शन 24 ( 24"_) को लागू करें ; यदि नहीं, तो राशि वापस करें+/

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

— जोनाह
स्रोत
मैं वास्तव में जम्मू पता नहीं है, लेकिन कर सकते हैं 1 2 3→ i.3?
— ऊरीएल
@ यूरिल, i.3उत्पादन करता है 0 1 2, इसलिए आपको ऐसा करना होगा 1+i.3जो कोई शुल्क नहीं बचाता है लेकिन कम स्पष्ट है।
— जोनाह
दाईं ओर, मैं भूल गया कि J 0 अनुक्रमित है
— Uriel
[:+/8"0^:(1 2 3-:/:~)
— FrownyFrog
+/@,[*3*1 2 3-:/:~
— FrownyFrog
2

लूआ , 116 81 बाइट्स

-7 बाइट्स जोनाथन के लिए धन्यवाद

कमांड लाइन तर्क के रूप में इनपुट लेता है

Z=0S={}for i=1,#arg do
j=arg[i]+0S[j]=0Z=Z+j
end
print(#S>2 and#arg<4 and 24or Z)

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

स्पष्टीकरण:

एक स्पार्स सरणी बनाकर Sऔर इनपुट मानों के अनुरूप सूचकांकों में शून्य जोड़कर काम करता है । यदि पैरामीटर 3, 4, 7विरल हैं तो केवल उन सूचकांकों पर संख्याएँ होंगी। उस सरणी के साथ, हम उस ऑपरेटर के साथ लंबाई प्राप्त करते हैं #जो सूचकांक से 1उच्च सूचकांक तक गिना जाता है जिसमें इसका मूल्य है, अगर यह लंबाई बिल्कुल है 3, तो इसका मतलब है कि स्थिति में तत्व थे 1, 2और 3जो हम कर रहे हैं वह है की तलाश में विरल सरणी की लंबाई हमेशा बीच होगी 0और मापदंडों की संख्या Nकहां Nहै। इसलिए हमें यह जांचना होगा कि क्या पैरामीटर पैरामीटर और विरल सरणी दोनों की लंबाई है 3।

— फेलिप नारदी बतिस्ता
स्रोत
1
— केविन क्रूज़सेन
आपने कुछ भी नहीं देखा (मैंने अपनी टिप्पणी संपादित की, क्योंकि यह 5 मिनट के बाद अभी तक नहीं था; पी)
— केविन क्रूज़सेन
हाँ, मुझे अपने जवाब में बस वही दोष मिला .. मैंने इसे सरणी-लंबाई == 3 और ए == एस एंड एस> 0 का उपयोग करके तय किया। लेकिन मुझे लगता है कि #argsLua में लंबाई की जाँच करना थोड़ा भारी है? उस स्थिति में आप अपने 90-बाइट्स के जवाब में रोलबैक कर सकते हैं जो मुझे लगता है .. :(
— केविन क्रूज़सेन
— जोनाथन एस।
@JonathanS। एक अच्छा
— फेलिप नारदी बतिस्ता
2

आर , 55 45 54 49 57 54 48 बाइट्स

Ayb4btu के लिए धन्यवाद, कई बाइट्स और गलत समाधान सहेजे गए।

Giuseppe के लिए 3 9 बाइट्स को सहेजा गया । मैं इस तथ्य का दुरुपयोग करने के लिए नए तरीके सीखता रहता हूं F==0।

"if"((s=sum(x<-scan()))-prod(x)|sum(x|1)-3,s,24)

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

अन्य आर उत्तर अंत में जीता।

— बीएलटी
स्रोत
के लिए विफल रहता है [0,0,0]रिटर्न: 24के बजाय 0।
— ओलिवियर ग्रेजायर
मैं स्पष्ट रूप से 'नॉन-निगेटिव' और 'एक ही संख्या में' हो सकता है। रुको।
— बीएलटी
c(1,1,2,3)के 28बजाय रिटर्न7
— Ayb4btu
@ Ayb4btu धन्यवाद, अच्छी पकड़।
— BLT
1
x=scan();s=sum(x);"if"(s-prod(x)|s-6|length(x)-3,s,24)54 बाइट्स हालत गमागमन है और |इसके बजाय &हम घटाना कर सकते हैं।
— Giuseppe
1

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

O`
^1¶2¶3$
24
.+
$*
1

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

इनपुट लाइनफ़ीड-अलग है, लेकिन परीक्षण सूट सुविधा के लिए अल्पविराम-पृथक्करण का उपयोग करता है।

व्याख्या

O`

क्रमबद्ध संख्या (कोषगत, वास्तव में, लेकिन हम केवल मामले के बारे में परवाह है कि आदानों हैं 1, 2, 3कुछ आदेश है, जहां कि एक फर्क नहीं करता है)।

^1¶2¶3$
24

यदि इनपुट 1,2,3(किसी क्रम में) है, तो उसे 24 से बदल दें।

.+
$*

प्रत्येक संख्या को एकात्मक में बदलें।

1

1एस की संख्या की गणना करें , जो असमान संख्याओं को जोड़ता है और उन्हें वापस दशमलव में परिवर्तित करता है।

— मार्टिन एंडर
स्रोत
जिज्ञासा से बाहर, आपके स्पष्टीकरण के आधार पर मैं समझता हूं कि अंतिम पंक्ति मैच की सभी घटनाओं ( 1इस मामले में सभी s) को गिनाती है । क्या रेटिना हमेशा सिंगल फाइनल लाइन के लिए ऐसा करती है? या क्या यह भी संभव है कि सभी के 1बीच में कहीं भी गणना की जाए , और फिर उसके बाद परिणाम को कुछ और करने के लिए जारी रखें (जो दो लाइनों को फिर से प्रतिस्थापन-क्रियाओं के लिए उपयोग करता है)? इसके अलावा, एक और संबंधित प्रश्न: रेटिना में कौन से कार्यों के लिए केवल एक लाइन की आवश्यकता होती है? छँटाई ( O`) उनमें से एक है, और अन्य कार्य भी; लेकिन कोई और? बस रेटिना को थोड़ा और समझने की कोशिश कर रहा हूं। :)
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन हाँ आप बीच में कहीं एक (गिनती) मैच चरण का उपयोग कर सकते हैं, लेकिन आपको स्पष्ट रूप से इसे मैच चरण के रूप में चिह्नित करना होगा M`। यह केवल तभी होता है जब एक एकल अनुगामी रेखा होती है जो रेटिना ईप्‍लेस के Mबजाय Rखो जाने के लिए चूक जाती है। AGMTSसभी सिंगल-लाइन चरण हैं, Rदो लाइनें हैं, Oऔर Dएक या दो लाइनें हैं जो इस बात पर निर्भर करती है कि $विकल्प का उपयोग किया जाता है (जो उन्हें चरणों में क्रमबद्ध / घटा देता है )। अगर आपको और अधिक प्रश्न हैं तो मुझे रेटिना चैट रूम में पिंग करने के लिए स्वतंत्र महसूस करें: chat.stackexchange.com/rooms/41525/retina
— मार्टिन
1

हास्केल , 44 बाइट्स

f a|sum a==6,product a==6,a<[6]=24|1<2=sum a

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

के क्रमपरिवर्तन [1,2,3]का ही विभाजन कर रहे हैं 6जिसका उत्पाद है 6, को छोड़कर 6ही। (यह मानता है कि इनपुट गैर-नकारात्मक हैं, जो सभी परीक्षण मामलों के लिए लगता है ... मैंने ओपी से इस बारे में पूछा है।)

— लिन
स्रोत
— 2:38 बजे पूरी तरह से अमानवीय
1

पीएल / एसक्यूएल - 135 123 बाइट्स

मान लें कि मैं किसी भी आकार के पूर्णांक सरणी इनपुट के रूप में:

if (select sum(s) = exp(sum(ln(s))) from unnest(i) s) then
    return 24;
else
    return (select sum(s) from unnest(i) s);
end if;
— लियो वेस्क
स्रोत
PPCG में आपका स्वागत है! क्या आप सभी अतिरिक्त स्थानों को हटाकर इसे गोल्फ बनाने की कोशिश कर सकते हैं, भले ही यह उत्तर को अपठनीय बनाता है (जब तक यह संकलन करता है, हालांकि)?
— ओलिवियर ग्रेजायर
1

सी ++ 17, 56 54 बाइट्स

[](auto...i){return(-i&...)+4|(~i*...)+24?(i+...):24;}

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

ध्यान दें कि बनाया गया फंक्शन ऑब्जेक्ट कंपाइल समय पर प्रयोग करने योग्य है, इसलिए कंपाइलर द्वारा प्रोग्राम चलाए बिना ही टेस्ट किए जाते हैं।

स्पष्टीकरण:

[]             // Callable object with empty closure,
(auto...i)     // deduced argument types,
{              // and deduced return type
  return       //
      (-i&...) //   If the fold over the bitwise AND of the negation of each argument
    +4|        // is unequal to -4, or
      (~i*...) //   if the product of the bitwise complements of the arguments
    +24?       // is unequal to -24, then
      (i+...): //   return the sum of the arguments, otherwise
      24;}     //   return 24.

सबूत है कि केवल nonnegative i...जिसके लिए (-i&...)-4 और (~i*...)बराबर -24 बराबर है 1, 2, 3: के क्रमपरिवर्तन हैं :

हम पहले देखते हैं कि -0= के बाद से 0, यदि कोई i= 0फिर (-i&...) = 0, तो हम निष्कर्ष निकालते हैं कि सभी iसकारात्मक हैं।

अब, ध्यान दें कि 2 के पूरक में, -iके बराबर है ~(i - 1)और ~iके बराबर है -(i + 1)। डी मॉर्गन के नियम को लागू करते हुए, हम पाते हैं कि (-i & ...)= ~((i - 1) | ...)= -(((i - 1) | ...) + 1), इसलिए ((i - 1) | ...) = 3; इसी तरह, -1 ** n * ((i + 1) * ...) = -24इसलिए n, विषम और है ((i + 1) * ...) = 24।

24 के मुख्य कारक 2 ** 3 * 3 हैं, इसलिए n<= 4. यदि n= 1, हमारे पास है i - 1 = 3और i + 1 = 24इसलिए, n= 3. iजैसा कि वैफल लिखें a <= b <= c, तो स्पष्ट रूप से a= 1 अन्यथा अन्यथा (a + 1)(b + 1)(c + 1)> = 27। इसके अलावा c<= 4 अन्यथा (a - 1)|(b - 1)|(c - 1)> = 4. c4 नहीं हो सकता क्योंकि 5 24 का कारक नहीं है, इसलिए c<= 3. फिर आवश्यकतानुसार (a - 1)|(b - 1)|(c - 1) = 3c = 3, b = 2 को संतुष्ट करने के लिए।

— ecatmur
स्रोत
1

भूसी , 9 बाइट्स

?K24Σ=ḣ3O

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

व्याख्या

?K24Σ=ḣ3O
        O    Sort the input
?    =ḣ3     If it is equal to [1,2,3]:
 K24           Return 24
             Else:
    Σ          Return the sum of the input

पिछला समाधान

गलत परिणाम देता है [2,2], और शायद अन्य इनपुट भी, लेकिन यह अधिक दिलचस्प था।

?ṁD→E§eΠΣ
     §eΠΣ    Build a two-element list with the product and sum of the input
?   E        If the two elements are equal:
             (true for any permutation of [1,2,3] and the list [0,0,0]
 ṁD            Double both elements and sum them
               (This is 4 times the sum: 24 for permutations of [1,2,3], 0 for [0,0,0])
             Else:
   →          Return the last element (the sum)

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

— सिंह
स्रोत
यह 2,2 के लिए 24 देता है
— पुनरावर्ती
@recursive वास्तव में यह 16 देता है, लेकिन आप सही हैं। और शायद यह कुछ लंबे सरणियों के लिए भी गलत परिणाम देता है ... अरे, मुझे एक उबाऊ समाधान पर स्विच करने की आवश्यकता है
— लियो
0

पुष्य , 12 बाइट्स

gF3RFx?18;S#

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

यह इनपुट को छाँटकर काम करता है और, अगर यह [1, 2, 3]18 के बराबर है , तो। यह गणना की जाती है और मुद्रित की जाती है, उपज 24 और 18 को जोड़ा गया है, और सामान्य उत्तर अन्यथा।

         \ Implicit: Input on stack.
g        \ Sort input ascendingly
F3RF     \ On auxiliary stack, push range(3) -> [1, 2, 3]
x?       \ If the stacks are equal:
  18     \    Append 18 to the input
;
S#       \ Print sum of input.
— FlipTack
स्रोत
0

पायथन 2 , 41 39 बाइट्स

-1 बाइट के लिए धन्यवाद caird

-1 फ्लिपकार्ट के उत्तर से प्रेरणा लेकर

lambda*a:sum(a)*4**(sorted(a)==[1,2,3])

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

वैकल्पिक 39 बाइट्स समाधान

lambda*a:sum(a)<<2*(sorted(a)==[1,2,3])
— फेलिप नारदी बतिस्ता
स्रोत
1
— caird coinheringaahing
0

जेली , 10 9 बाइट्स

Ṣ24S⁼?3R¤

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

-1 बाइट एरिक के लिए धन्यवाद

वैकल्पिक ( श्री एक्सकोडर द्वारा ), 9 बाइट्स के लिए भी:

3R⁼Ṣ×18+S

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

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

Ṣ24S⁼?3R¤ - Main link. Argument: l (list)

Ṣ         - Sort
     ?    - Ternary if statement
    ⁼     -  Condition: Is l equal to...
      3R¤ -    [1, 2, 3]
 24       -  If condition: Return 24          
   S      -  Else: Return the sum of the list
— केर्ड सिक्काहिरिंग
स्रोत
आप Ṣ24S⁼?3R¤9 बाइट्स के लिए कर सकते हैं ।
— आउटगॉल्फ
या 3R⁼Ṣ×18+S9 बाइट्स के लिए भी।
— मिस्टर एक्सकोडर
0

अजगर , 9 बाइट्स

अन्य पायथ उत्तर से अलग aproach।

*sQ^4qS3S

स्पष्टीकरण:

मेरे पायथन जवाब से एक बंदरगाह

*sQ^4qS3SQ  # Full program (Q at the end is implicit and represents the input)

*           # A * B where A and B are the next two lines
  sQ        # Sum elements of input
  ^4        # 4 to the power of:
    qS3SQ   # Compares sorted input to [1, 2, 3] and returns 0 or 1

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

— फेलिप नारदी बतिस्ता
स्रोत
0

पॉवरशेल , 44 बाइट्स

param($a)($a-join'+'|iex)+18*!(diff(1..3)$a)

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

पायथन और जावास्क्रिप्ट के जवाबों के समान एल्गोरिथ्म। इनपुट को शाब्दिक सरणी के रूप में लेता है $a। फिर तुरंत $aएक साथ बैठता है, जो बाएं हाथ के ऑपरेटर बनाता है +।

दाहिने हाथ में diff( और के लिए उपनाम Compare-Object) है - या तो यह एक खाली सरणी है यदि वे समान हैं, या विभिन्न मदों की एक गैर-खाली सरणी है यदि वे बराबर नहीं हैं - एक बूलियन में संलग्न नहीं-नहीं। इसलिए, यदि वे समान हैं, तो खाली सरणी (एक गलत मूल्य) बनाता है ।1,2,3$a$true

इसके बाद गुणा करने के लिए और करने के लिए 18निहित है । तो दाहिने हाथ की ओर होगा यदि सरणियाँ समान हैं, और अन्यथा। यह सही परिणाम देता है यदि इनपुट सरणी किसी भी क्रमपरिवर्तन में है, और अन्यथा इनपुट सरणी का योग।$true1$false0180241,2,3

— AdmBorkBork
स्रोत
0

कोटलिन , 46 44 बाइट्स

if(i.sorted()==listOf(1,2,3))24 else i.sum()

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

संपादित करता

— jrtapsell
स्रोत
क्या आप listOf(1,2,3)2 बाइट बचाने के लिए उपयोग कर सकते हैं ? मैं कोटलिन को नहीं जानता, इसलिए मुझे यकीन नहीं है।
— श्री Xcoder
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.