चुनौती:

इनपुट:

दो पूर्णांक पैरामीटर aऔर b(जहां a<bऔर अंतर कम से कम 2 है)

आउटपुट:

इस पाठ को आउटपुट करें या लौटाएँ, जहाँ पर aऔर bभरे हुए हैं:

(a,b) = ]a,b[ = {a<x<b}   = {a<x&&x<b}   = a+1..b-1
[a,b) = [a,b[ = {a<=x<b}  = {a<=x&&x<b}  = a..b-1
(a,b] = ]a,b] = {a<x<=b}  = {a<x&&x<=b}  = a+1..b
[a,b] = [a,b] = {a<=x<=b} = {a<=x&&x<=b} = a..b

चुनौती नियम:

I / O लचीला है। STDOUT में मुद्रित किया जा सकता है, एक स्ट्रिंग / चरित्र-सरणी के रूप में लौटाया जा सकता है, आदि को दो पूर्णांक, दशमलव, स्ट्रिंग्स के रूप में इनपुट किया जा सकता है (यह सुनिश्चित नहीं है कि चूंकि आपको गणना करने की आवश्यकता है a+1और b-1, लेकिन मेरे अतिथि ..), आदि।
नई लाइनों की अग्रणी और / या अनुगामी किसी भी राशि की अनुमति है, और प्रत्येक पंक्ति के लिए अनुगामी और / या अग्रणी स्थानों की किसी भी राशि की अनुमति है।
समान संकेतों (एक ही कॉलम में उन्हें संरेखित करने सहित) पर रिक्त स्थान अनिवार्य हैं, अन्य वर्णों के बीच रिक्त स्थान की अनुमति नहीं है।
a+1और b-1इन गणनाओं के बाद सही मूल्यों के साथ प्रतिस्थापित किया जाता है।
आपको ≤इसके बजाय उपयोग करने की अनुमति नहीं है <=।
आपको &इसके बजाय उपयोग करने की अनुमति नहीं है &&।
आपको संख्याओं को आउटपुट करने की अनुमति है .0(जब तक यह सुसंगत है, और एक दशमलव शून्य से अधिक नहीं)।
आप मान सकते हैं aकि b( (a,b)सही होने के लिए) की तुलना में कम से कम 2 कम है ।
दिखाए गए क्रम में लाइनें आउटपुट होनी चाहिए।

उदाहरण:

इनपुट: a=-5, b=10
आउटपुट:

(-5,10) = ]-5,10[ = {-5<x<10}   = {-5<x&&x<10}   = -4..9
[-5,10) = [-5,10[ = {-5<=x<10}  = {-5<=x&&x<10}  = -5..9
(-5,10] = ]-5,10] = {-5<x<=10}  = {-5<x&&x<=10}  = -4..10
[-5,10] = [-5,10] = {-5<=x<=10} = {-5<=x&&x<=10} = -5..10

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति दी जाती है। तुम्हारा कॉल।
डिफ़ॉल्ट ढीले निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

पुनश्च: उन लोगों के लिए जिन्होंने सैंडबॉक्स में इस चुनौती को देखा था जब यह अभी भी एक कोलमोगोरोव-जटिलता के साथ चुनौती थी aऔर bकठिन-कोडित था, मैंने इसे बोरिंग हार्ड-कोडित और एन्कोडेड उत्तरों को रोकने के लिए एक इनपुट चुनौती में बदल दिया है जैसे हम आमतौर पर साथ होते हैं। केसी चुनौतियां।

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

2

तो के लिए a=5, b=6अभी भी उत्पादन (5,6) = ... = 6...5?

— l4m2

1

@ l4m2 आह .. इस बारे में नहीं सोचा था। आप मान सकते हैं aऔर bहमेशा कम से कम 2 अलग होंगे। मैं चुनौती संपादित करूंगा।

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

2

यह जितना मुझे उम्मीद थी उससे कहीं ज्यादा मजेदार निकला। अच्छी चुनौती!

— अरनौलड

@DigitalTrauma क्षमा करें, लेकिन यह सटीक क्रम है।

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

2

स्टेक्स , 74 बाइट्स

ÉyU≤₧pΔz▀σ┬`♪•a≤☻Σ╕←k►¬╗Ö)ßâL╫§▐ƒ┼°╚íS3:Y¶7]7♂e╖à╙ô≥;M0h8♦Oún┼ë`←B╠╫║┌♂α▲╚

इसे चलाएं और डीबग करें

यह स्टैक्स के स्ट्रिंग टेम्पलेट्स का भारी उपयोग करता है। अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह ऐसा दिखता है।

Y                   save second input in Y register (first is already in X)
.)].([|*            cross product of ")]" and "(["; this produces [")(", ")[", "](", "]["]
{                   begin block to map over interval delimiters
  E"`x,`y"a++       push delimiters separately, then wrap them around the inputs    e.g. "(-5,10)"
  c"(])["|t         copy last value, then replace parentheses with braces           e.g. "]-5,10["
  ih'=              push half the iteration index and "="                           e.g. 0 "="
  |;'=              push iteration parity (alternating 0 and 1) and "="             e.g. 0 "=" 0 "="
  "{`x<`*x<`*`y}"   multiply each equal sign by its occurrence, and template        e.g. "{-5<x<10}"
  c'x.x&:mR         copy last value, then replace "x" with "x&&x"                   e.g. "{-5<x&&x<10}"
  yvih xi|e         calculate final bounds offsets                                  e.g. -5 1 10 -1
  "`+..`+"          add inputs to offsets, and embed in template                    e.g. "-4..9"
  5l                combine last 5 values into array
m                   map [")(", ")[", "](", "]["] using block
:<                  left-align grid colums to add extra spaces
m" = "*             for each row, join with " = " and output

इसको चलाओ

— पुनरावर्ती
स्रोत

10

जावास्क्रिप्ट (ईएस 6), 184 182 181 180 बाइट्स

करी सिंटैक्स में इनपुट लेता है (a)(b)। 4 स्ट्रिंग्स की एक सरणी देता है।

a=>b=>[1,2,3,4].map(k=>'31,23 = 31,23 = {10x72}4{10x&&x72}45..6'.replace(/\d/g,(n,i)=>[(+n?k<3:k&1)?'<':'<=',a,b,'][)([[]('[(i*17^k*718)%9],'   = '.slice(k/2),a+k%2,b-(k<3)][n%7]))

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

कैसे?

1, k row 4 के साथ प्रत्येक पंक्ति k के लिए , हम निम्नलिखित टेम्पलेट से शुरू करते हैं:

"31,23 = 31,23 = {10x72}4{10x&&x72}45..6"

और प्रत्येक दशमलव अंकों की जगह एन की स्थिति में मैं निम्न तालिका के अनुसार:

  n  | Replaced with           | Code
-----+-------------------------+------------------------------------------
 0,7 | comparison operator     | (+n ? k < 3 : k & 1) ? '<' : '<='
  1  | a                       | a
  2  | b                       | b
  3  | interval bound          | '][)([[]('[(i * 17 ^ k * 718) % 9]
  4  | a substring of '   = '  | '   = '.slice(k / 2)
  5  | either 'a' or 'a + 1'   | a + k % 2
  6  | either 'b' or 'b - 1'   | b - (k < 3)

— Arnauld
स्रोत

4

पायथन 2 , 225 203 195 बाइट्स

a,b=input()
for d in 0,1:
 for m in 0,1:k=`a`+','+`b`;o='{'+`a`+'<'+m*'=';c='x<'+d*'='+`b`+'}'+'  '[m+d:];print' = '.join(['(['[m]+k+')]'[d],']['[m]+k+'[]'[d],o+c,o+'x&&'+c,`a+1-m`+'..'+`b-1+d`])

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

— OVS
स्रोत

3

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

t=a,b=input()
for j in 1,0:
 for i in 1,0:print"%%s%d,%d%%s = "%t*2%('[('[i],'])'[j],'[]'[i],']['[j])+"{%d<%sx%%s<%s%d}%s = "%(a,'='[i:],'='[j:],b,' '*(i+j))*2%('','&&x')+`a+i`+'..'+`b-j`

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

— XNOR
स्रोत

3

जावा (JDK 10) , 251 बाइट्स

a->b->("(a,b)q]a,b[q{a<x<b}  q{a<x&&x<b}  q"+-~a+".."+~-b+"\n[a,b)q[a,b[q{a<=x<b} q{a<=x&&x<b} qa.."+~-b+"\n(a,b]q]a,b]q{a<x<=b} q{a<x&&x<=b} q"+-~a+"..b\n[a,b]q[a,b]q{a<=x<=b}q{a<=x&&x<=b}qa..b").replace("a",a+"").replace("b",b+"").replace("q"," = ")

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

क्रेडिट

-50 बाइट्स केविन क्रूज़सेन को धन्यवाद

— ओलिवियर ग्रेजायर
स्रोत

मैं अभी भी गोल्फ कर रहा हूँ ...

— ओलिवियर ग्रेजायर

लगभग गोल्फ के साथ किया? मुझे 85 बाइट निकालने का सुझाव मिला। ;)

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

@KevinCruijssen मैं कर रहा हूँ, लेकिन मैंने 85 बाइट्स से बहुत कम दूर कर दिए ...

— ओलिवियर ग्राईगोइरे

1

तीन बोरिंग के साथ 251 बाइट्स.replace ।

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

हाँ, मूल रूप से मेरा पहला समाधान स्वरूपण के बजाय वास्तव में प्रतिस्थापित करता है। अच्छा लगा। बोरिंग वास्तव में, लेकिन अच्छा है! :-)

— ओलिवियर ग्रेजायर

3

पर्ल 5 , 181 बाइट्स

मुझे लगा कि इसने बहुत कम काम किया होगा ...

$_="sd,ds = sd,ds = {dsxsd}s= {dsx&&xsd}s= d..d
"x4;s!s!("()][<<   [)[[<=<  (]]]<<=  [][]<=<= "=~s/[<= ]+/$&$&/gr=~/ +|<=|./g)[$-++]!ge;s/d/$F[$x%2]+{8,1,9,-1,19,-1,28,1}->{$x++}/ge

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

व्याख्या

मूल रूप से यह एक का उपयोग कर रहा था printfप्रारूप स्ट्रिंग, लेकिन सिर्फ होने sऔर dजब साथ संयुक्त कम था s///।

पहले प्रारूप स्ट्रिंग में बनाया गया है $_और चौगुनी है, फिर सभी sएस प्रतिस्थापन ब्रैकेट के आधार पर <, इसी ब्रैकेट , <=या रिक्त स्थान के साथ बदल दिए जाते हैं । मैं प्रत्येक ब्लॉक के अंतिम 5 वर्णों के दोहराव के साथ कुछ और बाइट्स बचाने की उम्मीद करता हूं, लेकिन इससे केवल 2 बाइट्स की बचत होती है। परिणामी स्ट्रिंग को रिक्त स्थान के तत्वों, <=या एकल वर्णों में विभाजित किया गया है ।

अंत में सभी ds को वांछित संख्या से बदल दिया जाता है, जिसे हैश की के माध्यम से वर्तमान प्रतिस्थापन के सूचकांक के आधार पर समायोजित किया जाता है।

— डोम हेस्टिंग्स
स्रोत

3

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

x=>y=>`(0)7]0[7{1<x<2}  7{1<52}  73..4
[0)7[0[7{18x<26{185261..4
(0]7]0]7{1<x826{1<5=263..2
[0]7[0]7{18x82}7{185=2}71..2`.replace(/\d/g,d=>[[x,y],x,y,x+1,y-1,`x&&x<`,`}  = `,` = `,`<=`][d])

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

— झबरा
स्रोत

3

एम 4 , 194

मैक्रो प्रोसेसर के लिए एक नौकरी की तरह लगता है। यकीन नहीं होता कि m4 एक प्रोग्रामिंग भाषा के लिए हमारे मानकों को पूरा करता है। इसमें लूपिंग की क्षमता और अंकगणित का विस्तार है, इसलिए मैं इसके निशान के करीब हूं।

define(l,`$1a,b$2 = $3a,b$4 = {a<$5x<$6b} $8= {a<$5x&&x<$6b} $8= $7')dnl
l(`(',`)',],[,,,incr(a)..decr(b),`  ')
l([,`)',[,[,=,,a..decr(b),` ')
l(`(',],],],,=,incr(a)..b,` ')
l([,],[,],=,=,a..b,)

यह m4 पर मेरा पहला गैर-तुच्छ लुक है, इसलिए मुझे संदेह है कि मैंने जितने गोल्फिंग अवसर गंवाए हैं।

-Dकमांड लाइन पर मैक्रो परिभाषाओं का उपयोग करके इनपुट पारित किए जाते हैं । निश्चित नहीं है कि अगर स्कोर के लिए कुछ भी जोड़ने की जरूरत है, जहां तक मैं बता सकता हूं कि यह एकमात्र तरीका है जो सार्थक मानकों को पारित करता है:

$ m4 -Da=-5 -Db=10 intnot.m4
(-5,10) = ]-5,10[ = {-5<x<10}   = {-5<x&&x<10}   = -4..9
[-5,10) = [-5,10[ = {-5<=x<10}  = {-5<=x&&x<10}  = -5..9
(-5,10] = ]-5,10] = {-5<x<=10}  = {-5<x&&x<=10}  = -4..10
[-5,10] = [-5,10] = {-5<=x<=10} = {-5<=x&&x<=10} = -5..10 $

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

T4 में इतनी जल्दी M4 जोड़ने के लिए धन्यवाद @Dennis !

— डिजिटल आघात
स्रोत

1

मैं यह नहीं देखता कि एम 4 जवाब देने के लिए एक वैध प्रोग्रामिंग भाषा क्यों नहीं होगी, लेकिन मुझे क्या पता। ;) -Dतर्क के रूप में यह पूरी तरह से ठीक है। मेरे चुनौती विवरण में मैंने कहा कि I / O पूरी तरह से लचीला है, इसलिए आप इनपुट को STDIN, फंक्शन पैरामीटर्स, प्रोग्राम कमांड-लाइन आर्ग्युमेंट्स, कंपाइलर-झंडे, फाइल पढ़ना, या जो भी अन्य इनपुट-मेथड के बारे में सोच सकते हैं, वह पूरी तरह से है। आप पर निर्भर करता है।

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

2

पायथन 2 , 277 199 193 189 बाइट्स

a,b=input()
for i in 4,3,2,1:x,y=i%2,i>2;e='=';p=`a`+','+`b`;print'(['[x]+p+'])'[y],e,']['[x]+p+']['[y],e,2*('{%d<%s<%s%d} %s= '%(a,e*x+'%sx',e[y:],b,i/2*' '))%('','x&&')+`a+1-x`+'..'+`b-y`

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

— TFeld
स्रोत

2*('{%d<%s<%s%d} %s= '%(a,e*x+'%sx',e[y:],b,i/2*' '))%('','x&&')-> 2*('{%d<%s%%sx<%s%d} %s= '%(a,e*x,e[y:],b,i/2*' '))%('','x&&')दो बचाता है :)

