একটি বেস-প্রমাণ এক্সপ্রেশন আউটপুটিং


21

পটভূমি

কিছু সম্ভাব্য ফিউচারে, বিশ্ব তাদের সংখ্যাসূচক সিস্টেমগুলি দশমিক (বেস 10 বা b10) থেকে অন্য কোনও বেসে (বাইনারি b2, অক্টাল b8, হেক্সাডেসিমাল b16বা এমনকি অখাদ্য b1, যে ক্ষেত্রে আমরা ক্ষতিগ্রস্থ করেছি!) রূপান্তরিত করে । সুতরাং, এই সম্ভাব্য বিশ্ব-পরিবর্তিত ইভেন্টের প্রস্তুতির জন্য, আপনি আপনার সমস্ত প্রোগ্রামের বেস-প্রুফ করার সিদ্ধান্ত নিয়েছেন। বিদ্যমান সংখ্যার ধ্রুবক প্রতিস্থাপনের জন্য অপারেটরদের সাথে একত্রে একক 0s এবং 1s ব্যবহার করে এটি করা যেতে পারে ।

তবে, কেবল একটি সমস্যা রয়েছে: আপনার পরিবর্তনের জন্য এক টন প্রোগ্রাম রয়েছে এবং প্রতিটি সংখ্যাটিকে ম্যানুয়ালি রূপে রূপান্তরিত করতে কয়েক সপ্তাহ লাগবে! সুতরাং, আপনি প্রতিটি সংখ্যা প্রতিস্থাপন করা উচিত কি আপনার জন্য সিদ্ধান্ত নিতে একটি প্রোগ্রাম লিখুন (বা ফাংশন)।

ইনপুট

ইনপুটটি ইতিবাচক পূর্ণসংখ্যা হবে। আপনার কোডটি 1000 পর্যন্ত কোনও পূর্ণসংখ্যাকে পরিচালনা করতে সক্ষম হতে হবে

(যদি আপনার কোড দশমিক এবং / বা নেতিবাচক ইনপুট সমর্থন করে তবে নীচে স্কোরিং দেখুন))

আউটপুট

আপনার কোডে এমন একটি ভাব প্রকাশ করবে যা কমপক্ষে একটি ভাষায় ইনপুটটিকে মূল্যায়ন করবে। এটি কোনও ভাষা হতে পারে; এটিতে আপনার প্রোগ্রাম বা ফাংশনটি যেমন লেখা থাকে তেমনই হবে না Also এছাড়াও, এই প্রকাশটি একটি সম্পূর্ণ প্রোগ্রাম বা ফাংশন হওয়ার দরকার নেই।

স্পষ্টতার জন্য, আউটপুট এই অপারেশনগুলির মধ্যে যে কোনও একটি থাকতে পারে:

  • বৃদ্ধি / হ্রাস
  • যোগ / যোগফল
  • বিয়োগ / অবহেলা
  • গুন / দ্বিগুণ (কেবল যদি এটি সরাসরি সংখ্যায় জড়িত না হয় 2!)
  • বিভাজন / মডুলো
  • এক্সপোশন / লগারিদম
  • বর্গ / স্কয়ার্ট (আবার, কেবলমাত্র যদি এগুলি সরাসরি সংখ্যায় জড়িত না হয় 2!)
  • বিটওয়াইজ ক্রিয়াকলাপ (বিওআর, ব্যান্ড, বিএনওটি, বিএক্সআর, বিট শিফট)
  • ভেরিয়েবল স্থাপন / গ্রহণ করা
  • স্ট্যাক হেরফের

আপনি আউটপুট বা অন্য কোনও অনুরূপ ফাংশন ব্যবহার করতে পারবেন নাeval() । আপনি আউটপুটে উপরে উল্লিখিতগুলি ব্যতীত কোনও ক্রিয়া সম্পাদন করে এমন কোনও ফাংশনও আউটপুটে ব্যবহার করতে পারবেন না।

