एक बेस प्रूफ अभिव्यक्ति का उत्पादन


21

पृष्ठभूमि

कुछ संभावित वायदाओं में, दुनिया अपने संख्यात्मक सिस्टम को दशमलव (बेस 10 या b10) से किसी अन्य आधार (बाइनरी b2, ऑक्टल b8, हेक्साडेसिमल b16या यहां तक ​​कि एकात्मक b1, जिस स्थिति में हम खराब हैं!) में बदल देंगे । इस प्रकार, इस संभावित विश्व-बदलते आयोजन की तैयारी में, आप अपने सभी कार्यक्रमों को आधार-प्रमाण देने का निर्णय लेते हैं। यह मौजूदा संख्या स्थिरांक को बदलने के लिए ऑपरेटरों के साथ संयोजन में केवल एकवचन 0एस और 1एस का उपयोग करके किया जा सकता है ।

हालाँकि, वहाँ सिर्फ एक समस्या है: आपके पास बदलने के लिए एक टन कार्यक्रम है, और मैन्युअल रूप से प्रत्येक संख्या को अभिव्यक्ति में परिवर्तित करने में सप्ताह लगेंगे! इस प्रकार, आप यह तय करने के लिए एक प्रोग्राम (या फ़ंक्शन) लिखने का निर्णय लेते हैं कि प्रत्येक संख्या को किस अभिव्यक्ति को प्रतिस्थापित करना चाहिए।

इनपुट

इनपुट एक धनात्मक पूर्णांक होगा। आपका कोड 1000 तक किसी भी पूर्णांक को संभालने में सक्षम होना चाहिए।

(यदि आपका कोड दशमलव और / या नकारात्मक इनपुट का समर्थन करता है, तो नीचे स्कोरिंग देखें।)

उत्पादन

आपके कोड को एक अभिव्यक्ति का उत्पादन करना चाहिए जो कम से कम एक भाषा में इनपुट का मूल्यांकन करता है। यह कोई भी भाषा हो सकती है; इसमें वही नहीं होना चाहिए जो आपके प्रोग्राम या फंक्शन में लिखा गया है। इसके अलावा, इस एक्सप्रेशन को पूरा प्रोग्राम या फंक्शन होने की जरूरत नहीं है।

स्पष्टता के लिए, आउटपुट में इनमें से कोई भी ऑपरेशन हो सकता है:

  • वेतन वृद्धि / वृद्धि
  • जोड़ / योग
  • घटाना / नकारना
  • गुणा / डबल (केवल अगर यह सीधे नंबर शामिल नहीं करता है 2!)
  • विभाजित / मोडुलो
  • घातांक / लघुगणक
  • वर्ग / sqrt (फिर, केवल अगर ये सीधे संख्या को शामिल नहीं करते हैं 2!)
  • बिटवाइज़ ऑपरेशंस (bOR, bAND, bNOT, bXOR, बिट-शिफ्ट्स)
  • चर स्थापित करना / प्राप्त करना
  • ढेर में हेरफेर

आप आउटपुट में या इसी तरह के अन्य कार्यों का उपयोग नहीं कर सकते हैंeval() । आप आउटपुट में किसी भी फ़ंक्शन का उपयोग नहीं कर सकते हैं जो ऊपर बताए गए कार्यों के अलावा कोई कार्रवाई करते हैं।

ओह, और एक और बात: चूंकि हम चाहते हैं कि आउटपुट जितने संभव हो उतने आधारों में मान्य हो, केवल वही संख्या स्थिरांक हो सकती है, 0और 110जब तक भाषा इसे एक 1और एक के रूप में व्याख्या नहीं करती है, तब तक (दस) संख्याएँ अस्वीकृत हैं 0। तार का उपयोग संख्या या तो अनुमति नहीं है को रोकने के लिए, के रूप में इस तरह के CJam के रूप में अक्षरों का उपयोग किया जाता है A- K(जो प्रतिनिधित्व करते हैं 10- 20)।

परीक्षण के मामलों

(सभी आउटपुट जावास्क्रिप्ट में हैं, लेकिन अन्य भाषाओं में काम कर सकते हैं।)

इनपुट 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 से 1000 के लिए सभी आउटपुट की औसत बाइट-गिनती।

  • दशमलव स्कोर: यदि आपका कोड कम से कम 3 दशमलव स्थानों का समर्थन करता है, तो यह संख्या के अनुक्रम के सभी आउटपुट का औसत बाइट-काउंट है जो हर बार शुरू होने 0.001और 1000बढ़ने पर समाप्त होता है 1.0010.001, 1.002, 2.003...998.999, 1000.000फिर इस स्कोर का 50% हिस्सा लें।

  • नकारात्मक स्कोर: यदि आपका कोड नकारात्मक संख्या और शून्य का समर्थन करता है, तो यह सभी पूर्णांकों के आउटपुट के औसत बाइट-काउंट से -1000है 0। फिर इस स्कोर का 10% हिस्सा लें।

