การแสดงผลการแสดงออกหลักฐานฐาน


21

พื้นหลัง

ในอนาคตที่เป็นไปได้บางอย่างโลกจะแปลงระบบตัวเลขของพวกเขาจากฐานสิบ (ฐาน 10 หรือb10) ไปเป็นฐานอื่น (ฐานสองb2ฐานแปดฐานb8สิบหกb16หรือแม้แต่เอกb1ในกรณีนี้เรากำลังเมา!) ดังนั้นในการเตรียมการสำหรับเหตุการณ์ที่เปลี่ยนแปลงโลกที่เป็นไปได้นี้คุณตัดสินใจที่จะพิสูจน์โปรแกรมทั้งหมดของคุณ สิ่งนี้สามารถทำได้โดยใช้เพียงเอกพจน์0และ1s ร่วมกับตัวดำเนินการเพื่อแทนที่ค่าคงที่จำนวนที่มีอยู่

อย่างไรก็ตามมีเพียงปัญหาเดียว: คุณมีโปรแกรมมากมายให้เปลี่ยนและการแปลงแต่ละตัวเลขเป็นนิพจน์จะใช้เวลาหลายสัปดาห์! ดังนั้นคุณตัดสินใจที่จะเขียนโปรแกรม (หรือฟังก์ชัน) เพื่อตัดสินใจว่านิพจน์ใดควรแทนที่แต่ละตัวเลข

อินพุต

อินพุตจะเป็นจำนวนเต็มบวก รหัสของคุณจะต้องสามารถจัดการกับจำนวนเต็มใด ๆ ได้สูงสุด 1,000

(หากรหัสของคุณรองรับทศนิยมและ / หรืออินพุตเชิงลบให้ดูที่การให้คะแนนด้านล่าง)

เอาท์พุต

รหัสของคุณจะต้องส่งออกนิพจน์ที่ประเมินไปยังอินพุตในภาษาอย่างน้อยหนึ่งภาษา นี่อาจเป็นภาษาใดก็ได้ ไม่จำเป็นต้องเป็นโปรแกรมหรือฟังก์ชั่นเดียวกับที่คุณเขียนนอกจากนี้นิพจน์นี้ไม่จำเป็นต้องเป็นโปรแกรมหรือฟังก์ชั่นแบบเต็ม

เพื่อความชัดเจนเอาต์พุตอาจมีการดำเนินการใด ๆ เหล่านี้:

  • การเพิ่ม / ลด
  • เพิ่ม / ผลรวม
  • ลบ / ปฏิเสธ
  • ทวีคูณ / คู่ (เฉพาะในกรณีที่มันไม่เกี่ยวข้องโดยตรงกับจำนวน2!)
  • หาร / โมดูโล
  • เลขชี้กำลัง / ลอการิทึม
  • square / sqrt (อีกครั้งหากสิ่งเหล่านี้ไม่เกี่ยวข้องโดยตรงกับจำนวน2!)
  • การทำงานระดับบิต (bOR, bAND, bNOT, bXOR, bit-shift)
  • การตั้งค่า / รับตัวแปร
  • การจัดการกองซ้อน

คุณไม่สามารถใช้eval()หรือฟังก์ชั่นที่คล้ายกันในผลลัพธ์ คุณไม่สามารถใช้ฟังก์ชันใด ๆ ที่ดำเนินการนอกเหนือจากที่กล่าวถึงข้างต้นได้

โอ้และอีกอย่างหนึ่ง: เนื่องจากเราต้องการให้ผลลัพธ์ถูกต้องในฐานมากที่สุดเท่าที่จะเป็นไปได้ค่าคงที่จำนวนเดียวที่มันอาจมีคือ 01และ ตัวเลขเช่น10(สิบ) จะไม่ได้รับอนุญาตเว้นแต่ตีความภาษาที่เป็นและ1 0ไม่อนุญาตให้ใช้สตริงเพื่อเก็บตัวเลขเช่นเดียวกับการใช้อักขระเช่น CJam's A- K(ซึ่งใช้แทน10- 20)

การทดสอบกรณี