— योनातन एलन

1

एक्सेल, 399 बाइट्स

="("&A1&","&B1&") = ]"&A1&","&B1&"[ = {"&A1&"<x<"&B1&"}   = {"&A1&"<x&&x<"&B1&"}   = "&A1+1&".."&B1-1&"
 ["&A1&","&B1&") = ["&A1&","&B1&"[ = {"&A1&"<=x<"&B1&"}  = {"&A1&"<=x&&x<"&B1&"}  = "&A1&".."&B1-1&"
 ("&A1&","&B1&"] = ]"&A1&","&B1&"] = {"&A1&"<x<="&B1&"}  = {"&A1&"<x&&x<="&B1&"}  = "&A1+1&".."&B1&"
 ["&A1&","&B1&"] = ["&A1&","&B1&"] = {"&A1&"<=x<="&B1&"} = {"&A1&"<=x&&x<="&B1&"} = "&A1&".."&B1

यहां कुछ भी विशेष रूप से दिलचस्प नहीं है।

— Wernisch
स्रोत

1

सी (जीसीसी) , 224 237 बाइट्स

f(a,b,c,m,n,o){for(c=0;++c<5;printf("%c%d,%d%c = %c%d,%d%c = {%d<%sx<%s%d}%*s= {%d<%sx&&x<%s%d}%*s= %d..%d\n","[("[m],a,b,"])"[n],"[]"[m],a,b,"]["[n],a,"="+m,"="+n,b,o,"",a,"="+m,"="+n,b,o,"",a+m,b-n)){m=c%2;n=c<3;o=3-c/2;}}

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

