F (f (n)) == -n ශ්‍රිතය සැලසුම් කිරීම

මගේ අවසාන සම්මුඛ සාකච්ඡාවේදී මට ලැබුණු ප්‍රශ්නයක්:

ශ්‍රිතයක් සැලසුම් කරන්න f,

f(f(n)) == -n

nබිට් 32 අත්සන් කළ පූර්ණ සංඛ්‍යාවක් කොහිද ; ඔබට අංක ගණිතමය වශයෙන් භාවිතා කළ නොහැක.

මුළු සංඛ්‍යා පරාසය සඳහා ඔබට එවැනි ශ්‍රිතයක් සැලසුම් කළ නොහැකි නම්, හැකි විශාලතම පරාසය සඳහා එය සැලසුම් කරන්න.

අදහස් තිබේද?

කොහොමද:

f (n) = ලකුණ (n) - (-1) n * n

පයිතන්හි:

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)

පයිතන් ස්වයංක්‍රීයව පූර්ණ සංඛ්‍යා අත්තනෝමතික දිගට ප්‍රවර්ධනය කරයි. වෙනත් භාෂාවලින් විශාලතම ධන නිඛිලය පිරී ඉතිරී යනු ඇත, එබැවින් එය හැර අනෙක් සියලුම නිඛිල සඳහා එය ක්‍රියා කරයි.

තාත්වික සංඛ්‍යා සඳහා එය ක්‍රියා කිරීමට නම් (-1) ⁿ හි n ආදේශ කළ යුතුය .{ ceiling(n) if n>0; floor(n) if n<0 }

C # හි (පිටාර ගැලීම් අවස්ථා හැර, ඕනෑම දෙගුණයක් සඳහා ක්‍රියා කරයි):

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));
}

ඔවුන් බලාපොරොත්තු වූයේ කුමන ආකාරයේ භාෂාවක්දැයි ඔබ කීවේ නැත ... මෙන්න ස්ථිතික විසඳුමක් (හස්කල්). එය මූලික වශයෙන් වඩාත්ම වැදගත් බිටු 2 සමඟ අවුල් කරයි:

f :: Int -> Int
f x | (testBit x 30 /= testBit x 31) = negate $ complementBit x 30
    | otherwise = complementBit x 30

ගතික භාෂාවකින් (පයිතන්) එය වඩා පහසුය. තර්කය X අංකයක් දැයි පරීක්ෂා කර -X:

def f(x):
   if isinstance(x,int):
      return (lambda: -x)
   else:
      return x()

සියලු සංඛ්‍යා සඳහා, අතිරේක තොරතුරු භාවිතා නොකරන්නේ නම්, එවැනි ශ්‍රිතයක් පැවතිය නොහැක්කේ මන්ද යන්න පිළිබඳ සාක්ෂියක් මෙන්න (int 32bit හැර):

අපට f (0) = 0 තිබිය යුතුය. (සාධනය: f (0) = x යැයි සිතමු. එවිට f (x) = f (f (0)) = -0 = 0. දැන්, -x = f (f (x) )) = f (0) = x, එයින් අදහස් වන්නේ x = 0.)

තවද, ඕනෑම කෙනෙකුට xසහ y, සිතමු f(x) = y. අපට f(y) = -xඑවිට අවශ්‍යයි . සහ f(f(y)) = -y => f(-x) = -y. සාරාංශගත කිරීම සඳහා: එසේ f(x) = yනම් f(-x) = -y, සහ f(y) = -x, සහ f(-y) = x.

එබැවින්, 0 හැර සෙසු සියලු නිඛිල 4 කට්ටලවලට බෙදිය යුතුය, නමුත් අපට එවැනි පූර්ණ සංඛ්‍යා ගණනක් තිබේ; එපමණක් නොව, ධනාත්මක ප්‍රතිවිරෝධකයක් නොමැති පූර්ණ සංඛ්‍යාවක් අප ඉවත් කළහොත්, අපට තවමත් අංක 2 (mod4) ඇත.

අපි ඉතිරිව ඇති උපරිම අංක 2 ඉවත් කළහොත් (abs අගය අනුව), අපට ශ්‍රිතය ලබා ගත හැකිය:

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);
    }
}   

ඇත්ත වශයෙන්ම තවත් විකල්පයක් නම්, 0 ට අනුකූල නොවීම සහ අප ඉවත් කළ අංක 2 ප්‍රසාද දීමනාවක් ලෙස ලබා ගැනීමයි. (නමුත් එය මෝඩකමක් නම් පමණි.)

සී ++ හි අධික ලෙස පැටවීමට ස්තූතියි:

double f(int var)
{
 return double(var);
} 

int f(double var)
{
 return -int(var);
}

int main(){
int n(42);
std::cout<<f(f(n));
}

නැතහොත්, ඔබට පෙර සැකසුම්කරු අපයෝජනය කළ හැකිය:

#define f(n) (f##n)
#define ff(n) -n

int main()
{
  int n = -42;
  cout << "f(f(" << n << ")) = " << f(f(n)) << endl;
}

