गोल्फ सीपीयू गोल्फ चैलेंज: प्राइम पार्टिशन

Question

यह चुनौती सबसे कम-संचालन समस्याओं की एक श्रृंखला है जो GOLF CPU में लिखी जानी चाहिए । आप अगले एक को यहाँ पा सकते हैं

किसी संख्या का एक विभाजन N, उन संख्याओं की एक सूची है, जो जोड़ते हैं N। एक अभाज्य विभाजन उन अभाज्य संख्याओं की एक सूची है जो जोड़ते हैं N।

इस चुनौती के लिए, आपको एक पूर्णांक दिया जाता है N ≥ 2। आपको इसके लिए सबसे कम संभव प्राइम पार्टिशन तैयार करना होगा N। यदि कई संभावित विभाजन हैं, तो आप उनमें से किसी को भी प्रिंट कर सकते हैं।

उदाहरण:

9: [2, 7]
12: [5, 7]
95: [89, 3, 3]
337: [337]
1023749: [1023733, 13, 3]
20831531: [20831323, 197, 11]

आपका प्रोग्राम GOLF CPU में लिखा होना चाहिए । इनपुट / आउटपुट के लिए आप या तो STDIO या रजिस्टरों का उपयोग कर सकते हैं। सूची किसी भी क्रम में हो सकती है, और यदि आप STDOUT का उपयोग कर रहे हैं, तो व्हॉट्सएप या अल्पविराम (कोई ब्रैकेट आवश्यक नहीं) द्वारा अलग किया जा सकता है। जाहिर है, समाधानों की हार्डकॉडिंग की अनुमति नहीं है, और न ही पहले कुछ अपराधों की तुलना में हार्डकोडिंग अधिक है।

यह एक सबसे कम-संचालन समस्या है, इसलिए इसका उत्तर जो चक्र के सबसे कम मात्रा में उदाहरणों को हल करता है, जीतता है!

Comments

मेरे लिए GOLF-C को बढ़ावा देने का समय , जो कि .golf कार्यक्रमों को चलाने का एक तेज़ तरीका प्रदान करता है .. और शायद इस पर काम करने के लिए कुछ और

— क्लोडिउ

@ कलुआडू गोल्फ-सी यहां निश्चित रूप से अनुमति दी जाएगी

— नाथन मेरिल

क्या कोई आकार सीमा है?

— lirtosiast

मुझे संदेह है कि गोल्डबैक और लेवी के अनुमान यहाँ काम आएंगे ...

— 2012rcampion

@ThomasKwa नहीं, कोई आकार सीमा नहीं, लेकिन कोई हार्ड कोडिंग प्राइम (पहले जोड़े से परे)

— नाथन मेरिल

Answer 1

159,326,251 चक्र

इनपुट है n, उत्पादन होता है r, sऔर t(अनदेखी शून्य)।

# Input in register n
# Outputs in registers r, s, t
# (I use the return value as a debug parameter)

# hardcoded case n=2
cmp c, n, 2
jz skip_n2, c
  mov r, 2
  halt 0
skip_n2:
# hardcoded case n=4
cmp c, n, 4
jz skip_n4, c
  mov r, 2
  mov s, 2
  halt 0
skip_n4:

# Sieve of Eratosthenes
mov i, 1
sieve_loop:
  add i, i, 2
  lb a, i
  jnz sieve_loop, a

  mulu j, k, i, i
  geu c, j, n
  jnz end_sieve_loop, c

  sieve_inner_loop:
    sb j, 1
    add j, j, i
    lequ c, j, n
    jnz sieve_inner_loop, c

  jmp sieve_loop

end_sieve_loop:

lb a, n

# if n is even, skip to search
and c, n, 1
jz search, c

# if n is prime, the partition is simply [n]
jnz not_prime, a
  mov r, n
  halt 1
not_prime:

# if n is odd, check n-2
sub i, n, 2
lb a, i

jnz sub_3, a
# if n-2 is prime, the partition is [2, n-2]
mov r, 2
mov s, i
halt 2

sub_3:
# otherwise the partition is [3] + partition(n-3)
mov t, 3
sub n, n, 3

search:
mov i, 1
sub n, n, 1

search_loop:
  add i, i, 2
  sub n, n, 2
  lb a, i
  jnz search_loop, a
  lb a, n
  jnz search_loop, a
  mov r, i
  mov s, n
  halt 3

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

robert@unity:~/golf-cpu$ ./assemble.py partition.golf
robert@unity:~/golf-cpu$ ./golf.py -p r,s,t partition.bin n=9
2, 7, 0
Execution terminated after 51 cycles with exit code 2.
robert@unity:~/golf-cpu$ ./golf.py -p r,s,t partition.bin n=12
5, 7, 0
Execution terminated after 77 cycles with exit code 3.
robert@unity:~/golf-cpu$ ./golf.py -p r,s,t partition.bin n=95
3, 89, 3
Execution terminated after 302 cycles with exit code 3.
robert@unity:~/golf-cpu$ ./golf.py -p r,s,t partition.bin n=337
337, 0, 0
Execution terminated after 1122 cycles with exit code 1.
robert@unity:~/golf-cpu$ ./golf.py -p r,s,t partition.bin n=1023749
13, 1023733, 3
Execution terminated after 6654139 cycles with exit code 3.
robert@unity:~/golf-cpu$ ./golf.py -p r,s,t partition.bin n=20831531
229, 20831299, 3
Execution terminated after 152670560 cycles with exit code 3.
robert@unity:~/golf-cpu$ 

