Son röportajımda aldığım bir soru:
Bir işlev tasarlayın
f, öyle ki:f(f(n)) == -n
n32 bit işaretli tam sayı nerede ; karmaşık sayılar aritmetiği kullanamazsınız.Böyle bir işlevi tüm sayı aralığı için tasarlayamıyorsanız, mümkün olan en geniş aralık için tasarlayın.
Herhangi bir fikir?
Yanıtlar:
Nasıl olur:
f (n) = işaret (n) - (-1) n * n
Python'da:
def f(n):
if n == 0: return 0
if n >= 0:
if n % 2 == 1:
return n + 1
else:
return -1 * (n - 1)
else:
if n % 2 == 1:
return n - 1
else:
return -1 * (n + 1)
Python tamsayıları otomatik olarak rastgele uzunluk uzunluğuna yükseltir. Diğer dillerde, en büyük pozitif tamsayı taşacak, bu yüzden bunun dışındaki tüm tamsayılar için çalışacaktır.
Gerçek sayılar için çalışmasını sağlamak için size değiştirmeniz gerekiyor n içinde (-1) n ile { ceiling(n) if n>0; floor(n) if n<0 }.
C # 'da (taşma durumları hariç herhangi bir çift için çalışır):
static double F(double n)
{
if (n == 0) return 0;
if (n < 0)
return ((long)Math.Ceiling(n) % 2 == 0) ? (n + 1) : (-1 * (n - 1));
else
return ((long)Math.Floor(n) % 2 == 0) ? (n - 1) : (-1 * (n + 1));
}Ne tür bir dil beklediklerini söylemediniz ... İşte statik bir çözüm (Haskell). Temel olarak en önemli 2 bitle uğraşıyor:
f :: Int -> Int
f x | (testBit x 30 /= testBit x 31) = negate $ complementBit x 30
| otherwise = complementBit x 30Dinamik bir dilde (Python) çok daha kolay. Argümanın X numarası olup olmadığını kontrol edin ve -X döndüren bir lambda döndürün:
def f(x):
if isinstance(x,int):
return (lambda: -x)
else:
return x()class C a b | a->b where { f :: a->b }:; instance C Int (()->Int) where { f=const.negate }; instance C (()->Int) Int where { f=($()) }.
Ek bilgi kullanmıyorsa (32 bit int hariç), böyle bir işlevin neden tüm sayılar için var olamayacağının bir kanıtı:
F (0) = 0. olmalıdır. (İspat: diyelim ki f (0) = x. Sonra f (x) = f (f (0)) = -0 = 0. Şimdi, -x = f (f (x )) = f (0) = x, yani x = 0 anlamına gelir.)
Ayrıca, herhangi biri için xve yvarsayalım f(x) = y. O zaman istiyoruz f(y) = -x. Ve f(f(y)) = -y => f(-x) = -y. Özetlemek gerekirse: if f(x) = y, then f(-x) = -y, ve f(y) = -x, ve f(-y) = x.
Bu nedenle, 0 dışındaki tüm tam sayıları 4'lü kümelere ayırmalıyız, ancak bu sayıda tam sayıya sahibiz; sadece bu değil, pozitif karşılığı olmayan tamsayıyı kaldırırsak, hala 2 (mod4) numaramız var.
Kalan 2 maksimum sayıyı (abs değeriyle) kaldırırsak, işlevi alabiliriz:
int sign(int n)
{
if(n>0)
return 1;
else
return -1;
}
int f(int n)
{
if(n==0) return 0;
switch(abs(n)%2)
{
case 1:
return sign(n)*(abs(n)+1);
case 0:
return -sign(n)*(abs(n)-1);
}
} Tabii ki başka bir seçenek, 0'a uymamak ve kaldırdığımız 2 sayıyı bonus olarak almaktır. (Ama bu sadece aptalca.)
n = -2147483648(minimum değer) sakının ; abs(n)bu durumda yapamazsınız ve sonuç tanımsız (veya bir istisna) olacaktır.
C ++ 'da aşırı yükleme sayesinde:
double f(int var)
{
return double(var);
}
int f(double var)
{
return -int(var);
}
int main(){
int n(42);
std::cout<<f(f(n));
}Veya önişlemciyi kötüye kullanabilirsiniz:
#define f(n) (f##n)
#define ff(n) -n
int main()
{
int n = -42;
cout << "f(f(" << n << ")) = " << f(f(n)) << endl;
}Bu, tüm negatif sayılar için geçerlidir.
f (n) = abs (n)
İki tamamlayıcı tamsayı için pozitif sayılardan bir tane daha negatif sayı olduğu için , aynı ile aynı çözümden f(n) = abs(n)bir tane daha durum için geçerlidir . Birini yakaladım ...: Df(n) = n > 0 ? -n : nf(n) = -abs(n)
GÜNCELLEME
Hayır, sadece bir durum için geçerli değil çünkü az önce litb'nin yorumuyla tanıştım ... abs(Int.Min)sadece taşacak ...
Ben de mod 2 bilgilerini kullanmayı düşündüm, ama sonuçta, işe yaramadı ... erken. Doğru yapılırsa Int.Min, taşması dışında tüm sayılar için çalışır .
GÜNCELLEME
Bir süre onunla oynadım, güzel bir manipülasyon hilesi arıyorum, ancak mod 2 çözümü bir tanesine uyurken güzel bir tek astar bulamadım.
f (n) = 2n (abs (n)% 2) - n + sgn (n)
C # 'da bu şu olur:
public static Int32 f(Int32 n)
{
return 2 * n * (Math.Abs(n) % 2) - n + Math.Sign(n);
}
Tüm değerler için çalışan almak için, değiştirmek zorunda Math.Abs()olan (n > 0) ? +n : -nve bir in hesaplama dahil uncheckedblokta. Sonra Int.Minda kontrolsüz olumsuzlama gibi kendi kendine haritalanır.
GÜNCELLEME
Başka bir cevaptan esinlenerek işlevin nasıl çalıştığını ve böyle bir işlevi nasıl oluşturacağınızı açıklayacağım.
En baştan başlayalım. Fonksiyon f, nbir dizi değer veren belirli bir değere tekrar tekrar uygulanır .
n => f (n) => f (f (n)) => f (f (f (n))) => f (f (f (f (n))))) => ...
Soru , argümanın f(f(n)) = -nardışık iki olumsuz uygulamasıdır f. Diğer fdört uygulama - toplamda dört - tekrar ortaya çıkan argümanı yeniden reddetmektedir n.
n => f (n) => -n => f (f (f (n))) => n => f (n) => ...
Şimdi dört uzunluklu bariz bir döngü var. x = f(n)Elde edilen denklemin ikame edilmesi ve tutulması f(f(f(n))) = f(f(x)) = -x, aşağıdakileri verir.
n => x => -n => -x => n => ...
Böylece iki sayı ve dört sayı ile birlikte dört uzunluklu bir döngü elde ederiz. Döngüyü dikdörtgen olarak hayal ediyorsanız, reddedilen değerler karşıt köşelerde bulunur.
Böyle bir döngü oluşturmak için birçok çözümden biri, n'den başlayarak aşağıdakilerdir.
n => birini reddet ve çıkar -n - 1 = - (n + 1) => bir tane ekle -n => olumsuzlama ve bir tane ekleme n + 1 => birini çıkart n
Somut bir örnek böyle bir döngüdür +1 => -2 => -1 => +2 => +1. Neredeyse bitti. İnşa edilen döngünün tek bir pozitif sayı içerdiğini, hatta ardılı olduğunu ve her iki sayı da olumsuzladığını belirterek, tam sayıları bu tür döngülere kolayca bölebiliriz ( 2^32dördün katıdır) ve koşulları sağlayan bir işlev bulduk.
Ama sıfırla ilgili bir sorunumuz var. Döngü içermelidir 0 => x => 0çünkü sıfır kendi kendine reddedilir. Ve döngü halihazırda 0 => xbunu izlediği için 0 => x => 0 => x. Bu sadece iki uzunluklu bir döngüdür ve xiki uygulamadan sonra kendi içine dönüşür, içine dönüşmez -x. Neyse ki sorunu çözen bir vaka var. Eğer Xeşittir sıfır biz sadece sıfır içeren tek üyeli bir döngü elde etmek ve sıfır sabit nokta olduğunu biz bu sorun YAPILMASINA çözüldü f.
Bitti? Neredeyse. Biz 2^32sıfır bırakarak sabit bir nokta, sayıları 2^32 - 1sayı ve dört sayı döngü içine bu numarayı bölüm gerekmektedir. Kötü 2^32 - 1, dördün katı değildir - dört uzunluktaki herhangi bir döngüde olmayan üç sayı kalır.
Ben arasında değişen 3 bitlik imzalı itegers küçük kümesi kullanılarak çözeltinin geri kalan kısmını açıklayacağız -4için +3. Sıfırla işimiz bitti. Bir tam döngümüz var +1 => -2 => -1 => +2 => +1. Şimdi bize döngüsü başlayan inşa edelim +3.
+3 => -4 => -3 => +4 => +3
Ortaya çıkan sorun, +43 bit tam sayı olarak gösterilememesidir. Biz elde ediyorum +4olumsuzlaştırılmasıyla -3için +3hala geçerli 3 bitlik tamsayı nedir - - ama sonra bir eklenerek +3(ikili 011) verir 100ikili. İşaretsiz tam sayı olarak yorumlanır, +4ancak işaretli tam sayı olarak yorumlamamız gerekir -4. Yani aslında -4bu örnek için veya Int.MinValuegenel durumda tamsayı aritmetik olumsuzlamanın ikinci bir sabit noktasıdır - 0 ve Int.MinValuekendileriyle eşleştirilir. Yani döngü aslında aşağıdaki gibidir.
+3 => -4 => -3 => -4 => -3
Bu iki uzunluklu bir döngüdür ve ek +3olarak döngüye girer -4. Sonuç olarak -4, iki işlev uygulamasından sonra +3doğru şekilde eşlenir, -3iki işlev uygulamasından sonra doğru olarak eşlenir , ancak -3iki işlev uygulamasından sonra hatalı olarak eşlenir.
Bu yüzden biri hariç tüm tamsayılar için çalışan bir fonksiyon oluşturduk. Daha iyisini yapabilir miyiz? Hayır yapamayız. Neden? Dört uzunluktaki döngüleri inşa etmeliyiz ve dört değere kadar tam sayı aralığını kapsayabiliriz. Kalan değerler iki sabit noktadır 0ve Int.MinValuekendileri ve iki rastgele tamsayı xile eşlenmelidir ve -xbu iki işlev uygulaması tarafından birbirine eşlenmelidir.
Eşlemek için xiçin -xve ters bir dört devir oluşturmak içermesi ve bu döngü zıt köşelerinde yer almalıdır tam tersi. Sonuç olarak 0ve Int.MinValuede karşıt köşeleri olması gerekir. Bu , iki sabit noktayı ve iki işlev uygulamasından sonra doğru bir şekilde eşler xve -xdeğiştirir ve bizi iki hatalı girişle bırakır. Bu nedenle, tüm değerler için çalışan bir işlev oluşturmak mümkün değildir, ancak biri hariç tüm değerler için çalışan bir işlevimiz vardır ve bu elde edebileceğimiz en iyisidir.0Int.MinValue
Karmaşık sayıları kullanarak, bir sayıyı reddetme görevini etkili bir şekilde iki adıma bölebilirsiniz:
Harika bir şey, herhangi bir özel kullanım koduna ihtiyacınız olmamasıdır. Sadece i ile çarpmak işi yapar.
Ancak karmaşık sayılar kullanmanıza izin verilmez. Bu nedenle, veri aralığınızın bir bölümünü kullanarak bir şekilde kendi hayali ekseninizi oluşturmanız gerekir. Başlangıç değerleri kadar hayali (ara) değerlere ihtiyaç duyduğunuzdan, veri aralığının sadece yarısı kalır.
İmzalı 8 bit veri varsayarak bunu aşağıdaki şekilde görselleştirmeye çalıştım. Bunu 32 bit tamsayılar için ölçeklendirmeniz gerekir. İlk n için izin verilen aralık -64 ila +63'tür. İşte pozitif n için fonksiyonun yaptığı:
Negatif n için, fonksiyon -65 ..- 128 ara aralığını kullanır.
floatvs int). Birçok cevabın açıkladığı '4 element halkası', her biri 2 durumlu 2 boyut olarak gösterilebilen 4 durum gerektirir. Sorun bu cevap o ek işlem alanı gerektirir olmasıdır (-64..63 için sadece 'eserler', henüz ihtiyaçlar -128..127 boşluk) ve açıkça formüle yazılı açıkça belirtin yok!
İnt.MaxValue ve int.MinValue hariç çalışır
public static int f(int x)
{
if (x == 0) return 0;
if ((x % 2) != 0)
return x * -1 + (-1 *x) / (Math.Abs(x));
else
return x - x / (Math.Abs(x));
}
0etmek 0ve -2147483648karşı -2147483648, olumsuzluk operatör için bu iki sayının sabit beri noktaları x => -x. Diğer sayılar için yukarıdaki resimdeki okları takip edin. SurDin'in cevabından ve yorumlarından da anlaşılacağı gibi, bu durumda iki sayı olacak 2147483647ve -2147483647başka bir çiftin takası kalmayacak.
Soru giriş tipi ve işlevin dönüş değeri hakkında hiçbir şey söylemez folmak zorunda (en azından değil bunu takdim ettik yolu) ...
... sadece n 32 bitlik bir tam sayı olduğunda f(f(n)) = -n
Peki, böyle bir şeye ne dersin
Int64 f(Int64 n)
{
return(n > Int32.MaxValue ?
-(n - 4L * Int32.MaxValue):
n + 4L * Int32.MaxValue);
}
N 32 bitlik bir tamsayı ise f(f(n)) == -n, ifade true olur.
Açıkçası, bu yaklaşım daha da geniş bir sayı aralığında çalışmak üzere genişletilebilir ...
javascript (veya dinamik olarak yazılmış diğer diller) için, işlevin int veya nesneyi kabul etmesini ve diğerini döndürmesini sağlayabilirsiniz. yani
function f(n) {
if (n.passed) {
return -n.val;
} else {
return {val:n, passed:1};
}
}
vererek
js> f(f(10))
-10
js> f(f(-10))
10
alternatif olarak aşırı yazmayı güçlü yazılan bir dilde kullanabilirsiniz, ancak bu kurallara aykırı olabilir.
int f(long n) {
return n;
}
long f(int n) {
return -n;
}
Platformunuza bağlı olarak, bazı diller işlevde durumu korumanıza izin verir. VB.Net, örneğin:
Function f(ByVal n As Integer) As Integer
Static flag As Integer = -1
flag *= -1
Return n * flag
End Function
IIRC, C ++ buna da izin verdi. Yine de farklı bir çözüm aradıklarından şüpheleniyorum.
Başka bir fikir, işleve ilk çağrının sonucunu tanımlamadığı için, işareti ters çevirip çevirmeyeceğinizi kontrol etmek için tek / eşitliği kullanabileceğinizdir:
int f(int n)
{
int sign = n>=0?1:-1;
if (abs(n)%2 == 0)
return ((abs(n)+1)*sign * -1;
else
return (abs(n)-1)*sign;
}
Tüm çift sayıların büyüklüğüne bir tane ekleyin, tüm tek sayıların büyüklüğünden birini çıkarın. İki çağrının sonucu aynı büyüklüğe sahiptir, ancak işareti takas ettiğimiz tek çağrı. Bunun işe yaramayacağı bazı durumlar vardır (-1, maks veya min int), ancak şimdiye kadar önerilenlerden daha iyi çalışıyor.
JavaScript istisnalarını kullanma.
function f(n) {
try {
return n();
}
catch(e) {
return function() { return -n; };
}
}
f(f(0)) => 0
f(f(1)) => -1
Tüm 32 bit değerler için (-0, -2147483648 olan uyarı ile)
int rotate(int x)
{
static const int split = INT_MAX / 2 + 1;
static const int negativeSplit = INT_MIN / 2 + 1;
if (x == INT_MAX)
return INT_MIN;
if (x == INT_MIN)
return x + 1;
if (x >= split)
return x + 1 - INT_MIN;
if (x >= 0)
return INT_MAX - x;
if (x >= negativeSplit)
return INT_MIN - x + 1;
return split -(negativeSplit - x);
}
Temel olarak her -x => x => -x döngüsünü ay => -y => y döngüsüyle eşleştirmeniz gerekir. Ben de onun karşıt taraflarını eşleştirdim split.
4 bitlik tamsayılar için:
0 => 7 => -8 => -7 => 0
1 => 6 => -1 => -6 => 1
2 => 5 => -2 => -5 => 2
3 => 4 => -3 => -4 => 3
Muhtemelen kuralları bir şekilde büken ancak tüm sayısal tipler (şamandıralar, ints, çiftler) ve hatta tekli eksi aşırı yüklenen sınıf tipleri için çalışan bir C ++ sürümü:
template <class T>
struct f_result
{
T value;
};
template <class T>
f_result <T> f (T n)
{
f_result <T> result = {n};
return result;
}
template <class T>
T f (f_result <T> n)
{
return -n.value;
}
void main (void)
{
int n = 45;
cout << "f(f(" << n << ")) = " << f(f(n)) << endl;
float p = 3.14f;
cout << "f(f(" << p << ")) = " << f(f(p)) << endl;
}
x86 asm (AT&T stili):
; input %edi
; output %eax
; clobbered regs: %ecx, %edx
f:
testl %edi, %edi
je .zero
movl %edi, %eax
movl $1, %ecx
movl %edi, %edx
andl $1, %eax
addl %eax, %eax
subl %eax, %ecx
xorl %eax, %eax
testl %edi, %edi
setg %al
shrl $31, %edx
subl %edx, %eax
imull %ecx, %eax
subl %eax, %edi
movl %edi, %eax
imull %ecx, %eax
.zero:
xorl %eax, %eax
ret
Kod kontrol edildi, tüm olası 32 bit tamsayılar geçti, -2147483647 (düşük akış) hatası.
Globalleri kullanıyor ... ama öyle mi?
bool done = false
f(int n)
{
int out = n;
if(!done)
{
out = n * -1;
done = true;
}
return out;
}
Bu Perl çözümü tamsayılar, kayan noktalar ve dizgiler için çalışır .
sub f {
my $n = shift;
return ref($n) ? -$$n : \$n;
}
Bazı test verilerini deneyin.
print $_, ' ', f(f($_)), "\n" for -2, 0, 1, 1.1, -3.3, 'foo' '-bar';
Çıktı:
-2 2
0 0
1 -1
1.1 -1.1
-3.3 3.3
foo -foo
-bar +bar
n, 548'in "First_Time_548" haline gelebilmesi için bir dize olsaydı ve bir sonraki işlevde çalıştığında ... if (prefix == First_Time_ ")" First_Time_ "yerine" - "yazın
Ben aslında sorunun kendisi için bir çözüm vermeye çalışmıyorum, ama birkaç yorum var, soru bu sorunun ortaya atıldığı gibi (iş?) Röportajın bir parçası olduğunu belirtti:
int.MinValueiçin int.MaxValue, ve her biri için nbu aralık çağrısında f(f(n))ve sonucu kontrol ediyor -nSonra böyle bir işleve ulaşmak için Test Driven Development kullanırsınız söylüyorum).Oh, bu cevap röportaj bir C # programlama ile ilgili pozisyon için olduğunu varsayar. Röportaj matematikle ilgili bir pozisyon için olsa elbette aptalca bir cevap olurdu. ;-)
En önemli 2 biti değiştirirdim.
00.... => 01.... => 10.....
01.... => 10.... => 11.....
10.... => 11.... => 00.....
11.... => 00.... => 01.....
Gördüğünüz gibi, taşınan biti dışarıda bırakarak sadece bir ek.
Cevabı nasıl buldum? İlk düşüncem sadece simetriye ihtiyaç duyuyordu. Başladığım yere geri dönmek için 4 dönüş. İlk başta, bu 2bits Gray kod düşündüm. Sonra standart ikili yeterli olduğunu düşündüm.
Burada, karmaşık sayıların bu sorunu çözmek için kullanılamayacağı gereksiniminden veya iddiadan esinlenen bir çözüm.
-1'in kare kökü ile çarpmak, -1'in tamsayıların üzerinde bir kare kökü olmadığı için başarısız gibi görünen bir fikirdir. Ancak mathematica gibi bir programla oynamak, örneğin
(1849436465 2 + 1) mod (2 32 -3) = 0.
ve bu neredeyse -1 kareköküne sahip olmak kadar iyidir. İşlevin sonucunun işaretli bir tam sayı olması gerekir. Bu nedenle, 0'a en yakın olan x modulo n'ye y tamsayısını döndüren değiştirilmiş bir modulo işlemi mods (x, n) kullanacağım. Sadece çok az sayıda programlama dilinde bir modulo işlemi var, ancak kolayca tanımlanabilir . Örneğin, pitonda:
def mods(x, n):
y = x % n
if y > n/2: y-= n
return y
Yukarıdaki denklemi kullanarak, problem artık şu şekilde çözülebilir:
def f(x):
return mods(x*1849436465, 2**32-3)
Bu f(f(x)) = -x, aralıktaki tüm tamsayıları karşılar . Sonuçları da bu aralıktadır, ancak elbette hesaplamanın 64 bit tamsayılara ihtiyacı olacaktır.[-231-2, 231-2]f(x)
2 ^ 32-1 sayılar aralığı için C #, (Int32.MinValue) hariç tüm int32 numaraları
Func<int, int> f = n =>
n < 0
? (n & (1 << 30)) == (1 << 30) ? (n ^ (1 << 30)) : - (n | (1 << 30))
: (n & (1 << 30)) == (1 << 30) ? -(n ^ (1 << 30)) : (n | (1 << 30));
Console.WriteLine(f(f(Int32.MinValue + 1))); // -2147483648 + 1
for (int i = -3; i <= 3 ; i++)
Console.WriteLine(f(f(i)));
Console.WriteLine(f(f(Int32.MaxValue))); // 2147483647
baskılar:
2147483647
3
2
1
0
-1
-2
-3
-2147483647
Esasen, fonksiyonun mevcut aralığı 4 döngüsüne bölmek zorundadır, n döngüsünün karşı ucunda -n ile. Bununla birlikte, 0, aksi halde, boyut 1 döngüsünün bir parçası olmalıdır 0->x->0->x != -x. 0 tek başına olduğu için, ürün yelpazemizde (boyutu 4'ün katı olan) 3 elementle uygun bir döngüde olmayan 3 değer daha olmalıdır.
Ben olmak için bu ekstra garip değerleri seçti MIN_INT, MAX_INTve MIN_INT+1. Dahası, MIN_INT+1plan yapacak MAX_INTdoğru, ama orada takılıp ve geri eşlemeyin. Bence bu en iyi uzlaşmadır, çünkü doğru çalışmayan sadece aşırı değerlerin güzel özelliğine sahiptir. Ayrıca, tüm BigInts için işe yarayacağı anlamına gelir .
int f(int n):
if n == 0 or n == MIN_INT or n == MAX_INT: return n
return ((Math.abs(n) mod 2) * 2 - 1) * n + Math.sign(n)
Kimse bunun vatansız olması gerektiğini söylemedi.
int32 f(int32 x) {
static bool idempotent = false;
if (!idempotent) {
idempotent = true;
return -x;
} else {
return x;
}
}
Hile, ancak çok sayıda örnek kadar değil. Arayanızın adresinin & f olup olmadığını görmek için yığını daha da kötüleştirmek olurdu, ancak bu daha taşınabilir olacaktır (iş parçacığı güvenli olmasa da ... iş parçacığı için güvenli sürüm TLS kullanacaktır). Daha da kötülük:
int32 f (int32 x) {
static int32 answer = -x;
return answer;
}
Tabii ki, bunların hiçbiri MIN_INT32 için çok iyi çalışmıyor, ancak daha geniş bir tür döndürmenize izin verilmedikçe, bu konuda yapabileceğiniz çok az şey var.
31. biti hayali ( i ) bit olarak toplam aralığın yarısını destekleyecek bir yaklaşım olarak düşünebilirim .
n = [0 .. 2 ^ 31-1] için çalışır
int f(int n) {
if (n & (1 << 31)) // highest bit set?
return -(n & ~(1 << 31)); // return negative of original n
else
return n | (1 << 31); // return n with highest bit set
}
Sorun "32 bitlik imzalı tamsayı" devletler ama onlar olup olmadığını belirtmez ikiler-tamamlayıcı veya olanları-tamamlayıcısı .
Ones-complement kullanırsanız, 2 ^ 32 değerinin tümü dört uzunluktaki döngülerde gerçekleşir - sıfır için özel bir duruma ihtiyacınız yoktur ve ayrıca koşullara da ihtiyacınız yoktur.
C dilinde:
int32_t f(int32_t x)
{
return (((x & 0xFFFFU) << 16) | ((x & 0xFFFF0000U) >> 16)) ^ 0xFFFFU;
}
Bu, tarafından çalışır
İki geçişten sonra orijinal değerin bitsel tersine sahibiz. Bir-tamamlayıcı temsil hangi olumsuzlama eşdeğerdir.
Örnekler:
Pass | x
-----+-------------------
0 | 00000001 (+1)
1 | 0001FFFF (+131071)
2 | FFFFFFFE (-1)
3 | FFFE0000 (-131071)
4 | 00000001 (+1)
Pass | x
-----+-------------------
0 | 00000000 (+0)
1 | 0000FFFF (+65535)
2 | FFFFFFFF (-0)
3 | FFFF0000 (-65535)
4 | 00000000 (+0)
return x ^ ((x%2) ? 1 : -INT_MAX);
Bir matematikçi olarak bu ilginç soruna bakış açımı paylaşmak istiyorum. Bence en verimli çözüme sahibim.
Doğru hatırlıyorsam, sadece ilk biti çevirerek işaretli bir 32 bit tamsayıyı reddedersiniz. Örneğin, n = 1001 1101 1110 1011 1110 0000 1110 1010 ise, -n = 0001 1101 1110 1011 1110 0000 1110 1010.
Öyleyse, imzalı bir 32 bit tamsayı alan ve başka bir imzalı 32 bit tamsayı döndüren f işlevini, iki kez f almanın ilk biti çevirmeyle aynı olduğunu nasıl tanımlarız?
Tamsayı gibi aritmetik kavramlardan bahsetmeden soruyu yeniden ifade edeyim.
Sıfırlar dizisi ve 32 uzunluktaki dizileri alan ve aynı uzunluktaki sıfır dizileri ve aynı uzunluktaki dizileri döndüren bir f işlevini nasıl tanımlarız, iki kere f alma özelliği ilk biti çevirmekle aynıdır?
Gözlem: Yukarıdaki soruyu 32 bit kasa için cevaplayabiliyorsanız, 64 bit kasa, 100 bit kasa vb. İçin de cevap verebilirsiniz. Sadece ilk 32 bit'e f uygularsınız.
Şimdi soruyu 2 bit durum için cevaplayabilirseniz, Voila!
Ve evet, ilk 2 biti değiştirmek yeterli.
İşte sözde kod
1. take n, which is a signed 32-bit integer.
2. swap the first bit and the second bit.
3. flip the first bit.
4. return the result.
Not: Adım 2 ve adım 3 birlikte (a, b) -> (-b, a) şeklinde yazılabilir. Tanıdık geliyor? Bu size uçağın 90 derecelik dönüşünü ve -1'in kare kökü ile çarpılmasını hatırlatmalıdır.
Eğer sadece uzun bir başlangıç olmadan sahte kodu sadece sunsaydım, şapkadan bir tavşan gibi görünüyordu, çözümü nasıl aldığımı açıklamak istedim.