यो लड़का, यह राशि चाहिए


67

प्रत्येक सकारात्मक पूर्णांक को किसी भी आधार b .5 में अधिकतम तीन पलिंडिक धनात्मक पूर्णांक के योग के रूप में व्यक्त किया जा सकता है ।   सिलेरुएलो एट अल।, 2017

एक धनात्मक पूर्णांक किसी दिए गए आधार में पैलिंड्रोमिक होता है यदि उस आधार में इसका प्रतिनिधित्व, अग्रणी शून्य के बिना, उसी पीछे की ओर पढ़ता है। निम्नलिखित में, केवल आधार b = 10 पर विचार किया जाएगा।

पैलिंड्रोमिक संख्याओं के योग के रूप में अपघटन अद्वितीय नहीं है । उदाहरण के लिए, के 5रूप 5में या के रूप में सीधे व्यक्त किया जा सकता है 2, 3। इसी तरह, के 132रूप में 44, 44, 44या के रूप में विघटित किया जा सकता है121, 11

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए, इसके योग अपघटन को तीन या उससे कम सकारात्मक पूर्णांकों में उत्पन्न करते हैं, जो आधार 10 में पलिंडोमिक हैं।

अतिरिक्त नियम

  • उपयोग किए गए एल्गोरिदम को मनमाने ढंग से बड़े इनपुट के लिए काम करना चाहिए। हालाँकि, यह स्वीकार्य है यदि प्रोग्राम मेमोरी, समय या डेटा प्रकार प्रतिबंधों द्वारा सीमित है।

  • इनपुट और आउटपुट किसी भी उचित माध्यम से लिया जा सकता है । इनपुट और आउटपुट प्रारूप हमेशा की तरह लचीला है।

  • आप प्रत्येक इनपुट के लिए एक या एक से अधिक वैध डिकम्पोजिशन का उत्पादन करने का विकल्प चुन सकते हैं, जब तक कि आउटपुट प्रारूप अस्पष्ट है।

  • प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा मेंमानक खामियों को मना किया जाता है।

  • बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण

चूंकि एक इनपुट में कई डिकम्पोजिशन हो सकते हैं, ये उदाहरण हैं जैसे कि परीक्षण के मामले। प्रत्येक अपघटन को एक अलग रेखा पर दिखाया गया है।

Input  ->  Output

5     ->   5
           2, 3

15    ->   1, 3, 11
           9, 6

21    ->   11, 9, 1
           7, 7, 7

42    ->   22, 11, 9
           2, 7, 33

132   ->   44, 44, 44
           121, 11

345   ->   202, 44, 99
           2, 343

1022  ->   989, 33
           999, 22, 1

9265  ->   9229, 33, 3
           8338, 828, 99

32
एमएमएम, शीर्षक
में वाक्य

मुझे आश्चर्य है: क्या कोई पूर्णांक है जिसे दो पैलिन्ड्रोम में बनाया जाना चाहिए? यह एक अच्छा परीक्षण का मामला होगा (यदि नहीं, हे, गोल्फरों इस तथ्य का उपयोग कर सकते हैं और केवल जाँच k=1और k=3।)
लिन

@ लियन लगता है "असम्भव" है, क्योंकि प्रत्येक इनपुट के लिए काफी कुछ डिकम्पोजिशन निकलता है। लेकिन जैसा कि हम जानते हैं, मैथ्स में अंतर्ज्ञान इतना भ्रामक हो सकता है ...
लुइस मेंडो

1
यदि आप अनुमति दे रहे हैं तो k=1(मूल संख्या पहले से ही एक ख़ास है ) के रूप में, इसका मतलब है कि आप अन्य 2 संख्याओं को मान रहे हैं दोनों 0. तो यदि 0 संख्याओं में से एक के रूप में स्वीकार्य है, तो किसी भी संख्या को किया जाना चाहिए। के साथ k=2भी काम करेगा k=3अगर तीन में से एक नंबर 0. है
डारेल हॉफमैन