प्रारूप स्ट्रिंग में "<[=]" को ले जाने से मुझे सरणी को पूरी तरह से हटाने की अनुमति मिली। इसके अलावा, लूप printf()में जाने से forएक अर्धविराम बच गया।

मूल उत्तर

f(a,b,c,m,n,o){char*e[]={"<=","<"};for(c=0;++c<5;){m=c%2;n=c<3;o=3-c/2;printf("%c%d,%d%c = %c%d,%d%c = {%d%sx%s%d}%*s= {%d%sx&&x%s%d}%*s= %d..%d\n","[("[m],a,b,"])"[n],"[]"[m],a,b,"]["[n],a,e[m],e[n],b,o,"",a,e[m],e[n],b,o,"",a+m,b-n);}}

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

यहाँ विशेष रूप से उल्लेखनीय कुछ भी नहीं है: मैंने फ़ंक्शन के आकार को शेविंग करने के लिए सामान्य ट्रिक्स का उपयोग किया ( intफ़ंक्शन हेडर में ऑटो को उतारा , K & R शैली का उपयोग करके, स्ट्रिंग स्थिरांक में अनुक्रमण किया।) "{<=", "<}} को एक में संग्रहीत करना। सरणी इस चुनौती के लिए एक प्रारूप विनिर्देशक सम्मिलित करने की तुलना में अधिक आकार-कुशल साबित हुई क्योंकि इसका उपयोग एक से अधिक बार किया गया था।