සියලුම negative ණ සංඛ්‍යා සඳහා මෙය සත්‍ය වේ.

    f (n) = abs (n)

ද්වි අනුපූරක නිඛිල සඳහා ධනාත්මක සංඛ්‍යා ඇතිවාට වඩා එක් negative ණ සංඛ්‍යාවක් ඇති හෙයින්, විසඳුමට f(n) = abs(n)වඩා එක සිද්ධියක් සඳහා වලංගු වේ . ඔබට එකින් එක තේරුණා ...: ඩීf(n) = n > 0 ? -n : nf(n) = -abs(n)

යාවත්කාලීන කරන්න

නැත, ලිට්බ්ගේ අදහස් දැක්වීමෙන් මා හඳුනාගත් පරිදි තවත් එක් සිද්ධියක් සඳහා එය වලංගු නොවේ ... abs(Int.Min)පිටාර ගැලෙනු ඇත ...

මම මෝඩ් 2 තොරතුරු භාවිතා කිරීම ගැනද සිතුවෙමි, නමුත් නිගමනය කළ පරිදි, එය ක්‍රියා නොකරයි ... මුල් කාලයට. නිවැරදිව සිදු කළ හොත්, මෙය Int.Minපිටාර ගැලීම හැර අනෙක් සියලුම සංඛ්‍යා සඳහා ක්‍රියා කරයි .

යාවත්කාලීන කරන්න

මම ටික වේලාවක් එය සමඟ සෙල්ලම් කළෙමි, හොඳ හැසිරවීමේ උපක්‍රමයක් සොයමින් සිටියෙමි, නමුත් මට ලස්සන එක ලයිනර් එකක් සොයා ගැනීමට නොහැකි වූ අතර මෝඩ් 2 විසඳුම එකකට ගැලපේ.

    f (n) = 2n (abs (n)% 2) - n + sgn (n)

C # හි, මෙය පහත පරිදි වේ:

public static Int32 f(Int32 n)
{
    return 2 * n * (Math.Abs(n) % 2) - n + Math.Sign(n);
}

එය සියලු අගයන් සඳහා වැඩ කිරීමට නම්, ඔබ එය ප්‍රතිස්ථාපනය Math.Abs()කර (n > 0) ? +n : -nගණනය කිරීම uncheckedබ්ලොක් එකකට ඇතුළත් කළ යුතුය . එවිට ඔබ Int.Minවිසින්ම පරීක්ෂා කර නොගත් ප්‍රතික්ෂේප කිරීමක් සිදු වේ.

යාවත්කාලීන කරන්න

තවත් පිළිතුරකින් දේවානුභාවයෙන් මම ශ්‍රිතය ක්‍රියා කරන ආකාරය සහ එවැනි ශ්‍රිතයක් ගොඩනඟන්නේ කෙසේද යන්න පැහැදිලි කිරීමට යන්නෙමි.

ආරම්භයේදීම ආරම්භ කරමු. සාරධර්ම අනුපිළිවෙලක් fලබා දෙන අගයකට ශ්‍රිතය නැවත නැවතත් යොදනු ලැබේ n.

    n => f (n) => f (f (n)) => f (f (f (n))) => f (f (f (f (n)))) => ...

ප්‍රශ්නය ඉල්ලා සිටින්නේ f(f(n)) = -n, fඑය තර්කය ප්‍රතික්ෂේප කිරීමේ අනුප්‍රාප්තික යෙදුම් දෙකකි . තවත් අයදුම්පත් දෙකක් f- සම්පුර්ණයෙන්ම හතරක් - නැවත ඉදිරිපත් කරන තර්කය ප්‍රතික්ෂේප කරන්න n.

    n => f (n) => -n => f (f (f (n))) => n => f (n) => ...

දැන් පැහැදිලි දිග හතරක චක්‍රයක් තිබේ. x = f(n)ලබාගත් සමීකරණය පවතින බව ආදේශ කිරීම සහ සටහන් කිරීම f(f(f(n))) = f(f(x)) = -x, පහත සඳහන් දේ ලබා දෙයි.

    n => x => -n => -x => n => ...

එබැවින් අපට සංඛ්‍යා දෙකක් සහිත දිග හතරක චක්‍රයක් ලැබෙන අතර සංඛ්‍යා දෙක නිෂේධනය වේ. චක්‍රය සෘජුකෝණාස්රයක් ලෙස ඔබ සිතන්නේ නම්, ප්‍රතික්ෂේප කළ අගයන් ප්‍රතිවිරුද්ධ කොන් වල පිහිටා ඇත.

එවැනි චක්‍රයක් තැනීම සඳහා බොහෝ විසඳුම්වලින් එකක් පහත දැක්වෙන්නේ n සිට ආරම්භ වීමෙනි.

 n => එකක් ප්‍රතික්ෂේප කර අඩු කරන්න
-n - 1 = - (n + 1) => එකක් එක් කරන්න
-n => ප්‍රතික්ෂේප කර එකක් එකතු කරන්න
 n + 1 => එකක් අඩු කරන්න
 n

