Verifica se un numero è un quadrato


16

Scrivi un programma di assemblaggio GOLF che ha dato un intero senza segno a 64 bit nel registro ninserisce un valore diverso da zero nel registro sse nè un quadrato, altrimenti 0in s.

Il file binario GOLF (dopo il montaggio) deve contenere 4096 byte.


Il tuo programma verrà valutato usando il seguente programma Python3 (che deve essere inserito nella directory GOLF ):

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)

Assicurati di aggiornare GOLF all'ultima versione con git pull. Eseguire il programma di punteggio utilizzando python3 score.py your_source.golf.

Usa un seme statico per generare un insieme di numeri di cui circa 1/16 è quadrato. L'ottimizzazione verso questo insieme di numeri è contro lo spirito della domanda, posso cambiare il seme in qualsiasi momento. Il programma deve funzionare per qualsiasi numero di input a 64 bit non negativo, non solo per questi.

Il punteggio più basso vince.


Poiché GOLF è molto nuovo, includerò alcuni suggerimenti qui. Dovresti leggere il GOLF specifiche con tutte le istruzioni e i costi del ciclo . Nel repository Github sono disponibili esempi di programmi.

Per i test manuali, compilare il programma su un file binario eseguendo python3 assemble.py your_source.golf. Quindi eseguire il programma utilizzando python3 golf.py -p s your_source.bin n=42, questo dovrebbe avviare il programma con l' nimpostazione su 42 e stampa il registro se il conteggio dei cicli dopo essere usciti. Vedi tutti i valori dei contenuti del registro all'uscita del programma con il -dflag - usa --helpper vedere tutti i flag.


Ho srotolato un ciclo di 32 iterazioni per salvare ~ 64 operazioni per test. Questo è probabilmente al di fuori dello spirito della sfida. Forse questo funzionerebbe meglio come velocità divisa per dimensione del codice?
Sparr,

Lo srotolamento di @Sparr Loop è consentito, purché il file binario si adatti a 4096 byte. Pensi che questo limite sia troppo alto? Sono disposto ad abbassarlo.
orlp,

@Sparr Il tuo binario in questo momento è 1.3k, ma penso che lo srotolamento del ciclo a 32 iterazioni sia un po 'troppo. Come suona un limite binario di 1024 byte?
orlp,

Avvertimento per tutti i concorrenti! Aggiorna il tuo interprete GOLF con git pull. Ho trovato un bug nell'operando di sinistra che non si chiudeva correttamente.
orlp,

Non ne sono sicuro. 1024 mi richiederebbe di eseguire il ciclo solo una volta; Con lo srotolamento risparmierei ancora ~ 62 operazioni per test. Ho il sospetto che qualcuno potrebbe anche mettere a frutto lo stesso spazio come tabella di ricerca. Ho visto alcuni algoritmi che vogliono 2-8k di tabelle di ricerca per radici quadrate a 32 bit.
Sparr,

Risposte:


2

Punteggio: 22120 (3414 byte)

La mia soluzione utilizza una tabella di ricerca da 3 KB per eseguire il seeding di un solutore di metodo di Newton che viene eseguito per zero o tre iterazioni a seconda delle dimensioni del risultato.

    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

10

Punteggio: 27462

A proposito di tempo competerei in una sfida GOLF : D

    # 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

Se rubo la tua idea di ricerca, il mio punteggio scende da 161558 a 47289. Il tuo algoritmo vince ancora.
Sparr,

Hai provato a srotolare il circuito di Newton? Di quante iterazioni ha bisogno, nel caso peggiore?
Sparr,

@Sparr Sì, non è più veloce srotolarlo perché c'è un'elevata varianza nel numero di iterazioni.
orlp,

si completa mai in zero o una iterazione? qual è il massimo?
Sparr,

L'idea della tabella di ricerca era anche nella risposta stackoverflow.com/a/18686659/4339987 .
lirtosiast,

5

Punteggio: 161558 227038 259038 260038 263068

Ho preso l'algoritmo radice quadrata intera più veloce che ho trovato e restituito se il resto è zero.

# 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

EDIT 1: rimosso il test di squadratura, restituisci direttamente! Resto, salva 3 operazioni per test

MODIFICA 2: utilizzare direttamente n come resto, salvare 1 operazione per test

EDIT 3: semplificata la condizione del loop, risparmia 32 operazioni per test

EDIT 4: srotolato il loop, risparmia circa 65 operazioni per test


1
Puoi usare le espressioni complete di Python nelle istruzioni, in modo da poter scrivere 0x4000000000000000come 1 << 62:)
orlp

3

Punteggio: 344493

Esegue una semplice ricerca binaria nell'intervallo [1, 4294967296)per approssimare sqrt(n), quindi controlla se nè un quadrato perfetto.

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

Bella risposta iniziale! Hai qualche feedback sulla programmazione nell'assemblaggio GOLF , sugli strumenti che ho creato per GOLF o sulla sfida? Questo tipo di sfida è molto nuovo e non vedo l'ora di
ricevere

La tua risposta è infastidita per n = 0 purtroppo, 0 è 0 al quadrato :)
orlp

@orlp risolto per n = 0. Inoltre, suggerirei di aggiungere un'istruzione per stampare il valore di un registro durante l'esecuzione, che potrebbe facilitare il debug dei programmi GOLF .
es1024,

Non aggiungerò tali istruzioni (ciò significherebbe che le sfide devono aggiungere regole extra sulle istruzioni di debug non consentite), invece ho pianificato il debug interattivo, con punti di interruzione e visualizzazione di tutti i contenuti del registro.
orlp,

potresti accelerare ponderando la tua ricerca binaria per atterrare in un posto diverso dal punto medio. la media geometrica dei due valori forse?
Sparr,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.