अवलोकन

अंकों की सूची को देखते हुए, 100 बनाने के लिए सबसे कम संचालन खोजें

इनपुट

अंकों की एक स्ट्रिंग, जो संख्यात्मक क्रम में हो सकती है या नहीं भी हो सकती है। अंकों के क्रम को बदला नहीं जा सकता है, हालांकि प्लस (+) या माइनस (-) ऑपरेटरों को प्रत्येक के बीच जोड़ा जा सकता है ताकि कुल योग 100 के बराबर हो।

उत्पादन

अंकों की संख्या और ऑपरेटरों के पूर्ण अनुक्रम के बाद ऑपरेटरों की संख्या को जोड़ा गया। दो को एक स्थान, टैब या नई लाइन अनुक्रम द्वारा अलग किया जा सकता है।

उदाहरण

वैध

इनपुट: 123456789
आउटपुट:3 123–45–67+89

अमान्य
इनपुट: 123456789
आउटपुट:
6 1+2+34-5+67-8+9
(कम संचालन के साथ इसे हल करने के तरीके हैं)

— CyberJacob
स्रोत

जावास्क्रिप्ट (ईएस 6), 153 176 बाइट्स

संपादित करें: गैर-सख्त मोड में, जेएस 0-उपसर्गों के संख्यात्मक अभिव्यक्तियों को अष्टक के रूप 017में व्याख्या करता है (जैसे दशमलव में 15 के रूप में पार्स किया गया है)। यह एक निश्चित संस्करण है जो प्रमुख शून्य का समर्थन करता है।

let f =

s=>[...Array(3**(l=s.length,l-1))].map((_,n)=>m=eval((x=s.replace(/./g,(c,i)=>c+['','+','-'][o=(n/3**i|0)%3,j-=!o,o],j=l)).replace(/\b0+/g,' '))-100|j>m?m:(S=x,j),m=l)&&m+' '+S

console.log(f("123456789"))
console.log(f("20172117"))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

अच्छा है, इनपुट के रूप में 20172117 के बारे में क्या?

— mdahmoune

@LuisMendo वास्तव में, मुझे लगता है कि अपेक्षित उत्तर है 2-017-2+117। लेकिन 017जेएस में एक ऑक्टल नोटेशन है, जो दशमलव में 15 देता है। इसलिए मेरा वर्तमान कोड केवल खोजता है 2-0-17-2+117। मैं आज उस समस्या को हल करने की कोशिश करूंगा।

— अरनुलद

@ अर्नुलद आह, मैंने वह दूसरा उपाय नहीं देखा था। मेरी टिप्पणी को हटाने

— लुइस मेंडू

@mdahmoune इसे लाने के लिए धन्यवाद। अब तय हो गया।

— अरनुलद

3**(l=s.length,l-1)=>3**~-(l=s.length)

— l4m2

5

MATL , 37 36 बाइट्स

n'+-'OhZ^!t2\s&SZ)"G@!vXzU100=?@z3M.

टेस्ट केस में TIO में लगभग 6 सेकंड लगते हैं।

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

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

n        % Implicitly input a string. Number of elements, say k
'+-'     % Push this string
Oh       % Append char 0. This is treated like ' ' (space)
Z^       % Cartesian power of the three-char string '+- ' raised to k.
         % Gives a matrix where each row is a Cartesian k-tuple
!        % Transpose
t        % Duplicate
2\       % Modulo 2. This turns '+' and '-' into 1, and ' ' into 0
s        % Sum of each column: number of '+' and '-' symbols
&S       % Sort and push the indices of the sorting
Z)       % Apply as column indices. This sorts the columns (k-tuples)
         % by the number of '+' and '-' they contain
"        % For each column, i.e. each k-tuple formed by '+', '-' and ' '
  G      %   Push input string again
  @!     %   Push k-tuple as row vector (string)
  v      %   Concatenate vertically into a 2×k char array
  Xz     %   Remove space (and char 0). Gives a string as result. In this
         %   process, the 2×k array is linearized in column major order 
         %   (down, then across). So the '+' and '-' signs are between 
         %   digits of the input, or at the end
  U      %   Convert to number. This performs the operation determined by
         %   by the '+' and '-' signs and returns the result. A trailing
         %   '+' or '-' sign makes the input invalid, which causes an
         %   empty result
  100=   %   Is it equal to 100?
  ?      %   If so
    @    %     Push current k-tuple
    z    %     Number of nonzeros, i.e. of '+' and '-' signs
    3M   %     Push linearized string without spaces again
    .    %     Break for loop
         %   Implicit end
         % Implicit end
         % Implicitly dispplay stack