එවැනි චක්‍රයක් සඳහා ස්ථිර උදාහරණයක් +1 => -2 => -1 => +2 => +1. අපි බොහෝ දුරට අවසන්. ඉදිකරන ලද චක්‍රයේ අමුතු ධනාත්මක සංඛ්‍යාවක් ඇති බවත්, එහි අනුප්‍රාප්තිකයා සහ සංඛ්‍යා දෙකම නිෂේධනය කරන බවත් සඳහන් කරමින්, අපට පූර්ණ සංඛ්‍යා පහසුවෙන් එවැනි බොහෝ චක්‍රවලට බෙදිය හැකිය ( 2^32හතරෙන් ගුණනයකි) සහ කොන්දේසි සපුරාලන ශ්‍රිතයක් සොයාගෙන ඇත.

නමුත් අපට ශුන්‍යය පිළිබඳ ගැටලුවක් තිබේ. චක්‍රය අඩංගු විය යුත්තේ 0 => x => 0ශුන්‍යය තමාටම ප්‍රතික්ෂේප වන බැවිනි. චක්‍රය දැනටමත් සඳහන් කර ඇති 0 => xනිසා එය අනුගමනය කරයි 0 => x => 0 => x. මෙය දිග දෙකක චක්‍රයක් පමණක් වන අතර xයෙදුම් දෙකකට පසුව එය බවට හැරේ -x. වාසනාවකට මෙන් ගැටලුව විසඳන එක් සිද්ධියක් තිබේ. Xබිංදුවට සමාන නම් අපි ශුන්‍යයක් පමණක් අඩංගු දිග චක්‍රයක් ලබා ගන්නා අතර ශුන්‍යය ස්ථාවර ලක්ෂ්‍යයක් යැයි නිගමනය කළෙමු f.

කළාද? පාහේ. අපට 2^32සංඛ්‍යා ඇත, ශුන්‍යය යනු ස්ථාවර ලක්ෂ්‍යයක් තබන 2^32 - 1සංඛ්‍යා වන අතර, අපි එම සංඛ්‍යාව සංඛ්‍යා හතරක චක්‍රවලට බෙදිය යුතුය. 2^32 - 1හතරෙන් ගුණයක් නොවන නරක - හතරේ දිග චක්‍රයක නොමැති සංඛ්‍යා තුනක් පවතිනු ඇත.

මම දක්වා වූ 3 ටිකක් අත්සන් itegers යන කුඩා කට්ටලයක් භාවිතා විසඳුම ඉතිරි කොටස පැහැදිලි කරනු ඇත -4ගැනීමට +3. අප සිදු කර ඇත්තේ බිංදුවෙනි. අපට එක් සම්පූර්ණ චක්‍රයක් +1 => -2 => -1 => +2 => +1ඇත. දැන් අපි චක්‍රය ආරම්භ කරමු +3.

    +3 => -4 => -3 => +4 => +3

පැන නගින ගැටළුව වන්නේ +4බිට් 3 නිඛිලයක් ලෙස නිරූපණය නොවේ. වලංගු 3 බිටු නිඛිල සංඛ්‍යාවක් වන +4නිෂේධනය -3කිරීමෙන් අපි ලබා ගත හැකි +3නමුත් +3(ද්විමය 011) අස්වැන්නක් 100ද්විමය ලෙස එකතු කිරීමෙන් . එය අත්සන් නොකළ පූර්ණ සංඛ්‍යාවක් ලෙස +4අර්ථකථනය කර ඇති නමුත් අප එය අත්සන් කළ පූර්ණ සංඛ්‍යාවක් ලෙස අර්ථ දැක්විය යුතුය -4. ඒ නිසා ඇත්තටම -4මෙම උදාහරණය සඳහා හෝ Int.MinValueපොදු නඩුවේ පූර්ණ සංඛ්යාමය අංක ගණිතමය නිශේධනය දෙවන කවියක් වන්නේ - 0 හා Int.MinValuethemselve චේට ඇත. එබැවින් චක්රය ඇත්ත වශයෙන්ම පහත පරිදි වේ.

    +3 => -4 => -3 => -4 => -3

එය දිග දෙකක චක්‍රයක් වන අතර ඊට අමතරව +3 චක්‍රයට ඇතුල් වේ -4. ප්රතිඵලයක් ලෙස -4නිවැරදිව කාර්යය අයදුම්පත් දෙකකට පසු තමන් වෙත සිතියම් ගත කෙරේ, +3නිවැරදි ලෙස සිතියම් ගත කර ඇත -3කාර්යය අයදුම්පත් දෙකකට පසු, නමුත් -3වැරදි සහගත ක්රියාව අයදුම්පත් දෙකකට පසු තමන් වෙත සිතියම් ගත කර ඇත.

