Bir sayının 2 olup olmadığını belirlemenin akıllı yolları var . Bu artık ilginç bir problem değil, o zaman verilen bir tamsayı -2 olan bir tamsayı olup olmadığını belirleyelim . Örneğin:

-2 => yes: (-2)¹
-1 => no
0 => no
1 => yes: (-2)⁰
2 => no
3 => no
4 => yes: (-2)²

kurallar

• Bir program veya fonksiyon yazabilir ve giriş alma ve çıkış sağlama standart yöntemlerinden herhangi birini kullanabilirsiniz .

• Girişiniz tek bir tamsayıdır ve tamsayı -2 tamsayı kuvveti ise çıktının bir aldatma değeri, aksi takdirde sahte bir değer olması gerekir. Başka bir çıkışa (örn. Uyarı mesajları) izin verilmez.

• Her zamanki tamsayı taşması kuralları geçerlidir: çözümünüz, tüm tam sayıların varsayılan olarak sınırsız olduğu, ancak programınız uygulama nedeniyle uygulamada başarısız olursa, dilinizin varsayımsal (veya belki de gerçek) bir sürümünde rasgele büyük tam sayılarda çalışabilmelidir. Bu kadar büyük tamsayıları desteklememek, çözümü geçersiz kılmak değildir.

• Herhangi bir programlama dilini kullanabilirsiniz , ancak bu boşlukların varsayılan olarak yasak olduğunu unutmayın .

Kazanma koşulu

Bu bir kod golf yarışması: En az bayt olan cevap (seçtiğiniz kodlamada) kazanır.

Mathematica, 22 bayt