मुझे नहीं लगता कि कोई संख्या है जो केवल 2. के योग के रूप में व्यक्त की जा सकती है। इसलिए, आप केवल 3 और 1 के मामले को कवर कर सकते हैं और 2 को अनदेखा कर सकते हैं
मैजिक ऑक्टोपस Urn

जवाबों:


19

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

~+ℕᵐ.↔ᵐ

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

हैरानी की बात है कि धीमी गति से नहीं।

व्याख्या

(?)~+  .          Output is equal to the Input when summed
     ℕᵐ.          Each element of the Output is a positive integer
       .↔ᵐ(.)     When reversing each element of the Output, we get the Output

2
.स्पष्टीकरण में यादृच्छिक के साथ क्या है , और (.)? वास्तव में Brachylog पता नहीं है।
मैजिक ऑक्टोपस Urn

3
@MagicOctopusUrn .आउटपुट चर है। ~+, ℕᵐऔर ↔ᵐविधेय हैं जिनके पास एक बाएँ और दाएँ चर हैं। उन लोगों के दोहराव से .संकेत मिलता है कि आउटपुट उन 3 विधेयकों में से प्रत्येक में सीधे शामिल है। अंतिम (.)यहाँ प्रदर्शित करने के लिए है कि आउटपुट वैरिएबल प्रोग्राम के अंतिम चर है। इसलिए, अंतिम वर्णित संबंध वास्तव में है .↔ᵐ.जिसका अर्थ है "आउटपुट में आउटपुट परिणामों पर रिवर्स मैपिंग"
घातक

पिछले इनपुट में बहुत अच्छा> 10000 हो सकता है
RosLuP


8

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

ŒṗDfU$ṪḌ

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

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

ŒṗDfU$ṪḌ  Main link. Argument: n (integer)

Œṗ        Find all integer partitions of n.
  D       Convert each integer in each partition to base 10.
     $    Combine the two links to the left into a chain.
    U     Upend; reverse all arrays of decimal digits.
   f      Filter the original array by the upended one.
      Ṫ   Take the last element of the filtered array.
          This selects  the lexicographically smallest decomposition of those with
          the minimal amount of palindromes.
       Ḍ  Undecimal; convert all arrays of decimal digits to integers.

5
मैं बस ~ 140 बाइट्स के साथ एक समाधान प्रस्तुत करना चाहता था, फिर मुझे 8 बाइट्स दिखाई देते हैं और मैं पसंद कर रहा हूं: "नहीं, मेरा पोस्ट नहीं करना चाहिए"।
YU NO WORK

15
भाषाओं में स्कोर की तुलना बहुत अधिक अर्थहीन है। मैंने एक पायथन जवाब खुद पोस्ट किया है , इसलिए नहीं कि इस जवाब को हराने का मौका है, बल्कि इसलिए कि यह सबसे छोटा पायथन जवाब है जिसके बारे में मैं सोच सकता हूं।
डेनिस

8

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

def f(n):p=[x for x in range(n+1)if`x`==`x`[::-1]];print[filter(None,[a,b,n-a-b])for a in p for b in p if n-a-b in p]

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

सूची की एक सूची प्रिंट करता है, जिनमें से प्रत्येक एक समाधान है। रॉड ने 9 बाइट बचाए।


-9 बाइट्स फंक्शन पर स्विच करना, cघटाना के साथ बदलना और उपयोग करनाfilter
रॉड

1
@Rod धन्यवाद! filter(Noneजब मैं रात का खाना बना रहा था, तब मुझे मारा। c → n-a-bअच्छा है :)
लिन

7

जावास्क्रिप्ट (ईएस 6), 115 ... 84 83 बाइट्स

हमेशा एक तीन-तत्व सरणी देता है, जहां अप्रयुक्त प्रविष्टियों को शून्य के साथ गद्देदार किया जाता है।

