একটি নম্বর বর্গক্ষেত্র কিনা পরীক্ষা করা হচ্ছে

Question

একটি লিখুন গলফ সমাবেশ প্রোগ্রাম যা রেজিস্টার একটি 64-বিট স্বাক্ষরবিহীন পূর্ণসংখ্যা দেওয়া nরাখে রেজিস্টার মধ্যে একটি অ শূন্য মান sযদি nএকটি বর্গক্ষেত্র, অন্যথায় নয় 0মধ্যে s।

আপনার জিএলএফ বাইনারি (একত্রিত হওয়ার পরে) অবশ্যই 4096 বাইটে মাপসই করা উচিত

---

তোমার প্রোগ্রাম নিম্নলিখিত Python3 প্রোগ্রাম (যা ভিতরে রাখা হতে হবে ব্যবহার স্কোর করা হবে গলফ ডিরেক্টরি):

import random, sys, assemble, golf, decimal

def is_square(n):
    nd = decimal.Decimal(n)
    with decimal.localcontext() as ctx:
        ctx.prec = n.bit_length() + 1
        i = int(nd.sqrt())
        return i*i == n

with open(sys.argv[1]) as in_file:
    binary, debug = assemble.assemble(in_file)

score = 0
random.seed(0)
for i in range(1000):
    cpu = golf.GolfCPU(binary)

    if random.randrange(16) == 0: n = random.randrange(2**32)**2
    else:                         n = random.randrange(2**64)

    cpu.regs["n"] = n
    cpu.run()
    if bool(cpu.regs["s"]) != is_square(n):
        raise RuntimeError("Incorrect result for: {}".format(n))
    score += cpu.cycle_count
    print("Score so far ({}/1000): {}".format(i+1, score))

print("Score: ", score)

এর সাথে সর্বশেষ সংস্করণে জিওএলএফ আপডেট করার বিষয়টি নিশ্চিত করুন git pull। স্কোর প্রোগ্রাম ব্যবহার করে চালান python3 score.py your_source.golf।

এটি সংখ্যার একটি সেট তৈরি করতে স্থির বীজ ব্যবহার করে যার প্রায় ১/১16 বর্গক্ষেত্র। এই সংখ্যার সংখ্যার প্রতি অনুকূলিতকরণ প্রশ্নের চেতনাবিরোধী, আমি যে কোনও সময়ে বীজ পরিবর্তন করতে পারি। আপনার প্রোগ্রামটি অবশ্যই এইগুলি নয়, কোনও অ-নেতিবাচক -৪-বিট ইনপুট সংখ্যার জন্য কাজ করবে।

সর্বনিম্ন স্কোর জয়।

---

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

ম্যানুয়াল পরীক্ষার জন্য, চালিয়ে আপনার বাইনারি থেকে আপনার প্রোগ্রামটি সংকলন করুন python3 assemble.py your_source.golf। তারপরে আপনার প্রোগ্রামটি ব্যবহার করে চালান python3 golf.py -p s your_source.bin n=42, এটি n42 টি সেট সহ প্রোগ্রামটি শুরু করা উচিত এবং প্রিন্ট রেজিস্টার sএবং প্রস্থানের পরে চক্র গণনা শুরু করা উচিত। -dপতাকাটি সহ প্রোগ্রামের প্রস্থানে নিবন্ধক সামগ্রীর সমস্ত মান দেখুন - --helpসমস্ত পতাকা দেখতে ব্যবহার করুন ।

Comments

আমি পরীক্ষায় প্রতি operations 64 ক্রিয়াকলাপ সংরক্ষণ করতে একটি 32-পুনরাবৃত্তি লুপটি তালিকাভুক্ত করেছি। এটি সম্ভবত চ্যালেঞ্জের চেতনার বাইরে। হয়তো এই কোডাইজ দ্বারা বিভক্ত গতি হিসাবে ভাল কাজ করবে?

— স্পার

আপনার বাইনারি যতক্ষণ না 4096 বাইটে ফিট হয় ততক্ষণ স্প্পার লুপ আনআরোলিং করার অনুমতি রয়েছে। আপনি কি মনে করেন যে এই সীমাটি খুব বেশি? আমি এটি কমাতে ইচ্ছুক।

— orp

