चुनौती

एक सकारात्मक पूर्णांक Nजो कि 28 या उससे अधिक है, को देखते हुए , संख्याओं की एक सूची को आउटपुट Nकरता है जो प्रत्येक अंक 1को 7एक बार बिल्कुल उपयोग करता है । आप एक कार्यक्रम या फ़ंक्शन के रूप में दे सकते हैं।

जब तक आप उनमें से प्रत्येक का उपयोग दोहराव के बिना करते हैं, तब तक अंक स्वयं या संक्षिप्त रूप से प्रकट हो सकते हैं। उदाहरण के लिए, [12, 34, 56, 7]मान्य है, जैसा है [1, 27, 6, 4, 35]और है [1234, 567], लेकिन है [123, 34567]या नहीं [3, 2, 1476]। संख्याओं को सूचीबद्ध करने वाला क्रम कोई मायने नहीं रखता।

यदि N1-7 के साथ नहीं बनाया जा सकता है, तो रिटर्न या आउटपुट कुछ भी नहीं।

अन्य सूचना

यह कोड गोल्फ है, इसलिए गुरुवार 15 अक्टूबर तक बाइट्स में सबसे छोटा कोड है।
टिप्पणियों में कोई भी प्रश्न पूछें।
चुनौती में जो कुछ भी मैं निर्दिष्ट नहीं करता, वह आपके ऊपर है।
मानक खामियों को अस्वीकार कर दिया जाता है।

उदाहरण

ये किसी भी भ्रम को दूर कर सकते हैं:

इनपुट

उत्पादन

[1, 2, 3, 4, 5, 6, 7]

इनपुट

उत्पादन

[56, 7, 4, 31, 2]

इनपुट

उत्पादन

[1234567]

इनपुट

उत्पादन

कुछ नहीं, 29 अमान्य है।

इनपुट

उत्पादन

[1234, 657]

इनपुट

उत्पादन

[15, 342, 7, 6]

जरूरत पड़ने पर और बनाऊंगा।

यहाँ FryAmTheEggman के सौजन्य से इन सात नंबरों के साथ बनाए गए सभी संभावित नंबरों का एक पेस्टबिन है।

code-golf math number

— The_Basset_Hound
स्रोत

इसके लिए आउटपुट क्या है 29?

— ज्योबिट्स

4

यदि आप चाहते हैं कि आउटपुट कुछ भी नहीं हो, तो (N/A)आउटपुट के रूप में मत डालें ।

— mbomb007 20

1

@LukStorms [1234566, 1]एक मान्य आउटपुट नहीं है, क्योंकि 6 को दोहराया जाता है। आप आउटपुट में संख्याओं को नहीं दोहरा सकते हैं।

— The_Basset_Hound

2

हो सकता है कि ... ... दशमलव अंकों 1 से 7 तक की संख्या की सूची जो N «तक की राशि है, जो वर्तमान में प्रश्न की तुलना में एक स्पष्ट शब्द है।

— पाओलो एबरमन

3

थोड़ी कम ब्रूट फोर्स सॉल्यूशन के लिए: यह प्रत्येक के लिए 10-गुणांक को निर्दिष्ट करने के बराबर है, 1, ..,, 7ताकि कम से कम उतने 1ही 10कम से कम उतने कम से कम 10'एस 100' के रूप में हो , और इसी तरह।

— xnor

9

पायथ, 18 14 बाइट्स

hfqSjkTjkS7./Q

2 बाइट्स से गोल्फिंग के लिए @isaacg और 2 और के लिए रास्ता प्रशस्त करने के लिए धन्यवाद।

यदि कोई आउटपुट नहीं होना चाहिए, तो कोड क्रैश हो जाएगा, जिसके कारण कोई आउटपुट उत्पन्न नहीं होता है।

यदि आप पर्याप्त धैर्य रखते हैं और यदि पर्याप्त समय और स्मृति दी जाती है, तो यह छोटे-ईश इनपुट के लिए काम करेगा।

सत्यापित करने के लिए कि कोड काम करता है के रूप में इरादा, आप बदल सकते हैं 7एक साथ 3के लिए अंक 1 की रकम 3 के माध्यम से । परीक्षण सूट के लिए यहां क्लिक करें ।

उदाहरण चलता है

$ time pyth/pyth.py -c 'hfqSjkTjkS7./Q' <<< 28
(1, 2, 3, 4, 5, 6, 7)

real    4m34.634s
user    4m34.751s
sys     0m0.101s
$ time pyth/pyth.py -c 'hfqSjkTjkS7./Q' <<< 29 2>/dev/null