f=(n,b=a=0)=>(r=[b,a%=n,n-a-b]).some(a=>a-[...a+''].reverse().join``)?f(n,b+!a++):r

परीक्षण के मामलों


6

आर, 126 बाइट्स 145 बाइट्स

19 बाइट्स बंद करने के लिए Giuseppe को धन्यवाद

function(n){a=paste(y<-0:n)
x=combn(c(0,y[a==Map(paste,Map(rev,strsplit(a,"")),collapse="")]),3)
unique(x[,colSums(x)==n],,2)}

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

व्याख्या

R के पास स्ट्रिंग्स को रिवर्स करने के लिए एक देशी तरीका नहीं है और कई डिफ़ॉल्ट स्ट्रिंग ऑपरेशन नंबरों पर काम नहीं करते हैं। इसलिए पहले हम सकारात्मक पूर्णांक (प्लस 0) की श्रृंखला को वर्णों में बदलते हैं।

आगे हम 0 और सभी पैलिंड्रोम के वेक्टर का निर्माण करते हैं। स्ट्रिंग रिवर्सल के लिए वर्णों द्वारा प्रत्येक संख्या को विभाजित करने की आवश्यकता होती है, वेक्टर के क्रम को उलटते हुए और बिना किसी अंतराल के उन्हें वापस चिपकाते हैं।

आगे मैं तीन के सभी समूहों (यहां जहां 0 महत्वपूर्ण हैं) को जांचना चाहता हूं, सौभाग्य से आर में एक संयोजन संयोजन फ़ंक्शन है जो एक मैट्रिक्स, प्रत्येक कॉलम को एक संयोजन में लौटाता है।

मैं आवेदन करता हूं colSums फ़ंक्शन को मैट्रिक्स पर और केवल उन तत्वों को रखता जो आपूर्ति किए गए लक्ष्य के बराबर हैं।

अंत में, क्योंकि दो 0 हैं, दो सकारात्मक पूर्णांकों के किसी भी सेट को डुप्लिकेट किया जाएगा, इसलिए मैं स्तंभों पर एक अद्वितीय फ़ंक्शन का उपयोग करता हूं।

आउटपुट एक मैट्रिक्स है जहां प्रत्येक स्तंभ सकारात्मक, लंबित पूर्णांक का एक सेट होता है जो लक्ष्य मान के लिए योग होता है। यह आलसी है और रिटर्न 0 है जब 3 से कम तत्वों का उपयोग किया जाता है।


1
128 बाइट्स । , हालांकि, Mappalindromes उत्पन्न करने के लिए अच्छा उपयोग !
Giuseppe

ओह, एक 126 बटर
Giuseppe

4

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

L<4aŒḂ€Ạ
ŒṗÇÐf

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

बहुत, बहुत अकुशल।


बहुत धीमा लगता है, भले ही लक्ष्य कोड लंबाई हो, मेरे लिए यह केवल लंबाई नहीं है
RosLuP

@RosLuP यहां आपको कोड को कुशल बनाए रखने का लक्ष्य नहीं है, यहां आप जितना संभव हो कोड को छोटा करने का लक्ष्य रखते हैं। सिद्धांत में काम करना पड़ता है , जरूरी नहीं कि यह व्यवहार में है, क्योंकि यह एक कोड-गोल्फ चुनौती है, न कि कोड-गोल्फ प्रतिबंधित-जटिलता या कोड-गोल्फ प्रतिबंधित-समय चुनौती।
आउटगोल्फ

4

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

RŒḂÐfṗ3R¤YS⁼³$$Ðf

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

-6 बाइट्स हाइपरएनुट्रिनो का धन्यवाद।

सभी तरह से आउटपुट देता है। हालाँकि आउटपुट में कुछ डुप्लिकेट होते हैं।


1
वहाँ एक is palindrome
बिलिन

इसके अलावा, यदि आप सामान्य (उभरी हुई) सीमा का उपयोग करते हैं, तो आप अपनी अंतिम 4 बाइट्स निकाल सकते हैं
हाइपरयूट्रीनो


