एक अंडरलोड संख्या का सबसे छोटा प्रतिनिधित्व

Question

स्वाद का पाठ

ढेर आधारित esolang लादना कार्यात्मक प्रोग्रामिंग करने के लिए कुछ रोचक संबंध है। उनमें से एक संख्यात्मक डेटाटाइप का इसका उपचार है - लैम्ब्डा कैलकुलस की तरह, आप एक फ़ंक्शन द्वारा प्राकृतिक संख्या एन का प्रतिनिधित्व करते हैं जो एक क्रिया एन बार करते हैं।

चीजों को सरल बनाने के लिए, हम केवल अंडरलोड कमांड के केवल सबसेट पर विचार करेंगे:

• : - यह कमांड स्टैक पर शीर्ष आइटम को डुप्लिकेट करता है।
• * - यह कमांड स्टैक पर शीर्ष दो वस्तुओं को एक आइटम में समेटता है।

हम एक अंडरलोड अंक एन को एक स्ट्रिंग के रूप में परिभाषित करते हैं :और *जिसे निष्पादित करते समय, स्टैक पर शीर्ष आइटम का उपभोग करते हैं, और उस आइटम की एन प्रतियों को एक साथ मिलाते हैं। कुछ उदाहरण:

• कोई अंडरलोड अंक 0, -1, 1/2, num हैं।
• खाली स्ट्रिंग अंडरलोड अंक 1 है, क्योंकि यह स्टैक को अछूता छोड़ देता है।
• :*अंडरलोड अंक 2 है, क्योंकि यह शीर्ष आइटम को डुप्लिकेट करता है, और फिर उन दो प्रतियों को एक ही आइटम में समेट देता है: (A):*= (A)(A)*= (AA)।
• ::**अंडरलोड अंक है 3: (A)::**= (A)(A):**= (A)(AA)*= (AAA)।
• :::*** अंडरलोड अंक 4 है।
• :*:*अंडरलोड अंक भी है: 4 (A):*:*= (AA):*= (AA)(AA)*= (AAAA)।

सामान्य तौर पर, आप पाएंगे कि, यदि Mऔर Nअंडरलोड अंक एम और एन हैं, तो :N*अंक एन + 1 है, और MNअंक एम × एन है।

चुनौती

आपका काम सबसे छोटा प्रोग्राम (STDIN पर इनपुट लेना) या फ़ंक्शन (तर्क के माध्यम से इनपुट लेना) लिखना है, जो एक स्ट्रिंग के रूप में अपने इनपुट के लिए अंडरलोड अंक का सबसे कम प्रतिनिधित्व पैदा करता है । कहने का तात्पर्य यह है कि, यदि इनपुट एक पॉजिटिव नेचुरल नंबर N> 1 है, तो आपको एक अंडरलोड अंक N का उत्पादन करना चाहिए, जिसकी लंबाई वर्णों की तुलना में कम है या हर दूसरे अंडरलोड संख्या N के बराबर है।

नमूना इनपुट और आउटपुट: ("इनपुट - OUTPUT")

• 1 - ।
• 2 - :*।
• 5 - ::*:**(2 × 2 + 1)।
• 7 - ::*::***(2 × 3 + 1) या :::**:**(3 × 2 + 1)।
• 33 - ::*:*:*:*:**(2 × 2 × 2 × 2 × 2 + 1)।
• 49 - ::*:*:*:*::***(16 × 3 + 1, लंबाई 14) लेकिन नहीं ::*::***::*::***(7 × 7, लंबाई 16)।

यदि इनपुट एक सकारात्मक प्राकृतिक संख्या नहीं है, तो आप एक त्रुटि वापस करने के लिए स्वतंत्र हैं, अपरिभाषित व्यवहार का उत्पादन करते हैं, या यहां तक ​​कि समाप्त करने में विफल रहते हैं। जवाब प्रस्तुत करने की आपके प्रस्तुत करने के तरीके की व्याख्या की सराहना की जाती है।

स्टैंडर्ड बचाव प्रतिबंध लागू होते हैं: बिना किसी अतिरिक्त इनपुट, कोई वेब अनुरोध, उत्पादन / वापसी मान वास्तव में इस सवाल का जवाब न कि किसी के अनंत यादृच्छिक धारा होना चाहिए :और *, आदि