(เอาต์พุตทั้งหมดอยู่ใน JavaScript แต่อาจทำงานในภาษาอื่น ๆ )

อินพุต 1:

2

เอาต์พุตที่เป็นไปได้ 1:

1+1

อินพุต 2:

13

เอาต์พุตที่เป็นไปได้ 2:

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

อินพุต 3:

60

เอาต์พุตที่เป็นไปได้ 3:

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

อินพุต 4:

777

เอาต์พุตที่เป็นไปได้ 4:

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

อินพุต 5:

1000

เอาต์พุตที่เป็นไปได้ 5:

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

เกณฑ์การให้คะแนน

เป้าหมายของการท้าทายนี้คือการย่อรหัสของคุณให้สั้นที่สุด คะแนนของคุณจะถูกคำนวณด้วยวิธีนี้:

  • คะแนนฐาน:จำนวนไบต์เฉลี่ยของเอาต์พุตทั้งหมดสำหรับจำนวนเต็ม 1 ถึง 1,000

  • คะแนนทศนิยม:หากรหัสของคุณรองรับทศนิยมอย่างน้อย 3 ตำแหน่งนี่คือจำนวนไบต์เฉลี่ยของเอาต์พุตทั้งหมดของลำดับตัวเลขที่เริ่มต้น0.001และสิ้นสุดที่1000เพิ่มขึ้นโดย1.001ในแต่ละครั้ง 0.001, 1.002, 2.003...998.999, 1000.000จากนั้นลด 50% จากคะแนนนี้

  • คะแนนลบ:หากรหัสของคุณรองรับจำนวนลบและศูนย์นี่คือจำนวนไบต์เฉลี่ยของเอาต์พุตของจำนวนเต็มทั้งหมดจาก-10000การ จากนั้นลด 10% จากคะแนนนี้

(วิธีที่ง่ายที่สุดในการคำนวณสิ่งเหล่านี้น่าจะเป็นลูปกับโปรแกรม / ฟังก์ชันของคุณภายใน)

คะแนนสุดท้ายของคุณคือค่าเฉลี่ยของสูตรใด ๆ ข้างต้นที่ใช้

หากผลลัพธ์ไม่ได้กำหนดไว้ (เช่นค่อนข้างสุ่มการรันหลายครั้งด้วยอินพุตเดียวกันจะสร้างเอาต์พุตที่ไม่ซ้ำกันหลายรายการ) คะแนนสำหรับแต่ละอินพุตนั้นถูกกำหนดโดยเอาท์พุทที่ใหญ่ที่สุดในสิบซีพียูของฉัน

นอกจากนี้ในขณะที่คุณไม่ทราบว่าข้อมูลคอมพิวเตอร์ที่มีค่าจะเป็นอย่างไรในอนาคตจำนวนตัวสร้างโค้ดไบต์ของคุณจะต้องน้อยกว่า 512 ไบต์

คะแนนต่ำสุดในสองสัปดาห์ (วันที่ 30 ก.ย. ) จะถูกประกาศให้เป็นผู้ชนะ ขอแสดงความยินดีกับผู้ชนะของคุณ @ThomasKwa !


ลีดเดอร์บอร์ด

เพื่อให้แน่ใจว่าคำตอบของคุณแสดงอย่างถูกต้องโปรดเริ่มด้วยหัวข้อนี้:

# Language name/Other language name, X points

Xคะแนนของคำตอบของคุณอยู่ที่ไหน ตัวอย่าง:

# CJam/Pyth, 25.38 points

หากคุณมีคำถามหรือข้อเสนอแนะโปรดแจ้งให้เราทราบ โชคดี!


ฉันสามารถใช้ตัวแปรที่เก็บไว้0หรือ1โดยค่าเริ่มต้นได้หรือไม่
Dennis

@Dennis ฉันไม่เห็นปัญหาใด ๆ กับมันเลยไปเลย!
ETHproductions

ฉันสมมติว่าฉันไม่สามารถทำการแปลงฐานระหว่างฐาน 2 และฐานเริ่มต้นได้
บลู

@muddyfish Nope ไม่อนุญาตให้แปลงฐานในเอาต์พุต
ETHproductions