@cairdcoinheringaahing अभी भी न तो डेनिस को हरा सकता है और न ही एरिक को। वैसे भी क्या मैं खंडित -संकुचित-आधारित Base64- एन्कोडेड URL को डीक्रिप्ट करने जा रहा हूं ?
user202729

@ user202729 हुह, लिंक को सही ढंग से कॉपी नहीं किया होगा। कोड थाRŒḂÐfṗ3R¤YS⁼¥Ðf
caird coinheringaahing



3

हास्केल , 90 86 79 बाइट्स

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

f=filter
h n=[f(>0)t|t<-mapM(\_->f(((==)<*>reverse).show)[0..n])"123",sum t==n]

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

कुछ दोहराव के साथ सभी समाधानों की एक सूची देता है।


79 बाइट्स mapMऔर घोषणा के साथ f=filter: इसे ऑनलाइन आज़माएं!
लकोनी

3

जावा (ओपनजेडके 8) , 185 बाइट्स

n->{for(int i=0,j=n,k;++i<=--j;)if(p(i))for(k=0;k<=j-k;k++)if(p(k)&p(j-k))return new int[]{j-k,k,i};return n;}
boolean p(int n){return(""+n).equals(""+new StringBuffer(""+n).reverse());}

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

सही राशि प्राप्त करने के लिए TIO से 1 बाइट निकालें क्योंकि सबमिशन ;में लैम्बडा नहीं है।


मेरी राय में यह अब तक पोस्ट किए गए सभी एक अन्य समाधानों से बेहतर है
RosLuP

@RosLuP ऐसा क्यों है, अगर मैं पूछ सकता हूं?
ओलिवियर ग्रेजायर 12

क्योंकि अंत में इनपुट के लिए जवाब दें> 500000 (अगर मुझे अच्छी तरह याद है)
RosLuP

के i++<--jबजाय सुझाव++i<=--j
छत 18

2

प्रोटॉन , 117 बाइट्स

a=>filter(l=>all(p==p[by-1]for p:map(str,l)),(k=[[i,a-i]for i:1..a-1])+sum([[[i,q,j-q]for q:1..j-1]for i,j:k],[]))[0]

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

एक समाधान आउटपुट


920 इनपुट के रूप में tio में 1 मिनट में आउटपुट नहीं लौटाते हैं ... मैं 364757698688 की बात नहीं करता, लेकिन केवल 920
RosLuP

1
@RosLuP इससे कोई फर्क नहीं पड़ता। कोड-गोल्फ में दक्षता एक महत्वपूर्ण चीज नहीं है। यह सैद्धांतिक रूप से इनपुट के सभी आकारों के लिए काम करेगा ताकि कोई फर्क न पड़े; पर्याप्त समय दिया गया है, यह
920 के

2

पायथ ,  16 12  10 बाइट्स

ef_I#`MT./

यहाँ यह कोशिश करो!

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