(इनकी गणना का सबसे आसान तरीका संभवत: आपके प्रोग्राम / फंक्शन के अंदर एक लूप होगा।)

आपका अंतिम अंक उपरोक्त सूत्रों में से जो भी लागू हो, का औसत है।

यदि आउटपुट गैर-निर्धारक है (यानी कुछ हद तक यादृच्छिक; एक ही इनपुट के साथ कई रन कई अद्वितीय आउटपुट उत्पन्न करते हैं), तो प्रत्येक इनपुट के लिए स्कोर मेरे सीपीयू पर दस से अधिक रन से सबसे अधिक आउटपुट द्वारा निर्धारित किया जाता है।

इसके अलावा, जैसा कि आप नहीं जानते कि भविष्य में कंप्यूटर डेटा कितना कीमती होगा, आपके जनरेटर कोड की बाइट-गिनती 512 बाइट्स से कम होनी चाहिए।

दो सप्ताह में सबसे कम अंक (30 सितंबर को) को विजेता घोषित किया जाएगा। अपने विजेता @ThomasKwa को बधाई!


लीडरबोर्ड

यह सुनिश्चित करने के लिए कि आपका उत्तर सही तरीके से दिखाता है, कृपया इसे इस शीर्षक से शुरू करें:

# Language name/Other language name, X points

Xआपके उत्तर का स्कोर कहां है उदाहरण:

# CJam/Pyth, 25.38 points

यदि आपके कोई प्रश्न या सुझाव हैं, तो कृपया मुझे बताएं। सौभाग्य!


क्या मैं वैरिएबल का उपयोग कर सकता हूं जो डिफ़ॉल्ट रूप से 0या होल्ड 1करता है?
डेनिस

@ डेनिस मुझे इससे कोई समस्या नहीं है, इसलिए आगे बढ़ें!
ETHproductions

मैं मान रहा हूं कि मैं आधार 2 और डिफ़ॉल्ट आधार के बीच आधार रूपांतरण नहीं कर सकता।
ब्लू

@muddyfish नोप, आउटपुट में कोई आधार रूपांतरण की अनुमति नहीं है।
ETHproductions

मुझे लगता है कि हमें भी कुछ का उपयोग करने की अनुमति नहीं है Integer.parseInt("1000", 1+1+1+1+1+1+1+1+1+1)? मैं बहुत यकीन है कि parseIntका उपयोग करता है केवल अनुमति संचालन ;-)
पाउलो Ebermann

जवाबों:


10

पायथन / ज़िलॉग 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

हम न्यूनतम वजन संतुलित बाइनरी प्रतिनिधित्व BBR2 के एक छोटे से संशोधन का उपयोग करते हैं । चूंकि BBR2 वजन (अशून्य अंकों की संख्या) को कम करता है, लेकिन हम वजन के साथ साथ थोड़ा बदलाव की संख्या को कम करना चाहते हैं, हम से एल्गोरिथ्म में एक निरंतर बदलने 3/2के लिए 5/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  #))#

संभव अनुकूलन: ओपी कि नियमों inc hऔर dec hनिर्देशों का है, जो सीधे के ऊपरी बाइट बदलने hl, अवैध हैं, लेकिन sla hऔर undocumented 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<

मेरा शब्द, वह तेज था! लिंक फ़ायरफ़ॉक्स में काम नहीं करते हैं, हालांकि।
ETHproductions

के बाद से इस कोड गोल्फ नहीं है, मैं प्रत्येक की जगह %एक लंबे समय तक अभिव्यक्ति के साथ। लिंक अब काम करना चाहिए।
डेनिस

इनपुट 34 देता है 1. किस इनपुट पर यह बेहतर काम करता है
किशन कुमार

2
@ किशनकुमार सत्यापन सभी 1000 संभावित इनपुट का परीक्षण करता है। आउटपुट 1 इंगित करता है कि तुलना सफल रही।
डेनिस

क्या आप कुछ उदाहरण आउटपुट जोड़ सकते हैं?
पाओलो एबरमैन

3

ß / ब्रेनफक, 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)

अगर किसी को दिलचस्पी है, तो मैं एक स्पष्टीकरण जोड़ूंगा। बीएफ आउटपुट पहले से ही काफी अनुकूलित है, लेकिन मुझे लगता है कि मैं लागू करने के लिए शेष 318B कोड का उपयोग कर सकता हूं

  • लूप-नेस्टिंग-ऑप्टिमाइज़ेशन,
  • अधिक 8bit अतिप्रवाह शॉर्टकट,
  • ऑपरेटर टक्कर को हटाने