EvenQ@Log2@Max[#,-2#]&

Çevrimiçi deneyin! (Bunun yerine, çözümün de çalıştığı yerde Matematik kullanarak).

Bir süre bitsel operatörlerle bir çözüm bulmaya çalıştım ve kesinlikle var olsa da, muhtemelen daha basit bir şey buldum:

• Max[#,-2#]negatifse girişi -2 ile çarpar . Bir başka faktör ile çarpmak -2 değer bir elektrik olup olmadığı değişmez -2 ya da değil. Ama şimdi hepsi tek güçler -2 bile güçler haline getirilmiştir -2 .
• Ama güçlerinin -2 bile yetkileri de vardır 2'ye biz basit kullanabilmesi, Log2@...(o bir güç var olup olmadığını kontrol etmek ve sonuç bir tamsayı olup olmadığını kontrol 2 ). Bu zaten iki baytı kurtarır Log[4,...]( -2'ye eşit güçlere bakmak için başka bir yol ).
• Ek bir bonus olarak, bir değerin bir tamsayı olup olmadığını kontrol etmek sadece bir tamsayı olup olmadığını kontrol etmekten daha kısadır: EvenQyerine üç bayttan tasarruf sağlayabiliriz IntegerQ.

Jöle , 5 bayt

æḟ-2=

Çevrimiçi deneyin!

Nasıl çalışır

æḟ-2=  Main link. Argument: n

æḟ-2   Round n towards 0 to the nearest power of -2.
    =  Test if the result is equal to n.

Python , 46 bayt

@Ovs sayesinde -2 bayt.

def g(x):
 while x%-2==0!=x:x/=-2
 return x==1

Kullanım fonksiyonu:

g(4) # put your number between the brackets

Çevrimiçi deneyin!

Jöle , 6 bayt

b-2S⁼1

Çevrimiçi deneyin!

Bu jöle bir tamsayıyı nasıl dönüştüreceğini dayanmaktadır N rasgele bir baz ile B dönüştürerek bu sayede, N , her tam sayı bir rakam olduğu, bir dizi için d (arasında K ) _B , bir değer 0≤ olabilir, V _d < B . Burada, her rakam ekler sağdan, yani 0-göstergesi basamak olacaktır V _d B ^d oluşturmak üzere N . V _d < B ⇔ V _D B ^d < BB ^d = B ^{d + 1} , bu nedenle, mümkün olan her türlü( N ) _B'deki baştaki 0'ları yok sayarsak N'nin tek bir temsili vardır .

Burada, d = giriş, B = -2. N = B ^d = 1 B ^d = V _d B ^d ⇔1 = V _d ⇔ V _d = 1 ve biz yetkileri başka katları katamazsın beri B , her V , Şu anda 0. olurdu dizi, d 0s ile birleştirilmiş 1 olmalıdır . Jelly 1 soldan indekslediğinden, dizinin ilk elemanının 1 ve diğer tüm elemanların 0 olup olmadığını kontrol etmeliyiz.

Hmm ... hepsi iyi, değil mi? Hayır? Neler oluyor? Evet, daha iyi bir fikrim var! Öncelikle, dizideki tüm tam sayıların toplamını alalım, onu tamsayı dizisiymiş gibi görelim, üs-2'deki bir sayı değil. 1 ise, sadece bir 1 olduğu ve tüm diğer tamsayıların 0 olduğu anlamına gelir. Çünkü, 0 _-2 durumu dışında baştaki sıfır olamaz.(toplamın yine de 0 any olduğu yerlerde), birinci tamsayı sıfır olmamalıdır. Dizideki yalnızca sıfır olmayan tam sayı 1, bu nedenle ilk olmalıdır. Bu nedenle, dizideki tüm tam sayıların toplamının 1 olabileceği tek durum budur, çünkü bir çift pozitif tamsayının en küçük toplamı is {1,1} = 2'dir, çünkü en küçük pozitif tam sayı 1'dir. Temel gösterimdeki her tamsayı negatif değildir, bu nedenle toplamın 1 olması için tek yol yalnızca bir tane olmaktır ve diğer tüm tamsayılar 0'dır. Bu nedenle, sadece tüm tamsayıların toplamının toplam olup olmadığını kontrol edebiliriz. dizi 1.

İşte kod ne yapar:

b-2S⁼1 Main link. Arguments: d
b-2    Convert d to base -2.
   S   Take the sum.
    ⁼1 Check if the sum is equal to 1.

Python 2 , 35 34 32 bayt

f=lambda n:n==1or n!=n%2<f(n/-2)

Çevrimiçi deneyin!

Python 2 , 98 50 bayt

lambda x:x*(x&-x==abs(x))*((x<0)^x.bit_length()&1)

Çevrimiçi deneyin!

Excel, 40 36 bayt

^{CallumDA tarafından 4 byte kurtarıldı}

Excel kesinlikle yapabilir, ancak hataları düzeltmek 11 bayt ekler

=IFERROR(-2^IMREAL(IMLOG2(A1)),1)=A1

Giriş hücrede A1. Çıktı TRUEveyaFALSE

Bunun karşılığında ya izin verildi ise FALSEveya #NUM!yanlış değerler için hata, sadece 25 byte olacaktır:

=-2^IMREAL(IMLOG2(A1))=A1

05AB1E , 8 bayt

Y(IÄÝm¹å

Çevrimiçi deneyin! veya Test paketi olarak

açıklama

Y(         # push -2
  IÄÝ      # push range [0 ... abs(input)]
     m     # element-wise power
      ¹å   # check if input is in the resulting list

JavaScript (ES6), 37 28 24 bayt

f=x=>!x|x%2?x==1:f(x/-2)

Arnauld sayesinde 4 byte kurtarıldı.

f=x=>!x|x%2?x==1:f(x/-2)

console.log(f(-2));
console.log(f(-1));
console.log(f(0));
console.log(f(1));
console.log(f(2));
console.log(f(3));
console.log(f(4));

C (gcc) , 34 29 bayt

f(n){n=n%2?n==1:f(n?n/-2:2);}

Çevrimiçi deneyin!

MATL , 9 8 bayt

2_y|:q^m

Çevrimiçi deneyin!Veya tüm test durumlarını doğrulayın .

Nasıl çalışır

-8Bir örnek olarak girişi düşünün

2_    % Push -2
      % STACK: -2
y     % Implicit input. Duplicate from below
      % STACK: -8, -2, -8
|     % Absolute value
      % STACK: -8, -2, 8
:     % Range
      % STACK: -8, -2, [1 2 3 4 5 6 7 8]
q     % Subtract 1, element-wise
      % STACK: -8, -2, [0 1 2 3 4 5 6 7]
^     % Power, element-wise
      % STACK: -8, [1 -2 4 -8 16 -32 64 -128]
m     % Ismember. Implicit display
      % STACK: 1

Octave , 28 bayt

@(n)any((-2).^(0:abs(n))==n)

Bu isimsiz bir işlevi tanımlar. Yaklaşım MATL cevabımda buna benzer.

Çevrimiçi deneyin!

PHP, 41 Bayt

for(;$argn%-2==0;)$argn/=-2;echo$argn==1;

PHP, 52 Bayt

echo($l=log(abs($argn),2))==($i=$l^0)&&$argn>0^$i%2;

PHP, 64 Bayt

Regex ile Çalışma

echo preg_match("#^".($argn>0?1:"1+0")."(00)*$#",decbin($argn));

Python 3, 34 bayt

lambda n:n==(-2)**~-n.bit_length()

JavaScript (ES6), 21 bayt

0Veya döndüren özyinelemeli bir işlev true.

f=n=>n==1||n&&f(n/-2)

Nasıl çalışır

Bu , girişin -2 tam bir gücü olmadığında , yinelemeyi erken durdurmak için herhangi bir açık testi ( ntek veya abs(n)daha az olmak gibi) içermez .

Sadece nya 1da tam olarak eşit olduğunda çıkıyoruz 0.

Ancak bu işe yarar, çünkü herhangi bir IEEE-754 şamandırası 0, aritmetik akış nedeniyle, sonunda 2 (veya -2) yeterli zamana bölündüğünde yuvarlanır .

Test durumları

f=n=>n==1||n&&f(n/-2)

console.log(f(-2));
console.log(f(-1));
console.log(f(0));
console.log(f(1));
console.log(f(2));
console.log(f(3));
console.log(f(4));

C (gcc) , 33 bayt

f(n){return n%2?n==1:n&&f(n/-2);}

Çevrimiçi deneyin!

Java 7, 55 bayt

boolean c(int n){return n==0?0>1:n%-2==0?c(n/-2):n==1;}

Açıklama:

boolean c(int n){  // Method with integer parameter and boolean return-type
  return n==0 ?    //  If n is zero:
    0>1//false     //   Return false
   : n%-2==0 ?     //  Else-if n mod -2 is zero:
    c(n/-2)        //   Recursive call for the input divided by -2
   :               //  Else:
    n==1;          //   Return if n is one
}                  // End of method

Test kodu:

Burada dene.

class M{
  static boolean c(int n){return n==0?0>1:n%-2==0?c(n/-2):n==1;}

  public static void main(String[] a){
    for(int i = -2; i <= 4; i++){
      System.out.println(i + ": " + c(i));
    }
  }
}

Çıktı:

-2: true
-1: false
0: false
1: true
2: false
3: false
4: true

Haskell, 24 23 bayt

f 0=0
f 1=1
f n=f(-n/2)

-2 ve başkaları için fdöndürülen bir işlevi tanımlar .10

Diğer mücadeleye ilk gönderimimin golf versiyonu .

Javascript (ES7), 45 bayt

x=>-1**Math.log2(Math.abs(x))*Math.abs(x)==x

Perl 6 , 21 bayt

{$_==(-2)**(.lsb//0)}

Dene

Expanded:

{  # bare block lambda with implicit parameter ｢$_｣

  $_                  # is the input
  ==                  # equal to
  (-2)**( .lsb // 0 ) # -2 to the power of the least significant bit of the input
}

Numara olarak kullanıldığında hangi uyarı veren 0.lsbdöner Nil, yani tanımlanmış veya işleç  //kullanılır.
( Farklı bir eğimli //gibi düşünün ||)

Bir terimin beklendiği durumlarda savunucusuz bir yöntem çağrısı dolaylı olarak çağrılır $_. ( .lsb)

İle de çalışır.msb .

Prolog (SWI) , 44 bayt

p(X):-X=1;X\=0,X mod 2=:=0,Z is X/(-2),p(Z).

Çevrimiçi tercüman

Python , 24 bayt

lambda n:n*n&n*n-1<n%3%2

Çevrimiçi deneyin!

Bit numarası , 2 (veya ) gücünün k&k-1==0olup olmadığını kontrol eder . Bu denetleme olarak mı söyler 2'nin bir güçtür.kk==0k=n*nn*n&n*n-1==0abs(n)

-2'lik nbir güç olup olmadığını görmek için , sadece bunu kontrol etmemiz gerekir n%3==1. Bu çalışır çünkü mod 3, -2 değeri 1'e eşittir, bu nedenle güçleri 1'dir. Buna karşın, olumsuzlukları 2 mod 3'tür ve elbette 0, 0 mod 3 verir.

Çeklerin birleştirmek n*n&n*n-1==0ve n%3==1tek bir ifadeye. İlki , asla olumsuz olmadığı <1için yazılabilir ==0. n%3==1Eşdeğerdir n%3%20 veya 1 Yani, biz bunları birleştirebilirsiniz vererek n*n&n*n-1<n%3%2.

R, 22 bayt

Stdin'den girdi alır, döner TRUEveya FALSEbuna göre.

scan()%in%(-2)^(0:1e4)

Bunun geçerli bir cevap olduğundan% 100 emin değilim, çünkü yalnızca R'nin boyut sınırına kadar olan tam sayılar için çalışıyor ve tam sayılar sınırlanmamışsa işe yaramaz. Bununla birlikte, kurallar şöyledir:

Her zamanki tamsayı taşması kuralları geçerlidir: çözümünüz, tüm tam sayıların varsayılan olarak sınırsız olduğu, ancak programınız uygulama nedeniyle uygulamada başarısız olursa, dilinizin varsayımsal (veya belki de gerçek) bir sürümünde rasgele büyük tam sayılarda çalışabilmelidir. Bu kadar büyük tamsayıları desteklememek, çözümü geçersiz kılmak değildir.

R varsayımsal versiyonunda yok sınırsız tamsayılar, o zaman aynı bayt sayım için aşağıdaki kodu kullanabilirsiniz izin:

scan()%in%(-2)^(0:Inf)

Tabii ki, gerçek R, yukarıdaki kod sadece verir Error in 0:Inf : result would be too long a vector.

bc 88 bayt

bc -l <<< "n=$1;q=l(sqrt(n*n));p=4*a(1);((n<1)*c(q/l(2)*p/2)+(n>1)*(s(q/l(4)*p)))^2==0"

Bu bir dosyada var neg2.shve 1güçleri için basar -2ve 0başka türlü

Çok uzun zamandır biliyorum ama eğlenceliydi.

Ölçek

$ for i in {-129..257}; do echo -n "$i: "; ./neg2.sh $i; done | grep ': 1'
-128: 1
-32: 1
-8: 1
-2: 1
1: 1
4: 1
16: 1
64: 1
256: 1

açıklama

Ana gövdenin iki yarısı vardır, her ikisi de güçleri için sıfıra eşit olmaya çalışıyor -2.

q=l(sqrt(n*n))               % ln of the absolute value of the input
p=4*a(1)                     % pi: arctan(1) == pi/4
q/l(2) -> l(sqrt(n*n))/l(2)  % change of base formula -- this gives
                             % the power to which 2 is raised to equal
                             % sqrt(n*n). It will be an integer for 
                             % numbers of interest
n<1                          % 1 if true, 0 if false. for negative
                             % numbers check for powers of 2
n>1                          % for positive numbers, check for powers
                             % of 4
c(q/l(2)*p/2)                % cos(n*pi/2) == 0 for integer n (2^n)
s(q/l(4)*p)                  % sin(n*pi) == 0 for integer n (4^n)
(....)^2==0                  % square the result because numbers are
                             % not exactly zero and compare to 0

Julia 0.5 , 20 bayt

!n=n∈(-2).^(0:n^2)

Çevrimiçi deneyin!

Fourier , 53 bayt

I~X1~N~G0(0-2*G~GX*X~PG*G>P{1}{0~O~N}G{X}{1~O0~N}N)Oo

Bunu daha sonra golf oynamaya çalışacağım, ancak bunun ana hatları:

X = User input
G = N = 1
Loop until N = 0
    G = -2 * G
    P = X*X 
    If G*G > P then
        N = O = 0
    End if
    If G = X then
        O = 1
        N = 0
    End if
End loop
Print O

Nerede çıkışı 0için Falsey ve 1için truthy .

Çevrimiçi deneyin!

Casio BASIC , 76 bayt

Hesap makinemde 76 bayt olduğunu söylüyor.

?→X
0→O
While Abs(X)≥1
X÷-2→X
If X=1
Then 1→O
IfEnd
WhileEnd
O

Bu benim Casio BASIC'e ilk girişim ... Bir hesap makinesine bu kadar iyi programlar yazabileceğimin farkında değildim: D

Python 2.7, 40 bayt

a=input()
while a%-2==0:a/=-2
print a==1

Bay Xcoder'a 43 byte uzunluğundaki orijinal kod için kredi verir . Yorum yapacak kadar itibarım yok çünkü ayrı bir cevap olarak göndermek zorunda kaldım.

Retina , 27 bayt

+`(1+)\1
$1_
^(1|-1_)(__)*$

Çevrimiçi deneyin!

Retina için oldukça standart olan unary de girdi. İlk iki satır, Öğretici girişten gelen ilk iki kod satırına dayanarak (herhangi bir yabancı 1s, eşleşmenin yine de başarısız olmasına neden olur) ilk iki kod satırını temel alarak ikili dönüşüm için kısmi olarak tek parça yapar. iki.

+`(1+)\1\1\1
$1_
^(-1)?1_*$

Çevrimiçi deneyin!

Bu sefer dört dönüşümü temel almak için kısmi birim. Dörtlü ^1_*$güçler, iki kişilik olumsuz tekli güçler gibi bitiyor ^-11_*$.

+`\b(1111)*$
$#1$*
^(-1)?1$

Çevrimiçi deneyin!

Sadece yapabilirim ve kontrol olduğunca dörde bölünerek tutmak Bu kez 1veya -11sonunda.

+`\b(1+)\1\1\1$
$1
^(-1)?1$

Çevrimiçi deneyin!

Dörde bölünmenin başka bir yolu. Ve hala sinir bozucu 27 byte ...

Şema, 60 bayt

(define(f n)(cond((= 1 n)#t)((<(abs n)1)#f)(#t(f(/ n -2)))))

Özyinelemeli çözüm.