Scrivi un programma che controlla se l'intero è una potenza di 2.

Input di esempio:

8

Uscita campione:

Yes

Input di esempio:

10

Uscita campione:

No

Regole:

• Non usare +, -operazioni.

• Utilizzare una sorta di flusso di input per ottenere il numero. L'input non dovrebbe essere inizialmente memorizzato in una variabile.

• Vince il codice più breve (in byte).

È possibile utilizzare qualsiasi risposta di verità / falsa (ad esempio, true/ false). Si può presumere che il numero di input sia maggiore di 0.

GolfScript, 6 caratteri, nessun decremento

~.3/&!

Ecco una soluzione che non utilizza il x & (x-1)metodo in nessuna forma. Usa x & (x/3)invece. ;-) Emette 0se falso, 1se vero.

Spiegazione:

• ~ elimina la stringa di input per trasformarla in un numero,
• .lo duplica (per il successivo &),
• 3/ lo divide per tre (troncando verso il basso),
• & calcola il AND bit per bit del valore diviso con l'originale, che sarà zero se e solo se l'ingresso è zero o una potenza di due (cioè ha al massimo un bit impostato), e
• ! nega logicamente questo, mappando zero su uno e tutti gli altri valori su zero.

Gli appunti:

• Secondo le regole chiarite, zero non è un input valido , quindi questo codice è OK, anche se viene emesso 1se l'input è zero.

• Se l'operatore di decremento GolfScript (è consentito, è sufficiente la soluzione a 5 caratteri ~.(&! pubblicata da aditsu . Tuttavia, sembra andare contro lo spirito delle regole , se non la lettera.

• Ho inventato il x & (x/3)trucco anni fa sulla mailing list di Fun With Perl. (Sono sicuro di non essere il primo a scoprirlo, ma l'ho (ri) inventato in modo indipendente.) Ecco un link al post originale , inclusa una prova che funziona davvero.

APL (7)

Sì, sono 7 byte . Supponiamo per il momento che sto usando la tabella codici IBM 907 anziché Unicode e quindi ogni carattere è un byte :)

0=1|2⍟⎕

vale a dire 0 = mod(log(input(),2),1)

GolfScript, 11 (per 1 (vero) e 0 (falso))

.,{2\?}%?0>

Metti il ​​numero in pila e poi esegui.

GolfScript, 22 (per Sì / No)

.,{2\?}%?0>'Yes''No'if

Adoro il modo in cui la conversione 1/ 0in Yes/ Noaccetta tanto codice quanto la sfida stessa: D

Avvertenza: ESTREMAMENTE inefficiente;) Funziona bene per numeri fino a 10000, ma una volta che si arriva così in alto si inizia a notare un leggero ritardo.

Spiegazione:

• .,: si trasforma nin n 0..n( .duplicato, ,intervallo 0..n)
• {2\?}: alla potenza di 2
• %: mappa "potenza di 2" su "0..n" in modo che diventi n [1 2 4 8 16 ...]
• ?0>: verifica se l'array contiene il numero (0 è maggiore dell'indice)

Mathematica 28

Numerator[Input[]~Log~2]==1

Per potenze intere pari a 2, il numeratore del registro di base 2 sarà 1 (il che significa che il registro è una frazione di unità).