Comments

@Geobits मैंने निष्पादन समय के बारे में कुछ नहीं कहा है, इसलिए जब तक आप यह साबित कर सकते हैं कि यह अंततः सही उत्तर देगा, आप अच्छे हैं।

— एल्गोरिथमशार्क

यह समस्या अतिरिक्त श्रृंखलाओं से संबंधित है; विशेष रूप से, इनपुट के लिए सही उत्तर की लंबाई xहै 2*A117498(x)जहां A117498 एक अतिरिक्त श्रृंखला खोजने के लिए द्विआधारी और कारक विधियों का इष्टतम संयोजन देता है।

— पीटर टेलर

Answer 1

गोल्फस्क्रिप्ट ( 61 60 55 54 53 वर्ण)

~:X'']({:A{.'.+'\*A{2$+}%~}%}*{,}${1\~X=}?{44/'*:'=}%

यह मेरे पहले संस्करण की तुलना में कम मुश्किल है और थोड़ा अलग दृष्टिकोण लेता है, लेकिन यह अभी भी क्रूर बल है। हम जानते हैं कि ':'X*'*'X*+यह एक उम्मीदवार समाधान है, इसलिए यदि हम उस लंबाई तक सभी अच्छी तरह से संतुलित तार उत्पन्न करते हैं और सबसे छोटा लेते हैं जो सही चीज़ का मूल्यांकन करता है तो हम एक को खोजने के लिए निश्चित हो सकते हैं।

# Evaluate input and store the target number in X
~:X
# Seed the generator with the empty string
'']
# X times...
({
    # Store the array of strings so far into A
    :A
    # Generate A' by mapping each element
    {
        # Dup: this leaves an untouched copy of the current string
        .
        # Wrap the duplicate in .+
        '.+'\*
        # For each element in A, generate that element suffixed with the current string
        A{2$+}%~
    }%
}*
# Order by length
{,}$
# Find the first element which evaluates to X
{1\~X=}?
# tr .+ :*
{44/'*:'=}%

हॉवर्ड के लिए धन्यवाद, जिनके समाधान से मैंने 1-चार tweaks के जोड़े को चुराया है।

Comments

हाहा, 3 के इनपुट को वेब दुभाषिया पर अमल करने में तीन सेकंड अधिक लगते हैं। अपनी बेहतरीन पर गोल्फ।

— एल्गोरिथमशार्क

@ अल्गोरिद्मशर्क, आप इसे कटौती के स्थान के साथ काफी तेज कर सकते हैं। डालें .&(यानी के बीच सिर्फ भीतरी पाश के बाद ~}%और }*।

— पीटर टेलर

Answer 2

गोल्फस्क्रिप्ट ( 54 53 वर्ण)

यह एक दृष्टिकोण है जो हॉवर्ड की भावना में है (निर्माण स्ट्रिंग्स जो सही मूल्य का मूल्यांकन करते हैं और उम्मीदवार स्ट्रिंग्स के माध्यम से क्रूर बल के बजाय, जो सही मूल्य का मूल्यांकन करते हैं, खोजने के लिए सबसे कम का चयन करते हैं), लेकिन पर्याप्त रूप से अलग है जो मुझे लगता है कि यह एक अलग उत्तर में है।

