Mathemania รายละเอียด:

ชิ้นส่วนของรหัส Mathemania 2ทุกคนเริ่มออกด้วยหมายเลข จาก2, คุณสามารถทำการดำเนินการต่อไปนี้:

• e: การยกกำลัง ค่าเริ่มต้นของคำสั่งนี้กำลังสองจำนวน
• f: แฟคทอเรียล ค่าเริ่มต้นของคำสั่งนี้ใช้แฟคทอเรียลเดียวกับหมายเลข ( using f on 2 = 2! = 2)
• r: รูต ค่าเริ่มต้นของคำสั่งนี้คือการรูทแบบตัวเลข
• c: ฟังก์ชั่นเพดาน
• lฟังก์ชั่นชั้น

เพื่อสร้างตัวเลขใน Mathemania 2คุณต้องร่วมกันสตริงคำสั่งเหล่านี้ซึ่งจะดำเนินการจากซ้ายไปขวาบนจำนวน

ตัวอย่าง:

ef = (2^2)! = 4! = 24
rl = floor(sqrt(2)) = floor(1.4...) = 1
er = sqrt(2^2) = sqrt(4) = 2
efrrc = ceil(sqrt(sqrt((2^2)!)))
      = ceil(sqrt(sqrt(24)))
      = ceil(sqrt(4.89...))
      = ceil(2.21...)
      = 3

e, fและrคำสั่งที่สามารถเปลี่ยนแปลงได้โดยคำสั่ง Mathemania พิเศษ (ซึ่งเริ่มต้นด้วยการ2เป็นจำนวนของ "ฐาน") เพื่อสร้าง exponentiations ที่แตกต่างกัน factorials และรากโดยการวางวงเล็บหลังจากที่ฟังก์ชั่นที่มีการเปลี่ยนแปลงและการวางคำสั่ง Mathemania ภายในนั้น

ตัวอย่างเช่นหากต้องการลูกบาศก์ตัวเลขแทนการยกกำลังสองคุณสามารถใส่คำสั่ง3หลังจากeนั้น:

e(efrrc) -> cube a number, "efrrc" = 3

หมายเหตุ: สำหรับวัตถุประสงค์ของเราคำสั่งแฟกทอเรียล ( f) เริ่มต้นด้วย2แฟคทอเรียล ดังนั้นถ้าคุณทำเช่นf(efrrc)นั้นจะได้รับการประเมินเป็นแฟคทอเรียลสองเท่าไม่ใช่แฟคทอเรียล

สำหรับn-factorials (เช่น double factorials = 2-factorial, triple factorial = 3-factorial ฯลฯ ) หมายเลขฐานจะถูกคูณด้วยจำนวนที่nน้อยกว่านั้นและnน้อยกว่านั้นและจนกว่าจะถึงหมายเลขสุดท้ายจะไม่สามารถ ลบออกโดยnไม่กลายเป็น0หรือลบ

ตัวอย่างเช่น:

7!! = 7 * 5 * 3 * 1 = 105 (repeatedly subtract 2, 1 is the last term as
                           1 - 2 = -1, which is negative)
9!!! = 9 * 6 * 3 = 162 (repeatedly subtract 3, 3 is the last term as
                        3 - 3 = 0, which is 0)

สำหรับข้อมูลเพิ่มเติมโปรดดูที่นี่

คุณสามารถแทรกได้ทุกที่และมันจะได้รับการปฏิบัติโดย Mathemania เป็นฟังก์ชั่นเดียว:

e(efrrc)rc = ceil(sqrt(2^3))
           = ceil(2.82...)
           = 3

คุณยังได้รับอนุญาตให้ซ้อนสิ่งเหล่านี้ในกันและกัน:

e(e(e)) = e(4th power)
        = (2^4)th power
        = 16th power

สำหรับล่ามของรหัส Mathemania คลิกที่นี่ (ไชโย @ BradGilbertb2gills!)

งาน:

งานของคุณคือการสร้างโปรแกรมที่เมื่อได้รับเป็นจำนวนเต็มบวกnเป็น input สร้างโปรแกรม Mathemania nว่าเมื่อดำเนินการส่งกลับ

อย่างไรก็ตามโปรแกรม Mathemania ที่คุณสร้างจะต้องเป็นขนาดเล็ก (แข็งแรงเล่นกอล์ฟ) เป็นไปได้และคะแนนสุดท้ายของคุณจะถูกกำหนดโดยผลรวมของจำนวนไบต์ในการสร้างโปรแกรม Mathemania ของกลุ่มตัวอย่างซึ่งเป็นจำนวนเต็มที่จะ10,000 10,100คะแนนต่ำสุดชนะ

กฎและข้อกำหนด:

• โปรแกรมของคุณจะต้องส่งออกโปรแกรม Mathemania ที่ถูกต้องสำหรับจำนวนเต็มบวกใด ๆ แต่จะมีเพียงตัวเลขระหว่าง10,000และ10,100จะถูกทดสอบ
• คุณไม่ได้รับอนุญาตให้แสดงผลโปรแกรม Mathemania ที่ไม่ได้เป็นจำนวนเต็ม หากคุณทำเช่นนั้นโปรแกรมของคุณจะถูกตัดสิทธิ์
• สำหรับคำสั่งe, fและrรหัส Mathemania ภายในฟังก์ชันเหล่านั้น (เช่นe(efrrc)ที่efrrcเป็นรหัสภายในฟังก์ชั่น) 2จะต้องประเมินเป็นจำนวนเต็มบวกดังกล่าวข้างต้น หากโปรแกรมของคุณไม่ปฏิบัติตามกฎนี้ก็จะถูกตัดสิทธิ์เช่นกัน
• โปรแกรมของคุณต้องส่งคืนโปรแกรม Mathemania สำหรับหนึ่งในจำนวนเต็ม 101 ทดสอบใน 30 นาทีในแล็ปท็อปที่ทันสมัย
• โปรแกรมของคุณจะต้องส่งคืนโซลูชันเดียวกันสำหรับจำนวนเต็มใด ๆ ทุกครั้งที่เรียกใช้ ตัวอย่างเช่นเมื่อโปรแกรมได้รับอินพุต5และเอาต์พุตefrcมันจะต้องเอาต์พุตที่ทุกครั้งที่อินพุต5ถูกกำหนด
• คุณไม่สามารถเขียนโค้ดวิธีแก้ปัญหาสำหรับจำนวนเต็มบวกใด ๆ
• เพื่อเพิ่มศักยภาพการเล่นกอล์ฟอย่างเต็มที่ในผลลัพธ์ของคุณโปรแกรมของคุณควรจะสามารถจัดการกับจำนวนเต็มขนาดใหญ่โดยพลการ มันไม่ใช่ข้อกำหนด แต่โชคดีถ้าภาษาของคุณไม่รองรับสิ่งนี้

นี่คือmetagolfดังนั้นคะแนนต่ำสุดจึงชนะ!

Python 3.5 คะแนนของ ??

ณ ตอนนี้ฉันไม่มีเอาต์พุตสำหรับอินพุต 101 ทั้งหมด แต่เมื่อฉันรันโปรแกรมสำหรับกรณีทดสอบทั้งหมดฉันจะอัปเดตด้วยคะแนนของฉัน

from math import *

memoized = {}
same = {}

def _(mathmania, n):
    memoized[n] = mathmania
    return mathmania

def is_prime(n):
    if n == 2:
        return True
    if n % 2 == 0 or n <= 1:
        return False
    for divisor in range(3, int(sqrt(n)) + 1, 2):
        if n % divisor == 0:
            return False
    return True

def pair_key(pair):
    low, high = pair
    diff = high - low
    if diff == 0:
        return 100
    low_done, high_done, diff_done = low in memoized, high in memoized, diff in memoized
    if high_done and memoized[high] == None or low_done and memoized[low] == None:
        return -1
    return (high_done + diff_done + (diff + 1 == low)) * 33 + low / high

def major_pairs(n):
    for i in range(n, int(sqrt(n)), -1):
        d = n / i
        if i - d < d - 1:
            break
        if d == int(d):
            yield (int(d), i)

def fact_key(pair):
    i, f = pair
    if i in memoized:
        if memoized[i] == None:
            return -1
        return 1
    return i / f

def near_fact(n, level):
    s = 4
    if n in same:
        s = same[n]
    for i in range(s, n ** 2 ** level):
        f = factorial(i)
        if f > (n - 1) ** 2 ** level:
            if f < (n + 1) ** 2 ** level:
                same[n] = i
                yield (i, f)
            else:
                return

def generate_mathmania(n):
    if n in memoized and memoized[n] != None:
        return memoized[n]
    memoized[n] = None
    binx = log(n, 2)
    if binx == int(binx):
        if binx == 2:
            return _("e", n)
        if binx == 1:
            return _("er", n)
        if binx == 0:
            return _("rl", n)
        return _("e(" + generate_mathmania(int(binx)) + ")", n)
    sq = sqrt(n)
    if sq == int(sq):
        return _(generate_mathmania(int(sq)) + "e", n)
    low, high = max(major_pairs(n), key=pair_key)
    if pair_key((low, high)) == -1:
        level = 1
        while True:
            try:
                i, f = max(near_fact(n, level), key=fact_key)
            except:
                level += 1
                continue
            if fact_key((i, f)) == -1:
                return _(generate_mathmania((n - 1) ** 2 + 1) + "rc", n)
            if f == n ** 2 ** level:
                return _(generate_mathmania(i) + "f" + "r" * level, n)
            if f < n ** 2 ** level:
                return _(generate_mathmania(i) + "f" + "r" * level + "c", n)
            return _(generate_mathmania(i) + "f" + "r" * level + "l", n)
    if low != 1:
        if low == high:
            return _(generate_mathmania(low) + "e", n)
        if high - low == 1:
            return _(generate_mathmania(high) + "f", n)
        return _(generate_mathmania(high) + "f(" + generate_mathmania(high - low + 1) + ")", n)
    good = None
    for i in range(n ** 2 - 1, (n - 1) ** 2, -1):
        if i in memoized:
            return _(generate_mathmania(i) + "rc", n)
        if not is_prime(i):
            good = i
    if good:
        return _(generate_mathmania(good) + "rc", n)
    for i in range((n + 1) ** 2 - 1, n ** 2, -1):
        if i in memoized:
            return _(generate_mathmania(i) + "rl", n)
        if not is_prime(i):
            good = i
    if good:
        return _(generate_mathmania(good) + "rl", n)
    return _(generate_mathmania((n - 1) ** 2 + 1), n)

นอกจากนี้ฉันไม่สามารถตรวจสอบผลลัพธ์ของบางกรณีทดสอบที่ฉันพยายามเนื่องจากขนาดจำนวนเต็มที่และ ณ จุดนั้น @ ล่ามออนไลน์ของ BradGilbertb2gills หมดเวลา หวังว่าเอาต์พุตทั้งหมดจะทำงาน