real    9m5.819s
user    9m6.069s
sys     0m0.093s

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

           ./Q    Compute all integer partitions of the input.
 f                Filter the integer partitions:
    jkT             Join the integers with empty separator.
   S                Sort the characters of the resulting string.
      jkS7          Join [1, ..., 7] with empty separator.
  q                 Check both results for equality.
                  Keep the partition of `q' returned True.
h                 Retrieve the first element of the filtered list.
                  For a non-empty list, this retrieves the solution.
                  For the empty list, it causes an error and produces no output.

— डेनिस
स्रोत

2

बहुत बढ़िया! काफी एक नवीन दृष्टिकोण। `` `MS7`` से छोटा है r\1\8। इसके अलावा भी @ .. 0ऐसा ही है h।

— isaacg

@isaacg धन्यवाद! मुझे यकीन नहीं है कि मैं कैसे चूक गया h, लेकिन मुझे नहीं पता था Sकि आप इस तरह से उपयोग कर सकते हैं । (ऑनलाइन दुभाषिया में चार संदर्भ का उल्लेख नहीं किया गया है।) अब jkS7भी कम लगता है, क्योंकि मुझे sअब और ज़रूरत नहीं है।

— डेनिस

5

अजगर 3, 109

def f(n,s=set('1234567'),l='0,'):[f(n,s-{x},l+x+c)for c in(',','')for x in s]or n-sum(eval(l))or~print(l[2:])

एक फ़ंक्शन जो एक संख्या लेता है और जैसे में एक ट्यूपल आउटपुट करता है 123,4567,। हां, यह एक मान्य टपल है।

विचार के लिए सभी संभव तार की तरह उत्पन्न करने के लिए है 43,126,7,5,कि अंक 1के माध्यम से 7कोई भी दो अल्पविराम का लगातार साथ अल्पविराम के द्वारा अलग। इस अभिव्यक्ति का एक टूपल के रूप में मूल्यांकन करें, और इसका योग बराबर होता है n, इसे प्रिंट करें और त्रुटि के साथ समाप्त करें।

ऐसे सभी तार बनाने के लिए, हम sउपयोग करने के लिए वर्णों के सेट को ट्रैक करते हैं, और प्रत्येक को या तो अल्पविराम से जोड़ने की कोशिश करते हैं, जिससे अंक प्रविष्टि समाप्त हो जाता है, या बिना, जिस स्थिति में भविष्य के अंक उस पर संक्षिप्त हो जाएंगे।

लघु सर्किटिंग कि जाँच करने के लिए प्रयोग किया जाता है sखाली है, क्योंकि सूची कंप्यूटर अनुप्रयोग खाली है, और है कि n==sum(eval(l)), जिस स्थिति में हम प्रिंट lऔर लेने के द्वारा एक त्रुटि के साथ समाप्त ~की Noneमुद्रण द्वारा दिया (इस के लिए Sp3000 के लिए धन्यवाद।)।

मेरा मानना है कि पायथन 3.5 में, दो वर्णों को लिखकर बचाया जा सकता है s={*'1234567'}(धन्यवाद Sp3000)।

वहाँ कुछ छोटे झुंझलाहट है कि चार खाने के लिए है। एक यह है कि इस मामले में, जो बिना कॉमा के साथ lदिख 1234567रहा है, इसे एक ही नंबर के रूप में पार्स किया जाता है और कॉलिंग sumएक त्रुटि देता है। यह lतत्व के साथ शुरू करने 0और प्रिंट करते समय इसे छीनने की हैक के साथ नियंत्रित किया जाता है । इसकी कीमत 6 चार्ट है।

पुनरावृत्ति cअल्पविराम और रिक्त स्ट्रिंग से अधिक annoyingly अधिक शब्दों वाले है for c in(',',''), के बाद से अजगर 3 इस टपल नग्न होने के लिए अनुमति नहीं है। मुझे लगता है कि वहाँ कुछ चार होना चाहिए ?जो संख्या में अनदेखा किया जाता है ',?'4 चार्ट कम करने के लिए, लेकिन ऐसा कोई चार्ट नहीं लगता है।

पुरानी विधि:

अजगर 2, 117

def f(n,s={1,2,3,4,5,6,7},l=[],p=0):
 if{n,p}|s=={0}:print l;1/0
 if p:f(n-p,s,l+[p])
 for x in s:f(n,s-{x},l,p*10+x)

एक फ़ंक्शन को परिभाषित करता है जो एक नंबर लेता है और एक सूची प्रिंट करता है।

विचार यह है कि हर शाखा को आज़माने के लिए पुनरावृत्ति का उपयोग किया जाए। चर ट्रैक हैं

शेष राशि की nआवश्यकता है
sउपयोग करने के लिए शेष अंकों का समूह
lअब तक की गई संख्या की सूची
वर्तमान आंशिक रूप से गठित संख्या p

जब n==0और sखाली है, प्रिंट lऔर त्रुटि द्वारा समाप्त।