— ErikF
स्रोत

216 बाइट्स

— छत

1

जावास्क्रिप्ट, 273 258 232 बाइट्स

धन्यवाद केविन क्रूज़सेन मुझे 15 बाइट्स बचाने के लिए!

e=>f=>'(j)h]j[h{a<x<b}  h{a<x&&x<b}  hc..d\n[j)h[j[h{a<=x<b} h{a<=x&&x<b} ha..d\n(j]h]j]h{a<x<=b} h{a<x&&x<=b} hc..b\n[j]h[j]h{a<=x<=b}h{a<=x&&x<=b}ha..b'.replace(/a|b|c|d|h|j/g,m=>{return{a:e,b:f,c:e+1,d:f-1,h:" = ",j:e+","+f}[m]})

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

मुझे उस विचार को देने के लिए TFeld के लिए धन्यवाद, मेरे मूल उत्तर से लगभग 60 बाइट्स की बचत।

अधूरा:

e => f => '(j)h]j[h{a<x<b}  h{a<x&&x<b}  hc..d'
 + '\n[j)h[j[h{a<=x<b} h{a<=x&&x<b} ha..d'
 + '\n(j]h]j]h{a<x<=b} h{a<x&&x<=b} hc..b'
 + '\n[j]h[j]h{a<=x<=b}h{a<=x&&x<=b}ha..b'