එබැවින් අපි සියලු සංඛ්‍යා සඳහා ක්‍රියා කරන ශ්‍රිතයක් ගොඩනගා ගත්තෙමු. අපට මීට වඩා හොඳින් කළ හැකිද? අපිට බෑ කිසිම. මන්ද? අපට දිග හතරේ චක්‍ර සෑදිය යුතු අතර සමස්ත සංඛ්‍යා පරාසය අගයන් හතරක් දක්වා ආවරණය කළ හැකිය. ඉතිරි අගයන් ස්ථාවර ලකුණු දෙකක් 0හා Int.MinValueඒ තමන් සහ අත්තනෝමතික නිඛිල දෙකක් චේට කළ යුතුය xසහ -xඑම කාර්යය අයදුම්පත් දෙකක් එකිනෙක වෙත සිතියම් ගත කළ යුතුය.

සිතියම් ගත xකිරීමට -xසහ අනෙක් අතට ඒවා චක්‍ර හතරක් සෑදිය යුතු අතර ඒවා එම චක්‍රයේ ප්‍රතිවිරුද්ධ කොනෙහි පිහිටා තිබිය යුතුය. ප්රතිඵලයක් ලෙස 0හා Int.MinValueද විරුද්ධ කොන් තිබිය යුතුය. මෙම නිවැරදිව සිතියම් ඇත xහා -xනමුත් ස්ථාවර කරුණු දෙකක් හුවමාරු 0හා Int.MinValueකාර්යය අයදුම්පත් දෙකකට පසුව හා අසමත් යෙදවුම් දෙකක් අපට තබන්න. එබැවින් සියලු අගයන් සඳහා ක්‍රියා කරන ශ්‍රිතයක් තැනීමට හැකියාවක් නැත, නමුත් එකක් හැර සෙසු සියලු අගයන් සඳහා ක්‍රියා කරන එකක් අප සතුව ඇති අතර මෙය අපට ළඟා කර ගත හැකි හොඳම දේ වේ.

සංකීර්ණ සංඛ්‍යා භාවිතා කරමින්, අංකයක් ප්‍රතික්ෂේප කිරීමේ කාර්යය පියවර දෙකකට බෙදිය හැකිය:

• n න් i න් ගුණ කරන්න, එවිට ඔබට n * i ලැබෙනු ඇත, එය n 90 ° ප්‍රතිවිරුද්ධ දිශාවට භ්‍රමණය වේ
• i මගින් නැවත ගුණ කරන්න, එවිට ඔබට -n ලැබේ

විශිෂ්ට දෙය නම් ඔබට විශේෂ හැසිරවීමේ කේතයක් අවශ්‍ය නොවීමයි. මම ගුණ කිරීමෙන් පමණක් කාර්යය ඉටු කරයි.

නමුත් ඔබට සංකීර්ණ අංක භාවිතා කිරීමට අවසර නැත. එබැවින් ඔබේ දත්ත පරාසයේ කොටසක් භාවිතා කරමින් ඔබ කෙසේ හෝ ඔබේම මන inary කල්පිත අක්ෂයක් නිර්මාණය කළ යුතුය. ආරම්භක අගයන් තරම් මන inary කල්පිත (අතරමැදි) අගයන් ඔබට අවශ්‍ය බැවින්, ඔබට ඉතිරිව ඇත්තේ දත්ත පරාසයෙන් අඩක් පමණි.

අත්සන් කළ බිටු 8 දත්ත උපකල්පනය කරමින් මම පහත රූපයේ මෙය දෘශ්‍යමාන කිරීමට උත්සාහ කළෙමි. ඔබට මෙය බිටු 32 ක පූර්ණ සංඛ්‍යාවක් සඳහා පරිමාණය කිරීමට සිදුවේ. ආරම්භක n සඳහා අවසර ලත් පරාසය -64 සිට +63 දක්වා වේ. ධනාත්මක n සඳහා ශ්‍රිතය කරන්නේ කුමක්ද:

• N 0..63 (ආරම්භක පරාසය) තුළ තිබේ නම්, ශ්‍රිත ඇමතුම 64 එකතු කරයි, n සිතියම්ගත කිරීම 64..127 පරාසයට (අතරමැදි පරාසය)
• N 64..127 (අතරමැදි පරාසය) නම්, ශ්‍රිතය 64 සිට n අඩු කරයි, n සිතියම්ගත කිරීම 0 පරාසයට අනුරූප වේ ..- 63

Negative ණ n සඳහා, ශ්‍රිතය අතරමැදි පරාසය -65 ..- 128 භාවිතා කරයි.

Int.MaxValue සහ int.MinValue හැර ක්‍රියා කරයි

    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));
    }

ප්රශ්නය එම ශ්රිතයේ ආදාන වර්ගය සහ නැවත අගය දේ ගැන කිසිම දෙයක් කියන්නේ නැහැ fවිය යුතු (ඔබ එය ඉදිරිපත් කළා එසේ නොවේ අවම වශයෙන්) ...

... n යනු බිටු 32 ක පූර්ණ සංඛ්‍යාවක් වන විට පමණි f(f(n)) = -n

ඉතින්, කොහොමද වගේ දෙයක්

Int64 f(Int64 n)
{
    return(n > Int32.MaxValue ? 
        -(n - 4L * Int32.MaxValue):
        n + 4L * Int32.MaxValue);
}