— लुइस मेंडो
स्रोत

महान, इनपुट के रूप में 299399 क्या है?

— mdahmoune

1

@mdahmoune 299399का कोई हल नहीं है और इसलिए एक वैध इनपुट नहीं है (ऑपरेटरों को "अंकों के बीच" जाने के लिए निर्दिष्ट किया गया था, उस इनपुट की आवश्यकता होगी -299+399जहां -अंकों के बीच नहीं है)।

— जोनाथन एलन

@mdahmoune यदि अंकों को केवल अंकों के बीच डाला जा सकता है (जैसा कि चुनौती पाठ कहता है), मुझे लगता है कि कोई समाधान नहीं है। यदि उन्हें पहले अंक में भी रखा जा सकता है, तो समाधान है -299+399, और उस स्थिति में मुझे अपने कोड में एक छोटे से बदलाव की आवश्यकता है । मैंने ओपी से स्पष्टीकरण के लिए कहा है

— लुइस मेंडो

इसके अलावा उल्लेखनीय है कि अगर यह दोनों से पहले हो सकता है के लिए बने थे और उसके बाद उदाहरण के बीच 123456789के संचालक गिनती करना चाहिए था 4नहीं 3।

— जोनाथन एलन

@mdahmoune ओपी ने पुष्टि की है कि संकेत केवल अंकों के बीच हो सकते हैं। तो मेरा कोड सही है और 299399एक अमान्य इनपुट है क्योंकि, जैसा कि ओपी ने भी स्पष्ट किया है, हर इनपुट में कम से कम एक समाधान होना चाहिए

— लुइस मेंडो

3

[अजगर 2], 164 158 बाइट्स

from itertools import*
f=lambda N:min((len(s)-len(N),s)for s in(''.join(sum(zip(N,p+('',)),()))for p in product(('+','-',''),repeat=len(N)-1))if eval(s)==100)

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

N को अंकों की एक स्ट्रिंग के रूप में लें; एक टपल लौटाता है (अंक, एक्सप्रेशन स्ट्रींग)।

मूल रूप से दूसरों के समान दृष्टिकोण; का उपयोग करता है itertools.product का निर्माण करने के लिए व्यक्तिगत "मामलों" उदाहरण के लिए N == '1322', "केस" होगा ('-','','+'), और '1-32 + 2' का मूल्यांकन करेगा।

यदि इनपुट अमान्य है (लेकिन मुझे लगता है कि ओपी किसी भी अवैध इनपुट के लिए इनपुट नहीं है) एक मान को फेंकता है।

— चास ब्राउन
स्रोत

3

PHP, 166 171 बाइट्स

for(;$n<3**$e=strlen($x=$argn);eval("return $s;")-100?:$r[]=sprintf("%2d $s",strlen($s)-$e))for($i=0,$s="",$k=$n++;a&$c=$x[$i];$k/=3)$s.="+-"[$i++?$k%3:2].$c;echo min($r);

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसका परीक्षण करें ।

परिणामों को क्रमबद्ध करने के लिए स्वरूपित संख्याओं का उपयोग करता है ->
अग्रणी रिक्त स्थान प्रिंट कर सकता है (और 99 अंकों से अधिक इनपुट के लिए विफल हो सकता है; संख्या %2dको ठीक करने के लिए बढ़ाएं )।

10 अंकों से अधिक नहीं, 161 बाइट्स

for(;$n<3**$e=strlen($x=$argn);eval("return $s;")-100?:$r[]=(strlen($s)-$e)." $s")for($i=0,$s="",$k=$n++;a&$c=$x[$i];$k/=3)$s.="+-"[$i++?$k%3:2].$c;echo min($r);

टूट - फूट

for(;$n<3**$e=strlen($x=$argn); # loop $n up
    eval("return $s;")-100?:        # 2. evaluate term, if 100 then
                                    # prepend number of operations, add to results
        $r[]=sprintf("%2d $s",strlen($s)-$e)
)
                                # 1. create term
    for($i=0,$s="",$k=$n++;         # init variables, increment $n
        a&$c=$x[$i];$k/=3)          # loop through digits/operator index
        $s.="+-"[$i++?$k%3:2].$c;   # prepend operator for base-3 digit (nothing for 2)