.replace(/a|b|c|d|h|j/g, m=>{
        return {a:e,b:f,c:e+1,d:f-1,h:" = ",j:e+","+f}[m]
    }
)

जावास्क्रिप्ट (मूल उत्तर), 340 बाइट्स

(a,b)=>alert(`(${a},${b}) = ]${a},${b}[ = {${a}<x<${b}}   = {${a}<x&&x<${b}}   = ${a+1}..${b-1}\n[${a},${b}) = [${a},${b}[ = {${a}<=x<${b}}  = {${a}<=x&&x<${b}}  = ${a}..${b-1}\n(${a},${b}] = ]${a},${b}] = {${a}<x<=${b}}  = {${a}<x&&x<=${b}}  = ${a+1}..${b}\n[${a},${b}] = [${a},${b}] = {${a}<=x<=${b}} = {${a}<=x&&x<=${b}} = ${a}..${b}\n`)

— यादृच्छिक आदमी
स्रोत

1

नई-लाइन {a<=x&&\nx<=b}वहां नहीं होनी चाहिए, और आप पहले गायब हैं (a,b) = । कुछ गोल्फ के लिए: चेतावनी के बजाय आप बस परिणाम वापस कर सकते हैं। (m)=>हो सकता है m=>। (e,f)=>हो सकता है e=>f=>। और अगर आप उपयोग कर सकते हैं gबजाय बनाने के सीधे let g=: m=>{return{a:e,b:f,c:e+1,d:f-1}[m]}। इसे ऑनलाइन 258 बाइट्स आज़माएं । और शायद अधिक गोल्फ हो सकता है, मैं जेएस में बहुत कुशल नहीं हूं ..

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

