Latar Belakang

Dalam beberapa kemungkinan masa depan, dunia akan mengkonversi sistem numerik mereka dari desimal (basis 10 atau b10) ke beberapa basis lain (biner b2, oktal b8, heksadesimal b16, atau bahkan unary b1, dalam hal ini kami mengacaukan!). Jadi, dalam persiapan untuk acara yang mengubah dunia ini, Anda memutuskan untuk membuktikan semua program Anda. Ini dapat dilakukan dengan hanya menggunakan 0s dan s tunggal 1dalam hubungannya dengan operator untuk mengganti konstanta angka yang ada.

Namun, hanya ada satu masalah: Anda memiliki banyak program untuk diubah, dan mengonversi setiap angka secara manual ke ekspresi akan membutuhkan waktu berminggu-minggu! Dengan demikian, Anda memutuskan untuk menulis sebuah program (atau fungsi) untuk memutuskan untuk Anda ekspresi apa yang harus diganti setiap angka.

Memasukkan

Input akan berupa bilangan bulat positif. Kode Anda harus mampu menangani bilangan bulat apa pun hingga 1000.

(Jika kode Anda mendukung desimal dan / atau input negatif, lihat Penilaian di bawah ini.)

Keluaran

Kode Anda harus menampilkan ekspresi yang mengevaluasi input dalam setidaknya satu bahasa. Ini mungkin bahasa apa pun; tidak harus sama dengan yang ditulis oleh program atau fungsi Anda. Juga, ungkapan ini tidak harus berupa program atau fungsi lengkap.

Untuk kejelasan, output mungkin mengandung operasi-operasi berikut:

• kenaikan / penurunan
• tambah / jumlah
• kurangi / negasikan
• kalikan / gandakan (hanya jika itu tidak secara langsung melibatkan nomor 2!)
• bagi / modulo
• eksponen / logaritma
• square / sqrt (sekali lagi, hanya jika ini tidak secara langsung melibatkan nomor 2!)
• operasi bitwise (bOR, bAND, bNOT, bXOR, bit-shift)
• pengaturan / mendapatkan variabel
• manipulasi tumpukan

Anda tidak boleh menggunakan eval()atau fungsi serupa dalam output. Anda juga tidak dapat menggunakan dalam output fungsi apa pun yang melakukan tindakan selain yang disebutkan di atas.

Oh, dan satu hal lagi: karena kita ingin output menjadi valid dalam basis sebanyak mungkin, satu-satunya konstanta angka yang dikandungnya adalah 0dan 1. Angka seperti 10(sepuluh) tidak diizinkan, kecuali bahasa menafsirkannya sebagai a 1dan a 0. Menggunakan string untuk memuat angka juga tidak diperbolehkan, seperti halnya menggunakan karakter seperti CJam's A- K(yang mewakili 10- 20).

Kasus uji

(Semua output dalam JavaScript, tetapi dapat bekerja dalam bahasa lain.)

Input 1:

2

Output yang mungkin 1:

1+1

Input 2:

13

Kemungkinan hasil 2:

(a=1+1+1)*a+a+1

Input 3:

60

Kemungkinan hasil 3:

(b=(a=1+1+1+1)*a)*a-a

Input 4:

777

Kemungkinan hasil 4:

(c=(b=((a=1+1+1+1)*a-a+1)*a)*a+b)+c+c-a+1

Input 5:

1000

Kemungkinan hasil 5:

Math.pow((a=1+1+1)*a+1,a)

Mencetak gol

Tujuan dari tantangan ini adalah untuk mempersingkat output kode Anda sebanyak mungkin. Skor Anda akan dihitung dengan cara ini:

• Skor dasar: Penghitungan byte rata-rata dari semua output untuk bilangan bulat 1 hingga 1000.

• Skor desimal: Jika kode Anda mendukung setidaknya 3 tempat desimal, ini adalah jumlah byte rata-rata dari semua output dari urutan angka mulai 0.001dan berakhir pada 1000, meningkat 1.001setiap kali. 0.001, 1.002, 2.003...998.999, 1000.000Kemudian ambil potongan 50% dari skor ini.

• Nilai negatif: Jika kode Anda mendukung angka negatif dan nol, ini adalah rata-rata byte-output dari semua bilangan bulat dari -1000hingga 0. Kemudian ambil potongan 10% dari skor ini.

(Cara termudah untuk menghitung ini kemungkinan akan menjadi loop dengan program / fungsi Anda di dalamnya.)

Skor akhir Anda adalah rata-rata yang mana dari rumus di atas berlaku.

Jika output non-deterministik (yaitu agak acak; beberapa kali berjalan dengan input yang sama menghasilkan beberapa output unik), maka skor untuk setiap input ditentukan oleh output terbesar dari sepuluh berjalan pada CPU saya.

Juga, karena Anda tidak tahu betapa berharganya data komputer di masa depan, jumlah byte kode generator Anda harus kurang dari 512 byte.