ฉันเดาว่าเรายังไม่ได้รับอนุญาตให้ใช้บางอย่างเช่นInteger.parseInt("1000", 1+1+1+1+1+1+1+1+1+1)? ฉันค่อนข้างมั่นใจว่าparseIntใช้การดำเนินการที่อนุญาตเท่านั้น ;-)
Pa --lo Ebermann

คำตอบ:


10

รหัสเครื่อง 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]

โบนัส: ตัวเลขติดลบ

สันนิษฐานว่าhlทั้งคู่ลงทะเบียนครั้งแรกถือเป็น 0 hlและผลตอบแทนใน

ใช้คำสั่งทั้งสามนี้เท่านั้น:

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

เราใช้การปรับเปลี่ยนเล็ก ๆ ของขั้นต่ำน้ำหนักสมดุลแทน binary BBR2 ตั้งแต่ BBR2 ลดน้ำหนัก (จำนวนของตัวเลขที่ไม่ใช่ศูนย์) แต่เราต้องการที่จะลดน้ำหนักบวกจำนวนกะบิตเราเปลี่ยนอย่างต่อเนื่องในขั้นตอนวิธีการจากไป3/25/3

ในการคำนวณคะแนนและตรวจสอบใช้รหัสนี้:

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

ตัวอย่างผลลัพธ์:

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

หรือในการชุมนุม:

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

โปรแกรมตัวอย่างเพิ่มเติม:

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

การเพิ่มประสิทธิภาพเป็นไปได้: กฎ OP ว่าinc hและdec hคำแนะนำที่โดยตรงเปลี่ยนไบต์บนของhlจะผิดกฎหมาย แต่sla hและไม่มีเอกสารsl1 h(กะบิตซ้ายโดยที่ 1 ในhการเปลี่ยนแปลงในที่0และ1ตามลำดับ) จะได้รับอนุญาต sla hและsl1 hแต่ละไบต์มีสองไบต์ แต่บางครั้งอาจทำให้เอาต์พุตสั้นลง


ดีมากต่ำสุด! ฉันคิดว่านี่เป็นหนึ่งในตัวอย่างที่รหัสเครื่องที่แท้จริงมีประโยชน์ ;)
ETHproductions

2
+1 นี่อาจจะไม่สามารถเอาชนะได้ นอกจากนี้สำหรับอัจฉริยะของการใช้รหัสเครื่อง (บนซีพียูที่มีชุดคำสั่ง 8 บิตส่วนใหญ่และการลงทะเบียน 16 บิตบางส่วน)
ระดับแม่น้ำเซนต์

มันแปลกว่าแปลว่า+ decฉันอ่านผิดไปเรื่อย ๆ
ETHproductions

9

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=

ไม่มีโบนัสใช้

ลองออนไลน์: ทดลองใช้งาน | เครื่องคิดเลขคะแนน | การตรวจสอบ

ตัวอย่างการวิ่ง

   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<

คำพูดของฉันเร็วมาก! แม้ว่าลิงก์จะไม่ทำงานใน Firefox
ETHproductions

เนื่องจากนี่ไม่ใช่โค้ดกอล์ฟฉันจึงแทนที่%ด้วยนิพจน์ที่ยาวกว่า ลิงค์ควรใช้งานได้แล้ว
Dennis

ข้อมูลเข้า 34 ให้ 1 ว่าข้อมูลใดทำงานได้ดีขึ้น
Kishan Kumar

2
@KishanKumar การตรวจสอบทดสอบ 1,000 อินพุตที่เป็นไปได้ทั้งหมด เอาท์พุท1บ่งชี้ว่าการเปรียบเทียบประสบความสำเร็จ
Dennis

คุณสามารถเพิ่มตัวอย่างผลลัพธ์ได้ไหม
Paŭlo Ebermann

3

เอสเอส / BrainFuck, 34.201 คะแนน

เอสเอสแหล่งที่มา (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)

หากใครสนใจฉันจะเพิ่มคำอธิบาย เอาท์พุท BF ได้รับการปรับให้เหมาะสมแล้ว แต่ฉันคิดว่าฉันสามารถใช้รหัสเหลือ 318B ของรหัสเพื่อนำไปใช้

  • ลูปซ้อน - การเพิ่มประสิทธิภาพ
  • ทางลัดมากเกิน 8 บิต
  • กำจัดการชนกันของผู้ประกอบการ

