Аз съм съгласна с теб, че вторият вариант изглежда най-чист. Няма if конструкция и не е труден за разбиране. Но също така съм съгласна с колегата Кочев, че е важно как тече твоята собствена мисъл. Важно е да се разбира добре логиката зад написаните редове. Както в математиката - ако разбираш добре какво се случва, то можеш да го приложиш в много различни ситуации с леки адаптации и да се справяш и с по-големи проблеми. Производителността на процесора няма да се повлияе значително от един вариант на друг от тези три (според мен), докато разбирането на задачата и удобството са с приоритет. Аз съм ползвала вариант 2, но всеки може да си избере каквото му е удобно.

Здравейте колеги,

С изненада откривам, че не само мен ме е заинтригувала идеята да намеря различни начини за преброяване на битовете със стойност '1' - т.е. вече има такава тема.

Аз открих до момента 8 различни начина за преброяване и ги тесвах в judge за performance, тъй като иначе като резултат - всички дават 100 точки.

Това е цялото решение с закоментирани допълнителни методи за преброяване.

Ето и резултатите от класацията:

    // first "1"-bits counting algorithm
        for (int i = 0; i < 64; i++)
        {
            ulong result = number & 1;
            if (result == 1)
            {
                counter++;
            }
            number = number >> 1;
        }

Memory: 8.21 MB
Time: 0.010 s

    // second "1"-bits counting algorithm 
        for (int i = 0; i < 64; i++)
        {
            mask = (ulong)1 << i;
            ulong result = number & mask;
            if (result == mask)
            {
                counter++;
            }
        }

Memory: 8.20 MB
Time: 0.011 s

   // sixth "1"-bits counting algorithm
        counter = binary.Split('1').Length - 1;

Memory: 8.29 MB
Time: 0.011 s

    // seventh "1"-bits counting algorithm
        counter = binary.Length - (binary.Replace("1", "").Length);

Memory: 8.30 MB
Time: 0.012 s

    // third "1"-bits counting algorithm
        for (int i = 0; i < binary.Length; i++)
        {
            if (binary[i] == '1')
            {
                counter++;
            }
        }

Memory: 8.36 MB
Time: 0.014 s

Link и Regex методите леко намаляват performance-a:

    // forth "1"-bits counting algorithm
        counter = binary.Count(x => x == '1');

Memory: 9.20 MB
Time: 0.014 s

 // eighth "1"-bits counting algorithm
      string pattern = "1";
      counter = Regex.Matches(binary, pattern).Count;

Memory: 9.29 MB
Time: 0.012 s

    // fifth "1"-bits counting algorithm
        counter = binary.Where(x => x == '1').Count();

Memory: 9.65 MB
Time: 0.033 s

Но ,честно казано, разликите са съвсем незначителни и може да се дължат и на натоовареността на judge в момента на тестване.

Преди да сменя BigInteger с ulong, резултата беше Memory: 8.47 MB, Time: 0.052 s - т.е. пак без огромна, тъй като разрешеното време е 0.25 s. Но все пак BigInteger е увеличил 5 пъти времето за изпълнение на програмата - в някои задачи това може да се окаже решаващ фактор.

Основният извод остава, че това преброяване на битивете със стойноост '1' наистина може да се направи по най-различни начини.

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

Можете ли да ми кажете дали задачата така ми е вярна, пък и макар не оптимизирана. В джъджа ми прехвърля времето.

http://pastebin.com/eHUyY6Tk