Skor terendah dalam dua minggu (pada 30 September) akan dinyatakan sebagai pemenang. Selamat kepada pemenang Anda, @ThomasKwa !

Papan peringkat

var QUESTION_ID=58084,OVERRIDE_USER=42545;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[3],language:a[1]+'/'+a[2],lang2:a[2],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size.toFixed(3)).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.lang2,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){var E=e.lang.toLowerCase(),S=s.lang.toLowerCase();return E>S?1:E<S?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size.toFixed(3)).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,])\/([^\n,]*[^\s,]),.*?([\.\d]+)(?=[^\n\.\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\.\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Languages</td><td>Score</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Output Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Untuk memastikan jawaban Anda muncul dengan benar, silakan mulai dengan tajuk ini:

# Language name/Other language name, X points

Di mana Xskor jawaban Anda. Contoh:

# CJam/Pyth, 25.38 points

Jika Anda memiliki pertanyaan atau saran, beri tahu saya. Semoga berhasil!

Kode mesin Python / Zilog Z80, 11.653 11.488

import math,numpy as np
def R(n):
    if n==0:return []
    if n<0:return -R(-n)
    e=int(math.log(n,2))
    if n >= 5/3 * 2**e:
        return np.append(2**(e+1),-R(2**(e+1)-n))
    return np.append(2**e,R(n-2**e))

def strR(n):
    b = R(n)
    s = ""
    if n==0:return s
    e=max(abs(b))
    while e:
        if e in b:s+="#"
        elif -e in b:s+="+"
        s+=")"
        e//=2
    return s[:-1]

Bonus: Angka negatif.

Mengasumsikan bahwa hlpasangan register awalnya memegang 0, dan mengembalikan hasilnya dalam hl.

Hanya tiga instruksi ini yang digunakan:

ASCII   Hex    Instruction
--------------------------
#       23     inc hl
)       29     add hl,hl
+       2B     dec hl

Kami menggunakan sedikit modifikasi dari representasi biner seimbang BBR2 berbobot minimum . Karena BBR2 meminimalkan bobot (jumlah digit bukan nol), tetapi kami ingin meminimalkan bobot plus jumlah pergeseran bit, kami mengubah konstanta dalam algoritma dari 3/2menjadi 5/3.

Untuk menghitung skor dan memverifikasi, gunakan kode ini:

def verify(n):
v = 0
for c in strR(n):
    if c=="#":v += 1
    elif c=="+":v -= 1
    else: v *= 2
return v==n

print(0.5*(sum([len(strR(n)) for n in range(1,1001)])/1000 + \
           sum([len(strR(n)) for n in range(-1000,1)])/1001 * 0.9))

print(all([verify(n) for n in range(-1000,1001)]))

Contoh output:

strR(486)
         '#)))))+)+))+)'

Atau dalam perakitan:

inc hl \ add hl,hl \ add hl,hl \ add hl,hl \ add hl,hl \ add hl,hl \ dec hl \ add hl,hl \ dec hl \ add hl,hl \ add hl,hl \ dec hl \ add hl,hl

Lebih banyak contoh program:

-256  +))))))))
-255  +))))))))#
-254  +)))))))#)
-253  +)))))))#)#
-252  +))))))#))
-251  +))))))#))#
-250  +))))))#)#)
-249  +)))))#)))+
-248  +)))))#)))
-247  +)))))#)))#
-246  +)))))#))#)
-245  +)))))#))#)#
-244  +)))))#)#))
-243  +)))))#)#))#
-242  +))))#)))+)
-241  +))))#))))+

  -5  +))+
  -4  +))
  -3  +)+
  -2  +)
  -1  +
   0  
   1  #
   2  #)
   3  #)#
   4  #))
   5  #))#

Kemungkinan pengoptimalan: aturan OP bahwa instruksi inc hdan dec h, yang secara langsung mengubah byte atas hl, adalah ilegal, tetapi sla hdan tidak berdokumen sl1 h(bit kiri bergeser 1 pada hshift itu di 0dan 1masing - masing) diizinkan. sla hdan sl1 hmasing-masing dua byte, tetapi terkadang dapat mempersingkat output.

CJam / CJam, 143.263 42.713 28.899 23.901 21.903 20.468

ri
[
    ['X\2b1>e`{~{"1)*)"*}{_({(')*1\"m<"}{"1)*"*}?}?}/]s
    "X1)*"/"1)"*
    "1)1)*"/"1)))"*
    "X1)m<"/"1)))"*
    _"1)"/("1):Y"+\'Y*+
]
{,}$0=

Tidak ada bonus yang berlaku.

Cobalah online: contoh jalankan | skor kalkulator | verifikasi

