ท้าทาย:

การป้อนข้อมูล:

พารามิเตอร์จำนวนเต็มสองตัว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อย่างน้อย 2 ต่ำกว่าb(เพื่อ(a,b)ให้ถูกต้อง)
• บรรทัดควรเป็นเอาต์พุตตามลำดับที่แสดง

ตัวอย่าง:

อินพุต: 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

กฎทั่วไป:

• นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ
  อย่าปล่อยให้ภาษาโค้ดกอล์ฟกีดกันคุณจากการโพสต์คำตอบด้วยภาษาที่ไม่ได้เข้ารหัส พยายามหาคำตอบสั้น ๆ ที่เป็นไปได้สำหรับภาษาโปรแกรม 'ใด ๆ '
• กฎมาตรฐานจะใช้สำหรับคำตอบของคุณดังนั้นคุณจึงได้รับอนุญาตให้ใช้ STDIN / STDOUT ฟังก์ชั่น / วิธีการที่มีพารามิเตอร์ที่เหมาะสมและชนิดผลตอบแทนโปรแกรมเต็มรูปแบบ การโทรของคุณ
• ช่องโหว่เริ่มต้นเป็นสิ่งต้องห้าม
• หากเป็นไปได้โปรดเพิ่มลิงค์พร้อมทดสอบรหัสของคุณ
• นอกจากนี้โปรดเพิ่มคำอธิบายหากจำเป็น

PS: สำหรับผู้ที่เคยเห็นความท้าทายนี้ใน Sandboxเมื่อมันยังคงเป็นความท้าทายที่ซับซ้อนของ kolmogorovด้วยaและbฮาร์ดโค้ดฉันได้เปลี่ยนมันเป็นความท้าทายอินพุตเพื่อป้องกันคำตอบที่เข้ารหัสยากและน่าเบื่อเหมือนที่เราเห็น ความท้าทายของ KC

Stax , 74 ไบต์

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

เรียกใช้และแก้ไขข้อบกพร่อง

สิ่งนี้ใช้เทมเพลตสตริงของ stax อย่างมาก คลายกล่อง ungolfed และแสดงความคิดเห็นมันมีลักษณะเช่นนี้

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

เรียกใช้อันนี้

JavaScript (ES6), 184 182 181 180 ไบต์

(a)(b)จะเข้าในไวยากรณ์ currying ส่งคืนอาร์เรย์ 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]))

ลองออนไลน์!

อย่างไร?

สำหรับแต่ละแถวkด้วย1 ≤ k ≤ 4เราเริ่มต้นด้วยแม่แบบต่อไปนี้:

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

และแทนที่แต่ละทศนิยมหลักnในตำแหน่งที่ฉันตามตารางต่อไปนี้:

  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)

Python 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`])

ลองออนไลน์!

Python 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`

ลองออนไลน์!

Java (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 ไบต์ขอบคุณKevin Cruijssen

Perl 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และสั้นเมื่อรวมกับds///

ครั้งแรกสตริงรูปแบบที่สร้างขึ้นใน$_และ quadruplicated แล้วทั้งหมดss จะถูกแทนที่ด้วยวงเล็บที่สอดคล้องกัน<, <=หรือช่องว่างขึ้นอยู่กับดัชนีทดแทน ฉันหวังว่าจะประหยัดไบต์ได้มากขึ้นด้วยการทำซ้ำ 5 ตัวอักษรสุดท้ายของแต่ละบล็อก แต่สิ่งนี้จบลงด้วยการประหยัดเพียง 2 ไบต์เท่านั้น สตริงผลลัพธ์ถูกแบ่งออกเป็นองค์ประกอบของช่องว่าง<=หรืออักขระเดียว

ในที่สุดds ทั้งหมดจะถูกแทนที่ด้วยหมายเลขที่ต้องการซึ่งจะถูกปรับตามดัชนีของการเปลี่ยนปัจจุบันผ่านทางปุ่มแฮช

JavaScript, 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])

ลองออนไลน์

m4 , 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 $

ลองมันออนไลน์

ขอบคุณ @Dennis ที่เพิ่ม m4 ให้กับ TIOอย่างรวดเร็ว!

Python 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`

ลองออนไลน์!

Excel, 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

ไม่มีอะไรน่าสนใจเป็นพิเศษที่นี่

C (gcc) , 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 โดยจัดทำดัชนีเป็นค่าคงที่สตริง) การจัดเก็บ {"<=", "<"} อาร์เรย์ได้รับการพิสูจน์แล้วว่ามีขนาดที่มีประสิทธิภาพมากกว่าการแทรกตัวระบุรูปแบบสำหรับความท้าทายนี้เนื่องจากมีการใช้มากกว่าหนึ่งครั้ง

Javascript, 273 258 232 bytes

ขอบคุณ Kevin Cruijssen ที่ช่วยฉัน 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 ไบต์จากคำตอบเดิมของฉัน

Ungolfed:

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]
    }
)

Javascript (คำตอบดั้งเดิม), 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`)

เรติน่า , 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+_
$&*___

แปลงค่าเป็น unary และเพิ่ม 2

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

ลบตัวยึดตำแหน่งสำหรับความไม่เท่าเทียมกันที่ต่ำกว่าอย่างเข้มงวดหรือความไม่เท่าเทียมด้านบนที่เข้มงวดเชิงลบ มันยังคงมี 2 เพิ่ม แต่ 1 จะถูกลบออกในภายหลังให้ผลลัพธ์ที่ต้องการ

___<
_

ลบ 2 จากความไม่เท่าเทียมที่เข้มงวดอื่น ๆ ที่ไม่เป็นศูนย์เรียกคืนค่าดั้งเดิมจากที่ 1 จะถูกลบออกในภายหลัง

__<
-1

เปลี่ยนความไม่เท่าเทียมกันด้านบนที่เข้มงวดของการ0-1

_(_*)
$.1

ลบ 1 จากความไม่เท่าเทียมที่เข้มงวดที่เหลือและแปลงเป็นทศนิยม

-0
0

แก้ไขกรณีขอบอื่น

Python 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)]

คำอธิบาย

โดยทั่วไปสร้าง f-string ที่ถูกประเมินในรายการความเข้าใจ การ%แก้ไขสตริงแบบเก่าใช้เพื่อหน่วงเวลาการประเมินนิพจน์จนกว่าจะมีการประเมิน f-string

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]}"เมื่อประเมิน f-string จะมีการเลือกวงเล็บที่ถูกต้อง

ส่วนที่สามของสตริงสร้างนิพจน์ช่วงสองช่วงถัดไป

ส่วนสุดท้ายจัดรูปแบบส่วน "a..b" ของ f-string

สตริง f ประกอบดูเหมือนว่า: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

เมื่อประเมิน f-string นิพจน์ทั้งหมดในเครื่องหมายปีกกา{}จะถูกแทนที่ด้วยค่าของพวกเขา ดังนั้น {a}ได้รับการแทนที่ด้วยค่าของaและ{'(['[j]}ได้รับการแทนที่ด้วย(ถ้า j เป็น 0 หรือ[ถ้า j เป็น 1

SOGL V0.12 , 110 ไบต์

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

ลองที่นี่!

Python 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])))

ลองออนไลน์!