echo min($r);                   # print lowest result

— टाइटस
स्रोत

3

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

L’⁾+_ṗż@€
ŒṖÇ€ẎµFV=ȷ2µÐfLÞḢFṄḟ³L

एक पूरा कार्यक्रम जो जेली ऑपरेटरों ( _इसके बजाय -) का उपयोग करके प्रदर्शित करता है ।

नोट: दिखाने के लिए -के बजाय उत्पादन में _(नहीं एक आवश्यकता) जोड़ने ⁾_-yके बीच Fऔर Ṅ( ⁾_-एक चरित्र जोड़ी शाब्दिक है ['_','-']और ydyadic "का अनुवाद" परमाणु है)।

कैसे?

L’⁾+_ṗż@€ - Link 1, form all sums from a partition: list of lists of characters
                                     e.g. ["12","345","67"]
L         - length                        3
 ’        - decremented                   2
  ⁾+_     - literal ['+','_']
     ṗ    - Cartesian power               ["++","+_","_+","__"]
      ż@€ - zip for €ach (swap @rguments) ["12+345+67","12+345_67","12_345+67","12_345_67"]

ŒṖÇ€ẎµFV=ȷ2µÐfLÞḢFṄḟ³L - Main link: list of characters
ŒṖ                     - all partitions
  Ç€                   - call the last link (1) as a monad for €ach
    Ẏ                  - tighten (flatten by 1 level)
     µ     µÐf         - filter keep if:
      F                -   flatten
       V               -   evaluate as Jelly code (perform the sum)
         ȷ2            -   literal 100
        =              -   equal?
               Þ       - sort by:
              L        -  length
                Ḣ      - head
                 F     - flatten
                  Ṅ    - print that and a newline
                   ḟ³  - filter out the characters from the input
                     L - length (number of operators)
                       - implicit print

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

— जोनाथन एलन
स्रोत

2

गणितज्ञ, १३६ 146 149 156 165 166 बाइट्स

#&@@Sort[{StringLength@#-e+9!(ToExpression@#-100)^2,#}&/@StringJoin/@(Riffle[b,#]&)/@Tuples[{"","+","-"},(e=Length[b=Characters@#])-1]]&

रिटर्न {3, 123-45-67+89}उदाहरण के लिए।

परीक्षण का मामला पूरा होने में लगभग 0.09 सेकंड लगते हैं।

— कीउ गण
स्रोत

2

पायथन 2 , 256 230 208 205 172 171 170 165 बाइट्स, पुनरावृत्ति विधि

चास ब्राउन को 33 धन्यवाद
एक बाइट बचा जब len(a)द्वारा प्रतिस्थापितw
एक बाइट बचा जब z-=1;d=zद्वारा प्रतिस्थापितd=z=z-1

q=[];a=input()
w=len(a);z=n=3**w
while z-n/3:
 d=z=z-1;j=0;b=''
 while d:r=d%3;d/=3;b+=a[j]+chr(r+43)*(d>0!=r-1);j+=1
 if eval(b)==100:q+=[(len(b)-w,b)]
print min(q)

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

थोड़ा स्पष्टीकरण , बेस 3 में प्रतिनिधित्व का उपयोग करते हुए, कोड सभी संभव संयोजनों के अनुसार ऑपरेटरों के साथ अंकों को इंटरएक्टिव करता है {'+', '-', कॉन्सेप्टन}।

पायथन 2 , 167 बाइट्स, पुनरावर्ती विधि

def f(s):
 if len(s)==1:return[s]
 b=s[0];q=[]
 for z in f(s[1:]):q+=[b+'+'+z,b+'-'+z,b+z]
 return q
a=input()
print min((len(x)-len(a),x)for x in f(a)if eval(x)==100)

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

कुछ आउटपुट

"399299"    --> (1, '399-299')
"987654321" --> (4, '98-76+54+3+21')
"1111111"   --> (3, '1+111-1-11')

— mdahmoune
स्रोत

1