वैसे तुम मुझसे ज्यादा कुशल हो। युक्तियों के लिए धन्यवाद, मैं उन्हें जवाब में जोड़ दूंगा

— यादृच्छिक आदमी

ठीक है, मैं ज्यादातर कोई है जो जावा (या श्वेत रिक्ति) में golfs हूँ, और इन गोल्फ युक्तियाँ भी जावा जवाब, जो ज्यादातर यही वजह है कि मैं उन्हें पता करने के लिए लागू होते हैं: (m)->करने के लिए m->; (e,f)->को e->f->, और var g=new int[]{...}return g[m]को return new int[]{...}[m]। ;) इसके अलावा, मैं इस SO पर अभी दो साल से अधिक समय से सक्रिय हूं, इसलिए मैंने देखा है कि JS उत्तर भी इस तरह की चीजों का उपयोग करते हैं।

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

1

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

.+
$&()][<<  ¶$&[)[[<=< ¶$&(]]]<<= ¶$&[][]<=<=
((.*),(.*))(.)(.)(.)(.)(<=?)(<=?)( *)
$4$1$5 = $6$1$7 = {$2$8x$9$3}$10 = {$2$8x&&x$9$3}$10 = $2_$8..$3_$9
_<=

\d+_
$&*___
T`<`_` _+<|\.-_+<
___<
_
__<
-1
_(_*)
$.1
-0
0

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
$&()][<<  ¶$&[)[[<=< ¶$&(]]]<<= ¶$&[][]<=<=
((.*),(.*))(.)(.)(.)(.)(<=?)(<=?)( *)
$4$1$5 = $6$1$7 = {$2$8x$9$3}$10 = {$2$8x&&x$9$3}$10 = $2_$8..$3_$9

परिणाम का मुख्य थोक बनाएँ।

_<=

यदि चर ढीली असमानता में शामिल है, तो मूल्य समावेशी है, इसलिए हम प्लेसहोल्डर को हटा सकते हैं।

\d+_
$&*___

मान को एक में परिवर्तित करें और 2 जोड़ें।

T`<`_` _+<|\.-_+<

सख्त निम्न असमानता या नकारात्मक सख्त ऊपरी असमानता के लिए प्लेसहोल्डर निकालें। यह अभी भी 2 जोड़ा गया है, लेकिन 1 वांछित परिणाम देने के बाद, बाद में घटाया जाएगा।

___<
_

अन्य गैर-शून्य सख्त असमानताओं से 2 घटाना, मूल मूल्य को बहाल करना, जिसमें से 1 बाद में घटाया जाएगा।

__<
-1

की एक सख्त ऊपरी असमानता बदलें 0करने के लिए -1।

_(_*)
$.1

शेष सख्त असमानताओं से 1 घटाएं और दशमलव में परिवर्तित करें।

-0
0

एक और धार मामले को ठीक करें।

— नील
स्रोत

1

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

lambda a,b:[eval('f"'+"{%r[j]}{a},{b}{%r[i]} = "*2%('([',')]','][','[]')+"{{{a}<{'='[:j]}x%s<{'='[:i]}{b}}}{'  '[i+j:]} = "*2%('','&&x')+'{a+j}..{b-i}"')for i in(1,0)for j in(1,0)]

व्याख्या

मूल रूप से एक एफ-स्ट्रिंग बनाता है जिसका मूल्यांकन सूची समझ में किया जाता है। पुरानी शैली के %स्ट्रिंग प्रक्षेप का उपयोग अभिव्यक्तियों के मूल्यांकन में देरी करने के लिए किया जाता है जब तक कि एफ-स्ट्रिंग का मूल्यांकन नहीं किया जाता है।

lambda a,b:[
    eval(
      'f"' +                                                            # f-string prefix
      "{%r[j]}{a},{b}{%r[i]} = "*2%('([',')]','][','[]') +              # first two terms
      "{{{a}<{'='[:j]}x%s<{'='[:i]}{b}}}{'  '[i+j:]} = "*2%('','&&x') + # second two terms
      '{a+j}..{b-i}"'                                                   # last term
      )
    for i in(1,0)for j in(1,0)
    ]

स्ट्रिंग का पहला भाग, 'f' ', f-string के लिए उपसर्ग बन जाएगा।

स्ट्रिंग का दूसरा भाग पहले दो अंतराल अभिव्यक्तियों के लिए प्रारूप स्ट्रिंग बनाता है। %rप्रारूप में उद्धरण लगाने की आवश्यकता से बचाने के लिए उपयोग किया जाता है, अर्थात, "{%r[j]}"जैसा है "{'%s'[j]}"। जब एफ-स्ट्रिंग का मूल्यांकन किया जाता है, तो सही ब्रैकेट का चयन किया जाता है।

स्ट्रिंग का तीसरा भाग अगले दो अंतराल अभिव्यक्तियों का निर्माण करता है।

अंतिम भाग एफ-स्ट्रिंग के "a..b" भाग को प्रारूपित करता है।

इकट्ठे हुए एफ-स्ट्रिंग की तरह दिखता है: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

जब एफ-स्ट्रिंग का मूल्यांकन किया जाता है, तो ब्रेसिज़ के सभी अभिव्यक्तियों को {}उनके मूल्य से बदल दिया जाता है। तो, {a}के मान से प्रतिस्थापित किया जाता है a, और यदि j 0 या यदि j 1 है, तो इसे {'(['[j]}बदल दिया जाता है।([

— RootTwo
स्रोत

1

SOGL V0.12 , 110 बाइट्स

<ŗŗ}”⁴
"{ŗ<ŗx³
W}↔b ,e++Κ+²
4∫2\f»¹Aa{Ƨ[(²a{Ƨ[]²ba{ =*}eο+++:³⁴;³&&x⁴a_beh+H⁶;!+ƨ.+Κο++++}⁰№Iā;0E{┼ē4=‽"δY↑æ‘┼

यह कोशिश करो!

— dzaima
स्रोत

0

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

def f(a,b):
 l=[['(',')','[','<',1],['[',']',']','<=',0]]
 r=[0,1]
 for i in r:
  for j in r:
   print(('%s%d,%d%s='*2+'{%d%sx%s%d}={%d%sx&&x%s%d}=%d..%d')%((l[j][0],a,b,l[i][1],l[1-j][2],a,b,l[i][2])+(a,l[j][3],l[i][3],b)*2+(a+l[j][4],b-l[i][4])))

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

— गौयांग किन
स्रोत

अंतराल की सूचनाएँ

चुनौती:

इनपुट:

आउटपुट:

चुनौती नियम:

उदाहरण:

सामान्य नियम:

स्टेक्स , 74 बाइट्स

जावास्क्रिप्ट (ईएस 6), 184 182 181 180 बाइट्स

कैसे?

पायथन 2 , 225 203 195 बाइट्स

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

जावा (JDK 10) , 251 बाइट्स

क्रेडिट

पर्ल 5 , 181 बाइट्स

व्याख्या

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

एम 4 , 194

पायथन 2 , 277 199 193 189 बाइट्स

एक्सेल, 399 बाइट्स

सी (जीसीसी) , 224 237 बाइट्स

जावास्क्रिप्ट, 273 258 232 बाइट्स

जावास्क्रिप्ट (मूल उत्तर), 340 बाइट्स

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

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

व्याख्या

SOGL V0.12 , 110 बाइट्स

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