ওহ, এবং আরও একটি বিষয়: যেহেতু আমরা আউটপুটটি যতটা সম্ভব বেসগুলিতে বৈধ হওয়া চাই, এটির মধ্যে কেবলমাত্র সংখ্যা ধ্রুবক রয়েছে 0এবং 110(দশ) এর মতো সংখ্যাগুলি অনুমোদিত নয়, যদি না ভাষা এটি এ 1এবং এ হিসাবে ব্যাখ্যা করে 0। সংখ্যার জন্য স্ট্রিংগুলি ব্যবহারের অনুমতি নেই, যেমন সিজেমের 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এবং শেষ হওয়া সংখ্যার ক্রমের সমস্ত আউটপুটগুলির এটি গড় বাইট-কাউন্ট । তারপরে এই স্কোরের 50% ছাড়ুন।10001.0010.001, 1.002, 2.003...998.999, 1000.000

  • নেতিবাচক স্কোর: আপনার কোড ঋণাত্মক সংখ্যা এবং শূন্য সমর্থন করে, এই থেকে সব পূর্ণসংখ্যার আউটপুট গড় বাইট গোনা হয় -1000থেকে 0। তারপরে এই স্কোর থেকে 10% ছাড়ুন।

(এগুলি গণনা করার সবচেয়ে সহজ উপায়টি সম্ভবত আপনার প্রোগ্রামের ভিতরে / কার্যক্রমে একটি লুপ হবে))

আপনার চূড়ান্ত স্কোর উপরোক্ত সূত্রগুলির যে কোনওটির প্রয়োগের গড়।

যদি আউটপুটটি অ-নিরবচ্ছিন্ন হয় (যেমন কিছুটা এলোমেলো; একই ইনপুট সহ একাধিক রান একাধিক অনন্য আউটপুট উত্পাদন করে), তবে প্রতিটি ইনপুটের জন্য স্কোরটি আমার সিপিইউতে দশ রানের বেশি আউটপুট দ্বারা নির্ধারিত হয়।

এছাড়াও, যেহেতু আপনি জানেন না যে ভবিষ্যতে কম্পিউটারের মূল্যবান মূল্যবান কতটা হবে, আপনার জেনারেটরের কোডের বাইট-কাউন্টটি অবশ্যই 512 বাইটের চেয়ে কম হওয়া উচিত।

দুই সপ্তাহের মধ্যে সর্বনিম্ন স্কোর (৩০ সেপ্টেম্বর) বিজয়ী হিসাবে ঘোষণা করা হবে। আপনার বিজয়ী, থমাসকওয়া অভিনন্দন!


লিডারবোর্ড

আপনার উত্তরটি সঠিকভাবে প্রদর্শিত হয়েছে তা নিশ্চিত করতে, দয়া করে এটি এই শিরোলেখ দিয়ে শুরু করুন:

# Language name/Other language name, X points

Xআপনার উত্তরের স্কোর কোথায় ? উদাহরণ:

# CJam/Pyth, 25.38 points

আপনার যদি কোনও প্রশ্ন বা পরামর্শ থাকে তবে দয়া করে আমাকে জানান। শুভকামনা!


আমি কি ভেরিয়েবলগুলি ব্যবহার করতে পারি যা ধারণ করে 0বা 1ডিফল্টরূপে?
ডেনিস

@ ডেনিস আমি এতে কোন সমস্যা দেখতে পাচ্ছি না, তাই এগিয়ে যান!
ETH প্রোডাকশনস

আমি ধরে নিচ্ছি যে আমি বেস 2 এবং ডিফল্ট বেসের মধ্যে বেস রূপান্তর করতে পারি না।
নীল

@ মুডিফিশ নোপ, আউটপুটটিতে কোনও বেস রূপান্তর অনুমোদিত নয়।
ETH প্রোডাকশনস

আমার ধারণা আমাদেরও কি এমন কিছু ব্যবহার করার অনুমতি নেই Integer.parseInt("1000", 1+1+1+1+1+1+1+1+1+1)? আমি নিশ্চিত যে parseIntকেবলমাত্র অনুমোদিত অপারেশনগুলি ব্যবহার করে ;-)
পেলো ইবারম্যান

উত্তর:


10

পাইথন / জিলোগ জেড 80 মেশিন কোড, 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

আমরা সর্বনিম্ন-ওজন ভারসাম্য বাইনারি উপস্থাপনা বিবিআর 2 এর একটি ছোট পরিবর্তন ব্যবহার করি । যেহেতু বিবিআর 2 ওজন হ্রাস করে (ননজারো অঙ্কের সংখ্যা), তবে আমরা ওজন কমিয়ে বিট শিফ্টের সংখ্যাটি কমিয়ে আনতে চাই, আমরা অ্যালগরিদমে একটি ধ্রুবককে পরিবর্তন 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এবং অনথিভুক্ত sl1 h(বাম বিট উপর বদল আনতে 1 hযে শিফট একটি 0এবং 1যথাক্রমে) অনুমতি দেওয়া হয়েছে। sla hএবং sl1 hপ্রতিটি দুটি বাইট হয় তবে তারা কখনও কখনও আউটপুট সংক্ষিপ্ত করতে পারে।