यदि वर्तमान आंशिक रूप से गठित संख्या pगैर-शून्य है, तो इसे सूची में जोड़ने और शेष राशि से हटाने का प्रयास करें।

प्रत्येक अंक के लिए xहम इसका उपयोग कर सकते हैं s, इसे जोड़ने pऔर इसे हटाने के लिए प्रयास करें s।

— XNOR
स्रोत

4

अजगर, २३

#iRThfqQsiR10Ts./M.pS7q

Naive brute बल, बहुत धीमा ऑनलाइन, मेरे कंप्यूटर पर लगभग एक मिनट लेता है। Pyth golfs के सामान्य "लूप को हमेशा के लिए अपवाद" के रूप में उपयोग करता है, जहाँ संयोजन की परिणामी फ़िल्टर्ड सूची तक पहुँचना असंभव संख्याओं के लिए एक त्रुटि का कारण बनता है, जैसे 29।

एक pythonic सूची की तरह आउटपुट, उदा

1891
[1234, 657]
100
[1, 2, 34, 56, 7]
370
[12, 345, 6, 7]

यहाँ सभी 10136 नंबरों का एक पेस्ट है जो इस तरह से बनाया जा सकता है।

— FryAmTheEggman
स्रोत

क्या मैं उदाहरणों के लिए पास्टबिन लिंक का उपयोग कर सकता हूं?

— The_Basset_Hound

@The_Basset_Hound बेशक, आगे बढ़ें।

— फ्राइअमईएग्गमैन

3

पायथन 2.7, 178 172 169 बाइट्स

n=input()
for i in range(8**7):
 for j in len(set('%o0'%i))/8*range(128):
    s=''
    for c in'%o'%i:s+='+'[:j%2*len(s)]+c;j/=2
    if eval(s)==n:print map(int,s.split('+'));1/0

ध्यान दें कि अंतिम तीन पंक्तियों को टैब के साथ इंडेंट किया जाना चाहिए, लेकिन मैं यह नहीं जान सकता कि इस संपादक में ऐसा कैसे किया जाए।

संपादित करें: Sp3000 की मदद से घोंसले के शिकार की एक परत चपटी

— xsot
स्रोत

दुर्भाग्य से एसई स्ट्रिप्स टैब, इसलिए यह कहना कि यह इंडेंट होने का मतलब कैसे ठीक है :)

— Sp3000

आह ठीक है, अभी भी इस साइट के आसपास मेरे रास्ते लगा।

— xsot

3

जावास्क्रिप्ट (ईएस 6), 165 196

थोड़ा छोटा संपादित करें । का उपयोग करके कम किया जा सकता हैeval , लेकिन मुझे यह पसंद है कि यह तेज हो

जानवर बल, शर्म से Pith संस्करण की तुलना में लंबे समय तक, लेकिन तेजी से। एक EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करें।

f=z=>{for(r=i=1e6;r&&++i<8e6;)for(m=/(.).*\1|[089]/.test(w=i+'')?0:64;r&&m--;t.split`+`.map(v=>r-=v,r=z))for(t=w[j=0],l=1;d=w[++j];l+=l)t+=l&m?'+'+d:d;return r?'':t}

function test() { O.innerHTML=f(+I.value) }

test()

// Less golfed

f=z=>{
  for(r=i=1e6; r&&++i<8e6;)
    for(m=/(.).*\1|[089]/.test(w=i+'')?0:64; r&&m--; t.split`+`.map(v=>r-=v,r=z))
      for(t=w[j=0],l=1;d=w[++j];l+=l)
        t+=l&m?'+'+d:d;
  return r?'':t
}

<input id=I value=28><button onclick=test()>-></button><span id=O></span>

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

— edc65
स्रोत

भाषा के कारण लंबे समय तक शर्म की बात नहीं है, मैं वास्तव में आपके जेएस उत्तरों का आनंद

— लेता हूं

1

अजगर 2, 270 268 बाइट्स

from itertools import*;P=permutations
x,d,f=range(1,8),[],input()
r=sum([[int(''.join(str(n)for n in i))for i in list(P(x,j))]for j in x],[])
z=1
while z:
 t=sum([[list(j)for j in P(r,z)]for i in x],[])
 v=filter(lambda i:sum(i)==f,t)
 if v:print v[0];break
 else:z+=1

अभी भी गोल्फिंग पर काम कर रहे हैं।

यह लूप तब तक मिलता है जब तक एक मैच नहीं मिलता है।

— Zach गेट्स
स्रोत

import asशायद ही कभी आवश्यक है - आप कर सकते हैंfrom itertools import*;P=permutations

— Sp3000

यह map(str,i)सूची समझने की तुलना में उपयोग करने के लिए कम है , और आप नेस्टेड सूची को समतल करने के बजाय सीधे सूची r का निर्माण कर सकते हैं: r=[int(''.join(map(str,i)))for j in x for i in P(x,j)]और t के लिए एक समान बात।