नमूने:

खिड़कियों में चल रहा है:

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

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

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

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

लिनक्स में चल रहा है:

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

ऑनलाइन बीएफ दुभाषिया में मान्य ।

स्कोर:

  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

रूबी / रूबी, 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 में संपादित, धन्यवाद
लेवल रिवर सेंट

3

सीलोन / सीलोन, 49.86 40.95 अंक

तीसरा संस्करण जनरेटर के लिए सीलोन 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 अक्टूबर को प्रकाशित किया गया था। मुझे नहीं लगता कि मैं इस एल्गोरिथ्म को सीलोन 1.1 में इस आकार में लागू कर पाऊंगा।)। अधिक विवरण नीचे, यहां मैं दूसरे संस्करण का वर्णन करूंगा। (इतिहास में पहला संस्करण देखा जा सकता है - इसने केवल सकारात्मक संख्याओं का समर्थन किया, लेकिन 256 बाइट्स में फिट हुआ।)

दूसरा संस्करण

अब दूसरा संस्करण, जो नकारात्मक पूर्णांक (और 0) का समर्थन करता है, और आम तौर पर इसके अतिरिक्त उपयोग करके थोड़ा छोटा आउटपुट बनाता है -। (यह संस्करण वास्तव में अनुमत लंबाई का उपयोग करता है, पहले वाले ने 512 के बजाय 256 बाइट्स के नीचे रहने की कोशिश की।)

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समारोह प्रत्यावर्तन के साथ, वास्तविक काम करता है।

तीसरा संस्करण, सीलोन 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;
}

गोल्फ संस्करण (यानी टिप्पणियाँ और व्हॉट्सएप हटा दिया गया) शीर्ष पर पोस्ट किया गया है, बिल्कुल कोड के 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

बीच में बड़े इंडेंट किए गए निर्माण तीन नेस्टेड इटरेबल कॉम्प्रिहेंशन हैं, आंतरिक दो एक लेट एक्सप्रेशन के अंदर। फिर दो बार विस्तार फ़ंक्शन का उपयोग करके उन्हें अनावश्यक किया जाता है, और reduceफ़ंक्शन उन स्ट्रिंग्स में सबसे कम पाता है।

मैंने एक सुविधा अनुरोध दर्ज किया है जो एक ही समझ में ऐसा करने में सक्षम है।

समझ के अंदर, हम मूल r, घातांक xऔर शेष ( n-wया) से एक स्ट्रिंग का निर्माण कर रहे हैंw-n ) ।

letअभिव्यक्ति और mapसमारोह सीलोन 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

उदाहरण के लिए, अब हमारे पास 1000 = (6 ^ 2-4) ^ 2-5 ^ 2 + 1 के बजाय 1000 = (3 ^ 2 + 1) ^ 3 है।


मैंने गलत तरीके से कार्यक्रम को 256 बाइट्स के रूप में याद किया ... 512 में थोड़ा और अधिक किया जा सकता है। बाद में कोशिश करेंगे।
पाओलो एबरमन

नहीं, यह कहता है less than 512। सौ आप अधिकतम उपयोग कर सकते हैं। 511 बाइट्स की;)
mnnxoma

मैंने इस भाषा के बारे में कभी नहीं सुना? : ओ लेकिन गंभीरता से, उत्कृष्ट व्याख्या! मुझे उन तकनीकों को समझने में अच्छा लगता है जो दूसरों को उनके उत्तरों में उपयोग होती हैं। +1
ETHproductions

@ETHproductions मैंने इसे केवल दो सप्ताह पहले यहां साइट पर पढ़ा था, और इसे पसंद करना शुरू किया। इसलिए इसे बेहतर तरीके से जानने के लिए, मैं सीलोन का उपयोग करके यहां सवालों के जवाब देने की कोशिश करता हूं।
पाओलो एबरमैन

2

रूबी / डीसी, 20.296 18.414 16.968

गतिशील प्रोग्रामिंग! उन कार्यों की एक सूची को परिभाषित करता है, जो एक डीसी निर्देश दिए गए हैं, एक नई अभिव्यक्ति और उस अभिव्यक्ति के संख्यात्मक मान को लौटाते हैं। फिर, 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

@ETHproductions कैसे है? ;) अब या तो नकारात्मक संख्याओं को जोड़ना मुश्किल नहीं होना चाहिए।
डेनिएरो

0

पायथन 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())))

यह सही लेकिन क्रिया आउटपुट उत्पन्न करता है:

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))
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.