@ স্প্পার আপনার বাইনারি এখনই 1.3 কে, তবে আমি মনে করি 32-পুনরাবৃত্তির লুপ আন্রোলিং কিছুটা বেশি। 1024 বাইটের বাইনারি সীমাটি কীভাবে শব্দ করে?

— orlp

সমস্ত প্রতিযোগীদের সতর্কতা! আপনার জিওএলএফ দোভাষী সাথে আপডেট করুন git pull। আমি লেফিশিফ্ট অপারেণ্ডে একটি বাগ পেয়েছি যেখানে এটি সঠিকভাবে মোড়েনি।

— orlp

আমি নিশ্চিত নই. 1024 কেবল একবার লুপ করা প্রয়োজন; আমি এখনও আনরোলিং করে পরীক্ষায় প্রতি 62 ডলার সাশ্রয় করব। আমি সন্দেহ করি যে কেউ লুকের টেবিল হিসাবে সেই জায়গাটি ভাল ব্যবহারের জন্য রেখে দিতে পারে। আমি কিছু অ্যালগরিদম দেখেছি যা 32 বিটের স্কোয়ার শিকড়ের জন্য 2-8k লুক টেবিল চায়।

— স্পার

Answer 1

স্কোর: 22120 (3414 বাইট)

আমার দ্রবণটি নিউটনের পদ্ধতি সমাধানকারীকে বীজের জন্য 3 কেবি দেখার সারণী ব্যবহার করে যা ফলাফলের আকারের উপর নির্ভর করে শূন্য থেকে তিনটি পুনরাবৃত্তির জন্য চলে।

    lookup_table = bytes(int((16*n)**0.5) for n in range(2**10, 2**12))

    # use orlp's mod-64 trick
    and b, n, 0b111111
    shl v, 0xc840c04048404040, b
    le q, v, 0
    jz not_square, q
    jz is_square, n

    # x will be a shifted copy of n used to index the lookup table.
    # We want it shifted (by a multiple of two) so that the two most 
    # significant bits are not both zero and no overflow occurs.
    # The size of n in bit *pairs* (minus 8) is stored in b.
    mov b, 24
    mov x, n 
    and c, x, 0xFFFFFFFF00000000
    jnz skip32, c
    shl x, x, 32
    sub b, b, 16
skip32:
    and c, x, 0xFFFF000000000000
    jnz skip16, c
    shl x, x, 16
    sub b, b, 8
skip16:
    and c, x, 0xFF00000000000000
    jnz skip8, c
    shl x, x, 8
    sub b, b, 4
skip8:
    and c, x, 0xF000000000000000
    jnz skip4, c
    shl x, x, 4
    sub b, b, 2
skip4:
    and c, x, 0xC000000000000000
    jnz skip2, c
    shl x, x, 2
    sub b, b, 1
skip2:

    # now we shift x so it's only 12 bits long (the size of our lookup table)
    shr x, x, 52

    # and we store the lookup table value in x
    add x, x, data(lookup_table)
    sub x, x, 2**10
    lbu x, x

    # now we shift x back to the proper size
    shl x, x, b

    # x is now an intial estimate for Newton's method.
    # Since our lookup table is 12 bits, x has at least 6 bits of accuracy
    # So if b <= -2, we're done; else do an iteration of newton
    leq c, b, -2
    jnz end_newton, c
    divu q, r, n, x
    add x, x, q
    shr x, x, 1

    # We now have 12 bits of accuracy; compare b <= 4
    leq c, b, 4
    jnz end_newton, c
    divu q, r, n, x
    add x, x, q
    shr x, x, 1

    # 24 bits, b <= 16
    leq c, b, 16
    jnz end_newton, c
    divu q, r, n, x
    add x, x, q
    shr x, x, 1

    # 48 bits, we're done!

end_newton:

    # x is the (integer) square root of n: test x*x == n
    mulu x, h, x, x
    cmp s, n, x
    halt 0

is_square:
    mov s, 1

not_square:
    halt 0

Answer 2

স্কোর: 27462