খুব সুন্দর, এখন পর্যন্ত সর্বনিম্ন! আমার ধারণা এটি এমন একটি উদাহরণ যেখানে খাঁটি মেশিন কোডটি কাজে আসে। ;)
ইটিএইচ প্রোডাকশনস

2
+1 এটি সম্ভবত অপরাজেয়। এছাড়াও মেশিন কোড ব্যবহার করার প্রতিভা জন্য (একটি বিস্তৃতভাবে 8 বিট নির্দেশিকা সেট এবং কিছু 16 বিট রেজিস্ট্রার সহ একটি সিপুতে)
লেভেল রিভার সেন্ট

এটি কীভাবে +অনুবাদ করে তা অদ্ভুত dec। আমি নেতিবাচক উদাহরণগুলি ভুল পড়তে থাকি।
ETH প্রোডাকশনস

9

সিজেএম / সিজোম, 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<

আমার কথা, তাড়াতাড়ি! যদিও লিঙ্কগুলি ফায়ারফক্সে কাজ করে না।
ETH প্রোডাকশনস

যেহেতু এটি কোড গল্ফ নয়, আমি প্রত্যেককে %আরও দীর্ঘ অভিব্যক্তি দিয়ে প্রতিস্থাপন করেছি । লিঙ্কগুলি এখনই কাজ করা উচিত।
ডেনিস

ইনপুট 34 দেয় 1. কোন
ইনপুটটিতে

2
@ কিশানকুমার যাচাইকরণটি সমস্ত 1000 সম্ভাব্য ইনপুট পরীক্ষা করে। আউটপুট 1 ইঙ্গিত দেয় যে তুলনা সফল হয়েছিল।
ডেনিস

আপনি কিছু উদাহরণ আউটপুট যোগ করতে পারেন?
পাওলো ইবারম্যান

3

ß / BrainFuck, 34.201 পয়েন্ট

ß উত্স (194 বি):

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)

যদি কেউ আগ্রহী হন তবে আমি একটি ব্যাখ্যা যুক্ত করব। বিএফ আউটপুট ইতিমধ্যে চমত্কারভাবে অনুকূল হয়েছে, তবে আমি অনুমান করি যে আমি প্রয়োগ করতে বাকী ৩১৮ বি কোড ব্যবহার করতে পারি

  • একটি লুপ-নেস্টিং-অপটিমাইজেশন,
  • আরও 8 বিট ওভারফ্লো শর্টকাট,
  • অপারেটর সংঘর্ষ অপসারণ

নমুনা:

উইন্ডোতে চলছে:

$ 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. Gণাত্মক গড় = 38.4765234765235 * 0.9 = ~34.629
  4. উপরের গড়, চূড়ান্ত স্কোর = (37.495 + 30.48 + 34.629)/3 = 34.201

1
আমি সবসময় নতুন ভাষাগুলি তৈরি করে দেখতে চাই। :) স্কোর ভাঙ্গনের জন্য ধন্যবাদ! আমি দশমিক অংশে আরও বোনাস রাখতে চাই, তাই আমি ছাড়টি 40% থেকে 50% এ পরিবর্তন করেছি।
ETH প্রোডাকশনস

@ এথ প্রডাকশন হ্যাঁ, আমি এটির জন্য একটি অনলাইন দোভাষী স্থাপনের চেষ্টা করব। প্রায় 435 উচ্চ বিমূর্ত অপারেটর রয়েছে, অতিরিক্ত 9,9k সংজ্ঞা দেওয়া যেতে পারে ;-)। আমি গণনা সংশোধন করেছি (আশা করি)।
mınxomaτ

3

রুবি / রুবি, 29.77885

31.873 * 0.9 (negativeণাত্মক) 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

@ থমাসকওয়া সম্পাদিত হয়েছে, ধন্যবাদ
লেভেল রিভার সেন্ট

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 পয়েন্টে নেমে যায় তবে আমি এটি শিরোনামের লাইনে রাখব না কারণ কেবলমাত্র 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