ตัวอย่าง:

ทำงานใน windows:

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

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

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

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

ทำงานใน linux:

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

ตรวจสอบในการล่าม BF ออนไลน์

คะแนน:

  1. = 37.495เฉลี่ยฐาน
  2. = 60.959 * 0.5 = ~30.48ทศนิยมเฉลี่ย
  3. ปริมาณเฉลี่ยติดลบ = 38.4765234765235 * 0.9 = ~34.629
  4. = (37.495 + 30.48 + 34.629)/3 = 34.201เฉลี่ยสูงกว่าคะแนนสุดท้าย

1
ฉันชอบที่จะเห็นภาษาใหม่ ๆ ที่ผู้คนสร้างขึ้นมาเสมอ :) ขอบคุณสำหรับคะแนนเสีย! ฉันต้องการเพิ่มโบนัสในส่วนทศนิยมดังนั้นฉันจึงเปลี่ยนการหักจาก 40% เป็น 50%
ETHproductions

@ETHproductions ใช่ฉันจะลองตั้งล่ามออนไลน์สำหรับสิ่งนี้ มีผู้ให้บริการที่เป็นนามธรรมสูงประมาณ 435 คนสามารถกำหนดเพิ่มเติมได้อีก 9,9k ;-) ฉันแก้ไขการคำนวณ (หวังว่า)
mınxomaτ

3

Ruby / Ruby, 29.77885

31.873 * 0.9 (ลบ) 30.872 (บวก)

กลยุทธ์พื้นฐานคือการแสดงฐานสมมาตร 3 ("ไตรภาคแบบสมดุล") คือเมื่อตัวเลขนั้น-1,0,1แทน0,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

นี่คือผลลัพธ์จาก 0 ถึง 40 ก่อนที่จะล้างข้อมูล

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

และหลังล้างข้อมูล

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

ฉันเชื่อว่ามันเรียกว่า "ไตรภาคแบบสมดุล"
lirtosiast

@ThomasKwa แก้ไขแล้วขอบคุณ
Level River St

3

ประเทศศรีลังกา / ศรีลังกา 49.86 40.95 คะแนน

รุ่นที่สามใช้ Ceylon 1.2 สำหรับเครื่องกำเนิดไฟฟ้าและรหัส 509 ไบต์:

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

มันลดลงเหลือ 35.22 จุด แต่ฉันจะไม่ใส่มันในบรรทัดหัวเรื่องเพราะ Celyon 1.2 เท่านั้นที่เผยแพร่ในเดือนตุลาคม 29 ฉันไม่คิดว่าฉันจะสามารถใช้อัลกอริทึมนี้ใน Ceylon 1.1 ในขนาดนี้ได้) รายละเอียดเพิ่มเติมที่นี่ฉันจะอธิบายรุ่นที่สอง (รุ่นแรกสามารถเห็นได้ในประวัติศาสตร์ - รองรับเฉพาะตัวเลขบวก แต่มีขนาดพอดีกับ 256 ไบต์)

รุ่นที่สอง

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

รหัสมีความยาว 487 ดังนั้นจึงมีพื้นที่เหลือสำหรับการปรับแต่งเพิ่มเติมในภายหลัง (นอกจากนี้ยังมีปริมาณสำรองในรูปแบบของช่องว่างและชื่อตัวแปรแบบยาว)

คะแนน:

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

ตัวอย่างผลลัพธ์บางส่วน:

   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

อย่างที่คุณเห็นว่าค่าลบนั้นเป็นหนึ่งไบต์ (นำหน้า-) นานกว่าค่าบวกที่สอดคล้องกันเสมอ

