Il tuo obiettivo è determinare se un numero è divisibile per 3 senza usare i condizionali. L'ingresso sarà un numero di 8 bit senza segno da 0 a 255. Creatività incoraggiata!

Hai il permesso di utilizzare SOLO

• Uguaglianza / disuguaglianza ( ==, !=, >, <, >=, <=)

• Aritmetica ( +, -, x)

• Operatori logici ( !non, &&e, || o)

• Bitwise Operatori ( ~non, &e, |o, ^xor, <<, >>, >>>sinistra aritmetica e logica e si sposta a destra)

• Costanti (sarebbe meglio se li tenessi piccoli)

• Assegnazione variabile

Uscita 0se falso, 1se vero.

Si applicano le regole standard di golf atomico. In caso di domande, lasciarle nei commenti. Metodi di esempio qui . Un token è una delle costanti e variabili escluse sopra.

C - 2 token

int div3(int x) {
    return x * 0xAAAAAAAB <= x;
}

Sembra funzionare fino a 2 ³¹ -1.

Ringraziamenti zalgo("nhahtdh")per l'idea inversa moltiplicativa.

Python, 3 token 2

Soluzione di forza bruta, ma funziona.

0x9249249249249249249249249249249249249249249249249249249249249249>>x&1

Grazie a Howard per la riduzione di 1 token.

C - 5 4 (?) Token

int div3_m2(uint32_t n) {
    return n == 3 * (n * 0xAAAAAAABull >> 33);
}

Funziona con qualsiasi numero a 32 bit senza segno .

Questo codice utilizza il modulo 2 ³² inverso moltiplicativo di un divisore per convertire l'operazione di divisione in operazione di moltiplicazione.

modificare

La mia soluzione (pubblicata 2 minuti dopo) ha lo stesso spirito della soluzione di Aditsu. Ringraziandolo per l'uso ==che migliora la mia soluzione di 1 token.

Riferimento

• Labor of Division - ridiculousfish.com
• Hacker's Delight - Numero magico
• Wikipedia - Inverso moltiplicativo modulare

C - 15 token (?)

int div3_m1(unsigned int n) {
    n = (n & 0xf) + (n >> 4);
    n = (n & 0x3) + (n >> 2);
    n = (n & 0x3) + (n >> 2);
    return n == 0 || n == 3;
}

Da 4 ≡ 1 (mod 3), abbiamo 4 ⁿ ≡ 1 (mod 3). La regola di somma delle cifre non si limita alla somma delle cifre, ma ci consente anche di suddividere arbitrariamente il numero in sequenze di cifre e di sommarle tutte mantenendo la congruenza.

Un esempio in base 10, divisore = 9:

1234 ≡ 12 + 34 ≡ 1 + 2 + 3 + 4 ≡ 123 + 4 ≡ 1 (mod 9)

Tutte le istruzioni nel programma fanno uso di questa proprietà. In realtà può essere semplificato in un ciclo che esegue l'istruzione n = (n & 0x3) + (n >> 2);fino a n < 4quando l'istruzione semplicemente interrompe il numero in base-4 alla cifra meno significativa e aggiunge le 2 parti.

Python (2 token?)

1&66166908135609254527754848576393090201868562666080322308261476575950359794249L>>x

O

1&0x9249249249249249249249249249249249249249249249249249249249249249L>>x

O

1&0b1001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001>>x

JavaScript: 3 token

function div3(n) {
    var a = n * 0.3333333333333333;
    return (a | 0) == a;
}

Ciò abusa del fatto che l'utilizzo di operatori bit a bit su un numero lo tronca a un numero intero in JavaScript.

C - 4 token

int div3(int x) {
    return ((x * 43) >> 7) * 3 == x;
}

Funziona fino a 383.

Versione precedente (costanti più grandi):

int div3(int x) {
    return ((x * 171) >> 9) * 3 == x;
}

Funziona fino al 1535

bash - ???

Non sono sicuro di come segnare questo.

seq 0 85 | awk '{print $1 * 3}' | grep -w [number] | wc -l

