Среди простых чисел найти найти такое, в двоичной записи которого максимальное число единиц.

#include <iostream>
 
typedef unsigned long long ull_t;
 
bool is_prime(ull_t);
size_t binary_1_number(ull_t);
 
int main()
{
    ull_t num;
 
    std::cout << "Enter n: ";
    std::cin >> num;
 
    size_t last_max_binary_1_number = 1;
    ull_t last_max_binary_1_empty = 2;
 
    for (ull_t n = 3; n <= num; ++n)
    {
        if (is_prime(n))
        {
            size_t current_binary_1_number = binary_1_number(n);
 
            if (last_max_binary_1_number <= current_binary_1_number)
            {
                last_max_binary_1_number = current_binary_1_number;
                last_max_binary_1_empty = n;
            }
        }
    }
 
    std::cout << last_max_binary_1_empty << std::endl;
 
    return 0;
}
 
bool is_prime(ull_t num)
{
    if (num < 2)
        return false;
 
    for (ull_t i = 2; i * i <= num; ++i)
        if (num % i == 0)
            return false;
 
    return true;
}
 
size_t binary_1_number(ull_t num)
{
    size_t count = 0;
 
    while (num != 0)
    {
        if ((num & 1) == 1)
            ++count;
 
        num >>= 1;
    }
 
    return count;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
 
bool is_prime(int &n){
  for(int i = 2; i <= n / 2; ++i)
    if ( !(n % i) )
      return false;
  return true;
}
 
std::string int_to_str(int one, std::string &r){
  std::ostringstream ost;
  ost << one;
  r = ost.str();
  return r;
}
 
std::string dec_to_bin(int one){
  std::string res;
  const int numb_symb = 2;
  while(one){
    std::string first;
    res += int_to_str(one % 2, first);
    one /= 2;
  }
  std::reverse(res.begin(), res.end());
  return res;
}
 
int main(){
  int n;
  std::cin >> n;
  std::vector<int> v;
  for(int i = 2; i <= n; ++i)
    if(is_prime(i)) v.push_back(i);
  std::cout << *std::max_element(v.begin(), v.end(), [](int &a, int &b) -> bool{
    std::string s_a = dec_to_bin(a), s_b = dec_to_bin(b);
    return std::count(s_a.begin(), s_a.end(), '1') <
           std::count(s_b.begin(), s_b.end(), '1');
  });
  return 0;
}

#include <iostream>
#include <bitset>
 
int GetEasyNumber(int MaxNumber)
{
   bool state = false;
   int MaxCount = 0;
   int NumberThisMaxBits;
   for (int num = 2; num <= MaxNumber; num++)
   {
      for (int i = 2; i < num && !state; i++)
         if (num % i == 0)
            state = true;
            
      if (!state)
      {
         std::bitset <32> bin_number(static_cast <unsigned long> (num));
         if (MaxCount < bin_number.count())
            NumberThisMaxBits = num;
         
      }
      state = false;
   }
   
   return NumberThisMaxBits;
}
 
int main()
{
   int number = 1000;
   
   std::cout << GetEasyNumber(number) << std::endl;
   
   return 0;
}

#include <conio.h>
#include <iostream.h>
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
    int DigitsAmount;
    cout<<"Vvedite kolichestvo chisel N: ";
        cin>>DigitsAmount;
        if(DigitsAmount<=0)
        {
            cout<<"Oshibka!!! N doljno biti > 0";
        }
        int CurrentDigit;
        int BiggestAmountOfTrues=0;
        int Result=0;
 
        for(int i=0;i<DigitsAmount;i++)
        {
            cout<<"Vvedite chislo N "<<i+1<<": ";
            cin>>CurrentDigit;
            int Summ=0;
            for(int j=0;j<32;j++)
                {
                    Summ+=(CurrentDigit>>j)&0x01;
                }
 
                if(Summ>BiggestAmountOfTrues)
                {
                    BiggestAmountOfTrues=Summ;
                        Result=CurrentDigit;
                }
        }
    cout<<"\Chislo v kotorom bolishe vsego edinits = "<<Result;
 
        getch();
    return 0;
}
//---------------------------------------------------------------------------

