Thử thách:

Đầu vào:

Hai tham số nguyên avà b(trong đó a<bvà chênh lệch ít nhất là 2)

Đầu ra:

Xuất hoặc trả lại văn bản này, ở đâu avà bđược điền vào:

(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

Quy tắc thử thách:

• I / O là linh hoạt. Có thể được in thành STDOUT, được trả về dưới dạng chuỗi / ký tự, v.v. Có thể được nhập dưới dạng hai số nguyên, số thập phân, chuỗi (không chắc tại sao vì bạn cần tính toán a+1và b-1, nhưng là khách của tôi ..), v.v.
• Bất kỳ số lượng dòng mới hàng đầu và / hoặc theo dõi nào đều được cho phép, và bất kỳ số lượng dấu vết và / hoặc khoảng trắng hàng đầu nào cho mỗi dòng được cho phép.
• Các khoảng trắng ở các dấu bằng nhau (bao gồm cả các dấu cách để sắp xếp chúng trong cùng một cột) là bắt buộc, khoảng trắng giữa các ký tự khác không được phép.
• a+1và b-1được thay thế bằng các giá trị chính xác sau những tính toán này.
• Bạn không được phép sử dụng ≤thay thế <=.
• Bạn không được phép sử dụng &thay thế &&.
• Bạn được phép xuất các số có .0(miễn là phù hợp và không quá một số thập phân).
• Bạn có thể giả sử alà ít nhất 2 thấp hơn b( (a,b)để chính xác).
• Các dòng nên được xuất theo thứ tự hiển thị.

Thí dụ:

Đầu vào: a=-5, b=10
Đầu ra:

(-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

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

PS: Đối với những người đã xem thử thách này trong Sandbox khi nó vẫn là một thử thách phức tạp kolmogorov với avà bđược mã hóa cứng, tôi đã thay đổi nó thành một thử thách đầu vào để ngăn chặn các câu trả lời được mã hóa và mã hóa nhàm chán như chúng ta thường thấy KC thách thức.

Stax , 74 byte

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

Chạy và gỡ lỗi nó

Điều này sử dụng rất nhiều mẫu chuỗi của stax. Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

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

Chạy cái này

JavaScript (ES6), 184 182 181 180 byte

Đưa đầu vào theo cú pháp currying (a)(b). Trả về một mảng gồm 4 chuỗi.

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

Hãy thử trực tuyến!

Làm sao?

Đối với mỗi hàng k có 1 ≤ k 4 , chúng tôi bắt đầu với mẫu sau:

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

và thay thế từng chữ số thập phân n tại vị trí i theo bảng sau:

  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 byte

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

Hãy thử trực tuyến!

Python 2 , 187 byte

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`

Hãy thử trực tuyến!

Java (JDK 10) , 251 byte

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"," = ")

Hãy thử trực tuyến!

Tín dụng

• -50 byte nhờ Kevin Cruijssen

Perl 5 , 181 byte

Tôi nghĩ rằng việc này sẽ diễn ra ngắn hơn rất nhiều ...

$_="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

Hãy thử trực tuyến!

Giải trình

Ban đầu điều này là sử dụng một printfchuỗi định dạng, nhưng chỉ có svà dngắn hơn khi kết hợp với s///.

Đầu tiên là chuỗi định dạng được xây dựng vào $_và quadruplicated, sau đó tất cả ss được thay thế bằng khung tương ứng, <, <=hoặc không gian, tùy thuộc vào chỉ số thay thế. Tôi hy vọng sẽ tiết kiệm được một số byte hơn với sự trùng lặp của 5 ký tự cuối cùng của mỗi khối, nhưng điều này cuối cùng chỉ tiết kiệm được 2 byte. Chuỗi kết quả được chia thành các phần tử của không gian <=hoặc các ký tự đơn.

Cuối cùng, tất cả các ds được thay thế bằng số mong muốn được điều chỉnh dựa trên chỉ số của sự thay thế hiện tại thông qua khóa băm.

JavaScript, 190 189 byte

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

Dùng thử trực tuyến

m4 , 194

Có vẻ như một công việc cho một bộ xử lý macro. Không chắc chắn nếu m4 đáp ứng các tiêu chuẩn của chúng tôi cho một ngôn ngữ lập trình. Nó không có khả năng lặp và eval số học, vì vậy tôi giả sử nó gần với nhãn hiệu.

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

Đây là cái nhìn không tầm thường đầu tiên của tôi ở m4, vì vậy tôi nghi ngờ có nhiều cơ hội chơi gôn hơn mà tôi đã bỏ lỡ.

Đầu vào được truyền bằng cách sử dụng -Dcác định nghĩa macro tại dòng lệnh. Không chắc chắn nếu có bất cứ điều gì cần được thêm vào điểm số cho những điều này, theo như tôi có thể nói đây là cách duy nhất để truyền tham số một cách có ý nghĩa:

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

Hãy thử trực tuyến .

Cảm ơn @Dennis đã nhanh chóng thêm m4 vào TIO !

Python 2 , 277 199 193 189 byte

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`

Hãy thử trực tuyến!

Excel, 399 byte

="("&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

Không có gì đặc biệt thú vị ở đây.

C (gcc) , 224 237 byte

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;}}

