ข้อความรส

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

เพื่อให้ง่ายขึ้นเราจะพิจารณาเฉพาะชุดย่อยของคำสั่ง Underload เท่านั้น:

• : - คำสั่งนี้ทำซ้ำรายการบนสุดในสแต็ก
• * - คำสั่งนี้ต่อสองไอเท็มบนสุดของสแต็กเข้ากับไอเท็มเดี่ยว

เรากำหนดUnderload numeral Nเป็นสตริง:และ*เมื่อดำเนินการใช้รายการบนสุดในสแต็กและสร้างสำเนา N ของรายการนั้นต่อกัน ตัวอย่างบางส่วน:

• ไม่มีตัวเลข Underload 0, -1, 1/2, π
• สตริงว่างคือ Underload ตัวเลข 1 เนื่องจากปล่อยให้สแต็กไม่ถูกแตะต้อง
• :*เป็น underload เลข 2 เพราะมันซ้ำรายการด้านบนแล้วเชื่อมทั้งสองเล่มด้วยกันเป็นรายการเดียว: (A):*= =(A)(A)*(AA)
• ::**เป็น underload เลขที่ (A)::**3: (A)(A):**= (A)(AA)*= (AAA)=
• :::*** เป็น Underload ตัวเลข 4
• :*:*นอกจากนี้ยังเป็น underload เลขที่ (A):*:*4: (AA):*= (AA)(AA)*= (AAAA)=

โดยทั่วไปแล้วคุณจะพบว่าหากMและNเป็น Underload numerals M และ N ก็:N*จะเป็นตัวเลข N + 1 และMNเป็นตัวเลข M × N

ความท้าทาย

งานของคุณคือการเขียนโปรแกรมที่สั้นที่สุด (รับอินพุตบน STDIN) หรือฟังก์ชั่น (รับอินพุตผ่านอาร์กิวเมนต์) ซึ่งสร้างการแสดงที่สั้นที่สุดของตัวเลข Underload สำหรับอินพุตเป็นสตริง กล่าวคือถ้าอินพุตเป็นจำนวนธรรมชาติบวก N> 1 คุณต้องสร้างตัวเลข Underload N ที่มีความยาวเป็นอักขระน้อยกว่าหรือเท่ากับของตัวเลขอื่น ๆ Underload 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)

หากอินพุตไม่ใช่จำนวนบวกคุณมีอิสระที่จะส่งคืนข้อผิดพลาดสร้างพฤติกรรมที่ไม่ได้กำหนดหรือแม้แต่ล้มเหลวในการยกเลิก คำอธิบายเกี่ยวกับวิธีการของการส่งคำตอบในการค้นหาคำตอบนั้น

ข้อ จำกัด ช่องโหว่มาตรฐานใช้: ไม่มีการป้อนข้อมูลเพิ่มเติมไม่มีคำขอเว็บค่าส่งออก / คืนจะต้องเป็นคำตอบที่แน่นอนและไม่กระแสสุ่มที่ไม่มีที่สิ้นสุดของ:และ*อื่น ๆ

GolfScript ( 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/'*:'=}%

ขอบคุณ Howard ที่โซลูชันของฉันได้ขโมย tweaks 1-char สองสามรายการ

GolfScript ( 54 53 ตัวอักษร)

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

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

การสาธิตออนไลน์ไม่สามารถใช้งานได้เนื่องจากเป็นล่ามรุ่น buggy