#include <iostream>
 
int weight(int n); // Вес числа (количество единиц)
 
using namespace std;
 
int main()
{
    int n;
    cout << "Input max number: ";
    cin >> n;
    ++n;
    int *arr = new int[n];
 
    // Получение простых чисел
    // Инициализация
    for (int i = 0; i < n; ++i)
        arr[i] = i;
    // Решето Эратосфена
    for (int i = 2; i*i < n; ++i)
    {
        if (arr[i] > 0);
            for (int j = i*i; j < n; j += i)
                arr[j] = 0;
    }
 
    // Определение числа с максимальным весом (количеством единиц)
    int maxweight = 0;
    int num = 0;
    for (int i = 2; i < n; ++i)
    {
        if (weight(arr[i]) > maxweight)
        {
            maxweight = weight(arr[i]);
            num = arr[i];
        }
    }
    cout << "weight(" << num << ") = " << maxweight << endl;
 
    delete [] arr;
    return 0;
}
 
// Определение веса числа
int weight(int n)
{
    int cnt = 0;
    while (n)
    {
        ++cnt;
        n &= n-1;
    }
    return cnt;
}

#include <iostream>
#include <stdarg.h>
using namespace std;
 
// параметр size - указывает на кол-во параметров
int  bin_max(int size, ...) {
   va_list arg;
   va_start(arg, size);
   int a = 0, b = 0, cnt = 0, tmp = 0, n = 0;
   while(size--) {
       cnt = va_arg(arg, unsigned int);
       tmp = cnt;
       for(; cnt; cnt >>= 1) {
          if(cnt & 0x1)
              a++;
       }
       if(a > b) {
          b   = a;
          n   = tmp;
       }
       a = 0;
   }
   va_end(arg);
   return  n;
}
 
 
 
int main(void) {
 
   cout << bin_max(2,   255,16)               << endl;
   cout << bin_max(4,   300,200,128,30)   << endl;
   cout << bin_max(7,   8,1,2,9, 0, 7, 4)   << endl;
   cout << bin_max(3,   24, 32, 64)          << endl;
 
   cin.get();
   return 0;
}

#include <conio.h>
#include <iostream.h>
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
    int DigitsAmount;
    cout<<"Vvedite kolichestvo chisel N: ";
        cin>>DigitsAmount;
        if(DigitsAmount<=0)
        {
            cout<<"Oshibka!!! N doljno biti > 0";
        }
        int CurrentDigit;
        int BiggestAmountOfTrues=0;
        int Result=0;
        int * SipleDigitsArray = new int [DigitsAmount];
    bool * TestSimpleArray = new bool[DigitsAmount];
        memset(TestSimpleArray, 0x00, sizeof(bool)*DigitsAmount);
    for(int k = 2; k < DigitsAmount; k++)
            TestSimpleArray[k] = true;
    for(int i = 2; i < sqrt(DigitsAmount); i++)
    {
            if(TestSimpleArray[i] == true)
            {
                for(int j = i * 2; j < DigitsAmount; j++)
                {
                        if(!(j % i))
                            TestSimpleArray[j] = false;
                }
                }
        }
        for(int i=0;i<DigitsAmount;i++)
        {
            if(!TestSimpleArray[i])
                    continue;
            CurrentDigit = i;
            cout<<"chislo "<< i+1<< " = :"<<CurrentDigit<<"\n";
 
            int Summ=0;
            for(int j=0;j<32;j++)
                {
                    Summ+=(CurrentDigit>>j)&0x01;
                }
 
                if(Summ>BiggestAmountOfTrues)
                {
                    BiggestAmountOfTrues=Summ;
                        Result=CurrentDigit;
                }
        }
    cout<<"\Chislo v kotorom bolishe vsego edinits = "<<Result;
        getch();
        delete [] TestSimpleArray;
        delete [] SipleDigitsArray;
    return 0;
}
//---------------------------------------------------------------------------