~.''':*':s@,{):x,2>{:^~$x^/~$+{s\*}x^%*}%{,}$0=}/]((=

ऑनलाइन डेमो उपलब्ध नहीं है क्योंकि यह दुभाषिया का एक छोटा संस्करण है।

# Let <N> denote the string which evaluates to N
# We want to enter the main loop with three values on the stack: <0> <1> <2>
# However, we'll never use <0>, so we can actually replace that with any value at all.
# Getting the input from underneath 3 items would normally use two stack manipulations.
# Trick: let's use the input value for <0>! (This gives a further bonus later).
# NB We store the value of <2> in the variable s
~.''':*':s@
# for x=1 to input_value ...
,{):x
    # for ^=2 to x-1 ...
    ,2>{:^
        # Use negative stack offsets to index the stack from the start
        # I.e. -1$ gets the first item on the stack, which is <0>
        # -2$ gets the second item on the stack, which is <1>
        # In general, val~$ gets <val>
        ~$x^/~$+
        # We have the string <^><x / ^> on the stack.
        # Increment it (x % ^) times to get a candidate <x>.
        {s\*}x^%*
    }%
    # Select a shortest string.
    {,}$0=
}/
# Group the stack into one array and select the appropriate offset,
# reusing that hacky <0> substitute for the offset.
]((=

Comments

यह जगह से एक दाढ़ी बनाने के लिए संभव हो जाएगा 3+के साथ )(तथ्य यह है कि शोषण []0=करता है, तो यह है कि नहीं थे स्टैक पर पत्ते कुछ भी नहीं) []2>एक त्रुटि पर ले जाया जाता।

— पीटर टेलर

[]2>[]बिना त्रुटि के उपज ।

— हावर्ड

@ हॉवर्ड, आह, golfscript.apphb.com एक पुराना संस्करण चला रहा होगा । लेकिन यह पता चला है कि मैं गलत था, क्योंकि उस प्रतिस्थापन से इनपुट के लिए गलत आउटपुट प्राप्त होता है '1'।

— पीटर टेलर

जिसे आप के ((=बजाय के साथ ठीक कर सकते हैं -1=।

— हावर्ड

और golfscript.apphb.com वास्तव में एक पुराना संस्करण चलाता है, नेस्टेड लूप उदाहरण काम नहीं करता है।

— हावर्ड

Answer 3

पायथन 2.7 - 87 84 92

u=lambda n:n>1and min([u(i)+u(n/i)for i in range(2,n)if n%i<1]+[':'+u(n-1)+'*'],key=len)or''

स्पष्टीकरण:
यह एक बहुत सीधा समाधान है। यह दो संख्याओं के उत्पाद के रूप में या तो n के सभी संभव अभ्यावेदन का पुनरावर्ती परीक्षण करता है :(n-1)*, और फिर न्यूनतम लंबाई का समाधान खोजता है। रेंज (2, n) आवश्यक है ताकि रिकर्सन ने गहराई को बांधा हो, और n <2 बेस केस देता है।

नोट:
i और n / i n के दो कारक हैं। ... और ... या ... के लिए प्रतिस्थापन ... यदि ... और ... काम नहीं करता क्योंकि '' असत्य का मूल्यांकन करता है। तार का न्यूनतम सबसे छोटा तार देता है। पायथन 2.7 // के बजाय / का उपयोग करके 1 वर्ण बचाता है।

संपादित करें: आधार मामले को अभिव्यक्ति के पीछे ले जाया गया, जिससे मुझे ... और ... या ... का उपयोग करने की अनुमति मिली और कुछ स्थानों को दागा गया।

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

u(1)
''
u(5)
'::*:**'
u(49)
'::*:*:*:*::***'

Comments

" तार के मिनट कम से कम तार में से एक देता है " जब तक आप वैकल्पिक तर्क की आपूर्ति सही नहीं है key=len। यह lexicographically जल्द से जल्द स्ट्रिंग देता है। ( उदाहरण )। चूंकि '*' < ':'इसका मतलब है कि आपके पास 2 की शक्तियों से संबंधित समाधानों के लिए एक पूर्वाग्रह है, लेकिन क्या वे हमेशा सबसे कम हैं?

— पीटर टेलर

उत्तर: वास्तव में पूर्वाग्रह अधिक जटिल है, लेकिन यह हमेशा सही उत्तर नहीं देता है। सबसे छोटा प्रतिधारण है u(33), जिसके लिए लेक्सोग्राफिक रूप से छांटना 14-चार देता है, ::**::*::*:***लेकिन लंबाई के अनुसार छांटना 12-चार देता है::*:*:*:*:**

— पीटर टेलर

मैं कभी नहीं जानता था कि पायथन स्ट्रिंग तुलना के बारे में। मैंने अपना उत्तर अपडेट कर दिया है।

— ईसैक

Answer 4

GolfScript, 63 58 56 वर्ण

~n./\{:v~[':*'1$*v,,2>{v,\%!},{.v=v,@/v=+}/]{,}$0=]}*-2=

कोड STDIN पर इनपुट लेता है और परिणाम प्रिंट करता है।

उदाहरण:

> 49
:::**:*:*:*:**

> 1234
::::*:*:*:**:*:*:**::**::***

आप अपने स्वयं के मामलों का परीक्षण ऑनलाइन कर सकते हैं ।

Comments

वाह, मैंने सोचा कि एक फैक्टरिंग आधारित दृष्टिकोण एक क्रूर बल दृष्टिकोण की तुलना में काफी लंबा होगा।

— पीटर टेलर

@PeterTaylor मैंने भी ऐसा ही सोचा था लेकिन यह पता चला कि ऐसा नहीं है। इसके अलावा, मेरा जानवर बल समाधान तुम्हारा से थोड़ा लंबा था ;-)

— हावर्ड

क्या आप बताएंगे कि प्रत्येक भाग क्या करता है? मैं केवल :x(=बिट तक का पालन कर सकता हूं । इसके अलावा, उचित समय में 49 को चलाने में सक्षम होने के लिए +1।

— एल्गोरिथमशार्क

@ अल्गोरिद्मशर्क मैं अभी भी समाधान पर काम कर रहा हूं इसलिए यह अभी भी बहुत बदल सकता है (जैसा कि यह अभी किया था)। मुख्य रूप से, भाग x,2>{x\%!},सभी सच्चे दिव्यांगों को देता है x, {.v=x@/v=+}/फिर सभी विभाजकों के लिए dऔर उनके समाधानों को x/dसमेटता है d। {,}$उन्हें लंबाई के अनुसार क्रमबद्ध करें और उनमें से 0=सबसे छोटा (प्लस प्रारंभिक :(x-1)*मामला) लें।

— हावर्ड

Answer 5

ब्रीज़लॉग 2 , 30 (शायद अंततः 26) बाइट्स, भाषा चुनौती देती है

यहाँ एक फ़ंक्शन है जो वर्तमान Brachylog 2 कार्यान्वयन के साथ काम करता है (और वर्ण कोड की एक सूची देता है क्योंकि वर्तमान कार्यान्वयन स्ट्रिंग के साथ कुछ समस्याएँ हैं):

∧.l∧?{ḋp~c×ᵐ{-₁↰₁:[42,58]c↻}ᵐc}

इसे ऑनलाइन आज़माएं!

भाषा अभी भी बहुत नई है। यहां कार्यक्रम का 26 बाइट संस्करण है जो विनिर्देश के अनुसार काम करना चाहिए, लेकिन कुछ अनिमित सुविधाओं का उपयोग करता है, और इस प्रकार अभी तक मान्य नहीं है, लेकिन शायद भविष्य में होगा (यह भी कम कुशल है):

{ḋp~c×ᵐ{-₁↰₁:"*:"c↻}ᵐc}ᶠlᵒh

व्याख्या

∧.l∧?{ḋp~c×ᵐ{-₁↰₁:[42,58]c↻}ᵐc}
∧.l∧?                            Evaluation hint: try shortest outputs first
     {                        }  Define an inner function
      ḋ                          Prime factor decomposition of the input
       p                         Find a permutation
        ~c                       Find an inverse concatenation (i.e. partition)
          ×ᵐ                     Take the product of each set inside the partition
      ḋp~c×ᵐ                     Find a decomposition into factors ≥ 2
            {              }ᵐ    For each of those factors:
             -₁                  Decrement it
               ↰₁                Call the inner function recursively
                 :[42,58]c       Append "*:" (as character codes)
                          ↻      Move the last element to the start
                             c   Append the results together

मूल विचार काफी सरल है: हम संख्या को एक (1 या अधिक) कारकों में नहीं बदलने के बीच वैकल्पिक करते हैं (जरूरी नहीं कि प्रमुख कारक, लेकिन 1 के कारकों की अनुमति नहीं है), और उनमें से प्रत्येक को 1 + (एक पुनरावर्ती से प्राप्त प्रतिनिधित्व) के रूप में व्यक्त करना कहते हैं)। यह संख्या के सभी संभावित अंडरलोड प्रतिनिधित्वों की खोज करने की गारंटी है (हम एक गुणन चरण "एक पंक्ति में दो बार" 2 से अधिक संख्याओं को एक साथ गुणा करके, और एक वेतन वृद्धि चरण दो बार एक पंक्ति में दो बार गुणा करके उन्हें गुणा कर सकते हैं जो गुणा करता है एक साथ सिर्फ एक नंबर)। हमें एक स्पष्ट आधार मामले की आवश्यकता नहीं है, क्योंकि 1 को प्रमुख कारकों में विघटित करने से हमें एक खाली सूची मिलती है, और इस प्रकार हम इसका निर्माण एक गुणन चरण के साथ करते हैं जो शून्य संख्याओं को एक साथ गुणा करता है।

कार्यक्रम काफी अक्षम है, विशेष रूप से क्योंकि मूल्यांकन आदेश संकेत मैंने दिया (आखिरकार उत्पादन के आकार के संदर्भ में सबसे कम समय तक उत्तर दें), जबकि प्रश्न का "सबसे छोटा" भाग हल करते हुए, यह उस संदर्भ में महान नहीं है वास्तव में कार्यक्रम को जल्दी से पूरा करना (एक बहुत अधिक उपयोगी संकेत होगा "प्रत्येक पुनरावर्ती चरण में केवल सबसे छोटा उत्तर", लेकिन यह अधिक बाइट्स लेता है ...)। इसके अतिरिक्त, ḋp~c×ᵐप्रत्येक बार कई बार गुणात्मक विभाजन उत्पन्न कर सकते हैं, जिससे प्रोग्राम बहुत अधिक निरर्थक कार्य कर सकता है।

Answer 6

जे - 81 चार

पश्चात के लिए, यह सबसे अच्छा था जो मैं जे में कर सकता था।

_2{::(0&(][,0{<@;"1@({~#(#~]-:"1<.)@(],.%)2}.i.@#)(/:#&>)@,':'<@,'*',~>@{:),~)&a:

हम परिणामों की एक सूची बनाते हैं, जिसकी शुरुआत दो खाली तारों (जो कि ,~और a:) का प्रतिनिधित्व करती है, 0 (कभी इस्तेमाल नहीं किए गए) और 1 का प्रतिनिधित्व करती है, और फिर उनके ऊपर एक क्रिया को टाइप करती है (हुक, ट्रेनों का चुपके से उपयोग &) और जो अगले नंबर का संक्षिप्त प्रतिनिधित्व प्रस्तुत करता है।

वास्तविक क्रिया जिसे हम पुनरावृत्त करते हैं, वह सूची की लंबाई का उपयोग इस बात के सूचक के रूप में करती है कि हम किस संख्या में काम कर रहे हैं। सबसे पहले, हम इस संख्या को कारकों के जोड़े ( #(#~]-:"1<.)@(],.%)2}.i.@#) में रखते हैं, और सरणी ( {~) से खींचकर प्रत्येक जोड़ी को पुनः प्राप्त करते हैं । हम उनमें से प्रत्येक जोड़े को चालू करते हैं (यदि संख्या प्रधान है तो उनमें से 0 एकल स्ट्रिंग में) हो सकती है ( <@;"1)।

फिर हम उस सूची में से कोष्ठकों के भीतर पिछले परिणाम के लिए प्रवेश संलग्न :और *, और तरह लंबाई से इस सूची ( (/:#&>))। अंत में, हम इस सूची ( 0{) से पहला परिणाम लेते हैं और आधार सरणी के अंत में संलग्न करते हैं ( [,)। जब लूप को पुनरावृत्त किया जाता है, तो हमारे पास इनपुट की तुलना में लंबाई 2 की एक सूची होती है, जो 0. पर शुरू होती है। इसलिए हमें जो वापस लौटना है वह अगले-से-अंतिम स्ट्रिंग ( _2{::) है।

   un =: _2{::(0&(][,0{<@;"1@({~#(#~]-:"1<.)@(],.%)2}.i.@#)(/:#&>)@,':'<@,'*',~>@{:),~)&a:
   un 49
::*:*:*:*::***
   un 1234
:*::*:*:*::*::***::*::*:****
   un 10010
:*::*:*::***::*:*:*:*:*:*:*::***
   2 * (1 + 3 * 2^2) * (1 + 3 * 2^7)
10010
   6!:2 'un 10010'   NB. time in seconds
19.5539

Answer 7

जेली , 33 बाइट्स, भाषा चुनौती देती है

ÆḌḊµ⁹÷Ñ;Ñð€
’ß”:;;”*W;ÇLÞḢµ“”>1$?

इसे ऑनलाइन आज़माएं!

एक सीधा जानवर बल समाधान।

व्याख्या

मुख्य कार्यक्रम

’ß”:;;”*W;ÇLÞḢµ“”>1$?
              µ  >1$?  If input is greater than 1, then:
’ß                       Run recursively on the input - 1
  ”:;                    Prepend a colon
     ;”*                 Append an asterisk
        W;               Cons to:
          Ç                the result of the helper, on {the original input}
           LÞ            Sort by length
             Ḣ           Take the first (i.e. shortest) result
               “”      Otherwise, return an empty string

मुख्य कार्यक्रम सहायक फ़ंक्शन का उपयोग गुणन के माध्यम से मान उत्पन्न करने के लिए सभी संभावित तरीकों की गणना करने के लिए करता है, फिर इसके अतिरिक्त मूल्य का उत्पादन करने की कोशिश करता है, और सबसे कम संभावना देता है। यह बेस केस (एक इनपुट 1) भी संभालता है ।

हेल्पर फ़ंक्शन

ÆḌḊµ⁹÷Ñ;Ñð€
ÆḌ µ     ð€            For all proper factors of the input
  Ḋ                    except the first (i.e. 1):
    ⁹÷                   Divide it into the input;
      Ñ                  Run the main program on it;
       ;                 Append the result of:
        Ñ                  the main program run on {the factor}

हेल्पर फ़ंक्शन इनपुट को दो संख्याओं के गुणन के रूप में व्यक्त करने के सभी संभावित तरीकों की कोशिश करता है, और आपसी-पुनरावर्ती अपने सबसे छोटे अभ्यावेदन पर प्राप्त करने के लिए मुख्य कार्यक्रम को कॉल करता है।

Answer 8

जीएनयू प्रोलॉग, 96 बाइट्स

v(N)-->{N#=1};{N#=A*B,A#<B,B#<N},v(A),v(B);{N#=M+1},":",v(M),"*".
s(N,S):-length(S,_),v(N,S,[]).

पहली पंक्ति एक व्याकरण है जो अंडरलोड मूल्यांकन को लागू करता है, और रिवर्स दिशा में काम करता है (वास्तव में, यह A#<Bबाधा के कारण आगे की दिशा में काफी काम नहीं करता है ; इसे A#<Nएक धीमे कार्यक्रम के लिए बदल दें जो दोनों तरीकों से काम करता है)। दूसरी पंक्ति फ़ंक्शन-जैसे विधेय को परिभाषित करती है s(जो कि इस प्रोग्राम के समाधान के रूप में कार्यान्वित किया गया फ़ंक्शन है) जो सबसे कम संभव स्ट्रिंग को खोजता है जो इनपुट के रूप में दी गई संख्या का मूल्यांकन करता है (यह निराशा की क्रिया है जो एक अपेक्षाकृत महत्वपूर्ण कार्य है, लेकिन कि आप के लिए प्रस्तावना है ...)।

यह कार्यक्रम बहुत ही आत्म-व्याख्यात्मक होना चाहिए, यह देखते हुए कि यह व्याकरण के लिए विनिर्देश का प्रत्यक्ष अनुवाद कम या ज्यादा है, और फिर वाक्यविन्यास को रोकना; की परिभाषा vका कहना है कि Nएक खाली स्ट्रिंग में 1 है, या Nहै A× B(साथ Aकी तुलना में कम Bकम से कम N) और स्ट्रिंग के संयोजन है v(A)और v(B), या Nहै M+ 1 और स्ट्रिंग है :साथ concatenated v(M)साथ concatenated *। दूसरी पंक्ति थोड़ी सूक्ष्मता है;length(S,_) "S की लंबाई कुछ है", लेकिन यह निर्दिष्ट करते हुए कि लाइन पर पहली चीज़ प्रोलॉग कार्यान्वयन के लिए एक संकेत के रूप में कार्य करती है कि इसे पहले कम से कम लंबाई की जाँच करनी चाहिए (जिसका अर्थ है कि हमें वापसी मूल्य के लिए सबसे कम संभव लंबाई मिलेगी) ।