Contoh berjalan

   1 X
   2 1)
   3 1))
   4 1)))
   5 1))))
   6 1))1)*
   7 1))1)*)
   8 X1))m<
   9 1)))1)*)
  10 1))))1)*
  11 1))))1)*)
  12 1))1)m<
  13 1))1)*1)*)
  14 1))1)*)1)*
  15 1))1)*)1)*)
  16 X1)))m<
  17 X1))m<1)*)
  18 1)))1)*)1)*
  19 1)))1)*)1)*)
  20 1))))1)m<

 981 1):Y)Y*)Y*)Y*Y*)Y*Y*)Y*Y*)
 982 1):Y)Y*)Y*)Y*Y*)Y*Y*)Y*)Y*
 983 1):Y)Y*)Y*)Y*Y*)Y*Y*)Y*)Y*)
 984 1):Y)Y*)Y*)Y*Y*)Y*)Y)m<
 985 1):Y)Y*)Y*)Y*Y*)Y*)Ym<Y*)
 986 1):Y)Y*)Y*)Y*Y*)Y*)Y*Y*)Y*
 987 1):Y)Y*)Y*)Y*Y*)Y*)Y*Y*)Y*)
 988 1):Y)Y*)Y*)Y*Y*)Y*)Y*)Ym<
 989 1):Y)Y*)Y*)Y*Y*)Y*)Y*)Y*Y*)
 990 1):Y)Y*)Y*)Y*Y*)Y*)Y*)Y*)Y*
 991 1):Y)Y*)Y*)Y*Y*)Y*)Y*)Y*)Y*)
 992 1):Y)Y*)Y*)Y*)Y)))m<
 993 1):Y)Y*)Y*)Y*)Y))m<Y*)
 994 1):Y)Y*)Y*)Y*)Y)m<Y*)Y*
 995 1):Y)Y*)Y*)Y*)Y)m<Y*)Y*)
 996 1):Y)Y*)Y*)Y*)Ym<Y*)Ym<
 997 1):Y)Y*)Y*)Y*)Ym<Y*)Y*Y*)
 998 1):Y)Y*)Y*)Y*)Ym<Y*)Y*)Y*
 999 1):Y)Y*)Y*)Y*)Ym<Y*)Y*)Y*)
1000 1):Y)Y*)Y*)Y*)Y*Y*)Y)m<

ß / BrainFuck, 34,201 poin

Sumber ß (194B):

E='++[------>+<]>++'°\c[1]<0°{E&='.'µA=ß"-ß°°c[1]),'')µE&='+++'°/B=1°(A[0]°\A[B]='.'°{µE&='--.++'°]E&=ß~A'+',A[B])&'.'&ß~A'-',A[B])°}°)°'ß"&E,'+-')+ß"&E,'-+')>0µE=ß"'ß"'E,'-+',''),'+-','')°!€E)

Jika seseorang tertarik, saya akan menambahkan penjelasan. Output BF sudah cukup dioptimalkan, tapi saya kira saya bisa menggunakan 318B kode ß yang tersisa untuk diimplementasikan

• optimasi loop-nesting,
• lebih banyak jalan pintas 8bit,
• penghapusan tabrakan operator .

Sampel:

Berjalan di windows:

$ sharps encode.ss 42
++[------>+<]>+++++++++.--.--

$ sharps encode.ss -42
++[------>+<]>++.+++++++.--.--

$ sharps encode.ss 1.427
++[------>+<]>++++++.---.++++++.--.+++++.-------

$ sharps encode.ss -946.427
++[------>+<]>++.++++++++++++.-----.++.--------.++++++.--.+++++.-------

Berjalan di linux:

$ WINEDEBUG=-all wine sharps source.ss -4.72
++[------>+<]>++.+++++++.------.+++++++++.-----.--

Validasikan dalam penerjemah BF online .

Skor:

1. Rata-rata dasar = 37.495.
2. Rata-rata desimal = 60.959 * 0.5 = ~30.48.
3. Rata-rata negatif. = 38.4765234765235 * 0.9 = ~34.629
4. Rata-rata di atas, skor akhir = (37.495 + 30.48 + 34.629)/3 = 34.201.

Ruby / Ruby, 29.77885

31.873 * 0,9 (negatif) 30,872 (positif).

Strategi dasar adalah representasi basis 3 simetris ("terner seimbang"), yaitu ketika digit -1,0,1bukan0,1,2

#function
f=->n{m=n  
  a='0' 
  7.times{|i|
    r=m%3;r-=r/2*3
    m=(m-r)/3
    #produce expression: replace 0 with (0*x+-1)
    #only add 0*x if there are higher base 3 digits to follow.
    #only add (..+-1) if the current base 3 digit is nonzero. 
    a.sub!('0',['','(','('][r]+(m.abs>0?'0*x':'')+['','+1)','-1)'][r])
  }
  #tidy up expression
  a.sub!('(-1)*','-')          #remove internal (-1)*
  a.sub!('(+1)*','')           #remove internal (+1)*
  a[-1]==')' && a=a[1..-2]     #remove unnecessary global brackets
  a.sub!('x','(x=1+1+1)')      #find the first x and define it as 1+1+1=3
  #special cases for small numbers 
  n.abs<8 && a=n==0?'0':['','1'+'+1'*(n-1).abs,'-1'*n.abs][n<=>0] 
  a 
}