— रूथ फ्रैंकलिन

आप `n`इसके बजाय का उपयोग कर सकते हैं str(n), क्योंकि nअधिकतम पूर्णांक से ऊपर कभी नहीं होगा।

— mbomb007

1

हास्केल (145 बाइट्स)

main=getLine>>=print.head.f[1..7].read
f[]0=[[]]
f b s=[n:j|(n,g)<-m b,j<-f g$s-n]
m b=[(d+10*z,g)|d<-b,(z,g)<-(0,filter(/=d)b):m(filter(/=d)b)]

पुनरावृत्ति का उपयोग करता है।

अनगोल्डेड (337 बाइट्स):

delete d = filter (/= d)
main = getLine >>= print . (`form` [1..7]) . read

form s [] | s == 0    = [[]]
form s ds | s <= 0    = []
form s ds | otherwise = [n:ns | (n, ds') <- makeNumbers ds, ns <- form (s-n) ds']

makeNumbers [] = []
makeNumbers ds  = [(d + 10 * n',ds') | d <- ds, (n',ds') <- (0,delete d ds):makeNumbers (delete d ds)]

— jkabrg
स्रोत

0

स्काला, 195 बाइट्स

यह सबसे अधिक कुशल नहीं है और 29 में से आउटपुट प्राप्त करने में 15 मिनट से अधिक समय लगता है लेकिन यह काम करता है

def g(s: Seq[Int]): Iterator[Seq[Int]]=s.combinations(2).map(c=>g(c.mkString.toInt +: s.filterNot(c.contains))).flatten ++ Seq(s)
def f(i: Int)=(1 to 7).permutations.map(g).flatten.find(_.sum==i)

यहाँ कुछ उत्पादन है

scala> f(100)
res2: Option[Seq[Int]] = Some(Vector(46, 35, 12, 7))

scala> f(1891)
res3: Option[Seq[Int]] = Some(Vector(567, 1324))

scala> f(370)
res4: Option[Seq[Int]] = Some(Vector(345, 12, 6, 7))

scala> f(29)
res5: Option[Seq[Int]] = None

— Josem
स्रोत

0

रूबी, 105 बाइट्स

पाशविक बल! 1 और 7654321 के बीच पूर्णांक के 0 और 7 के बीच लंबाई के हर सबसेट को चेक करता है और देखता है कि उनमें से कोई भी हमारे मानदंडों से मेल खाता है या नहीं। आप शायद इसे समाप्त करने के लिए इंतजार नहीं करना चाहते हैं।

->n{8.times{|i|[*1..7654321].permutation(i){|x|return x if
x.join.chars.sort==[*?1..?7]&&eval(x*?+)==n}}}

एल्गोरिथ्म को चलाने और सत्यापित करने के लिए आप खोज स्थान को कम कर सकते हैं, जो आपके द्वारा ज्ञात 7654321सबसे बड़ी संख्या के साथ बदलकर उत्तर में होगा। उदाहरण के लिए, n = 100 के लिए 56, या n = 1891 के लिए 1234। यहाँ उत्तरार्द्ध का एक परीक्षण रन है:

$ ruby -e "p ->n{8.times{|i|[*1..1234].permutation(i){|x|return x if x.join.chars.sort==[*?1..?7]&&eval(x*?+)==n}}}[gets.to_i]" <<< 1891
[657, 1234]

— daniero
स्रोत

0 से 7 पूर्णांक? आपको

— अत्यधिक

@ edc65 आपका मतलब 7 अंकों का है । परिणाम पूर्णांक का एक सेट है, और सेट का आकार इनपुट पर निर्भर करता है।

— डेनिएरो

मैं रूबी नहीं बोलता, मैं कार्यक्रम का काम करता हूं, लेकिन मुझे इसका स्पष्टीकरण नहीं मिला। यदि आपके पूर्णांक 1234567 से कम हैं, तो आपको 7654321 कैसे मिलेगा?

— edc65

@ edc65 आप सही हैं, मुझे उस नंबर को बदलना होगा। मैं इसे और भी बेहतर तरीके से समझाने की कोशिश करूँगा।

— डेनिएरो

7 के माध्यम से अंकों की संख्या 1

चुनौती

अन्य सूचना

उदाहरण

पायथ, 18 14 बाइट्स

उदाहरण चलता है

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

अजगर 3, 109

अजगर, २३

पायथन 2.7, 178 172 169 बाइट्स

जावास्क्रिप्ट (ईएस 6), 165 196

अजगर 2, 270 268 बाइट्स

हास्केल (145 बाइट्स)

स्काला, 195 बाइट्स

रूबी, 105 बाइट्स