# 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.
]((=

Python 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 การแทนที่ ... และ ... หรือ ... สำหรับ ... ถ้า ... อื่น ... ไม่ได้ผลเพราะ '' ประเมินว่าเป็นเท็จ min ของสตริงให้หนึ่งในสตริงที่สั้นที่สุด Python 2.7 บันทึก 1 อักขระโดยใช้ / แทน //

แก้ไข: ย้ายเคสพื้นฐานไปทางด้านหลังของนิพจน์ทำให้ฉันสามารถใช้ ... และ ... หรือ ... และ ... และโกนเว้นวรรคสองครั้ง

กรณีทดสอบ:

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

GolfScript, 63 58 56 ตัวอักษร

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

รหัสรับอินพุตบน STDIN และพิมพ์ผลลัพธ์

ตัวอย่าง:

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

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

คุณสามารถทดสอบกรณีของคุณเองออนไลน์

Brachylog 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 + (ตัวแทนที่ได้จากการเรียกซ้ำ โทร). สิ่งนี้รับประกันได้ว่าจะค้นหาการแทนค่า Underload ที่เป็นไปได้ทั้งหมด (เราสามารถใช้ขั้นตอนการคูณ "สองครั้งในแถว" โดยการคูณกันมากกว่า 2 หมายเลขและเพิ่มขั้นตอนสองครั้งในแถวโดยแยกพวกมันด้วยขั้นตอนคูณ รวมกันเพียงหนึ่งหมายเลข) เราไม่ต้องการกรณีพื้นฐานที่ชัดเจนเนื่องจากการแยก 1 เป็นปัจจัยสำคัญทำให้เรามีรายการว่างและทำให้เราสร้างมันขึ้นมาด้วยขั้นตอนการคูณที่คูณจำนวนศูนย์ด้วยกัน

โปรแกรมไม่มีประสิทธิภาพพอสมควรโดยเฉพาะอย่างยิ่งเพราะคำแนะนำการประเมินที่ฉันให้ (สร้างคำตอบที่สั้นที่สุดถึงยาวที่สุดในแง่ของขนาดของผลลัพธ์สุดท้าย) ในขณะที่การแก้ไขส่วน "สั้นที่สุด" ของคำถามนั้นไม่ได้ยอดเยี่ยมในแง่ของ ที่จริงแล้วการทำให้โปรแกรมเสร็จสมบูรณ์อย่างรวดเร็ว ( คำใบ้ที่มีประโยชน์มากกว่านั้นก็คือ "สร้างคำตอบที่สั้นที่สุดในแต่ละขั้นตอนแบบเรียกซ้ำ" แต่มันต้องใช้ไบต์มากกว่า ... ) นอกจากนี้ḋp~c×ᵐยังสามารถสร้างพาร์ติชันทวีคูณได้หลายครั้งในแต่ละครั้งทำให้โปรแกรมทำงานซ้ำซ้อนมากมาย

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

ความท้าทายของJelly , 33 ไบต์ภาษา postdates

ÆḌḊµ⁹÷Ñ;Ñð€
’ß”:;;”*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}

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

Prolog ของ GNU ขนาด 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,[]).

บรรทัดแรกคือไวยากรณ์ที่ใช้การประเมิน Underload และทำงานในทิศทางตรงกันข้าม (อันที่จริงแล้วมันไม่ได้ทำงานในทิศทางไปข้างหน้าเนื่องจากA#<Bข้อ จำกัด เปลี่ยนสิ่งนี้A#<Nเป็นโปรแกรมที่ช้ากว่าซึ่งทำงานได้ทั้งสองทิศทาง) บรรทัดที่สองกำหนดหน้าที่คล้ายคำกริยาs(ซึ่งเป็นฟังก์ชั่นที่นำมาใช้เป็นวิธีแก้ปัญหาของโปรแกรมนี้) ซึ่งค้นหาสตริงที่สั้นที่สุดที่เป็นไปได้ซึ่งประเมินจำนวนที่ให้ไว้เป็นอินพุต นั่นคืออารัมภบทสำหรับคุณ…)

โปรแกรมควรอธิบายตนเองได้ค่อนข้างดีเนื่องจากเป็นการแปลโดยตรงของสเปคให้กับไวยากรณ์มากขึ้นหรือน้อยลงและไปสู่ไวยากรณ์ของ Prolog นิยามของvบอกว่าNเป็น 1 ในสตริงที่ว่างเปล่าหรือNเป็นA× B(มีAน้อยกว่าBน้อยกว่าN) และสตริง concatenation ของv(A)และv(B)หรือNเป็นM+ 1 และสตริงที่มีการ:ตัดแบ่งกับv(M)concatenated *ด้วย บรรทัดที่สองนั้นเป็นบิตที่ละเอียดกว่าlength(S,_) หมายถึง "S มีความยาวบางส่วน" แต่การระบุสิ่งนี้เป็นสิ่งแรกในบรรทัดทำหน้าที่เป็นคำแนะนำในการใช้ Prolog ว่าควรตรวจสอบความยาวที่สั้นที่สุดก่อน (ซึ่งหมายความว่าเราจะได้ความยาวที่สั้นที่สุดที่เป็นไปได้สำหรับค่าตอบแทน) .