แนวคิดพื้นฐานเหมือนกับโปรแกรมก่อนหน้า: ค้นหาสี่เหลี่ยมจัตุรัสใกล้กับจำนวนเป้าหมายของเราและแสดงถึงรากและส่วนที่เหลือซ้ำ แต่ตอนนี้เราอนุญาตให้สแควร์ของเรามีขนาดใหญ่กว่าจำนวนเป้าหมายซึ่งทำให้ส่วนที่เหลือเป็นลบ ( +0.5สามารถเปลี่ยนเป็นค่าคงที่ที่แตกต่างกันเพื่อปรับแต่งอัลกอริทึม แต่ดูเหมือนว่าฉันได้ตีที่เหมาะสมแล้วที่นี่ - ทั้ง 0.4 และ 0.6 ให้ผลลัพธ์ที่แย่ลง)

ในการทำให้ค่าลบเป็นลบ (และมีโครงสร้างเดียวกันกับค่าบวกเราจะส่งโอเปอเรเตอร์signไปยังฟังก์ชันเวียนเกิดp- นั่นคือ"+"หรือ"-"เราสามารถใช้มันสำหรับผู้เข้าร่วมในกรณีเล็ก ๆ น้อย ๆ (เช่น n <9) สำหรับส่วนที่เหลือถ้ามันเป็นบวกและใช้เครื่องหมายตรงข้ามสำหรับส่วนที่เหลือถ้ามันเป็นลบ

proofฟังก์ชั่นจับสัญญาณเริ่มต้น (กับกรณีพิเศษ 0) ที่pฟังก์ชั่นไม่ทำงานจริงกับการเรียกซ้ำ

รุ่นที่สามสำหรับ 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;
}

รุ่น golfed (เช่นความคิดเห็นและลบช่องว่าง) ถูกโพสต์ที่ด้านบนที่รหัส 509 ไบต์

สิ่งนี้ใช้หลักการพื้นฐานเดียวกับเวอร์ชั่นที่สอง แต่แทนที่จะใช้กำลังสองมันจะพยายามใช้กำลังของตัวเลขที่สูงขึ้น (ลองเลขชี้กำลังจาก 2 เป็น 8) และใช้ผลลัพธ์ที่สั้นที่สุด นอกจากนี้ยังเก็บผลลัพธ์เช่นกันเพราะจะทำให้ช้าลงสำหรับหมายเลขที่ใหญ่กว่าด้วยการโทรซ้ำหลายครั้ง

เกณฑ์การให้คะแนน:

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

โครงสร้างเยื้องขนาดใหญ่ที่อยู่ตรงกลางคือความเข้าใจที่ซ้ำซ้อนสามระดับซ้อนกันและสองชั้นภายในที่อยู่ในนิพจน์ให้ สิ่งเหล่านี้จะไม่ถูกรบกวนโดยใช้ฟังก์ชัน expand สองครั้งและreduceฟังก์ชันจะค้นหาสตริงที่สั้นที่สุด

ฉันได้ส่งคำขอคุณสมบัติเพื่อให้สามารถทำสิ่งนี้ได้ในความเข้าใจเดียว

ภายในความเข้าใจเรากำลังสร้างสตริงจากรากrเลขชี้กำลังxและส่วนที่เหลือ ( n-wหรือw-n)

การletแสดงออกและmapฟังก์ชั่นใหม่ใน Ceylon 1.2 mapอาจถูกแทนที่ด้วยHashMap(ซึ่งจะต้องมีอักขระมากขึ้นสำหรับการนำเข้าแม้ว่ามันอาจจะเร็วกว่านี้เพราะฉันจะไม่สร้างแผนที่ใหม่สำหรับแต่ละรายการใหม่) การletแสดงออกเช่นlet (w = r ^ x)นี้อาจถูกแทนที่โดยใช้ifประโยคเช่นif(exists w = true then r ^ x)(แล้วฉันก็ไม่ต้องการทั้งสองexpandสาย) แต่นี่จะยังคงนานกว่านี้เล็กน้อยไม่เหมาะกับไบต์ที่อนุญาต 511

ตัวอย่างผลลัพธ์ที่ตรงกับที่เลือกไว้ด้านบนทั้งหมดทั้งหมดยกเว้นจำนวนน้อยจริง ๆ จะสั้นกว่า:

   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