Hãy thử trực tuyến!

Di chuyển "<[=]" vào chuỗi định dạng cho phép tôi loại bỏ mảng hoàn toàn. Ngoài ra, di chuyển printf()vào forvòng lặp lưu một dấu chấm phẩy.

Câu trả lời gốc

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

Hãy thử trực tuyến!

Không có gì đáng chú ý ở đây: Tôi đã sử dụng các thủ thuật thông thường để cạo kích thước của hàm (nâng intô tô vào tiêu đề hàm, sử dụng kiểu K & R, lập chỉ mục thành các hằng chuỗi.) Lưu trữ {"<=", "<"} vào một mảng tỏ ra hiệu quả hơn về kích thước so với việc chèn một bộ xác định định dạng cho thử thách này vì nó được sử dụng nhiều lần.

Javascript, 273 258 232 byte

Cảm ơn Kevin Cruijssen đã tiết kiệm cho tôi 15 byte!

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

Dùng thử trực tuyến

Cảm ơn TFeld đã cho tôi ý tưởng đó, tiết kiệm khoảng 60 byte từ câu trả lời ban đầu của tôi.

Ung dung:

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 (câu trả lời gốc), 340 byte

(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`)

Võng mạc , 216 byte

.+
$&()][<<  ¶$&[)[[<=< ¶$&(]]]<<= ¶$&[][]<=<=
((.*),(.*))(.)(.)(.)(.)(<=?)(<=?)( *)
$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

Hãy thử trực tuyến! Giải trình:

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

Xây dựng phần lớn kết quả chính.

_<=

Nếu biến có liên quan đến bất đẳng thức lỏng lẻo, thì giá trị được bao gồm, vì vậy chúng ta có thể xóa trình giữ chỗ.

\d+_
$&*___

Chuyển đổi giá trị thành unary và thêm 2.

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

Xóa bỏ giữ chỗ cho bất bình đẳng nghiêm ngặt thấp hơn hoặc bất bình đẳng nghiêm ngặt trên tiêu cực. Nó vẫn có thêm 2, nhưng 1 sẽ bị trừ sau, cho kết quả mong muốn.

___<
_

Trừ 2 từ các bất đẳng thức nghiêm ngặt khác không, khôi phục giá trị ban đầu, từ đó 1 sẽ được trừ sau.

__<
-1

Thay đổi một sự bất bình đẳng trên chặt chẽ 0đến -1.

_(_*)
$.1

Trừ 1 từ các bất đẳng thức nghiêm ngặt còn lại và chuyển thành thập phân.

-0
0

Sửa chữa một trường hợp cạnh khác.

Python 3, 180 byte:

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

giải trình

Về cơ bản xây dựng một chuỗi f được đánh giá theo cách hiểu danh sách. %Nội suy chuỗi kiểu cũ được sử dụng để trì hoãn việc đánh giá các biểu thức cho đến khi chuỗi f được ước tính.

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

Phần đầu tiên của chuỗi, 'f "', sẽ trở thành tiền tố cho chuỗi f.

Phần thứ hai của chuỗi xây dựng chuỗi định dạng cho hai biểu thức khoảng đầu tiên. %rđược sử dụng để tiết kiệm từ việc cần đặt dấu ngoặc kép ở định dạng, nghĩa "{%r[j]}"là giống như "{'%s'[j]}". Khi chuỗi f được ước tính, khung chính xác được chọn.

Phần thứ ba của chuỗi xây dựng hai biểu thức khoảng tiếp theo.

Phần cuối định dạng phần "a..b" của chuỗi f.

Chuỗi f được lắp ráp trông giống như: f"{'(['[j]}{a},{b}{')]'[i]} = .... = {a+j}..{b-i}"

Khi chuỗi f được ước tính, tất cả các biểu thức trong dấu ngoặc nhọn {}được thay thế bằng giá trị của chúng. Vì vậy, {a}được thay thế bằng giá trị của avà {'(['[j]}được thay thế bởi (nếu j bằng 0 hoặc [nếu j là 1.

SOGL V0.12 , 110 byte

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

Hãy thử nó ở đây!

Python 3, 248 byte

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

Hãy thử trực tuyến!