Menggunakan simbol matematika yang kita kenal: +, x, tanda kurung, dan bilangan rasional apa pun, mudah untuk membuat ekspresi yang mengevaluasi sejumlah bilangan yang diinginkan. Sebagai contoh: 1+(2x3)=7, (1+2)+(3x6.5)=22.5dan sebagainya. Cukup membosankan.

Dalam tantangan ini, kita akan menggunakan operator baru: ±. Penggunaan ±dalam ekspresi berarti Anda perlu mengevaluasi ekspresi dengan mengganti ±dengan +atau -dengan semua cara yang mungkin, dan mengembalikan set semua nilai yang mungkin. Sebagai contoh:

• 1±2±3 = {-4,0,2,6}karena 1±2±3dapat salah satu dari 1+2+3, 1+2-3, 1-2+3dan 1-2-3dan nilai-nilai mereka 6,0,2,-4masing-masing.
• (±2)x(2±3) = {-10,-2,2,10} untuk alasan yang sama.

Sekarang, ternyata, diberi himpunan bilangan real yang berbeda, itu mungkin untuk membuat ekspresi dengan +, x, (, ), ±, dan bilangan real yang mengevaluasi ke set yang diberikan.

Tugas

Tugas Anda adalah untuk menulis sebuah program atau fungsi dalam bahasa pilihan Anda, yang mengambil berurutan (daftar / array / format nyaman) dari bilangan bulat dan output ekspresi (sebagai string) yang terdiri dari +, x, (, ), ±, dan bilangan rasional yang mengevaluasi ke himpunan angka yang diberikan.

• Perhatikan bahwa karakter yang tepat ±tidak masalah; Anda dapat menggunakan karakter lain pilihan Anda selama itu dapat dibedakan dari karakter lain yang Anda gunakan. Tetapi Anda harus menyebutkan karakter yang Anda gunakan dalam kiriman Anda.
• Input diperbolehkan terdiri dari perkiraan desimal (hingga akurasi yang masuk akal) dari bilangan rasional yang digunakan.
• Input dan output dapat diambil dengan salah satu cara standar.
• Celah standar dilarang.
• Anda dapat mengasumsikan bilangan bulat yang diberikan akan berbeda, dan disediakan dalam urutan yang meningkat.
• Output mungkin berisi spasi dan baris baru.

Kriteria Kemenangan

Ini adalah kode-golf , jadi kode terpendek dalam byte menang.

Contohnya

Masukan | Output yang mungkin
------------- + -----------------------------
[1,2,3] | 2 ± 0,5 ± 0,5                   
[-7, -3,1,21] | (1 ± 2) x (3 ± 4)

_{Ide diambil dari pertanyaan di Turnamen Towns, Musim Gugur 2015 .}

Python 2 , 56 byte

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

Cobalah online!

The ?singkatan ±. Contoh penggunaan:

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

Idenya adalah bahwa kita dapat mengambil ekspresi Edan menyandingkan nilai baru hdengan melakukan nilai (.5±.5)*(E+-h)+h.

Haskell , 52 byte

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

Cobalah online!

Penggunaan ?untuk ±. Contoh:

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

Fungsi showstidak shows a b=(show a)++b, trik saya belajar dari Lynn.

shows 12 "abc" ->
"12abc"

Haskell , 58 byte

Menggunakan #untuk ±, karena satu byte lebih sedikit.

f mengambil daftar bilangan bulat dan mengembalikan string.

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

Hasilnya berupa n+(.5#.5)x(rest), di mana nelemen pertama dari daftar dan restmerupakan representasi dari semua yang lain dengan ndikurangkan dari masing-masing.

Cobalah online!

Jelly , 29 byte

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

Mencetak v + (0.5¤0.5) × (i ₁ + (0.5¤0.5) × ((i ₂ + (0.5¤0.5) × (... (i _n ) ...))) di mana v adalah angka pertama dalam array input dan i _n adalah n ^th perbedaan tambahan antara unsur-unsur dari array input.

Cobalah online!

Bagaimana?

“(¤)”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

Cobalah online!

Penjelasan

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

Sayangnya, membangun ekspresi dari kanan berakhir pada byte yang sama dengannya
0¸«¥¤s¨RvX;Dy"ÿ+(ÿ±ÿ)*(ÿ). 8 byte yang digunakan untuk setup adalah pemborosan besar di sini.

Haskell, 54 byte

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

tanda + adalah '?'. contoh:

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

Berdasarkan rumus @ JonathanAllan. @singkatan ±.