Sử dụng các ký hiệu toán học quen thuộc của chúng tôi: +, x, dấu ngoặc đơn và bất kỳ số hữu tỷ nào, thật dễ dàng để tạo các biểu thức ước lượng cho một số số mong muốn. Ví dụ: 1+(2x3)=7, (1+2)+(3x6.5)=22.5và vân vân. Chán đủ rồi.

Trong thử thách này, chúng tôi sẽ sử dụng một toán tử mới : ±. Việc sử dụng ±trong một biểu thức có nghĩa là bạn cần đánh giá biểu thức bằng cách thay thế ±bằng +hoặc -bằng tất cả các cách có thể và trả về tập hợp tất cả các giá trị có thể. Ví dụ:

• 1±2±3 = {-4,0,2,6}vì 1±2±3có thể là bất kỳ 1+2+3, 1+2-3, 1-2+3và 1-2-3và giá trị của họ là 6,0,2,-4tương ứng.
• (±2)x(2±3) = {-10,-2,2,10} vì những lý do tương tự.

Bây giờ, khi nó quay ra, đưa ra bất kỳ tập hợp các số thực khác biệt, bạn có thể tạo ra một biểu thức với +, x, (, ), ±, và số thực mà đánh giá lại các thiết lập nhất định.

Bài tập

Nhiệm vụ của bạn là viết một chương trình hoặc chức năng trong một ngôn ngữ bạn chọn, mà phải mất một chuỗi (danh sách / mảng / bất kỳ định dạng thuận tiện) của các số nguyên và kết quả đầu ra một biểu thức (như là một chuỗi) bao gồm +, x, (, ), ±, và số hữu tỉ ước lượng cho tập hợp các số đã cho.

• Lưu ý rằng nhân vật chính xác ±không quan trọng; bạn có thể sử dụng bất kỳ ký tự nào khác mà bạn chọn miễn là nó có thể phân biệt được với các ký tự khác bạn đang sử dụng. Nhưng bạn phải đề cập đến nhân vật bạn đang sử dụng trong trình của bạn.
• Đầu vào được phép bao gồm các xấp xỉ thập phân (độ chính xác hợp lý) của các số hữu tỷ được sử dụng.
• Đầu vào và đầu ra có thể được thực hiện theo bất kỳ cách tiêu chuẩn nào.
• Sơ hở tiêu chuẩn bị cấm.
• Bạn có thể giả sử các số nguyên đã cho sẽ khác biệt và được cung cấp theo thứ tự tăng dần.
• Đầu ra có thể chứa khoảng trắng và dòng mới.

Tiêu chí chiến thắng

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng.

Ví dụ

Đầu vào | Sản lượng có thể
------------- + -----------------------------
[1,2,3] | 2 ± 0,5 ± 0,5                   
[-7, -3,1,21] | (1 ± 2) x (3 ± 4)

_{Ý tưởng được lấy từ một câu hỏi trong Giải đấu Thị trấn, Mùa thu 2015 .}

Python 2 , 56 byte

f=lambda h,*t:t and"(.5?.5)*(%s+%%s)+"%f(*t)%-h+`h`or`h`

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

Các ?viết tắt cho ±. Ví dụ sử dụng:

f(-3,5,20) ->
(.5?.5)*((.5?.5)*(20+-5)+5+3)+-3

Ý tưởng là chúng ta có thể lấy một biểu thức Evà nối một giá trị mới hvào tập giá trị của nó bằng cách thực hiện (.5±.5)*(E+-h)+h.

Haskell , 52 byte

f(h:t)=shows h"+(.5?.5)*("++f[x-h|x<-t]++")"
f e="0"

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

Sử dụng ?cho ±. Thí dụ:

f [1,3,7] ->
1+(.5?.5)*(2+(.5?.5)*(4+(.5?.5)*(0)))

Chức năng showsnày shows a b=(show a)++b, một mẹo tôi học được từ Lynn.