#call like this
(1..1000).each{|p|
b=f.call(p)
puts b

Inilah output dari 0 hingga 40 sebelum pembersihan

(+1)
((+1)*x-1)
(+1)*x
((+1)*x+1)
(((+1)*x-1)*x-1)
((+1)*x-1)*x
(((+1)*x-1)*x+1)
((+1)*x*x-1)
(+1)*x*x
((+1)*x*x+1)
(((+1)*x+1)*x-1)
((+1)*x+1)*x
(((+1)*x+1)*x+1)
((((+1)*x-1)*x-1)*x-1)
(((+1)*x-1)*x-1)*x
((((+1)*x-1)*x-1)*x+1)
(((+1)*x-1)*x*x-1)
((+1)*x-1)*x*x
(((+1)*x-1)*x*x+1)
((((+1)*x-1)*x+1)*x-1)
(((+1)*x-1)*x+1)*x
((((+1)*x-1)*x+1)*x+1)
(((+1)*x*x-1)*x-1)
((+1)*x*x-1)*x
(((+1)*x*x-1)*x+1)
((+1)*x*x*x-1)
(+1)*x*x*x
((+1)*x*x*x+1)
(((+1)*x*x+1)*x-1)
((+1)*x*x+1)*x
(((+1)*x*x+1)*x+1)
((((+1)*x+1)*x-1)*x-1)
(((+1)*x+1)*x-1)*x
((((+1)*x+1)*x-1)*x+1)
(((+1)*x+1)*x*x-1)
((+1)*x+1)*x*x
(((+1)*x+1)*x*x+1)
((((+1)*x+1)*x+1)*x-1)
(((+1)*x+1)*x+1)*x
((((+1)*x+1)*x+1)*x+1)

Dan setelah pembersihan

0
1
1+1
1+1+1
1+1+1+1
1+1+1+1+1
1+1+1+1+1+1
1+1+1+1+1+1+1
(x=1+1+1)*x-1
(x=1+1+1)*x
(x=1+1+1)*x+1
((x=1+1+1)+1)*x-1
((x=1+1+1)+1)*x
((x=1+1+1)+1)*x+1
(((x=1+1+1)-1)*x-1)*x-1
(((x=1+1+1)-1)*x-1)*x
(((x=1+1+1)-1)*x-1)*x+1
((x=1+1+1)-1)*x*x-1
((x=1+1+1)-1)*x*x
((x=1+1+1)-1)*x*x+1
(((x=1+1+1)-1)*x+1)*x-1
(((x=1+1+1)-1)*x+1)*x
(((x=1+1+1)-1)*x+1)*x+1
((x=1+1+1)*x-1)*x-1
((x=1+1+1)*x-1)*x
((x=1+1+1)*x-1)*x+1
(x=1+1+1)*x*x-1
(x=1+1+1)*x*x
(x=1+1+1)*x*x+1
((x=1+1+1)*x+1)*x-1
((x=1+1+1)*x+1)*x
((x=1+1+1)*x+1)*x+1
(((x=1+1+1)+1)*x-1)*x-1
(((x=1+1+1)+1)*x-1)*x
(((x=1+1+1)+1)*x-1)*x+1
((x=1+1+1)+1)*x*x-1
((x=1+1+1)+1)*x*x
((x=1+1+1)+1)*x*x+1
(((x=1+1+1)+1)*x+1)*x-1
(((x=1+1+1)+1)*x+1)*x
(((x=1+1+1)+1)*x+1)*x+1

Ceylon / Ceylon, 49,86 40,95 poin

Versi ketiga menggunakan Ceylon 1.2 untuk generator dan 509 byte kode:

import ceylon.language{S=String,I=Integer,e=expand}S q(I n)=>n==0then"0"else(n<0then"-"+p(-n,"-")else p(n,"+"));variable Map<[I,S],S>c=map{};S p(I n,S s){S v=c[[n,s]]else(n<8then s.join([1].repeat(n)))else(let(a="+-".replace(s,""))e(e{for(x in 2..8)let(l=(n^(1.0/x)).integer){for(r in l:2)if(r>1)let(w=r^x){if(w-n<n)"("+p(r,"+")+")^("+p(x,"+")+")"+(w<n then s+p(n-w,s)else(n<w then a+p(w-n,a)else""))}}}).reduce<S>((x,y)=>x.size<y.size then x else y))else"";c=[n,s]in c then c else map{[n,s]->v,*c};return v;}

Ini turun menjadi 35,22 poin, tapi saya tidak akan menempatkan ini di baris judul karena Celyon 1.2 hanya diterbitkan pada 29 Oktober. Saya tidak berpikir saya akan dapat mengimplementasikan algoritma ini dalam Ceylon 1.1 dalam ukuran ini.). Lebih detail di sana, di sini saya akan menjelaskan versi kedua. (Versi pertama dapat dilihat dalam sejarah - versi ini hanya mendukung angka positif, tetapi cocok dengan 256 byte.)

