C++ Project Euler - Exercício 133 erros

[Fabiano Rauzer]

Bom dia. Tentei solucionar o exercício 133 do Project Eueler e obtive alguns erros aos quais não estou conseguindo resolver. Deixarei o código e os erros logo após. Obrigado desde já a quem puder ajudar.

 

#include <iostream>
#include <vector>

// return (a*b) % modulo
unsigned long long mulmod(unsigned long long a, unsigned long long b, unsigned long long modulo)
{
  // (a * b) % modulo = (a % modulo) * (b % modulo) % modulo
  a %= modulo;
  b %= modulo;

  // fast path
  if (a <= 0xFFFFFFF && b <= 0xFFFFFFF)
    return (a * b) % modulo;

  // we might encounter overflows (slow path)
  // the number of loops depends on b, therefore try to minimize b
  if (b > a)
    std::swap(a, b);

  // bitwise multiplication
  unsigned long long result = 0;
  while (a > 0 && b > 0)
  {
    // b is odd ? a*b = a + a*(b-1)
    if (b & 1)
    {
      result += a;
      result %= modulo;
      // skip b-- because the bit-shift at the end will remove the lowest bit anyway
    }

    // b is even ? a*b = (2*a)*(b/2)
    a <<= 1;
    a  %= modulo;

    // next bit
    b >>= 1;
  }

  return result;
}

// return (base^exponent) % modulo
unsigned long long powmod(unsigned long long base, unsigned long long exponent, unsigned long long modulo)
{
  unsigned long long result = 1;
  while (exponent > 0)
  {
    // fast exponentation:
    // odd exponent ? a^b = a*a^(b-1)
    if (exponent & 1)
      result = mulmod(result, base, modulo);

    // even exponent ? a^b = (a*a)^(b/2)
    base = mulmod(base, base, modulo);
    exponent >>= 1;
  }
  return result;
}

int main()
{
  // a large exponent for powmod => 10^(10^19)
  const unsigned long long digits = 10000000000000000000ULL;

  unsigned int tests = 1;
  std::cin >> tests;
  while (tests--)
  {
    unsigned int maxPrime = 100000;
    std::cin >> maxPrime;

    unsigned long long sum = 0;
    std::vector<unsigned int> primes;
    for (unsigned int i = 2; i < maxPrime; i++)
    {
      bool isPrime = true;

      // test against all prime numbers we have so far (in ascending order)
      for (auto x : primes)
      {
        // prime is too large to be a divisor
        if (x*x > i)
          break;

        // divisible => not prime
        if (i % x == 0)
        {
          isPrime = false;
          break;
        }
      }

      // no prime
      if (!isPrime)
        continue;

      primes.push_back(i);

      // check for divisibility by 9*prime
      auto modulo = 9 * i;
      // remainder must not be 1
      auto remainder = powmod(10, digits, modulo);
      if (remainder != 1)
        sum += i;
    }

    std::cout << sum << std::endl;
  }

  return 0;
}

Obtenho os seguintes erros (deixarei anexado a imagem dos erros também):

Line 81 Col 17: [error] 'x' does not a name a type 
Line 96 Col 7 [error] expected ';' before 'if'
Line 96 Col 7 [error] expected primary-expression before 'if'
 

[arfneto]

Devia deixar o enunciado aqui ou ao menos um link para o enunciado... 

Pode ser que alguém possa te ajudar mas não tenha ideia do que é isso. Como eu  

 

off-topic

 const unsigned long long digits = 10000000000000000000ULL;

Note que em C e C++ você pode escrever

    const unsigned long long digits = 10'000'000'000'000'000'000ULL;

Como o  "_" em java, esse é o separador de dígitos nessas linguagens

 

Acho que não foi você que escreveu esse programa, certo?

 

Não estaria usando um desses IDE antigos que vem configurados para o padrão da linguagem de 22 anos atrás, estaria? 

Tipo -std=c++98, o padrão da linguagem em 1998 onde auto por exemplo não estava disponível?

 

Se for o caso mude para -std=c++17... ou ao ao menos -std=c++11 que já é suficiente para compilar isso. Eu acho, porque meu IDE só aceita a partir de c++14 então não dá pra testar agora.
 

[Fabiano Rauzer]

@arfneto Muito obrigado. 
Sim, eu peguei esse código e estou tentando resolver o problema. Segue o enunciado: 
 

A number consisting entirely of ones is called a repunit. We shall define R(k) to be a repunit of length k; for example, R(6) = 111111.

Let us consider repunits of the form R(10n).

Although R(10), R(100), or R(1000) are not divisible by 17, R(10000) is divisible by 17. Yet there is no value of n for which R(10n) will divide by 19. In fact, it is remarkable that 11, 17, 41, and 73 are the only four primes below one-hundred that can be a factor of R(10n).

Find the sum of all the primes below one-hundred thousand that will never be a factor of R(10n).