Qui modifichiamo leggermente la funzione per visualizzare l'ingresso presunto. Usiamo #al posto di Input[]e aggiungiamo &per definire una funzione pura. Restituisce la stessa risposta che verrebbe restituita se l'utente inserisse il numero nella funzione sopra.

    Numerator[#~Log~2] == 1 &[1024]
    Numerator[#~Log~2] == 1 &[17]

Vero
Falso

Test di più numeri alla volta.

    Numerator[#~Log~2] == 1 &&/@{64,8,7,0}

{Vero, Vero, Falso, Falso}

Perl 6 (17 caratteri)

say get.log(2)%%1

Questo programma ottiene una linea dalla getfunzione STDIN , calcola il logaritmo con la base 2 su di esso ( log(2)) e controlla se il risultato si divide per 1 ( %%1, dove %%si divide per operatore). Non è breve come la soluzione GolfScript, ma lo trovo accettabile (GolfScript vince comunque tutto), ma molto più veloce (anche considerando che Perl 6 è lento in questo momento).

~ $ perl6 -e 'say get.log(2)%%1'
256
True
~ $ perl6 -e 'say get.log(2)%%1'
255
False

Ottava ( 15 23)

EDIT: aggiornato a causa dei requisiti di input dell'utente;

~mod(log2(input('')),1)

Consente all'utente di immettere un valore e di 1 per true, 0 per false.

Testato in Octave, dovrebbe funzionare anche in Matlab.

R, 13 11

Basato sulla soluzione Perl. Restituisce FALSEo TRUE.

!log2(i)%%1

Il parametro irappresenta la variabile di input.

Una versione alternativa con input dell'utente:

!log2(scan())%%1

GolfScript, 5

Emette 1 per vero, 0 per falso. Basato sull'idea di user3142747:

~.(&!

Nota: (è un decremento, si spera non contenga come -:)
Se lo fa (e i commenti del PO suggeriscono che potrebbe), si prega di fare riferimento invece alla soluzione di Ilmari Karonen .
Per l'output Y / N, aggiungere 'NY'1/=alla fine (altri 7 byte).

Python, 31

print 3>bin(input()).rfind('1')

C, 48

main(x){scanf("%i",&x);puts(x&~(x*~0)?"F":"T");}

Ho deciso di utilizzare un altro approccio, basato sul conteggio della popolazione o sulla somma laterale del numero (il numero di 1 bit). L'idea è che tutti i poteri di due hanno esattamente un 1bit, e nessun altro numero lo ha. Ho aggiunto una versione JavaScript perché l'ho trovata divertente, anche se sicuramente non vincerà alcuna competizione di golf.

J, 14 15 caratteri (uscite 0 o 1)

1=##~#:".1!:1]1

JavaScript, 76 caratteri (output vero o falso)

alert((~~prompt()).toString(2).split("").map(Number).filter(Boolean).length)

Clip , 9 8 7

!%lnxWO

Legge un numero dallo stdin.

Spiegazione:

Per cominciare, Z= 0, W= 2e O= 1. Ciò consente di collocare We Ouno accanto all'altro, mentre l'uso 2e 1verrebbe interpretato come il numero 21 senza uno spazio di separazione (un carattere aggiuntivo indesiderato). In Clip, la funzione modulo ( %) funziona su numeri non interi, quindi, per capire se un valore vè un numero intero, controlli se vmod 1 = 0. Usando la sintassi Clip, questo è scritto come =0%v1. Tuttavia, poiché i booleani vengono archiviati come 1(o qualsiasi altra cosa) e 0, controllare se qualcosa è uguale non 0significa semplicemente "non farlo". Per questo, Clip ha l' !operatore. Nel mio codice, vè lnx2. xè un input di stdin,nconverte una stringa in un numero ed labè la base bdi log di a. Il programma pertanto si traduce (più facilmente) in 0 = ((log base 2 of parseInt(readLine)) mod 1).

Esempi:

8

uscite

1

e

10

uscite

0

Modifica 1: sostituito 0, 1e 2con Z, Oe W.

Modifica 2: sostituito =Zcon !.

Anche:

Pyth , 5

Comprime ulteriormente la versione Clip, poiché Pyth ha Q per l'input già valutato e una funzione log2 (a) anziché solo log generale (a, b).

!%lQ1

Javascript (37)

a=prompt();while(a>1)a/=2;alert(a==1)

Script semplice che si divide semplicemente per 2 ripetutamente e controlla il resto.

Mathematica (21)

IntegerQ@Log2@Input[]

Senza input è un po 'più breve

IntegerQ@Log2[8]

Vero

IntegerQ@Log2[7]

falso

JavaScript, 41 40 caratteri

l=Math.log;alert(l(prompt())/l(2)%1==0);

Come funziona: prendi il logaritmo in base 2 usando l(prompt()) / l(2) , e se quel risultato modulo 1 è uguale a zero, allora è una potenza di 2.

Ad esempio: dopo aver preso il logaritmo di 8 su base 2, ottieni 3.3 modulo 1è uguale a 0, quindi questo restituisce vero.

Dopo aver preso il logaritmo di 7 sulla base 2, ottieni 2.807354922057604. 2.807354922057604 modulo 1è uguale a 0.807354922057604, quindi questo restituisce false.

JavaScript, 35

Funziona per i byte.

alert((+prompt()).toString(2)%9==1)

Versione a 46 caratteri , funziona per numeri a 16 bit.

x=(+prompt()).toString(2)%99;alert(x==1|x==10)

Il trucco funziona nelle lingue più dinamiche.

Spiegazione: Convertire il numero in base 2, interpretare quella stringa come base 10, fare modulo 9 per ottenere la somma delle cifre, che deve essere 1.

Perl 5.10+, 13 + 1 = 14 caratteri

say!($_&$_/3)

Utilizza lo stesso metodo di un vecchio filo FWP come la mia entrata GolfScript . stampe1 se l'ingresso ha una potenza di due e una riga vuota in caso contrario.

Deve essere gestito con perl -nE; la n costa un carattere in più , per un totale di 14 caratteri. In alternativa, ecco una versione di 18 caratteri che non richiede n:

say!(($_=<>)&$_/3)

python 3, 38

print(1==bin(int(input())).count('1'))

pitone, 32

Tuttavia, il codice non funziona in tutte le versioni.

print 1==bin(input()).count('1')

Si noti che la soluzione funziona anche per 0 (stampa Falso).

Rubino - 17 personaggi (quarto tentativo)

p /.1/!~'%b'%gets

Il mio attuale migliore è una fusione della risposta di @ steenslag con la mia. Di seguito sono riportati i miei precedenti tentativi.

Ruby - 19 personaggi (terzo tentativo)

p /10*1/!~'%b'%gets

Rubino - 22 caratteri (secondo tentativo)

p !('%b'%gets)[/10*1/]

Ruby - 24 caratteri (primo tentativo)

p !!('%b'%gets=~/^10*$/)

K / Kona ( 24 17)

d:{(+/(2_vs x))~1

Restituisce 1 se vero e 0 se falso. Qualsiasi potenza di 2 ha un singolo bit uguale a 1:

2_vs'_(2^'(!10))
(,1
1 0
1 0 0
1 0 0 0
1 0 0 0 0
1 0 0 0 0 0
1 0 0 0 0 0 0
1 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0)

(questo stampa tutti i poteri di 2 (da 0 a 9) in binario)

Quindi riassumo tutti i componenti dell'espressione binaria di xe vedo se è uguale a 1; se sì allora x=2^n, altrimenti no .

... sapevo che avrei potuto ridurlo

C # (54 caratteri)

 Math.Log(int.Parse(Console.ReadLine()),2)%1==0?"Y":"N"

Rebmu (9 caratteri)

z?MOl2A 1

Test

>> rebmu/args [z?MOl2A 1] 7
== false

>> rebmu/args [z?MOl2A 1] 8 
== true

>> rebmu/args [z?MOl2A 1] 9 
== false

Rebmu è un dialetto ristretto di Rebol. Il codice è essenzialmente:

z? mo l2 a 1  ; zero? mod log-2 input 1

Alternativa

14 caratteri: Rebmu non ha un bit a bit e AND ~

z?AND~aTIddA 3

In Rebol:

zero? a & to-integer a / 3

GTB , 46 byte

2→P`N[@N=Pg;1P^2→P@P>1E90g;2]l;2~"NO"&l;1"YES"

Python, 35

print bin(input()).strip('0')=='b1'

Non utilizza non solo le operazioni +/-, ma qualsiasi operazione matematica oltre alla conversione in forma binaria.

Altre cose (interessanti, ma non per la concorrenza):

Ho anche una versione di regexp (61) :

import re;print re.match(r'^0b10+$',bin(input())) is not None

(Adoro l'idea, ma la funzione di importazione e abbinamento la rende troppo lunga)

E bella, ma noiosa versione operazioni bit per bit (31) :

x=input();print x and not x&~-x

(sì, è più breve, ma usa ~ -x per il decremento che comporta - operazione)

Python 2.7 ( 30 29 39 37)

EDIT: aggiornato a causa dei requisiti di input dell'utente;

a=input()
while a>1:a/=2.
print a==1

Forza bruta, prova a dividere fino a = 1 (successo) o <1 (fallimento)

Python (33)

print int(bin(input())[3:]or 0)<1

Ruby, 33 , 28 , 25

p /.1/!~gets.to_i.to_s(2)

APL (12 per 0/1, 27 per sì / no)

≠/A=2*0,ιA←⍞ 

oppure, se dobbiamo produrre testo:

3↑(3x≠/A=2*0,ιA←⍞)↓'YESNO '

Leggi in A. Forma un vettore 0..A, quindi un vettore 2 ⁰ ..2 ^A (sì, è molto più del necessario), quindi un vettore che confronta A con ognuno di questi (risultante in un vettore di 0 e al massimo uno 1), quindi xo quello (non c'è un operatore xor in APL, ma ≠ applicato ai booleani agirà come uno.) Ora abbiamo 0 o 1.

Per ottenere SÌ o NO: moltiplicare 0 o 1 per 3, eliminare questo numero di caratteri da "YESNO", quindi prendere i primi 3 caratteri di questo.

C, 65 byte

main(k){scanf("%i",&k);while(k&&!(k%2))k/=2;puts(k==1?"T":"F");}

Haskell ( 52 50)

k n=elem n$map(2^)[1..n]
main=interact$show.k.read