मुझे Divmod का उपयोग पसंद है! कुछ गोल्फ मैं देख सकता हूं: list(input())बस के साथ बदलें input(), क्योंकि एक स्ट्रिंग 6 बाइट्स को बचाने के लिए पहले से ही चलने योग्य है; 12 बाइट्स को बचाने के b.count('+')+b.count('-')साथ बदलें len(b)-len(a); और उसके chr(r+43)साथ बदलें chr(r+43)*(d>0!=r-1)और फिर आप b=b[:-1].replace(',','')नेट 15 बाइट्स ( (d>0!=r-1)यह बराबर है (d>0 and 0!=r-1)) को बचाने के लिए लाइन को हटा सकते हैं ।

— चास ब्राउन

2

ब्रेकीलॉग , 36 बाइट्स

~cịᵐ{|ṅ}ᵐ{+100&{ℕṫ,"+"↻|ṫ}ᵐcbE&kl;E}

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

हालांकि इसमें से आधे से अधिक आउटपुट स्वरूप को प्राप्त करना है। वास्तविक मुख्य तर्क केवल:

15 बाइट्स

~cịᵐ{|ṅ}ᵐ.+100∧

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

यह [123, –45, –67,89] जैसी सूची देता है। अभिव्यक्ति तत्वों का योग है, और ऑपरेटरों की संख्या सूची की लंबाई से 1 कम है।

~cLhℕ∧100~+Lलगभग 12 बाइट्स के लिए लगभग काम करता है ( इसे ऑनलाइन आज़माएं! ) - लेकिन यह TIO पर पूर्ण 9 अंकों के इनपुट को संभालने के लिए बहुत धीमा है, और इससे भी महत्वपूर्ण बात यह है कि यह इनपुट के लिए विफल रहता है 10808- जैसे कि अग्रणी शून्य होने के लिए संख्याओं को विभाजित करने के लिए Brachylog बहुत स्मार्ट है, इसलिए doesn ' t [108, -08] विभाजन देखें।

— sundar - मोनिका को बहाल करना
स्रोत

1

हास्केल , 180 178 बाइट्स

m#[a]=[[a]]
m#(b:r)|s<-m#r=m(b:)=<<[s,m('+':)s,m('-':)s]
o '-'=(-)
o _=(+)
(p:r)?a|[(b,s)]<-lex r=s?o p a(read b)
_?a=a
g s=minimum[(sum[1|c<-t,c<'0'],t)|t<-map#s,('+':t)?0==100]

इसे ऑनलाइन आज़माएं! उपयोग: g "123456789"पैदावार (3,"123-45-67+89")।

#सभी संभावित शर्तों की एक सूची बनाता है, ?एक शब्द का मूल्यांकन करता है और gउन शर्तों को फ़िल्टर करता है जो 100 का मूल्यांकन करते हैं और एक को ऑपरेंड की न्यूनतम संख्या के साथ वापस करते हैं।

— Laikoni
स्रोत

0

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

L’““+“_”ṗ⁸żF¥ⱮV⁼ȷ2ƊƇLÞḢṄḟ⁸L

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

यह नहीं कह सकता कि मैंने जोनाथन एलन के पुराने उत्तर से कुछ संकेत नहीं लिए। ;-)

उनके जवाब की तुलना में, यह केवल दो बाइट्स छोटा (30) है, पांच नहीं, अगर हम भाषा के कारण तुलना निष्पक्ष बनाते हैं:

L’““+“_”ṗ⁸żF¥Ð€V⁼ȷ2$$ÐfLÞḢṄḟ⁸L

यदि हम दूसरे तरीके (पुराने के बजाय नए संस्करण) की तुलना करते हैं, तो अंतर समान होता है (उसके 29 बाइट्स बन जाते हैं, नीचे देखा गया है):

ŒṖżⱮL’⁾+_ṗƲ$€ẎFV=ȷ2ƲƇLÞḢFṄḟ³L

— आउटगोल्फ को एरिक करें
स्रोत

100 के लिए सबसे अच्छा संचालन

अवलोकन

इनपुट

उत्पादन

उदाहरण

जावास्क्रिप्ट (ईएस 6), 153 176 बाइट्स

MATL , 37 36 बाइट्स

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

[अजगर 2], 164 158 बाइट्स

PHP, 166 171 बाइट्स

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

कैसे?

गणितज्ञ, १३६ 146 149 156 165 166 बाइट्स

पायथन 2 , 256 230 208 205 172 171 170 165 बाइट्स, पुनरावृत्ति विधि

पायथन 2 , 167 बाइट्स, पुनरावर्ती विधि

ब्रेकीलॉग , 36 बाइट्स

15 बाइट्स

हास्केल , 180 178 बाइट्स

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