ตัวอย่างเช่นตอนนี้เรามี 1,000 = (3 ^ 2 + 1) ^ 3 แทน 1,000 = (6 ^ 2-4) ^ 2-5 ^ 2 + 1


ฉันจำผิดข้อ จำกัด ของโปรแกรมเป็น 256 ไบต์ ... ใน 512 สามารถทำได้มากกว่านี้อีกนิด จะลองอีกครั้งในภายหลัง
Paŭlo Ebermann

Nah less than 512ก็กล่าวว่า คุณสามารถใช้งานได้สูงสุด ของ 511 bytes;)
mınxomaτ

ฉันไม่เคยได้ยินภาษานี้ได้อย่างไร!? : O แต่อย่างจริงจังคำอธิบายที่ยอดเยี่ยม! ฉันชอบที่จะเข้าใจเทคนิคที่คนอื่นใช้ในคำตอบของพวกเขา +1
ETHproductions

@ETHproductions ฉันยังอ่านมันเมื่อประมาณสองสัปดาห์ที่ผ่านมาที่นี่บนเว็บไซต์และเริ่มชอบมัน ดังนั้นเพื่อทำความรู้จักให้ดีขึ้นฉันพยายามตอบคำถามที่นี่โดยใช้ Ceylon
Paŭlo Ebermann

2

ทับทิม / DC, 20.296 18.414 16.968

การเขียนโปรแกรมแบบไดนามิก! กำหนดรายการฟังก์ชันที่กำหนดคำสั่ง dc ให้ส่งคืนนิพจน์ใหม่และค่าตัวเลขของนิพจน์นั้น จากนั้นเริ่มต้นด้วยการ1สร้างแบบล่วงหน้ามันจะสร้างรายการของค่าที่สามารถเข้าถึงได้ทั้งหมดจนถึงและรวมถึงค่าที่ต้องการ

แก้ไข:

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

แก้ไข 2:

เพิ่มฟังก์ชั่นสำหรับ n (n-1) , n (n + 1)และn ^ 3ขณะที่ฉันอยู่ที่นี่ ทำให้รหัสสั้นลงอีกเล็กน้อยโดยมีขนาด 512 ไบต์

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]

หมายเลขที่สร้าง:

เอาต์พุตประกอบด้วยอักขระที่แตกต่างกันห้าตัว: 1ผลักดันค่า 1 บนสแต็กdทำซ้ำส่วนบนสุดของสแต็ก +, -และ* แสดงค่าสูงสุดสองค่าและเพิ่มผลรวมความแตกต่างและผลิตภัณฑ์ตามลำดับ แต่ละนิพจน์ที่สร้างขึ้นจะเพิ่มค่าเดียวให้กับสแต็กหลังจากการดำเนินการ

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

1
ค่อนข้างดีเต้นทุกอย่างยกเว้นรหัสเครื่อง z80 (แม้แต่เดนนิส 'CJam!) คุณคิดว่าคุณสามารถเพิ่ม-โอเปอเรเตอร์ขณะที่อยู่ในจำนวนไบต์ได้หรือไม่?
ประโยชน์ทับซ้อน

@ETHproductions เป็นไงบ้าง ;) ไม่ควรที่จะเพิ่มหมายเลขติดลบตอนนี้
daniero

0

Python 2.6, 78.069 - 66.265 คะแนน

ส่งคำตอบของฉันสำหรับสิ่งที่มีค่า (ไม่มากในกรณีนี้ ... แต่แสดงให้เห็นอย่างชัดเจนว่าสำหรับความท้าทายนี้มันไม่เพียงพอที่จะเพียงแค่คิดว่าการเขียนผลลัพธ์เป็นผลรวมของค่าบิต - กะเมื่อนำมาพิจารณาว่าไม่มีตัวเลข ด้านนอกของ 0 หรือ 1 อาจปรากฏในผลลัพธ์) ฉันอาจกลับมาใหม่ในภายหลังด้วยวิธีอื่นในการสร้างผลลัพธ์

โค้ดเองไม่ยาวเกินไป (176 ตัวอักษร):

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

มันสร้างผลลัพธ์ที่ถูกต้อง แต่ 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)

ตัวอย่างที่คำนวณคะแนน:

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))
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.