Вместо да работиш с маска = 1 (00001), работиш с маска 7 (000111). По този начин взимаш и заместваш всички числа, а не ги местиш едно по едно :)

Хареса ми твоето решение, чисто и добре обяснено. Ако пробваш с по-голямо число, тип 4294901775 както е дадено в примерите, ще ти гръмне програмата. Може да използваш uint, за да се презастраховаш.

Това е моето решение: Линк

Тази задача май е от по-лесните, поне според мен и е един ред код. Иначе ми харесва идеята, как ти проверяваш за result24 == 1 обаче така трябва да направиш същото за останалите две позиции и става малко като повтаряне на код.

Аз да се възползвам от темата на колегата и да помоля за малко помощ относно задача 16. Това е моето решение: Линк

Не ми се получава проверката с числото 4294901775. Аз получавам 4060020863 като резултат, вместо 4194238527 както е в условието. Останалите проверки сработват. Идеи къде бъркам?

 Здравейте колеги, Ето и моето решение на 15-та задача Линк

Ето и моето решение, има и коментари. Пробвах да го напиша по ясно :) Линк

Ето и моето решение използвал съм масиви, като превъртя стринговете в масив и заменя членовете 24, 25 и 26 с 3, 4 и 5 и използвам 3 временни променливи за размяната. Малко чийтърско ама нищо не ми дойде на акъла иначе работи.

П.С. Но, като разгледах вашите решения са по - хитри. :)

  Всъщност, задача 15 е частен случай на задача 16, с  р = 3, q = 24 и k=3. 

Ето го моето решение на 15, а на 16 съм го пуснала в отделна тема за 16 задача.

под LEFT имам предвид бита с по голям номер на позицията , а RIGHT - този с по-малкият номер на позицията. 

class BitsExchange

{

     static void Main() 

    { 

         while (true) 

        { 

             Console.Write("Enter a number (Min value = 0, Max value = ");

             Console.WriteLine(uint.MaxValue + "):\n");

             string line = Console.ReadLine();

             uint number;

             bool result = uint.TryParse(line, out number); 

             if (result == false) //not a valid uint number 

             { 

                   Console.WriteLine("\nThis is not a valid value for number!\n\n");

             } 

             else  // the input is valid 

             {    

                   //swap 3 with 24, 4 with 25, 5 with 26 

                   // "Right"  I call  the bit with bigger position ( this are bits 24, 25,26) and  

                   // "Left"  the bit with smaller position ( this are bits 3, 4, 5 ) 

                   int LeftPosition = 24; 

                   int RightPosition = 3; 

                   int leftBit_Value ; 

                   int rightBit_Value ;

                   uint maskLeft;

                   uint maskRight;

                   for (int i = 0; i < 3; i++) 

                   {

                        //getting the values in the bits

                        maskLeft = 1u << LeftPosition;

                        leftBit_Value = (int)(number & maskLeft) >> LeftPosition;

                        maskRight = 1u << RightPosition;

                        rightBit_Value = (int)(number & maskRight) >> RightPosition;

                        //replacing Left with Right

                        if (rightBit_Value == 1) 

                        { 

                               // then we change the Left Bit Value to 1 

                               number = (uint)(number | maskLeft); 

                        } 

                        else if (rightBit_Value == 0) 

                        { 

                               // than we change the Left Bit Value to 0 

                               maskLeft = ~ maskLeft; 

                               number = (uint)(number & maskLeft);

                        } 

                       // replacing Right with Left 

                       if (leftBit_Value == 1) 

                       { 

                               // then we changing the Right Bit Value to 1 

                               number = (uint)(number | maskRight); 

                       } 

                       else if (leftBit_Value == 0) 

                       { 

                                // change the Right Bit Value to 0 

                                maskRight = ~ maskRight;

                                number = (uint)(number & maskRight);

                       } 

                                LeftPosition ++;

                                RightPosition ++;

                       } 

                       Console.WriteLine("\nResult : \n\n" + number + " \n\n\n"); 

                 } 

            } 

      } 

}

Мъчих се 2 часа над тая задача и накрая естествено се оказа, че ми е грешно решението. anyway..

Въпроса ми е какво се случва когато  7 << 3

uint mask3 = 7 << 3;

От лекцията на Наков видях само, че когато е 1 << n и си пишем за n, кой бит по ред от дясно наляво искаме да заместим.

Форматирах кода на моето решение, по-нагоре , извинявам се .

За тези задачи с битовете , трябва да се разбере, че има в същност само три операции и стават после  много лесни !

1. Взимане (откриване)на стойността , която се намира вече в бита:

mask = 1 << Position;      // puting 1 under the bit in the given position

bitValue = number & mask >> LeftPosition;      // result 0 or 1

2. Вкарване в бита на стойност '1' (независимо от стойността , която вече е в него, дали е 0 или е 1):

number = number | mask;           // result 

                                               //new number = number * (2**position)  (if in bit was 0 before) 

                                               // new number = number (if in bit was 1) => No change occures !

3. Вкарване в бита на стойност '0' (пак  независимо от стойността , която вече е в него, дали е 0 или е 1) :

mask = ~ mask;                       

number = number & maskRight;   // result

                                                //new number = number / (2**position)  (if in the bit was 1 before) 

                                                // new number = number (if in bit was 0) => No change occures !