{q, q+1, …, q+k-1} е условието.

q+k-1 = 22+10-1 = 31

Практически имаме само 3 операции с битове .

1.Първата е откриването на стойността на бит, по дадена негова позиция( дали стойността в бита  е 0 или е 1 ).

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

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

И това е всичко .

Като знаем формулките за всяка една от тези операции сме готови, за всякакви задачи с битове .

На мен ми се видяхя много лесни, може би защото очахвах, по чуждите мнения, да са ужасно трудни - но не са - така ,че не се страхувайте от този тип задачи.

Ето един линк ,за побитови операции , на един WORKSHOP от академията Телерик, може да се окаже полезен на някого:

 http://www.youtube.com/watch?v=8vxQqbFGW-E

О, по повод последния отговор - писал съм главно РНР преди това и един път не ми се е налагало да използвам битовете като различно от стрингова резпрезентация, и не беше толкова лесно да вникна в баш побитовите операции :))

Иначе, да, в тези задачи се извършва точно това - намира се бит на определеня позиция и на него се слага 1 или 0.

За мен обаче е доста по клийн, ако двата бита (от който ще заменяш, и когото ще заменяш) са еднакви - просто да не правиш нищо. Да заменяш 0 с 0 или 1 с 1 ми се струва безсмислено.

https://github.com/RoYaLBG/SoftUni/blob/master/OperatorsExpressionsStatements/BitwiseInteraction/AdvancedBitExchange.cs

Ето някакво що-годе клийн решение.

Не е много красив кода, ще го дооправя, за сега си експериментирам разни други неща пр. да се пуска всеки скрипт от солюшъна от едно място, в зависимост от юзър инпут-а (за това метода ми тук е Start(), а не Main()) така че не обръщайте внимание на това.

Аз също мислех отначало , да правя проверка , за това дали са еднакви и ако са еднакви да не прави нищо програмата , но става по-дълго така и повече операции се извършват , отколкото да се вкарва 1 или 0, даже и да са еднакви.

Ето ми го кода - работи си нормално с всички стойностти и дава същите резултати ,като показаните ,освен в споменатият по-горе пример, който според мен оверфлоува 32- та бита на лонг интежер.

Като вдигна с 1 битовете , пък дава друг резултат от този в примера , подобен но друг.

Mod Edit: Нарушена т. 12 от Правилата на форума: Във всеки пост е позволено цитирането на не повече от 15 реда код. Ако искате да споделите по-дълъг код, използвайте сайтове като Pastebin и Github Gist).

Оправих го горе, вече може да го пуснеш !

Малко още е изкривено, но тава вече може сам са си го оправиш .

Ето и моето решение, след 2 часа родилни мъки се плеснах по челото и зацепих, че с една елементарна промяна на маската от предишната задача и набутването на кода 1 към 1 в for loop, нещата стават бетон...

staticvoid Main()

{

Console.Write("Enter number: ");

long number = uint.Parse(Console.ReadLine());

Console.Write("Enter p: ");

int p = int.Parse(Console.ReadLine());

Console.Write("Enter q: ");

int q = int.Parse(Console.ReadLine());

Console.Write("Enter k: ");

int k = int.Parse(Console.ReadLine());

if (Math.Max(p, q) + k > 32)

{

Console.WriteLine("Out of range");

}

elseif (Math.Min(p, q) + k > Math.Max(p, q))

{

Console.WriteLine("Overlapping");

}

else

{

int counter = q;

for (int i = p;i<=p+k-1;i++)

{

//Prosto kodut ot predishnata zadacha, vkaran v for cikul i s druga maska.

long mask = 1;

long firstBits = ((mask << i) & number) >> i;//Get bit p

long secondBits = ((mask << counter) & number) >> counter;//Get bit q

number = number & ~(mask << i);//Convert bit p to 0

number = number & ~(mask << counter);//Convert bit q to 0

number = number | (secondBits << i);//Replace bit p with q

number = number | (firstBits << counter);//Replace bit q with p

counter++;

}

Console.WriteLine(number);

Console.WriteLine(Convert.ToString(number, 2).PadLeft(32,'0'));

}

}

За сравнение, ето как съм решил предишната:

staticvoid Main()

{

Console.Write("Please eneter a number: ");

long number = uint.Parse(Console.ReadLine());

Console.WriteLine("You entered the number {0} in binary: {1}", number, Convert.ToString(number, 2).PadLeft(32, '0'));

long mask = 7;

long firstBits = ((mask << 3) & number)>>3;//Get bits 3,4,5

long secondBits = ((mask << 24) & number)>>24;//Get bits 24,25,26

number = number & ~(mask << 3);//Convert bits 3,4,5 to 0;

number = number & ~(mask << 24);//Convert bits 24,25,26 to 0;

number = number | (secondBits << 3);//Replaces bits 3,4,5 with saved bits 24,25,26

number = number | (firstBits << 24);//Replaces bits 24,25,26 with saved bits 3,4,5

Console.WriteLine("Result is: {0}",number);

Console.WriteLine("In binary: {0}",Convert.ToString(number, 2).PadLeft(32, '0'));

}

 Всичко на всичко, без форматирането, инпута и проверките - 9 реда код.Вече мога да спя спокойно :D