Versi kedua

Sekarang versi kedua, yang mendukung bilangan bulat negatif (dan 0), dan umumnya menghasilkan keluaran yang sedikit lebih pendek dengan menggunakan tambahan -. (Versi ini sebenarnya menggunakan panjang yang diizinkan, yang pertama mencoba untuk tetap di bawah 256 byte, bukan 512.)

String proof(Integer n) {
    if (n == 0) { return "0"; }
    if (n < 0) { return "-" + p(-n, "-"); }
    return p(n, "+");
}
String p(Integer n, String sign) {
    if (n < 9) {
        return sign.join([1].repeat(n));
    }
    value anti = (sign == "+") then "-" else "+";
    value root = ((n^0.5) + 0.5).integer;
    return "(" + p(root, "+") + ")^(1+1)" +
       ( (root^2 < n) then sign + p(n - root^2, sign) else
         ((n < root^2) then anti + p(root^2 - n, anti) else ""));
}

Kode memiliki panjang 487, jadi masih ada ruang untuk optimisasi lebih lanjut nanti. (Ada juga banyak cadangan dalam bentuk spasi putih dan nama variabel panjang.)

Skor:

Total positive: 42652
Average positive:42.652
Total negative: 43653
Average negative: 43.60939060939061
With bonus:39.24845154845155
Overall score: 40.95022577422577