shows 12 "abc" ->
"12abc"

Haskell , 58 byte

Sử dụng #cho ±, vì nó là một byte ít hơn.

f lấy một danh sách các số nguyên và trả về một chuỗi.

f[x]=show x
f(x:r)=show x++"+(.5#.5)x("++f((-x+)<$>r)++")"

Kết quả là của hình thức n+(.5#.5)x(rest), trong đó nlà yếu tố đầu tiên của danh sách và restlà đại diện của tất cả những người khác được ntrừ từ mỗi.

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

Thạch , 29 byte

“(¤)”j.⁾+×j;”(
I;@Ḣj¢;”)ẋ⁸L¤¤

In v + (0,5¤0,5) × (i ₁ + (0,5¤0,5) × ((i ₂ + (0,5¤0,5) × (... (i _n ) ...))) trong đó v là số đầu tiên trong mảng đầu vào và i _n là chênh lệch gia tăng ^thứ n giữa các thành phần của mảng đầu vào.

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

Làm sao?

“(¤)”j.⁾+×j;”( - Link 1, adjoining list: no input
“(¤)”          - literal     ['(','¤',')']
      .        - literal     0.5
     j         - join        ['(',0.5,'¤',0.5,')']
       ⁾+×     - literal     ['+','×']
          j    - join        ['+',['(',0.5,'¤',0.5,')'],'×']
            ”( - literal     '('
           ;   - concatenate ['+',['(',0.5,'¤',0.5,')'],'×','(']

I;@Ḣj¢;”)ẋ⁸L¤¤ - Main link: list a               e.g. [-1,5,2]
I              - incremental differences(a)           [6,-3]
   Ḣ           - head(a)                              [-1]
 ;@            - concatenate (rev @rgs)               [-1,6,-3]
     ¢         - last link (1) as a nilad             ['+',['(',0.5,'¤',0.5,')'],'×','(']
    j          - join                                 [-1,['+',['(',0.5,'¤',0.5,')'],'×','('],6,['+',['(',0.5,'¤',0.5,')'],'×','('],-3]
             ¤ - nilad followed by link(s) as a nilad
            ¤  -     nilad followed by link(s) as a nilad
          ⁸    -         link's left argument, a
           L   -         length                       3
       ”)      -     literal ')'
         ẋ     -     repeat                           [')',')',')']
      ;        - concatenate                          [-1,['+',['(',0.5,'¤',0.5,')'],'×','('],6,['+',['(',0.5,'¤',0.5,')'],'×','('],-3,')',')',')']
               - implicit print                       -1+(0.5¤0.5)×(6+(0.5¤0.5)×(-3))

05AB1E , 25 byte

0¸«¥X;D"+(ÿ±ÿ)*("ý¹g<')×J

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

Giải trình

0¸«                        # prepend a 0 to input list
   ¥                       # calculate delta's
    X;D                    # push 0.5 twice
       "+(ÿ±ÿ)*("          # push this string and interpolate 0.5 where "ÿ" is
                 ý         # merge the list of delta's with this string as a separator
                  ¹g<')×J  # add the closing parenthesis

Việc xây dựng biểu thức từ bên phải không may kết thúc ở cùng số byte đó
0¸«¥¤s¨RvX;Dy"ÿ+(ÿ±ÿ)*(ÿ). 8 byte được sử dụng để thiết lập là sự lãng phí lớn ở đây.

Haskell, 54 byte

f[]="0"
f(x:s)=show x++"+(.5?.5)*("++f(map(-x+)s)++")"

dấu + - là '?'. thí dụ:

f[1,2,3,4] = "1+(.5#.5)*(1+(.5#.5)*(1+(.5#.5)*(1+(.5#.5)*(0))))"

JavaScript (ES6), 56 51 byte

f=([v,...a],x=v)=>x?x+`+(.5@.5)*(${f(a,a[0]-v)})`:0

Dựa trên công thức của @ Jonathan ALLan. @là viết tắt của ±.