প্রায় সময় আমি একটি জিএলএফ চ্যালেঞ্জের মধ্যে প্রতিযোগিতা করব : ডি

    # First we look at the last 6 bits of the number. These bits must be
    # one of the following:
    #
    #     0x00, 0x01, 0x04, 0x09, 0x10, 0x11,
    #     0x19, 0x21, 0x24, 0x29, 0x31, 0x39
    #
    # That's 12/64, or a ~80% reduction in composites!
    #
    # Conveniently, a 64 bit number can hold 2**6 binary values. So we can
    # use a single integer as a lookup table, by shifting. After shifting
    # we check if the top bit is set by doing a signed comparison to 0.

    and b, n, 0b111111
    shl v, 0xc840c04048404040, b
    le q, v, 0
    jz no, q
    jz yes, n

    # Hacker's Delight algorithm - Newton-Raphson.
    mov c, 1
    sub x, n, 1
    geu q, x, 2**32-1
    jz skip32, q
    add c, c, 16
    shr x, x, 32
skip32:
    geu q, x, 2**16-1
    jz skip16, q
    add c, c, 8
    shr x, x, 16
skip16:
    geu q, x, 2**8-1
    jz skip8, q
    add c, c, 4
    shr x, x, 8
skip8:
    geu q, x, 2**4-1
    jz skip4, q
    add c, c, 2
    shr x, x, 4
skip4:
    geu q, x, 2**2-1
    add c, c, q

    shl g, 1, c
    shr t, n, c
    add t, t, g
    shr h, t, 1

    leu q, h, g
    jz newton_loop_done, q
newton_loop:
    mov g, h
    divu t, r, n, g
    add t, t, g
    shr h, t, 1
    leu q, h, g
    jnz newton_loop, q
newton_loop_done:

    mulu u, h, g, g
    cmp s, u, n 
    halt 0
yes:
    mov s, 1
no:
    halt 0

Comments

আমি যদি আপনার অনুসন্ধানের ধারণাটি চুরি করি তবে আমার স্কোর 161558 থেকে 47289 এ নেমে যাবে Your আপনার অ্যালগোরিদম এখনও জিতেছে।

— স্পার

আপনি কি নিউটনের লুপটি আনرولল করার চেষ্টা করেছেন? সবচেয়ে খারাপ ক্ষেত্রে এটির কতটি পুনরাবৃত্তি প্রয়োজন?

— স্পার

@ স্পার হ্যাঁ, তালিকাভুক্তি করা দ্রুত নয় কারণ পুনরাবৃত্তির সংখ্যায় উচ্চতর বৈচিত্র রয়েছে।

— orlp

এটি কি কখনও শূন্য বা একটি পুনরাবৃত্তিতে পূর্ণ হয়? সর্বোচ্চ কত?

— স্পার

সন্ধানের সারণী ধারণাটি স্ট্যাকওভারফ্লো . com/a/18686659/4339987 এও ছিল ।

— লিটারোসিয়াসট

Answer 3

স্কোর: 161558 227038 259038 260038 263068

আমি দ্রুততম পূর্ণসংখ্যার স্কোয়ার রুট অ্যালগরিদমটি পেয়েছি এবং এর অবশিষ্টটি শূন্য কিনা তা আমি ফিরে পেতে ও ফিরিয়ে আনতে পারি।

# based on http://www.cc.utah.edu/~nahaj/factoring/isqrt.c.html
# converted to GOLF assembly for http://codegolf.stackexchange.com/questions/49356/testing-if-a-number-is-a-square