Beberapa output sampel:

   27:  21: (1+1+1+1+1)^(1+1)+1+1
   28:  23: (1+1+1+1+1)^(1+1)+1+1+1
   29:  25: (1+1+1+1+1)^(1+1)+1+1+1+1
   30:  27: (1+1+1+1+1)^(1+1)+1+1+1+1+1
   31:  29: (1+1+1+1+1+1)^(1+1)-1-1-1-1-1
   32:  27: (1+1+1+1+1+1)^(1+1)-1-1-1-1
   33:  25: (1+1+1+1+1+1)^(1+1)-1-1-1
   34:  23: (1+1+1+1+1+1)^(1+1)-1-1

  -27:  22: -(1+1+1+1+1)^(1+1)-1-1
  -28:  24: -(1+1+1+1+1)^(1+1)-1-1-1
  -29:  26: -(1+1+1+1+1)^(1+1)-1-1-1-1
  -30:  28: -(1+1+1+1+1)^(1+1)-1-1-1-1-1
  -31:  30: -(1+1+1+1+1+1)^(1+1)+1+1+1+1+1
  -32:  28: -(1+1+1+1+1+1)^(1+1)+1+1+1+1
  -33:  26: -(1+1+1+1+1+1)^(1+1)+1+1+1
  -34:  24: -(1+1+1+1+1+1)^(1+1)+1+1


  993:  65: ((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)-(1+1+1+1+1+1)^(1+1)+1+1+1+1+1
  994:  63: ((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)-(1+1+1+1+1)^(1+1)-1-1-1-1-1
  995:  61: ((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)-(1+1+1+1+1)^(1+1)-1-1-1-1
  996:  59: ((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)-(1+1+1+1+1)^(1+1)-1-1-1
  997:  57: ((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)-(1+1+1+1+1)^(1+1)-1-1
  998:  55: ((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)-(1+1+1+1+1)^(1+1)-1
  999:  53: ((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)-(1+1+1+1+1)^(1+1)
 1000:  55: ((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)-(1+1+1+1+1)^(1+1)+1

 -993:  66: -((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)+(1+1+1+1+1+1)^(1+1)-1-1-1-1-1
 -994:  64: -((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)+(1+1+1+1+1)^(1+1)+1+1+1+1+1
 -995:  62: -((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)+(1+1+1+1+1)^(1+1)+1+1+1+1
 -996:  60: -((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)+(1+1+1+1+1)^(1+1)+1+1+1
 -997:  58: -((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)+(1+1+1+1+1)^(1+1)+1+1
 -998:  56: -((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)+(1+1+1+1+1)^(1+1)+1
 -999:  54: -((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)+(1+1+1+1+1)^(1+1)
-1000:  56: -((1+1+1+1+1+1)^(1+1)-1-1-1-1)^(1+1)+(1+1+1+1+1)^(1+1)-1

    1:   1: 1
    2:   3: 1+1
    3:   5: 1+1+1
    4:   7: 1+1+1+1
    5:   9: 1+1+1+1+1
    6:  11: 1+1+1+1+1+1
    7:  13: 1+1+1+1+1+1+1
    8:  15: 1+1+1+1+1+1+1+1
    9:  13: (1+1+1)^(1+1)
   10:  15: (1+1+1)^(1+1)+1

    0:   1: 0
   -1:   2: -1
   -2:   4: -1-1
   -3:   6: -1-1-1
   -4:   8: -1-1-1-1
   -5:  10: -1-1-1-1-1
   -6:  12: -1-1-1-1-1-1
   -7:  14: -1-1-1-1-1-1-1
   -8:  16: -1-1-1-1-1-1-1-1
   -9:  14: -(1+1+1)^(1+1)
  -10:  16: -(1+1+1)^(1+1)-1

Seperti yang Anda lihat, yang negatif selalu satu byte (yang -lebih dulu) lebih lama dari yang positif.

Ide dasarnya sama dengan program sebelumnya: temukan kotak di dekat nomor target kami, dan tampilkan akar dan sisanya secara rekursif. Tapi sekarang kami mengizinkan kuadrat kami juga beberapa lebih besar dari jumlah target, yang kemudian membuat sisanya negatif. ( +0.5Dapat diubah ke konstanta yang berbeda untuk mengubah algoritma, tetapi tampaknya saya sudah mencapai yang optimal di sini - baik 0,4 dan 0,6 memberikan hasil yang lebih buruk.)

Untuk membuat nilai negatif negatif (dan selain itu memiliki struktur yang sama dengan yang positif, kami meneruskan operator signke fungsi rekursif kami p- baik itu "+"atau "-". Kita dapat menggunakannya untuk joiner dalam kasus sepele (yaitu n <9) juga adapun sisanya jika positif, dan gunakan tanda sebaliknya untuk sisanya jika negatif.

The proofmenangani fungsi awal tanda (dengan kasus khusus untuk 0), pfungsi melakukan pekerjaan yang sebenarnya, dengan rekursi.

Versi ketiga, untuk Ceylon 1.2

import ceylon.language { S=String, I=Integer,e=expand }

// output a base-proof Ceylon expression for an integer
// (i.e. using only 0 and 1 as digits).
//
// Question: http://codegolf.stackexchange.com/q/58084/2338
// My Answer:  http://codegolf.stackexchange.com/a/58122/2338
//
// The goal is to produce an expression as short as possible, with
// the code staying under 512 bytes in length.
//
// This approach is to represent a positive integer as a square
// of a positive integer plus some remainder (where the remainder
// can be negative), and for negative integers replace the + on the
// outer level by -.

S q(I n) =>
        n == 0 then "0"
        else (n < 0 then "-" + p(-n, "-")
            else p(n, "+"));

// cache for values of p
variable Map<[I, S],S> c = map { };

// Transforms a positive number into a base-proof term, using
// the given sign for the summation on the outer level.
S p(I n, S s) {
    S v =
    // look into the cache
            c[[n, s]] else (
        // hard-code small numbers
        n < 8 then s.join([1].repeat(n)))
            else
    // do the complicated stuff
    (let (a = "+-".replace(s,""))
            e(e {
                    for (x in 2..8) // try these exponents
                        let (l = (n ^ (1.0 / x)).integer) // \[ sqrt[exp]{n} \] in LaTeX
                            { for (r in l:2) // lowerRoot, lowerRoot + 1
                                    if (r > 1)
                                        let (w = r ^ x)
                                            { if (w-n < n) // avoid recursion to larger or same number
                                                    // format the string as  r^x + (n-w)
                                                    "(" + p(r, "+") + ")^(" + p(x, "+") + ")" +
                                                            (w < n then s + p(n - w, s)
                                                                else (n < w then a + p(w - n, a)
                                                                    else ""))
                                            } } })
            // and now find the shortest formatted string
                .reduce<S>((x, y) => x.size < y.size then x else y))
    // this should never happen, but we can't tell the compiler
    // that at least some of the iterables are non-empty due to the if clause.
            else "";

    // this builds a new cache in each step – quite wasteful,
    // as this also happens when the value was found in the cache,
    // but we don't have more characters remaining.
    //// c = map { [n, s] -> v, *c };
    ///better way:
     c = [n,s] in c then c else map{[n,s]->v, *c}; 
    return v;
}

Versi golf (yaitu komentar dan spasi kosong dihapus) diposting di bagian atas, tepatnya 509 byte kode.

Ini menggunakan prinsip dasar yang sama dengan versi kedua, tetapi alih-alih hanya kuadrat, ia juga mencoba menggunakan kekuatan angka yang lebih tinggi (mencoba eksponen dari 2 hingga 8), dan menggunakan hasil terpendek. Itu juga cache hasil, karena kalau tidak, ini akan sangat lambat untuk nomor yang lebih besar dengan banyak panggilan rekursif.

Mencetak:

Total positive: 36622
Average positive: 36.622
Total negative: 37623
Average negative: 37.58541458541458
With bonus:33.826873126873124
Overall score: 35.22443656343656

Konstruksi lekukan besar di tengah adalah tiga pemahaman yang tersusun berulang, dua batin di dalam ekspresi let. Ini kemudian diuji menggunakan fungsi memperluas dua kali, dan reducefungsi menemukan yang terpendek dari string itu.

Saya telah mengajukan permintaan fitur untuk dapat melakukan ini dalam satu pemahaman.

Di dalam pemahaman, kita sedang membangun string dari root r, eksponen xdan sisanya ( n-watau w-n).

The letekspresi dan mapfungsi baru di Ceylon 1.2. mapbisa digantikan oleh HashMap(yang akan membutuhkan lebih banyak karakter untuk impor, meskipun mungkin akan lebih cepat, karena saya tidak akan membuat peta baru untuk setiap entri baru). The letekspresi seperti let (w = r ^ x)harus diganti dengan menggunakan ifklausa seperti if(exists w = true then r ^ x)(dan kemudian aku tidak akan diperlukan dua expandpanggilan baik), tapi ini masih akan sedikit lebih lama, tidak pas dalam 511 byte diperbolehkan.

Di sini sampel keluaran sesuai dengan yang dipilih di atas, semuanya kecuali jumlah yang sangat kecil lebih pendek:

   27:  15: (1+1+1)^(1+1+1)
   28:  17: (1+1+1)^(1+1+1)+1
   29:  19: (1+1+1)^(1+1+1)+1+1
   30:  21: (1+1)^(1+1+1+1+1)-1-1
   31:  19: (1+1)^(1+1+1+1+1)-1
   32:  17: (1+1)^(1+1+1+1+1)
   33:  19: (1+1)^(1+1+1+1+1)+1
   34:  21: (1+1)^(1+1+1+1+1)+1+1

  -27:  16: -(1+1+1)^(1+1+1)
  -28:  18: -(1+1+1)^(1+1+1)-1
  -29:  20: -(1+1+1)^(1+1+1)-1-1
  -30:  22: -(1+1)^(1+1+1+1+1)+1+1
  -31:  20: -(1+1)^(1+1+1+1+1)+1
  -32:  18: -(1+1)^(1+1+1+1+1)
  -33:  20: -(1+1)^(1+1+1+1+1)-1
  -34:  22: -(1+1)^(1+1+1+1+1)-1-1

  993:  39: ((1+1+1)^(1+1)+1)^(1+1+1)-1-1-1-1-1-1-1
  994:  37: ((1+1+1)^(1+1)+1)^(1+1+1)-1-1-1-1-1-1
  995:  35: ((1+1+1)^(1+1)+1)^(1+1+1)-1-1-1-1-1
  996:  33: ((1+1+1)^(1+1)+1)^(1+1+1)-1-1-1-1
  997:  31: ((1+1+1)^(1+1)+1)^(1+1+1)-1-1-1
  998:  29: ((1+1+1)^(1+1)+1)^(1+1+1)-1-1
  999:  27: ((1+1+1)^(1+1)+1)^(1+1+1)-1
 1000:  25: ((1+1+1)^(1+1)+1)^(1+1+1)

 -993:  40: -((1+1+1)^(1+1)+1)^(1+1+1)+1+1+1+1+1+1+1
 -994:  38: -((1+1+1)^(1+1)+1)^(1+1+1)+1+1+1+1+1+1
 -995:  36: -((1+1+1)^(1+1)+1)^(1+1+1)+1+1+1+1+1
 -996:  34: -((1+1+1)^(1+1)+1)^(1+1+1)+1+1+1+1
 -997:  32: -((1+1+1)^(1+1)+1)^(1+1+1)+1+1+1
 -998:  30: -((1+1+1)^(1+1)+1)^(1+1+1)+1+1
 -999:  28: -((1+1+1)^(1+1)+1)^(1+1+1)+1
-1000:  26: -((1+1+1)^(1+1)+1)^(1+1+1)

    1:   1: 1
    2:   3: 1+1
    3:   5: 1+1+1
    4:   7: 1+1+1+1
    5:   9: 1+1+1+1+1
    6:  11: 1+1+1+1+1+1
    7:  13: 1+1+1+1+1+1+1
    8:  13: (1+1)^(1+1+1)
    9:  13: (1+1+1)^(1+1)
   10:  15: (1+1+1)^(1+1)+1

    0:   1: 0
   -1:   2: -1
   -2:   4: -1-1
   -3:   6: -1-1-1
   -4:   8: -1-1-1-1
   -5:  10: -1-1-1-1-1
   -6:  12: -1-1-1-1-1-1
   -7:  14: -1-1-1-1-1-1-1
   -8:  14: -(1+1)^(1+1+1)
   -9:  14: -(1+1+1)^(1+1)
  -10:  16: -(1+1+1)^(1+1)-1

Sebagai contoh, sekarang kita memiliki 1000 = (3 ^ 2 + 1) ^ 3, bukan 1000 = (6 ^ 2-4) ^ 2-5 ^ 2 + 1.

Ruby / dc, 20.296 18.414 16.968

Pemrograman dinamis! Menentukan daftar fungsi yang, diberikan instruksi dc, mengembalikan ekspresi baru dan nilai numerik ekspresi itu. Kemudian, dimulai dengan 1prefined, ia membangun daftar semua nilai yang dapat dijangkau hingga dan termasuk nilai yang diinginkan.

edit:

Menambahkan fungsi untuk n-1 dan membuatnya menjalankan algoritma melalui beberapa lintasan. Tampaknya perlu 7 operan untuk menstabilkan. Harus mempersingkat beberapa nama variabel agar tetap dalam 512 byte.

edit 2:

Menambahkan fungsi untuk n (n-1) , n (n + 1) dan n ^ 3 saat saya masih di sana. Memperpendek kode lagi, mendarat tepat 512 byte.

N = gets.to_i

fns = [
  ->(n,s){[n-1,   s+'1-']},
  ->(n,s){[n+1,   s+'1+']},
  ->(n,s){[n*2,   s+'d+']},
  ->(n,s){[n*3,   s+'dd++']},
  ->(n,s){[n*~-n, s+'d1-*']},
  ->(n,s){[n*n,   s+'d*']},
  ->(n,s){[n*-~n, s+'d1+*']},
  ->(n,s){[n*n*n, s+'dd**']},
]

lst = []*(N+1)
lst[0..2] = %w[0 1 1d+]

loop do
  prev = lst.dup

  (1..N).each do |n|
    fns.each do |f|
      m,s = f[n, lst[n]]
      lst[m] = s if m <= N && (lst[m].nil? || lst[m].size > s.size)
    end
  end

  break if lst == prev
end

puts lst[N]

Angka yang dihasilkan:

Keluaran seluruhnya terdiri dari lima karakter yang berbeda: 1mendorong nilai 1 pada tumpukan; dmenggandakan bagian atas tumpukan; +,, -dan * muncul dua nilai teratas dan mendorong jumlah, perbedaan, dan produknya masing-masing. Setiap ekspresi yang dihasilkan menambahkan hanya satu nilai ke stack setelah eksekusi.

   1: 1
   2: 1d+
   3: 1dd++
   4: 1d+d+
   5: 1d+d+1+
   6: 1d+dd++
   7: 1d+dd++1+
   8: 1d+dd**
   9: 1dd++d*
  10: 1d+d+1+d+
  11: 1d+d+1+d+1+
  12: 1dd++d1+*
  13: 1dd++d1+*1+
  14: 1d+dd++1+d+
  15: 1d+d+d*1-
  16: 1d+d+d*
  17: 1d+d+d*1+
  18: 1dd++d*d+
  19: 1dd++d*d+1+
  20: 1d+d+d1+*
  21: 1d+d+d1+*1+
  22: 1d+d+1+d+1+d+
  23: 1d+dd**dd++1-
  24: 1d+dd**dd++
  25: 1d+d+1+d*

...

 989: 1d+d+d*d+d1-*1-1-1-
 990: 1d+d+d*d+d1-*1-1-
 991: 1d+d+d*d+d1-*1-
 992: 1d+d+d*d+d1-*
 993: 1d+d+d*d+d1-*1+
 994: 1d+d+d*d+d1-*1+1+
 995: 1d+d+d*d+d1-*1+1+1+
 996: 1d+d+1+dd**d+1-d+d+
 997: 1d+d+1+d+dd**1-1-1-
 998: 1d+d+1+d+dd**1-1-
 999: 1d+d+1+d+dd**1-
1000: 1d+d+1+d+dd**

Python 2.6, 78.069 - 66.265 poin

Menyerahkan jawaban saya untuk apa nilainya (tidak banyak dalam kasus ini ... tapi jelas menunjukkan bahwa untuk tantangan ini tidak cukup hanya dengan memikirkan menyusun output sebagai jumlah nilai bit-shifted; ketika diperhitungkan bahwa tidak ada digit di luar 0 atau 1 dapat muncul di output). Saya mungkin akan kembali lagi nanti dengan cara yang berbeda untuk menghasilkan output.

Kode itu sendiri tidak terlalu panjang (176 karakter):

def f(a):return'+'.join(('(1<<%s)'%['0','+'.join('1'*x)][x>0]).replace('(1<<0)','1')for x in[i for i,e in enumerate(bin(a)[::-1][:-2])if int(e)])
print"".join(f(int(input())))

Ini menghasilkan output yang benar tetapi verbose:

17
1+(1<<1+1+1+1)

800
(1<<1+1+1+1+1)+(1<<1+1+1+1+1+1+1+1)+(1<<1+1+1+1+1+1+1+1+1)

Cuplikan yang menghitung skor:

def f(a):return'+'.join(('(1<<%s)'%['0','+'.join('1'*x)][x>0]).replace('(1<<0)','1')for x in[i for i,e in enumerate(bin(a)[::-1][:-2])if int(e)])
print sum(len("".join(f(i)))for i in range(1000))