Досега писах задачата. Имам съмнение, че има невярни примери:

123456789
26
0
7
-
-
out of range

Това при мен си се изчислява, защото p + k - 1 (в случая 32) не е по-голямо от 32. При мен дава резултат: 1465634113.

Това пък:

33333333333
-1
0
33
-
-
out of range

направо гърми, защото е препълнен uint (то се вижда де - uint е макс 10 цифри). :)

//Write a program that exchanges bits {p, p+1, …, p+k-1} with bits {q, q+1, …, q+k-1} of a given 32-bit unsigned integer.
//The first and the second sequence of bits may not overlap.

using System;

class BitExchangeAdvanced
{
  static void Main()
  {
    uint myNumber; //n
    uint movedNumber; //the result
    int initialFirstBitRow; //p
    int initialSecondBitRow; //q
    int bitCounter; //k

    do
    {
      Console.WriteLine("Please enter a positive integer:");
      myNumber = uint.Parse(Console.ReadLine());
    }
    while (myNumber < 0);
    Console.WriteLine("Please enter the initial bit in the First row (p):");
    initialFirstBitRow = int.Parse(Console.ReadLine());
    Console.WriteLine("Please enter the initial bit in the Second row (q):");
    initialSecondBitRow = int.Parse(Console.ReadLine());
    Console.WriteLine("Please enter the number of bits in each row (k):");
    bitCounter = int.Parse(Console.ReadLine());

    //initial validation
    if (initialFirstBitRow < 0 || initialFirstBitRow > 31 || initialSecondBitRow < 0 || initialSecondBitRow > 31 || bitCounter < 1 || bitCounter > 32)
    {
      Console.WriteLine("Out of Range");
      return; //exit the program
    }

    if ((initialFirstBitRow + bitCounter - 1) > 31 || (initialSecondBitRow + bitCounter - 1) > 31)
    {
      Console.WriteLine("Out of Range");
      return; //exit the program
    }
    if (initialFirstBitRow == initialSecondBitRow)
    {
      Console.WriteLine("Overlapping");
      return; //exit the program
    }
    if (initialFirstBitRow < initialSecondBitRow)
    {
      if ((initialFirstBitRow + bitCounter -1) >= initialSecondBitRow)
      {
        Console.WriteLine("Overlapping");
        return; //exit the program
      }
    }
    if (initialFirstBitRow > initialSecondBitRow)
    {
      if ((initialSecondBitRow + bitCounter - 1) >= initialFirstBitRow)
      {
        Console.WriteLine("Overlapping");
         return; //exit the program
      }
    }

    movedNumber = myNumber;

    for (int i = initialFirstBitRow; i <= initialFirstBitRow + bitCounter - 1; i++) //replace first bit row
    {
      movedNumber = ModifyBitAtGivenPosition(movedNumber, i, GetBitAtGivenPosition(myNumber, initialSecondBitRow + (i - initialFirstBitRow)));
    }

    for (int i = initialSecondBitRow; i <= initialSecondBitRow + bitCounter - 1; i++) //replace second bit row
    {
      movedNumber = ModifyBitAtGivenPosition(movedNumber, i, GetBitAtGivenPosition(myNumber, initialFirstBitRow + (i - initialSecondBitRow)));
    }

    Console.Write("The binary representation of the number is: ");
    Console.WriteLine(Convert.ToString(myNumber, 2).PadLeft(32, '0'));
    Console.Write("The binary representation of the moved number is: ");
    Console.WriteLine(Convert.ToString(movedNumber, 2).PadLeft(32, '0'));
    Console.WriteLine("The decimal representation of the moved number is: {0}", movedNumber);
  }

  //this function gets the bit at bitIndex in myNumber integer
  static uint GetBitAtGivenPosition(uint myNumber, int bitIndex)
  {
  return ((myNumber >> bitIndex) & 1);
  }

  //this function changes the bit at bitIndex to bitValue in the myNumber integer
  static uint ModifyBitAtGivenPosition(uint myNumber, int bitIndex, uint bitValue)
  {
  return (bitValue == 0) ? myNumber & (uint)(~(1 << bitIndex)) : myNumber | (uint)(1 << bitIndex);
  }
}

Едит: Май видях къде бъркам - в 32-битовите числа мога да сменям от бит 0 до бит 31

Bit Exchange (Advanced)

Bit Exchange(advanced)

Здравейте, ако може някой да погледне моето решение на задачата тук. Заиграх се с типовете променливи. В началото зададох int, после като тествах, не ми стигна - замених го с uint и най-накрая с long. Във VS ми се появиха някакви грешки, но без описание. Имаше и предупреждения преди крайния вариант, но не разбрах какво не му харесва. Благодаря!