N යනු බිටු 32 ක පූර්ණ සංඛ්‍යාවක් නම් ප්‍රකාශය f(f(n)) == -nසත්‍ය වේ.

නිසැකවම, මෙම ප්‍රවේශය ඊටත් වඩා පුළුල් පරාසයක සංඛ්‍යා සඳහා වැඩ කිරීමට පුළුල් කළ හැකිය ...

ජාවාස්ක්‍රිප්ට් සඳහා (හෝ වෙනත් ගතිකව ටයිප් කළ භාෂා) ඔබට ශ්‍රිතය පූර්ණ හෝ වස්තුවක් පිළිගෙන අනෙක ආපසු ලබා දිය හැකිය. එනම්

function f(n) {
    if (n.passed) {
        return -n.val;
    } else {
        return {val:n, passed:1};
    }
}

දීම

js> f(f(10))  
-10
js> f(f(-10))
10

විකල්පයක් ලෙස ඔබට දැඩි ලෙස ටයිප් කළ භාෂාවකින් අධික ලෙස පැටවීම භාවිතා කළ හැකි නමුත් එය නීති කඩ කළ හැකිය

int f(long n) {
    return n;
}

long f(int n) {
    return -n;
}

ඔබගේ වේදිකාව මත පදනම්ව, සමහර භාෂාවන් මඟින් ක්‍රියාකාරීත්වය පවත්වා ගැනීමට ඔබට ඉඩ සලසයි. VB.Net, උදාහරණයක් ලෙස:

Function f(ByVal n As Integer) As Integer
    Static flag As Integer = -1
    flag *= -1

    Return n * flag
End Function

IIRC, C ++ ද මේ සඳහා ඉඩ දී ඇත. මම හිතන්නේ ඔවුන් වෙනස් විසඳුමක් සොයනවා.

තවත් අදහසක් නම්, ශ්‍රිතයට පළමු ඇමතුමේ ප්‍රති result ලය ඔවුන් විසින් නිර්වචනය කර නොමැති බැවින්, ලකුණ පෙරළා දැමිය යුතුද යන්න පාලනය කිරීම සඳහා ඔබට අමුතු / සන්ධ්‍යාවක් භාවිතා කළ හැකිය:

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;
}

සියලු ඉරට්ටේ සංඛ්‍යා වල විශාලත්වයට එකක් එක් කරන්න, සියලු අමුතු සංඛ්‍යා වල විශාලත්වයෙන් එකක් අඩු කරන්න. ඇමතුම් දෙකක ප්‍රති result ලයට එකම විශාලත්වයක් ඇත, නමුත් එක් ඇමතුමක් ඇති තැන පවා අපි ලකුණ මාරු කරමු. මෙය ක්‍රියාත්මක නොවන සමහර අවස්ථා තිබේ (-1, උපරිම හෝ මිනි ඉන්ට), නමුත් එය මෙතෙක් යෝජනා කර ඇති සියල්ලටම වඩා බොහෝ සෙයින් ක්‍රියා කරයි.

ජාවාස්ක්‍රිප්ට් ව්‍යතිරේකයන් ගසාකෑම.

function f(n) {
    try {
        return n();
    }
    catch(e) { 
        return function() { return -n; };
    }
}

f(f(0)) => 0

f(f(1)) => -1

සියලුම බිට් 32 අගයන් සඳහා (-0 -2147483648 යන අවවාදය සමඟ)

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);
}

ඔබ මූලික වශයෙන් එක් එක් -x => x => -x පුඩුවක් ay => -y => y පුඩුවක් සමඟ සම්බන්ධ කළ යුතුය. ඒ නිසා මම ප්‍රතිවිරුද්ධ පැති යුගලනය කළා split.

උදා: බිට් නිඛිල 4 ක් සඳහා:

0 => 7 => -8 => -7 => 0
1 => 6 => -1 => -6 => 1
2 => 5 => -2 => -5 => 2
3 => 4 => -3 => -4 => 3

සී ++ අනුවාදයක්, බොහෝ විට නීති රීති තරමක් නැමී ඇති නමුත් සියලු සංඛ්‍යාත්මක වර්ග සඳහා (පාවෙන, තීන්ත, ද්විත්ව) සහ ඒකීය us ණතාව ඉක්මවා යන පන්ති වර්ග සඳහා පවා ක්‍රියා කරයි:

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 style):

; 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

කේතය පරික්ෂා කර ඇත, හැකි 32bit පූර්ණ සංඛ්‍යා පසු කර ඇත, -2147483647 සමඟ දෝෂයකි (පිටාර ගැලීම).

ගෝලීය භාවිතා කරයි ... නමුත් එසේද?

bool done = false
f(int n)
{
  int out = n;
  if(!done)
  {  
      out = n * -1;
      done = true;
   }
   return out;
}

මෙම පර්ල් විසඳුම පූර්ණ සංඛ්‍යා, පාවෙන සහ නූල් සඳහා ක්‍රියා කරයි .

sub f {
    my $n = shift;
    return ref($n) ? -$$n : \$n;
}