# unrolled for speed, original source commented out at bottom
start:
    or u, t, 1 << 62
    shr t, t, 1
    gequ v, n, u
    jz nope62, v
    sub n, n, u
    or t, t, 1 << 62
    nope62:

    or u, t, 1 << 60
    shr t, t, 1
    gequ v, n, u
    jz nope60, v
    sub n, n, u
    or t, t, 1 << 60
    nope60:

    or u, t, 1 << 58
    shr t, t, 1
    gequ v, n, u
    jz nope58, v
    sub n, n, u
    or t, t, 1 << 58
    nope58:

    or u, t, 1 << 56
    shr t, t, 1
    gequ v, n, u
    jz nope56, v
    sub n, n, u
    or t, t, 1 << 56
    nope56:

    or u, t, 1 << 54
    shr t, t, 1
    gequ v, n, u
    jz nope54, v
    sub n, n, u
    or t, t, 1 << 54
    nope54:

    or u, t, 1 << 52
    shr t, t, 1
    gequ v, n, u
    jz nope52, v
    sub n, n, u
    or t, t, 1 << 52
    nope52:

    or u, t, 1 << 50
    shr t, t, 1
    gequ v, n, u
    jz nope50, v
    sub n, n, u
    or t, t, 1 << 50
    nope50:

    or u, t, 1 << 48
    shr t, t, 1
    gequ v, n, u
    jz nope48, v
    sub n, n, u
    or t, t, 1 << 48
    nope48:

    or u, t, 1 << 46
    shr t, t, 1
    gequ v, n, u
    jz nope46, v
    sub n, n, u
    or t, t, 1 << 46
    nope46:

    or u, t, 1 << 44
    shr t, t, 1
    gequ v, n, u
    jz nope44, v
    sub n, n, u
    or t, t, 1 << 44
    nope44:

    or u, t, 1 << 42
    shr t, t, 1
    gequ v, n, u
    jz nope42, v
    sub n, n, u
    or t, t, 1 << 42
    nope42:

    or u, t, 1 << 40
    shr t, t, 1
    gequ v, n, u
    jz nope40, v
    sub n, n, u
    or t, t, 1 << 40
    nope40:

    or u, t, 1 << 38
    shr t, t, 1
    gequ v, n, u
    jz nope38, v
    sub n, n, u
    or t, t, 1 << 38
    nope38:

    or u, t, 1 << 36
    shr t, t, 1
    gequ v, n, u
    jz nope36, v
    sub n, n, u
    or t, t, 1 << 36
    nope36:

    or u, t, 1 << 34
    shr t, t, 1
    gequ v, n, u
    jz nope34, v
    sub n, n, u
    or t, t, 1 << 34
    nope34:

    or u, t, 1 << 32
    shr t, t, 1
    gequ v, n, u
    jz nope32, v
    sub n, n, u
    or t, t, 1 << 32
    nope32:

    or u, t, 1 << 30
    shr t, t, 1
    gequ v, n, u
    jz nope30, v
    sub n, n, u
    or t, t, 1 << 30
    nope30:

    or u, t, 1 << 28
    shr t, t, 1
    gequ v, n, u
    jz nope28, v
    sub n, n, u
    or t, t, 1 << 28
    nope28:

    or u, t, 1 << 26
    shr t, t, 1
    gequ v, n, u
    jz nope26, v
    sub n, n, u
    or t, t, 1 << 26
    nope26:

    or u, t, 1 << 24
    shr t, t, 1
    gequ v, n, u
    jz nope24, v
    sub n, n, u
    or t, t, 1 << 24
    nope24:

    or u, t, 1 << 22
    shr t, t, 1
    gequ v, n, u
    jz nope22, v
    sub n, n, u
    or t, t, 1 << 22
    nope22:

    or u, t, 1 << 20
    shr t, t, 1
    gequ v, n, u
    jz nope20, v
    sub n, n, u
    or t, t, 1 << 20
    nope20:

    or u, t, 1 << 18
    shr t, t, 1
    gequ v, n, u
    jz nope18, v
    sub n, n, u
    or t, t, 1 << 18
    nope18:

    or u, t, 1 << 16
    shr t, t, 1
    gequ v, n, u
    jz nope16, v
    sub n, n, u
    or t, t, 1 << 16
    nope16:

    or u, t, 1 << 14
    shr t, t, 1
    gequ v, n, u
    jz nope14, v
    sub n, n, u
    or t, t, 1 << 14
    nope14:

    or u, t, 1 << 12
    shr t, t, 1
    gequ v, n, u
    jz nope12, v
    sub n, n, u
    or t, t, 1 << 12
    nope12:

    or u, t, 1 << 10
    shr t, t, 1
    gequ v, n, u
    jz nope10, v
    sub n, n, u
    or t, t, 1 << 10
    nope10:

    or u, t, 1 << 8
    shr t, t, 1
    gequ v, n, u
    jz nope8, v
    sub n, n, u
    or t, t, 1 << 8
    nope8:

    or u, t, 1 << 6
    shr t, t, 1
    gequ v, n, u
    jz nope6, v
    sub n, n, u
    or t, t, 1 << 6
    nope6:

    or u, t, 1 << 4
    shr t, t, 1
    gequ v, n, u
    jz nope4, v
    sub n, n, u
    or t, t, 1 << 4
    nope4:

    or u, t, 1 << 2
    shr t, t, 1
    gequ v, n, u
    jz nope2, v
    sub n, n, u
    or t, t, 1 << 2
    nope2:

    or u, t, 1 << 0
    shr t, t, 1
    gequ v, n, u
    jz nope0, v
    sub n, n, u
    nope0:

end:
    not s, n        # return !remainder
    halt 0


# before unrolling...
#
# start:
#     mov b, 1 << 62  # squaredbit = 01000000...
# loop:               # do {
#     or u, b, t      #   u = squaredbit | root
#     shr t, t, 1     #   root >>= 1
#     gequ v, n, u    #   if remainder >= u:
#     jz nope, v
#     sub n, n, u     #       remainder = remainder - u
#     or t, t, b      #       root = root | squaredbit
# nope:
#     shr b, b, 2     #   squaredbit >>= 2
#     jnz loop, b      # } while (squaredbit > 0)
# end:
#     not s, n        # return !remainder
#     halt 0

সম্পাদনা 1: স্কোয়ারিং পরীক্ষা সরানো হয়েছে, ফিরে আসুন! প্রত্যক্ষভাবে, প্রতি পরীক্ষায় 3 ডলার বাঁচান

সম্পাদনা 2: সরাসরি বাকি হিসাবে এন ব্যবহার করুন, পরীক্ষায় প্রতি 1 ওপেন সঞ্চয় করুন

সম্পাদনা 3: লুপের শর্তটি সরল করে, প্রতি পরীক্ষায় 32 অপশন সঞ্চয় করুন

সম্পাদনা 4: লুপটি অনিয়ন্ত্রিত, প্রতি পরীক্ষায় 65 টি ওপেন সঞ্চয় করুন

Comments

আপনি নির্দেশাবলী পূর্ণ পাইথন এক্সপ্রেশন ব্যবহার করতে পারেন যাতে আপনি লিখতে পারেন 0x4000000000000000যেমন 1 << 62:)

— orlp

Answer 4

স্কোর: 344493

ব্যবধানের মধ্যে [1, 4294967296)আনুমানিকের জন্য একটি সাধারণ বাইনারি অনুসন্ধান করে sqrt(n), তবে nনিখুঁত বর্গক্ষেত্র কিনা তা পরীক্ষা করে ।

mov b, 4294967296
mov c, -1

lesser:
    add a, c, 1

start:
    leu k, a, b
    jz end, k

    add c, a, b
    shr c, c, 1

    mulu d, e, c, c

    leu e, d, n
    jnz lesser, e
    mov b, c
    jmp start

end:
    mulu d, e, b, b
    cmp s, d, n

    halt 0

Comments

দুর্দান্ত উত্তর! আপনি প্রোগ্রামিং এর উপর কোন মতামত থাকে না গলফ সমাবেশ, সরঞ্জাম আমি জন্য তৈরি গলফ , অথবা চ্যালেঞ্জ? এই ধরণের চ্যালেঞ্জটি খুব নতুন, এবং আমি প্রতিক্রিয়া শুনতে আগ্রহী :)

— orp

আপনার উত্তরটি n = 0 এর জন্য বাগড হয়েছে দুঃখের সাথে, 0 টি 0 স্কোয়ার্ড :)

— orlp

এন = 0. এছাড়াও নির্দিষ্ট @orlp, আমি একটি রেজিস্টার মান মধ্য সঞ্চালনের, যা ডিবাগ বানাতে পারে প্রিন্ট করতে একটি নির্দেশ যোগ করার সুপারিশ করছি গলফ প্রোগ্রাম সহজ।

— es1024

আমি এই জাতীয় নির্দেশ যুক্ত করতে যাচ্ছি না (এর অর্থ হ'ল চ্যালেঞ্জগুলি অস্বীকার করা ডিবাগিং নির্দেশাবলী সম্পর্কে অতিরিক্ত নিয়ম যুক্ত করতে হবে) এর পরিবর্তে আমার ইন্টারঅ্যাকটিভ ডিবাগিং পরিকল্পনা রয়েছে, ব্রেকপয়েন্ট এবং সমস্ত নিবন্ধের বিষয়বস্তু দেখার জন্য।

— orp

মিডপয়েন্ট ব্যতীত অন্য কোথাও পৌঁছতে আপনার বাইনারি অনুসন্ধানকে ভার করে আপনি সম্ভবত এটির গতি বাড়িয়ে তুলতে পারেন। দুটি মানের জ্যামিতিক গড় সম্ভবত?

— স্পার