ef_I # `MT। / ~ पूर्ण कार्यक्रम।

        ./ ~ पूर्णांक विभाजन
 f ~ एक चर T के साथ फ़िल्टर करें।
     `MT ~ एक स्ट्रिंग प्रतिनिधित्व के लिए टी के प्रत्येक तत्व का नक्शा।
    # 1 फ़िल्टर।
  _I ~ पैलिंड्रोम है? (यानी उलटा पर आक्रमणकारी?)
ई ~ अंतिम तत्व प्राप्त करें।

2

05AB1E , 17 बाइट्स

LʒÂQ}U4GXNãDO¹QÏ=

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


परिणाम को तीन सूचियों में इस प्रकार प्रस्तुत करता है:

  • लंबाई 1 की पैलिंड्रोमिक सूची (मूल संख्या IFF यह पैलिंड्रोमिक है)।

  • लंबाई 2 की पलिंड्रोमिक सूची।

  • लंबाई की पैलिंड्रोमिक सूची 3।


2

Axiom, 900 बाइट्स

R(x)==>return x;p(r,a)==(n:=#(a::String);if r<0 then(a=0=>R a;n=1 or a=10^(n-1)=>R(a-1);a=10^(n-1)+1=>R(a-2));if r>0 then(n=1 and a<9=>R(a+1);a=10^n-1=>R(a+2));r=0 and n=1=>1;v:=a quo 10^(n quo 2);repeat(c:=v;w:=(n rem 2>0=>v quo 10;v);repeat(c:=10*c+w rem 10;w:=w quo 10;w=0=>break);r<0=>(c<a=>R c;v:=v-1);r>0=>(c>a=>R c;v:=v+1);R(c=a=>1;0));c)
b:List INT:=[];o:INT:=0
f(a:NNI):List INT==(free b,o;o:=p(-1,o);w:=0;c:=#b;if c>0 then w:=b.1;e:=a-o;e>10000000=>R[];if w<e then repeat(w:=p(1,w);w>e=>break;b:=cons(w,b));g:List INT:=[];for i in #b..1 by-1 repeat(b.i>e=>break;g:=cons(b.i,g));if o>e then g:=cons(o,g);n:=#g;for i in 1..n repeat(x:=g.i;x=a=>R[x];3*x<a=>break;for j in i..n repeat(y:=g.j;t:=x+y;t>a=>iterate;t=a=>R[x,y];t+y<a=>break;for k in j..n repeat(z:=t+g.k;z=a=>R[x,y,g.k];z<a=>break)));[])
D(a:NNI):List INT==(free o;p(0,a)=1=>[a];o:=a;for j in 1..10 repeat(t:=f(a);#t>0=>R t);[])

परीक्षण कोड

--Lista random di n elmenti, casuali compresi tra "a" e "b"
randList(n:PI,a:INT,b:INT):List INT==
    r:List INT:=[]
    a>b =>r
    d:=1+b-a
    for i in 1..n repeat
          r:=concat(r,a+random(d)$INT)
    r

test()==
   a:=randList(20,1,12345678901234)
   [[i,D(i)] for i in a]

यदि इस कोड को 1,2,3 palindrome में X की संख्या को विघटित करना है, तो यह कोड क्या करता है, यह palindrome N <X के पास की कोशिश करता है और 2 palindrome में XN को विघटित करता है; यदि XN के इस अपघटन में सफलता प्रतिफल 3 पैलिंड्रोम मिला है; यदि यह विफल हो जाता है, तो यह प्रचलित palindrome G <N <X की कोशिश करता है और XG 2 पैलिंड्रोम आदि में अपघटित करने की कोशिश करता है। Ungolf कोड (लेकिन यह कुछ बग संभव है)

 R(x)==>return x

-- se 'r'=0 ritorna 1 se 'a' e' palindrome altrimenti ritorna 0
-- se 'r'>0 ritorna la prossima palindrome >'a'
-- se 'r'<0 ritorna la prossima palindrome <'a'
p(r,a)==(n:=#(a::String);if r<0 then(a=0=>R a;n=1 or a=10^(n-1)=>R(a-1);a=10^(n-1)+1=>R(a-2));if r>0 then(n=1 and a<9=>R(a+1);a=10^n-1=>R(a+2));r=0 and n=1=>1;v:=a quo 10^(n quo 2);repeat(c:=v;w:=(n rem 2>0=>v quo 10;v);repeat(c:=10*c+w rem 10;w:=w quo 10;w=0=>break);r<0=>(c<a=>R c;v:=v-1);r>0=>(c>a=>R c;v:=v+1);R(c=a=>1;0));c)

b:List INT:=[]   -- the list of palindrome
o:INT:=0         -- the start value for search the first is a

--Decompose 'a' in 1 or 2 or 3 palindrome beginning with prev palindrome of o
--if error or fail return []
f(a:NNI):List INT==
    free b,o
    -- aggiustamento di o, come palindrome piu' piccola di o
    o:=p(-1,o)
    -- aggiustamento di b come l'insieme delle palindromi tra 1..a-o compresa
    w:=0;c:=#b
    if c>0 then w:=b.1 --in w la massima palindrome presente in b
    e:=a-o
    output["e=",e,"w=",w,"o=",o,"#b=",#b]
    e>10000000=>R[]   --impongo che la palindrome massima e' 10000000-1
    if w<e then       --se w<a-o aggiungere a b tutte le palindromi tra w+1..a-o
          repeat(w:=p(1,w);w>e=>break;b:=cons(w,b))
                      -- g e' l'insieme dei b palindromi tra 1..a-o,o
    g:List INT:=[];for i in #b..1 by-1 repeat(b.i>e=>break;g:=cons(b.i,g))
    if o>e then g:=cons(o,g)
    --output["g=",g,b]
    n:=#g
    for i in 1..n repeat
        x:=g.i
        x=a  =>R[x]
        3*x<a=>break
        for j in i..n repeat
           y:=g.j;t:=x+y
           t>a   =>iterate
           t=a   =>R[x,y]
           t+y<a =>break
           for k in j..n repeat
                z:=t+g.k
                z=a =>R[x,y,g.k]
                z<a =>break
    []

--Decompose 'a' in 1 or 2 or 3 palindrome
--if error or fail return []
dPal(a:NNI):List INT==
   free o
   p(0,a)=1=>[a]
   o:=a                  -- at start it is o=a
   for j in 1..10 repeat -- try 10 start values only
        t:=f(a)
        #t>0=>R t
   []

परिणाम:

(7) -> [[i,D(i)] for i in [5,15,21,42,132,345,1022,9265] ]
   (7)
   [[5,[5]], [15,[11,4]], [21,[11,9,1]], [42,[33,9]], [132,[131,1]],
    [345,[343,2]], [1022,[999,22,1]], [9265,[9229,33,3]]]
                                                      Type: List List Any
                                   Time: 0.02 (IN) + 0.02 (OT) = 0.03 sec
(8) -> test()
   (8)
   [[7497277417019,[7497276727947,624426,64646]],
    [11535896626131,[11535888853511,7738377,34243]],
    [2001104243257,[2001104011002,184481,47774]],
    [3218562606454,[3218561658123,927729,20602]],
    [6849377785598,[6849377739486,45254,858]],
    [375391595873,[375391193573,324423,77877]],
    [5358975936064,[5358975798535,136631,898]],
    [7167932760123,[7167932397617,324423,38083]],
    [11779002607051,[11779000097711,2420242,89098]],
    [320101573620,[320101101023,472274,323]],
    [5022244189542,[5022242422205,1766671,666]],
    [5182865851215,[5182864682815,1158511,9889]],
    [346627181013,[346626626643,485584,68786]],
    [9697093443342,[9697092907969,443344,92029]],
    [1885502599457,[1885502055881,542245,1331]], [10995589034484,[]],
    [1089930852241,[1089930399801,375573,76867]],
    [7614518487477,[7614518154167,246642,86668]],
    [11859876865045,[11859866895811,9968699,535]],
    [2309879870924,[2309879789032,81418,474]]]
                                                      Type: List List Any
      Time: 0.25 (IN) + 115.17 (EV) + 0.13 (OT) + 28.83 (GC) = 144.38 sec

1

जावा (ओपनजेडके 8) , 605 बाइट्स

प्रिंटों को धोखा दिया जाता है लेकिन वे अफिक पर प्रतिबंध नहीं लगाते हैं

a->{int i=0,j,k,r[]=new int[a-1];for(;i<a-1;r[i]=++i);for(i=0;i<a-1;i++){if(r[i]==a&(""+r[i]).equals(""+new StringBuffer(""+r[i]).reverse()))System.out.println(r[i]);for(j=0;j<a-1;j++){if(r[i]+r[j]==a&(""+r[i]).equals(""+new StringBuffer(""+r[i]).reverse())&(""+r[j]).equals(""+new StringBuffer(""+r[j]).reverse()))System.out.println(r[i]+" "+r[j]);for(k=0;k<a-1;k++)if(r[i]+r[j]+r[k]==a&(""+r[i]).equals(""+new StringBuffer(""+r[i]).reverse())&(""+r[j]).equals(""+new StringBuffer(""+r[j]).reverse())&(""+r[k]).equals(""+new StringBuffer(""+r[k]).reverse()))System.out.println(r[i]+" "+r[j]+" "+r[k]);}}}

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




1

पर्ल 6 , 51 बाइट्स

{first *.sum==$_,[X] 3 Rxx grep {$_ eq.flip},1..$_}

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

  • grep { $_ eq .flip }, 1 .. $_ 1 से इनपुट नंबर तक सभी पैलिंड्रोमिक संख्याओं की सूची तैयार करता है।
  • 3 Rxx उस सूची को तीन बार दोहराता है।
  • [X]क्रॉस-उत्पाद ऑपरेटर के साथ उस सूची-की-सूचियों को कम कर देता है X, जिसके परिणामस्वरूप 1 से इनपुट नंबर तक सभी 3-ट्यूलिप की संख्या सूची में होती है।
  • first *.sum == $_ पहला ऐसा 3-टूपल खोजता है जो इनपुट नंबर को बताता है।

आप एक बाइट को उल्टा न करके बचा सकते हैं xx 3
जो राजा

1

पायथन 3 , 106 बाइट्स

lambda n:[(a,b,n-a-b)for a in range(n)for b in range(n)if all(f'{x}'==f'{x}'[::-1]for x in(a,b,n-a-b))][0]

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

TIO लिंक में मैंने तेज (लेकिन 1 बाइट लंबा संस्करण) का उपयोग किया है जो संभावित संयोजनों की पूरी सूची बनाने और पहले लेने के बजाय जनरेटर के रूप में पहला वैध परिणाम लेता है।


0

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

0 से n तक 3 पलिंड्रोम्स के सभी संभावित संयोजनों की एक सूची बनाता है, पहले एक का पता लगाता है, जिसका योग मिलान करता है, फिर जीरो को चुभता है।

->n{a=(0..n).select{|x|x.to_s==x.to_s.reverse};a.product(a,a).find{|x|x.sum==n}-[0]}

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


0

++ , 62 बाइट्स जोड़ें

D,g,@,BDdbR=
D,l,@@,$b+=
D,k,@@*,
L,RÞgdVBcB]Gd‽kdG‽k€bF++A$Þl

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

~ 50 बाइट्स एक स्पष्टीकरण लिखते समय गोल्फ। एक लंबो फ़ंक्शन को परिभाषित करता है जो समाधान युक्त सूचियों की एक सूची देता है।

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

1,231nn

1,2,...,ngRÞggA

अगले भाग को तीन और भागों में विभाजित किया जा सकता है:

BcB]
Gd‽k
dG‽k€bF

A[1 2 3 4 ...][[1] [2] [3] [4] ... ]Ak

D,k,@@*,

यह फ़ंक्शन मूल रूप से कुछ भी नहीं करता है। यह दो तर्क प्राप्त करता है और उन्हें एक सरणी में लपेटता है। हालांकि, मेज जल्दी, यहाँ जादू की चाल है। यह दो सूचियाँ लेता है और उन दो सूचियों के बीच तत्वों की प्रत्येक जोड़ी उत्पन्न करता है। इसलिए [1 2 3]और [4 5 6]उत्पन्न करता है [[1 4] [1 5] [1 6] [2 4] [2 5] [2 6] [3 4] [3 5] [3 6]]। यह तब अपना कार्यात्मक तर्क लेता है (इस मामले में k) और प्रत्येक जोड़ी पर उस फ़ंक्शन को चलाता है, जो इस मामले में, बस जोड़े को उसी रूप में लौटाता है।

A€bF

1,23nln

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