per esempio

$ seq 0 85 | awk '{print $1 * 3}' | grep -w 11 | wc -l
0

$ seq 0 85 | awk '{print $1 * 3}' | grep -w 12 | wc -l
1

$seq 0 85 | awk '{print $1 * 3}' | grep -w 254 | wc -l
0

$seq 0 85 | awk '{print $1 * 3}' | grep -w 255 | wc -l
1

Befunge 93 - 5 token

Risolto - divisione rimossa.

v      @._1.@
         \   
         0   
         +   
         3   
>&>3-:0\`|   
  ^      <   

Ottiene l'input, continua a sottrarre 3 fino a quando è inferiore a 0, indirizza il puntatore verso l'alto ('|'), quindi aggiunge 3. Se il valore è 0, il puntatore si sposta a destra (" 1. @" genera '1') altrimenti si sposta a sinistra ("@. " genera '0'). '@' termina il programma.

Lotto - 7 token

penso

@echo off
for /L %%a in (0,3,%1) do set a=%%a
if %a%==%1 echo 1

Restituisce 1se il numero dato (come stdin) è divisibile per tre.

Rubino, 6 token (?)

Non sono davvero sicuro di come contare i token. OP, puoi segnarmi?

Penso che sia 6 ... 1, 0, 0, *, 255,x

Si noti che *non è una moltiplicazione intera.

def div3(x)
  ([1,0,0]*255)[x]
end

Python 0

Ho pubblicato un auricolare ma ho usato i condizionali. Ecco per non usare condizionali e token, solo parole chiave

def g(x): return ([[lambda : g(sum(int(y) for y in list(str(x)))),lambda: 0][[False,True].index(x in[0,1,2,4,5,7,8])], lambda: 1][[False,True].index((lambda y: y in[3,6,9])(x))])()

usa il trucco che il multiplo di 3 ha cifre che si sommano a 3

Modifica: rimosso lambda non necessario

def g(x):return([[lambda: g(sum(int(y) for y in list(str(x)))),lambda:0][[False,True].index(x in[0,1,2,4,5,7,8])], lambda:1][[False,True].index(x in[3,6,9])])()

Modifica: golfato ulteriormente (117 caratteri) ancora nessun gettone

exec"g=`x:(((`:g(sum(int(y)for y in str(x)),`:0)[x in[0,1,2,4,5,7,8]],`:1)[x in[3,6,9]])()".replace('`','lambda ')

Accesso diretto ucciso per l'ottimo getitem di Python Più a 132 caratteri

exec"g={0}x:((({0}:g(sum(int(y)for y in str(x))),{0}:0{1}0,1,2,4,5,7,8]),{0}:1{1}3,6,9]))()".format('lambda ',').__getitem__(x in[')

http://www.codeskulptor.org/#user34_uUl7SwOBJb_0.py

Python - 25 token

Per iniziare, ho una lunga soluzione che è l'implementazione di una delle risposte nel link nel mio primo post. nè inserito.

a = (n>>7)-((n&64)>>6)+((n&32)>>5)-((n&16)>>4)+((n&8)>>3)-((n&4)>>2)+((n&2)>>1)-(n&1)
print(a==0 or a==3)

orè equivalente a ||.

JavaScript - 3 token

Provalo sulla console del tuo browser:

a = prompt().split('');
sum = 0;

do {
  sum = a.reduce(function(p, c) {
     return parseInt(p) + parseInt(c); 
  });

  a = sum.toString().split('');

} while(a.length > 1)

alert([3, 6, 9].indexOf(+sum) > -1)

JavaScript
_{non è sicuro del token #}

function mod3 (i) { return {'undefined':'100','0':'0'}[[0][i]][i.toString (3).split('').pop ()]}

o se l'uscita per 0 può essere 1;

function mod3 (i) { return '100'[i.toString (3).split('').pop ()]}

Tcl , 83 byte

proc T n {while \$n>9 {set n [expr [join [split $n ""] +]]};expr {$n in {0 3 6 9}}}

Provalo online!