පරීක්ෂණ දත්ත කිහිපයක් උත්සාහ කරන්න.

print $_, ' ', f(f($_)), "\n" for -2, 0, 1, 1.1, -3.3, 'foo' '-bar';

ප්‍රතිදානය:

-2 2
0 0
1 -1
1.1 -1.1
-3.3 3.3
foo -foo
-bar +bar

F (x) එකම වර්ගයේ විය යුතු යැයි කිසිවෙකු පවසා නැත.

def f(x):
    if type(x) == list:
        return -x[0]
    return [x]


f(2) => [2]
f(f(2)) => -2

මම ඇත්ත වශයෙන්ම ගැටලුවට විසඳුමක් ලබා දීමට උත්සාහ නොකරමි, නමුත් අදහස් කිහිපයක් තිබේ, මෙම ප්‍රශ්නය මතු වූ ප්‍රශ්නය (රැකියාව?) සම්මුඛ සාකච්ඡාවක කොටසකි:

• මම මුලින්ම අසන්නේ "එවැනි කාර්යයක් අවශ්‍ය වන්නේ ඇයි? මෙහි ඇති විශාලතම ගැටළුව කුමක්ද?" එම ස්ථානයේ ඇති සැබෑ ගැටළුව විසඳීමට උත්සාහ කරනවා වෙනුවට. මෙයින් මා සිතන්නේ කෙසේද සහ මා මෙවැනි ගැටළු විසඳන්නේ කෙසේද යන්න පෙන්වයි. කවුද දන්නෙ? සම්මුඛ සාකච්ඡාවකදී ප්‍රශ්නය ඇසූ සැබෑ හේතුව එය විය හැකිය. පිළිතුර නම් "කමක් නෑ, එය අවශ්‍ය යැයි උපකල්පනය කර ඔබ මෙම ක්‍රියාව සැලසුම් කරන්නේ කෙසේදැයි මට පෙන්වන්න." මම දිගටම එසේ කරමි.
• ඉන්පසුව, මම භාවිතා කරන C # පරීක්ෂණ සිද්ධි කේතය ලියමි (පැහැදිලිව: ලූප සිට සිට int.MinValueදක්වා)int.MaxValue , සහ එක් එක් සඳහා nබව පරාසයක ඇමතුමක් f(f(n))අතර එහි ප්රතිඵල පරීක්ෂා වේ-n නම් මම එවැනි ක්රියාවන් සඳහා ලබා ගැනීමට ටෙස්ට් පලවා හරින්න සංවර්ධන භාවිතා කරන කියන,).
• සම්මුඛ පරීක්‍ෂකවරයා දිගින් දිගටම මගෙන් ඉල්ලා සිටින ගැටලුව විසඳන ලෙස ඉල්ලා සිටියහොත් පමණක් මම සම්මුඛ පරීක්ෂණය අතරතුරදී ව්‍යාජ කේතයක් ලිවීමට උත්සාහ කර යම් ආකාරයක පිළිතුරක් ලබා ගැනීමට උත්සාහ කරමි. කෙසේ වෙතත්, සම්මුඛ පරීක්‍ෂකවරයා සමාගම කෙබඳුද යන්න පිළිබඳ කිසියම් ඇඟවීමක් කළහොත් මම රැකියාව භාර ගැනීමට පනින්නෙමි යැයි මම නොසිතමි ...

ඔහ්, මෙම පිළිතුර උපකල්පනය කරන්නේ සම්මුඛ පරීක්ෂණය සී # ක්‍රමලේඛනය හා සම්බන්ධ තනතුරක් සඳහා බවය. සම්මුඛ පරීක්ෂණය ගණිතය හා සම්බන්ධ තනතුරක් සඳහා නම් ඇත්ත වශයෙන්ම මෝඩ පිළිතුරක් වනු ඇත. ;-)

මම ඔබට වඩාත්ම වැදගත් බිටු 2 වෙනස් කරමි.

00.... => 01.... => 10.....

01.... => 10.... => 11.....

10.... => 11.... => 00.....

11.... => 00.... => 01.....

ඔබට පෙනෙන පරිදි, එය එකතු කිරීමක් පමණි.

මම පිළිතුරට ආවේ කෙසේද? මගේ පළමු සිතුවිල්ල සමමිතිය සඳහා අවශ්‍යතාවයක් පමණි. මා ආරම්භ කළ ස්ථානයට ආපසු යාමට වාර 4 ක්. මුලදී මම හිතුවා, ඒක 2bit අළු කේතය කියලා. එවිට මම සිතුවේ ඇත්ත වශයෙන්ම සම්මත ද්විමය ප්‍රමාණවත් බවයි.

මෙම ගැටළුව විසඳීම සඳහා සංකීර්ණ සංඛ්‍යා භාවිතා කළ නොහැකි බවට අවශ්‍යතාවයෙන් හෝ ප්‍රකාශ කිරීමෙන් විසඳුමක් මෙන්න.