যেমন আপনি দেখতে পাচ্ছেন, -positive ণাত্মকগুলি সর্বদা সংশ্লিষ্ট ধনাত্মকগুলির চেয়ে এক বাইট (শীর্ষস্থানীয় ) দীর্ঘ হয়।

মূল ধারণাটি পূর্ববর্তী প্রোগ্রামের মতোই: আমাদের লক্ষ্য সংখ্যার কাছে একটি বর্গক্ষেত্র সন্ধান করুন এবং এর মূল এবং বাকীটি পুনরাবৃত্তভাবে উপস্থাপন করুন। তবে এখন আমরা আমাদের বর্গক্ষেত্রকে লক্ষ্য সংখ্যার চেয়ে কিছুটা বড় হওয়ার অনুমতি দিই যা পরে বাকীটিকে negativeণাত্মক করে তোলে। ( +0.5অ্যালগরিদমটি টুইট করার জন্য এটিকে অন্য ধ্রুবক হিসাবে পরিবর্তিত করা যেতে পারে, তবে মনে হয় আমি ইতিমধ্যে এখানে সর্বোত্তমকে আঘাত করেছিলাম - 0.4 এবং 0.6 উভয়ই খারাপ ফলাফল দেয়))

নেতিবাচক মানগুলিকে নেতিবাচক করে তুলতে (এবং অন্যথায় ধনাত্মক মানগুলির মতো একই কাঠামো থাকতে, আমরা অপারেটরটিকে signআমাদের পুনরাবৃত্ত ফাংশনে পাস করি p- এটি হয় "+"বা হয় "-"। আমরা তুচ্ছ মামলায় সংযোজকের জন্যও এটি ব্যবহার করতে পারি (যেমন এন <9) বাকিটি ইতিবাচক হলে, এবং যদি এটি negativeণাত্মক হয় তবে অবশিষ্টগুলির জন্য বিপরীত চিহ্নটি ব্যবহার করুন।

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 = (3 ^ 2 + 1) ^ 3, এর পরিবর্তে 1000 = (6 ^ 2-4) -5 2-5 ^ 2 + 1।


আমি প্রোগ্রামটির বিধিনিষেধটিকে ভুলভাবে 256 বাইট হিসাবে মনে রেখেছিলাম ... 512-এ আরও কিছুটা করা যায়। পরে চেষ্টা করবে।
পাওলো ইবারম্যান

নাহ, এটা বলে less than 512। আপনি একটি সর্বোচ্চ ব্যবহার করতে পারেন। 511 বাইটের;)
mınxomaτ

এই ভাষা আমি কখনই শুনিনি?!? : ও তবে সিরিয়াসলি, দুর্দান্ত ব্যাখ্যা! অন্যরা তাদের উত্তরগুলিতে যে কৌশলগুলি ব্যবহার করে তা বুঝতে আমি পছন্দ করি। +1
ETH প্রোডাকশনস

@ ইথ প্রডাকশনগুলি আমি প্রায় দুই সপ্তাহ আগে সাইটে এটি পড়েছি এবং এটি পছন্দ করতে শুরু করেছি। সুতরাং এটি আরও ভালভাবে জানতে, আমি সিলন ব্যবহার করে এখানে প্রশ্নের উত্তর দেওয়ার চেষ্টা করি।
পাওলো ইবারম্যান

2

রুবি / ডিসি, 20,296 18,414 16,968

ডায়নামিক প্রোগ্রামিং! একটি ডিসি নির্দেশনা দেওয়া, কার্যকারিতার একটি তালিকা নির্ধারণ করে যা একটি নতুন এক্সপ্রেশন এবং সেই এক্সপ্রেশনটির সংখ্যাসূচক মান দেয়। তারপরে, 1পূর্বনির্ধারিত দিয়ে শুরু করে , এটি সমস্ত প্রাপ্য মানগুলির একটি তালিকা তৈরি করে যাচ্ছিল মানটি সহ including

সম্পাদনা:

এন -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 মেশিন কোড ছাড়াও সমস্ত কিছু হারাচ্ছে (এমনকি ডেনিসের সিজেএম!)। আপনি কি মনে -করেন বাইট কাউন্টের মধ্যে থাকতে থাকতে আপনি কোনও অপারেটরে যুক্ত করতে সক্ষম হতে পারেন ?
ETH প্রোডাকশনস

পছন্দ করুন ;) এখনই, নেতিবাচক সংখ্যা যুক্ত করা কঠিন হওয়া উচিত নয়।
দানিরো

0

পাইথন ২.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))
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.