Answer 2

उदाहरण के लिए कुल चक्र: 477,918,603

अद्यतन 1: Lemoine के अनुमान का उपयोग करने के लिए अद्यतन किया गया ।

अद्यतन 2: अद्यतनों को भोलेपन से खोजने के बजाय एराटोस्थनीज की छलनी का उपयोग करने के लिए अपडेट किया गया ।

साथ दौड़ो:

python3 assemble.py 52489-prime-partitions.golf
python3 golf.py 52489-prime-partitions.bin x=<INPUT>

उदाहरण रन:

$ python3 golf.py 52489-prime-partitions.bin x=10233
5
5
10223
Execution terminated after 194500 cycles with exit code 0.

उदाहरण इनपुट के लिए चक्र गणना:

Input    Cycles
9        191
12       282
95       1,666
337      5,792
1023749  21,429,225
20831531 456,481,447

हम (N+1)*8ढेर के पहले बाइट्स पर विचार करते हैं , एक सरणी है जिसमें N+164-बिट मान हैं। (जैसा कि ढेर आकार में सीमित है, यह केवल काम करेगा N < 2^57)। प्रविष्टि का मूल्य i*8इंगित करता है कि वेदर iएक प्रमुख है:

Value Description
-1    Not a prime
0     Unknown
1     The largest prime found
n > 1 This is a prime and the next prime is n

जब हम एरे का निर्माण करते हैं तो यह कैसा दिखेगा [-1, -1, 3, 5, -1, 7, -1, 11, -1, -1, -1, 13, ...]।

हम सरणी बनाने के लिए Eratosthenes की छलनी का उपयोग करते हैं ।

अगले कार्यक्रम छद्म कोड में निम्नलिखित करता है:

if is_prime(x):
    print x
else:
    if is_even(x):
        for p in primes:
            if is_prime(x - p):
                print p, x - p
                exit
    else:
        if is_prime(x - 2):
            print 2, x - 2
        else:
            for p in primes:
                if is_prime(x - 2 * p):
                    print p, p, 2 * p
                    exit

लेमोइन के अनुमान के कारण और गोल्डबैक के कमजोर अनुमान के कारण काम करने की गारंटी है । लेमोइन का अनुमान अभी तक सिद्ध नहीं हुआ है, लेकिन यह संभवतः 2 ^ 57 से नीचे की संख्या के लिए सही है।

    call build_primes

    mov q, x
    call is_prime

    jnz print_prime, a

    and b, x, 1
    jz find_pair, b

    # Check if x - 2 is a prime
    sub q, x, 2
    call is_prime
    jnz print_prime_odd2, a

# Input: x, b
find_pair:
    mov p, 2
find_pair_loop:
    mov d, p
    jz find_pair_even, b

    add d, d, p

find_pair_even:
    sub q, x, d

    call is_prime
    jnz print_prime2_or_3, a

    shl i, p, 3
    lw p, i
    jmp find_pair_loop

print_prime2_or_3:
    jz print_prime2, b

    mov x, p
    call write_int_ln

print_prime2:
    mov x, p
    call write_int_ln

    mov x, q
    call print_prime

print_prime_odd2:
    mov p, 2
    call print_prime2

print_prime:
    call write_int_ln
    halt 0

# Input: x
# Memory layout: [-1, -1, 3, 5, -1, 7, -1, 11, ...]
# x: max integer
# p: current prime
# y: pointer to last found prime
# i: current integer
build_primes:
    sw 0, -1
    sw 8, -1
    sw 16, 1
    mov y, 16

    mov p, 2

build_primes_outer:
    mulu i, r, p, p
    jnz build_primes_final, r

    geu a, i, x
    jnz build_primes_final, a

build_primes_inner:
    shl m, i, 3
    sw m, -1

    add i, i, p

    geu a, i, x
    jz build_primes_inner, a

build_primes_next:
    inc p
    shl m, p, 3
    lw a, m
    jnz build_primes_next, a

    sw y, p
    mov y, m
    sw y, 1

    jmp build_primes_outer

build_primes_final:
    inc p
    geu a, p, x
    jnz build_primes_ret, a

    shl m, p, 3
    lw a, m
    jnz build_primes_final, a

    sw y, p
    mov y, m
    sw y, 1

    jmp build_primes_final

build_primes_ret:
    ret

# Input: q
# Output: a
is_prime:
    shl m, q, 3
    lw a, m
    neq a, a, -1
    ret a

write_int:
    divu x, m, x, 10
    jz write_int_done, x
    call write_int
write_int_done:
    add m, m, ord("0")
    sw -1, m
    ret

write_int_ln:
    call write_int
    mov m, ord("\n")
    sw -1, m
    ret

Comments

क्या आप उदाहरण में सूचीबद्ध संख्याओं के लिए चक्रों की संख्या प्रिंट कर सकते हैं?

— नाथन मेरिल

@ नथनमेरिल ने किया।

— टायिलो