-1 හි වර්ග මූලයෙන් ගුණ කිරීම අදහසකි, එය අසාර්ථක වන බව පෙනෙන්නේ -1 ට පූර්ණ සංඛ්‍යා වලට වඩා වර්ග මූලයක් නොමැති බැවිනි. නමුත් ගණිතය වැනි වැඩසටහනක් සමඟ සෙල්ලම් කිරීම උදාහරණයක් ලෙස සමීකරණය ලබා දෙයි

(1849436465 ² +1) මොඩ් (2 ³² -3) = 0.

මෙය -1 හි වර්ග මූලයක් තිබීම තරම්ම හොඳයි. ශ්‍රිතයේ ප්‍රති result ලය අත්සන් කළ පූර්ණ සංඛ්‍යාවක් විය යුතුය. එනිසා මම නවීකරණය කරන ලද මොඩියුලෝ මෙහෙයුම් මොඩ්ස් (x, n) භාවිතා කිරීමට බලාපොරොත්තු වන අතර එය පූර්ණ සංඛ්‍යා y x x මොඩියුලෝ n වෙත 0 ට ආසන්න වන අතර එය 0 ට ආසන්න වේ. . උදා: පයිතන්හි එය:

def mods(x, n):
    y = x % n
    if y > n/2: y-= n
    return y

ඉහත සමීකරණය භාවිතා කරමින් ගැටළුව දැන් විසඳා ගත හැකිය

def f(x):
    return mods(x*1849436465, 2**32-3)

f(f(x)) = -xපරාසය තුළ ඇති සියලුම නිඛිල සඳහා මෙය තෘප්තිමත් වේ . ප්‍රති results ල ද මෙම පරාසය තුළ ඇත, නමුත් ඇත්ත වශයෙන්ම ගණනය කිරීම සඳහා බිට් 64 පූර්ණ සංඛ්‍යාවක් අවශ්‍ය වේ.[-231-2, 231-2]f(x)

2 # 32 - 1 ඉලක්කම් සඳහා C #, (Int32.MinValue) හැර අනෙකුත් සියලුම int32 අංක

    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

මුද්‍රණ:

2147483647
3
2
1
0
-1
-2
-3
-2147483647

අත්‍යවශ්‍යයෙන්ම ශ්‍රිතයට පවතින පරාසය 4 ප්‍රමාණයේ චක්‍රවලට බෙදිය යුතු අතර, n හි චක්‍රයේ ප්‍රතිවිරුද්ධ කෙළවරේ. කෙසේ වෙතත්, 0 ප්‍රමාණය 1 ප්‍රමාණයේ චක්‍රයක කොටසක් විය යුතුය0->x->0->x != -x . 0 තනිව සිටීම නිසා, අපගේ පරාසය තුළ තවත් අගයන් 3 ක් තිබිය යුතුය (ඒවායේ ප්‍රමාණය 4 න් ගුණ කළ යුතුය) මූලද්‍රව්‍ය 4 ක් සහිත නිසි චක්‍රයක නොවේ.

මම කල මෙම අතිරේක අමුතු අගයන් තීරණය MIN_INT, MAX_INTසහ MIN_INT+1. තව දුරටත්, නිවැරදිව MIN_INT+1සිතියම් ගත කරනු ඇත MAX_INT, නමුත් එහි සිරවී නැවත සිතියම් ගත නොකරනු ඇත. මම හිතන්නේ මෙය හොඳම සම්මුතියකි, මන්ද එය සතුව ඇත්තේ නිවැරදි අගයන් පමණක් නිවැරදිව ක්‍රියා නොකිරීමේ හොඳ දේපලකි. එසේම, එයින් අදහස් වන්නේ එය සියලු බිග් ඉන්ට්ස් සඳහා වැඩ කරන බවයි.

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)

කිසිවෙකු කීවේ එය අස්ථායි විය යුතු බවයි.

int32 f(int32 x) {
    static bool idempotent = false;
    if (!idempotent) {
        idempotent = true;
        return -x;
    } else {
        return x;
    }
}

වංචා කිරීම, නමුත් බොහෝ උදාහරණ තරම් නොවේ. ඊටත් වඩා නපුර වනුයේ ඔබේ අමතන්නාගේ ලිපිනය & f දැයි බැලීමට තොගය සොයා ගැනීමයි, නමුත් මෙය වඩාත් අතේ ගෙන යා හැකි වනු ඇත (නූල් ආරක්ෂිත නොවුනත් ... නූල්-ආරක්ෂිත අනුවාදය TLS භාවිතා කරයි). ඊටත් වඩා නපුර:

int32 f (int32 x) {
    static int32 answer = -x;
    return answer;
}

ඇත්ත වශයෙන්ම, මේ දෙකම MIN_INT32 සම්බන්ධයෙන් එතරම් හොඳින් ක්‍රියා නොකරයි, නමුත් පුළුල් වර්ගයක් ආපසු ලබා දීමට ඔබට ඉඩ නොදුනහොත් ඔබට ඒ පිළිබඳව කළ හැකි වටිනා අල්ප ප්‍රමාණයක් ඇත.

31 වන බිට් එක මන inary කල්පිත ලෙස භාවිතා කිරීම මට සිතාගත හැකිය ( i ) බිට් යනු මුළු පරාසයෙන් අඩකටම සහාය වන ප්‍රවේශයකි.

n = [0 .. 2 ^ 31-1] සඳහා ක්‍රියා කරයි

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
}

ප්රශ්නය රාජ්යයන් "32-bit අත්සන් නිඛිල" නමුත් ඔවුන් ද යන්න සඳහන් නොවේ දෙදෙනා බැගින්-සහකාරියක් හෝ අය-සහකාරියක් .

ඔබ ඒවා අනුපූරක ලෙස භාවිතා කරන්නේ නම්, සියලු 2 ^ 32 අගයන් හතරවන චක්‍රයේ සිදු වේ - ඔබට ශුන්‍යය සඳහා විශේෂ අවස්ථාවක් අවශ්‍ය නොවන අතර ඔබට කොන්දේසි ද අවශ්‍ය නොවේ.

සී හි:

int32_t f(int32_t x)
{
  return (((x & 0xFFFFU) << 16) | ((x & 0xFFFF0000U) >> 16)) ^ 0xFFFFU;
}

මෙය ක්‍රියාත්මක වන්නේ

1. ඉහළ සහ අඩු 16-බිට් බ්ලොක් හුවමාරු කිරීම
2. එක් බ්ලොක් එකක් පෙරළීම

පාස් දෙකකට පසු අපට මුල් අගයේ බිටු ප්‍රතිලෝම ඇත. ඒවායින් අනුපූරක නිරූපණය ප්‍රතික්ෂේප කිරීමට සමාන වේ.

උදාහරණ:

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)

: ඩී

boolean inner = true;

int f(int input) {
   if(inner) {
      inner = false;
      return input;
   } else {
      inner = true;
      return -input;
   }
}

return x ^ ((x%2) ? 1 : -INT_MAX);

ගණිත ian යෙකු ලෙස මෙම සිත්ගන්නා ගැටලුව පිළිබඳ මගේ මතය බෙදා ගැනීමට මම කැමතියි. මම හිතන්නේ මට වඩාත්ම කාර්යක්ෂම විසඳුමක් තිබේ.

මට නිවැරදිව මතක නම්, ඔබ අත්සන් කළ බිටු 32 ක පූර්ණ සංඛ්‍යාවක් පළමු බිට් එක පෙරළීමෙන් ප්‍රතික්ෂේප කරයි. උදාහරණයක් ලෙස, n = 1001 1101 1110 1011 1110 0000 1110 1010 නම්, -n = 0001 1101 1110 1011 1110 0000 1110 1010.

එසේ නම්, අත්සන් කරන ලද 32-බිටු නිඛිලයක් ගෙන, අත්සන් කළ තවත් 32-බිටු සංඛ්‍යාවක් පූර්ණ ගුණාංගයක් ආපසු ලබා දෙන එෆ් ශ්‍රිතය පළමු බිට් එක පෙරළීමට සමාන වේ.

පූර්ණ සංඛ්‍යා වැනි අංක ගණිත සංකල්ප සඳහන් නොකර ප්‍රශ්නය නැවත ලිවීමට මට ඉඩ දෙන්න.

එෆ් ශ්‍රිතයක් අර්ථ දක්වන්නේ කෙසේද? එය ශුන්‍ය අනුක්‍රමයක් සහ දිග 32 ක් ගෙන ශුන්‍ය අනුක්‍රමයක් සහ එකම දිගකින් යුත් අනුපිළිවෙලක් ලබා දෙයි.

නිරීක්‍ෂණය: ඔබට ඉහත ප්‍රශ්නයට බිට් 32 නඩුවකට පිළිතුරු දිය හැකි නම්, ඔබට බිට් 64 කේස්, බිට් 100 කේස් ආදිය සඳහා ද පිළිතුරු දිය හැකිය. ඔබ පළමු බිට් 32 ට එෆ් යොදන්න.

දැන් ඔබට බිට් 2 නඩුව සඳහා ප්‍රශ්නයට පිළිතුරු දිය හැකි නම්, වොයිලා!

ඔව්, පළමු බිටු 2 වෙනස් කිරීම ප්‍රමාණවත් බව පෙනේ.

මෙන්න ව්‍යාජ කේතය

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.

සටහන: පියවර 2 සහ 3 පියවර එකට (a, b) -> (-b, a) ලෙස ගිම්හානය කළ හැකිය. හුරුපුරුදු බව පෙනේ? එමඟින් ඔබට තලයෙහි අංශක 90 භ්‍රමණය සහ -1 හි වර්ග මූලයෙන් ගුණ කිරීම මතක් කළ යුතුය.

දිගු පෙරවදනකින් තොරව මම ව්‍යාජ කේතය පමණක් ඉදිරිපත් කළහොත්, එය තොප්පියෙන් එළියට ගිය හාවෙකු මෙන් පෙනේ, මට විසඳුම ලැබුණේ කෙසේද යන්න පැහැදිලි කිරීමට මට අවශ්‍ය විය.