C Numero representado como soma de primos em C

Marcelly · 24 de março de 2020

Estou trabalhando em um código, porém não consigo compreender o que há de errado. A sequencia só funciona para a primeira entrada, e depois simplesmente apaga. É suposto que o usuario entre com um numero qualquer (0 a 10ˆ8) e o programa retorne se aquele numero inserido pode ser representado como a soma de 4 primos , por exemplo:

Entrada: 87

Saída: 2ˆ2 + 3ˆ2+ 5ˆ2+7ˆ2

Entrada: 100

Saída: Não é possível a representação

Qualquer dica, agradeço imensamente.

Obs: É proibido utilizar funções, vetores, breaks e etc. É um trabalho de faculdade sobre as funções mais básicas: ifs, fors e whiles. Obrigada!

Eis o código:

#include <stdio.h>
#include <math.h>

int main() {

    int j1, j2, j3, j4, next, i, numb, prime;

    printf("Entrada: ");
    scanf("%d", &n);

    while(1){
        if((j1 *j1) + (j2 *j2) + (j3 *j3) + (j4 *j4) == n){
            printf("Saida: %d + %d + %d + %d", j1, j2, j3, j4);
        }
        next = p4+2;
        if(next > n)
        printf("Impossivel");
        while(1)
        for(i=3; i<= sqrt(next); i=i+2){
            if(next % i == 0)
                prime = false;
                    else{
                        prime = true;}
        }
        if(prime == true){
                p1=p2;
                p2=p3;
                p3=p4;
                p4=next;
            }
            else{
                next = next +2;}
    }

        return 0;
        }

devair1010 · 24 de março de 2020

@Marcelly parece que ele entra dentro do segundo while e como é um loop eterno , ele fica ali dentro pois não pode usar break , por isso não mostra nada ns tela .

arfneto · 25 de março de 2020

6 horas atrás, Marcelly disse:

A sequencia só funciona para a primeira entrada, e depois simplesmente apaga. É suposto que o usuario entre com um numero qualquer (0 a 10ˆ8) e o programa retorne se aquele numero inserido pode ser representado como a soma de 4 primos , por exemplo:

Entrada: 87

Saída: 2ˆ2 + 3ˆ2+ 5ˆ2+7ˆ2

Entrada: 100

Saída: Não é possível a representação

Está certa sobre esse enunciado? Está de fato escrito assim e só tem isso?

Isso não é a soma de 4 primos, é a soma de 4 primos ao quadrado. E nada se fala sobre os tais primos. Podem ser quaisquer primos? No exemplo são consecutivos. Será sempre assim? É uma restrição do enunciado?

É um problema interessante, mas estou duvidando de que tenham proposto algo assim. É algo um pouco sofisticado para um programa que não seja de algo tipo um curso de simulação ou Teoria dos Números ou Análise Combinatória ou algo assim.

Eis o que você teria que fazer: pegar todos os possíveis grupos de 4 primos possíveis considerando o número digitado e simular. As menores parcelas seriam claro 4, 9 e 25. E aí teria que achar o maior possível primo do conjunto, que seria o menor que a raiz quadrada de (N-38) para o número digitado N.

Imagino que tenha entendido a origem disso, mas um exemplo ajuda

2,3 e 5 são os primeiros primos, então 4, 9 e 25 são as menores parcelas substituindo lá na fórmula.
Somando isso dá 38. Então x = (n-38) é o que sobra. No seu exemplo de N = 87 teriamos x = (87-38) = 49, e fica fácil de ver porque 49 é 7 * 7 e tem a solução. Claro, esse é o menor número possível e por isso o exemplo. Trivial.

Mas e se o número fosse, digamos, 1000?

1000 - 38 = 962
raiz quadrada de 962 fica entre 31 e 32. 962 = 31*31 + 1 na verdade
então o maior primo possivel teria que ser o anterior a 31, já que 31 obviamente não serve: 29 no caso.
Note que como 962 é 31*31+1--- 31 é primo --- então 999 serviria: 2+2 + 3*3 + 5+5 + 31*31 = 999
Voltando ao 1000: então o maior primo possível seria 29 e teriamos que testar as possíveis combinações de 4 primos ao quadrado nesse conjunto de primos entre 2 e 29: [2,3,5,7,11,13,17,19,23,29]
Combinações de 10 elementos 4 a 4: tema de cursinho.

Resumindo:

Calcula o último primo possível
Calcula o total de combinações
Testa uma por uma
Game Over

Estou escrevendo sem pensar muito mas acho que é isso.

De volta ao seu programa:


    int j1, j2, j3, j4, next, i, numb, prime;

    printf("Entrada: ");
    scanf("%d", &n);

    while(1){
        if((j1 *j1) + (j2 *j2) + (j3 *j3) + (j4 *j4) == n){
            printf("Saida: %d + %d + %d + %d", j1, j2, j3, j4);
        }

Pra que está lendo o número antes do programa estar pronto? Só vai te atrasar. Use uma atribuição simples. Não leva a nada ler o número, exeto que você tem que perder um tempo.

Então não sei se entendi o que está tentando fazer. Ou melhor, não entendi mesmo.

int j1, j2, j3, j4, next, i, numb, prime;

Não inicializou nenhuma dessas variáveis. E aí escreve

 while(1)
{
        if((j1 *j1) + (j2 *j2) + (j3 *j3) + (j4 *j4) == n)
		{
            printf("Saida: %d + %d + %d + %d", j1, j2, j3, j4);
        }
        next = p4+2;
        if(next > n) printf("Impossivel");
        while(1)
        for(i=3; i<= sqrt(next); i=i+2){
                               
                               
                               ... continua

Está comparando a soma de 4 quadrados de números de você não leu e não vieram de lugar algum, para ver se é igual a um número que você leu. Vai levar a lugar algum também. Porque 4 quadrados?
Que seria p4+2?
Se por acaso (p4+2) for menor ou igual a n você vai entrar em outro loop, while(1) onde vai ficar para todo o sempre.
7 horas atrás, Marcelly disse:

if(prime == true){

. como esse prime não foi inicializado pode ser qualquer coisa.
C não tem essas constantes true e false

adicionado 11 minutos depois

Maldade não dizer a fórmula. Então aí está, como vimos no ensino médio. Ou no cursinho...

Para um conjunto de N elementos os possíveis conjuntos de k elementos serão

N! / (k! * (n-k)!)

considerando k < N e sem repetição. Para o exemplo de 1000 seriam 10 primos e então apenas 210 combinações.

Par valores de até 10^8 vai dar uma distração para seu computador por um tempinho.

Marcelly · 25 de março de 2020

@arfneto Olá! Como vai? Obrigada pela sua resposta. Na verdade eu venho alterando o código pois estou o dia inteiro mexendo nele e cada hora chego em uma conclusão diferente. Vou postar o código abaixo, e tentar explicar mais ou menos o problema que estou enfrentando agora:

1- Nao consigo enxergar uma forma de fazer isso sem True ou False;

2- Nao posso utilizar breaks, ja tentei whiles e etc mas nada dá certo;

3 - Era suposto fazer um loop para que o usuário só parasse de dar entradas se por acaso ele digitasse zero, e o programa deve funcionar para 0 < n < 10ˆ8;

4 - Não consigo incluir a saída para o caso de o numero não conseguir ser representado pelo quadrado de 4 números primos consecutivos.

Eis o código que tenho até agora:

Se você notar, se eu insiro um numero qualquer, por exemplo: 2020, o programa me retorna que ele pode ser representado pela soma de 17ˆ2+19ˆ2+23ˆ2+29ˆ2, ou se eu insiro 100 por exemplo, ele deveria me retornar que é impossível, mas ele fica pensando e não retorna nada.

Peço desculpas pela alteração do código anterior e do enunciado. Fiz alterações omitindo o que achava que já tinha em mãos, mas me enganei. É que horas e horas mexendo com isso, cada hora que penso estar no caminho certo, acho que embaralho mais ainda o conjunto.

#include <stdio.h>


#define TRUE 1
#define FALSE 0

int main() {

	int p1=2, p2=3, p3=5, p4=7, next, i, n, prime;

	printf("Entrada: ");
	scanf("%d", &n);

	while (TRUE){
		if((p1*p1) + (p2*p2) + (p3*p3) + (p4*p4) == n){
			printf("Saida: %dˆ2 + %dˆ2 + %dˆ2 + %dˆ2\n", p1, p2, p3, p4);
				break;
		}
		next = p4 + 2;
		if (next > n) {
				printf("Impossivel a representacao");
				break;}
			if(next < n) {
			prime = FALSE;
			while (next < n && prime == FALSE) {
				prime = TRUE;
				for (i=3; i < next && prime == TRUE; i+=2) {
					if (next % i == 0)
						prime = FALSE;		
				}
				if (prime == TRUE) {
					p1 = p2;
					p2 = p3;
					p3 = p4;
					p4 = next;
			}
				else {
					next += 2;
							}
				
						}
					}
				}

	return 0;
	}

adicionado 4 minutos depois

Digite um numero (0 < n < 10^8): 100
Nao existem 4 primos consecutivos cujos quadrados somam 100

Digite um numero (0 < n < 10^8): 1002172
1002172 = 491^2 + 499^2 + 503^2 + 509^2
Digite um numero (0 < n < 10^8): 0

Boa sorte!

Essa é a saída esperada pelo programa, @arfneto. Mas estou enfrentando dificuldade em defini-la.

arfneto · 25 de março de 2020

24 minutos atrás, Marcelly disse:

1- Nao consigo enxergar uma forma de fazer isso sem True ou False

Não precisa: 0 é false. O resto é true em C.

25 minutos atrás, Marcelly disse:

2- Nao posso utilizar breaks, ja tentei whiles e etc mas nada dá certo;

Não pode usar funções? Sei que já perguntei isso. Pode usar labels?

25 minutos atrás, Marcelly disse:

3 - Era suposto fazer um loop para que o usuário só parasse de dar entradas se por acaso ele digitasse zero, e o programa deve funcionar para 0 < n < 10ˆ8

Uma versão chique de dizer que o número pode ter até 8 dígitos. O loop não acrescenta nada. Use um valor constante ou o próprio argumento da linha de comando para testar. Depois em 5 minutos você põe um loop

28 minutos atrás, Marcelly disse:

Essa é a saída esperada pelo programa, @arfneto. Mas estou enfrentando dificuldade em defini-la.

Então os primos são consecutivos mesmo? Isso simplifica MUITO as coisas. Perde um pouco da graça, mas simplifica.

adicionado 1 minuto depois

Entendo quando o instrutor diz que você não pode por exemplo usar qsort() em seu programa de sort, ou strtok() no seu programa de manipulação de strings, mas um break? um continue?

Qual o propósito?

Marcelly · 25 de março de 2020

@arfneto Entao, nao é permitido utilizar funcoes, nem vetores, nem breaks nem nada. Na verdade eu inseri o break após ler muito e ver alguns exemplos pelo Google pois n tinha e continuo n tendo ideia do que utilizar. Eles exigem que voce utilize apenas o que foi visto em aula até aqui: if, for e while, nada além. Unica biblioteca permitida é <stdio.h> Para quem está iniciando na linguagem, é um pouco pesado devo dizer. voce poderia me dizer mais detalhadamente como coloco em pratica suas observacoes? Muitissimo obrigada ate aqui.

arfneto · 25 de março de 2020

16 minutos atrás, Marcelly disse:

Eles exigem que voce utilize apenas o que foi visto em aula até aqui: if, for e while, nada além. Unica biblioteca permitida é <stdio.h> Para quem está iniciando na linguagem, é um pouco pesado devo dizer

Esse é um jeito bem infantil de tentar ensinar. Meio estúpido eu diria. Em especial no caso de matemática ou computação. Mas se é assim não dá pra discutir. Apenas fica mais complicado. E essa dificuldade adicional não vai te ensinar nada.Uma função por exemplo é só um trecho de código com um nome. Só que você chama em um loop sem ter que repetir tudo.

Entendeu as coisas que eu falei?

20 minutos atrás, Marcelly disse:

voce poderia me dizer mais detalhadamente como coloco em pratica suas observacoes

Vou ler agora o seu programa considerando as restrições de que falou. Vi que corrigiu muitos dos problemas.

adicionado 0 minutos depois

Usar um vetor também está off-limits?

adicionado 15 minutos depois

		// o ideal aqui seria passar para o proximo primo direto
		// mas sem funcoes nao da
		next = p4 + 2; // p4 e impar
		if (next > n)
		{
			printf("Nao e possivel a representacao\n");
			break;
		};	// if()
		if (next < n) {
			prime = FALSE;

Por enquanto o programa testa para apenas um número então pode retornar se (next > n)

Talvez seja o caso de declarar um novo int, tipo proximo_primo, calcular o valor e a partir dai fazer a rotação deles, desprezando o p1 e voltando ao loop. Acho que é só isso que falta.

Marcelly · 25 de março de 2020

@arfneto Sim, vetor está fora dos limites. Eu concordo contigo, acho que todas essas restricoes acabam piorando o aprendizado.
voce chegou a rodar o programa? Esse trecho de codigo que voce postou por ultimo, nunca retorna que a representação não é possivel. É uma das coisas que está me deixando louca kkk

O next acho que faz exatamente isso que você disse de proximo primo. voce pode ver no final do codigo que existe p1 = p2, p2 = p3 e etc.

arfneto · 25 de março de 2020

1 minuto atrás, Marcelly disse:

voce chegou a rodar o programa? Esse trecho de codigo que voce postou por ultimo, nunca retorna que a representação não é possivel. É uma das coisas que está me deixando louca kkk

O next acho que faz exatamente isso que você disse de proximo primo. voce pode ver no final do codigo que existe p1 = p2, p2 = p3 e etc

Rodei sim. Mas acho que esse trecho não está ok ainda. Estou conferindo. Coloque uma mensagem lá.

Uma raiz quadrada tambem estaria condenada aqui?

Marcelly · 25 de março de 2020

@arfneto Sim, pois raiz quadrada precisaria da library math.h e nao posso utiliza-la...

arfneto · 25 de março de 2020

2 minutos atrás, Marcelly disse:

@arfneto Sim, pois raiz quadrada precisaria da library math.h e nao posso utiliza-la...

nem sei porque ue perguntei mais um loop então

adicionado 6 minutos depois

		if(next < n) {
			prime = FALSE;
			while (next < n && prime == FALSE) {
				prime = TRUE;
				for (i=3; i < next && prime == TRUE; i+=2) {
					if (next % i == 0)
						prime = FALSE;		
				}

Não entendi esse trecho. O que pretende fazer?

Testou se next está de fato com o próximo primo, como colocando um printf() ali ou usando o debugger?

adicionado 17 minutos depois

		if (next > n)
		{
			printf("Nao e possivel a representacao\n");
			return 0;
		};	// if()
		// se ainda da, rodamos a tabela de primos
		p1 = p2;
		p2 = p3;
		p3 = p4;
		p4 = next;
		// e continuamos
	};	// while()

O final pode ser só isso. Despreza o menor primo e continua igualzinho

adicionado 20 minutos depois

		// p4 e o ultimo primo
		// nas proximas linhas vamos definir next como
		// sendo... o proximo primo depois de p4
		int achou_proximo = FALSE;
		next = 0;
		for (long int i = p4 + 2; !achou_proximo; i = i + 2)
		{
			unsigned long int maior = (unsigned long int)sqrt((double)i);
			unsigned long int fator = 3;
			while (fator <= maior)
			{
				if (i % fator == 0)
				{	// entao 'i' nao e primo
					// forca sair do loop
					fator = 100000000; // tanto faz
				}
				else
				{
					fator = fator + 2;
				}
			}	// end while
			if (fator != (100000000))
			{
				next = i;
				achou_proximo = TRUE;
			};	// if()
		};	// for()
		// saindo daqui temos o primo depois de p4 em next

Esse trecho funciona. Leia com atenção e teste. Falta só tirar o sqrt(). Mais uns minutos

adicionado 30 minutos depois

Ok ok

troque por essas 3 linhas

			long int maior = 0;
			for (maior = 7; (maior * maior) < i; maior += 1);
			maior = maior - 1; // passou 1 da conta no for

E não precisa de math.h

arfneto · 25 de março de 2020

Se colocar o loop todo dentro disso

vai rodar até o cara entrar com zero desde que consiga ler algo. Dentro do segundo do{}while está o programa todo claro. Só tem duas maneiras de sair: ou sim ou nao para o numero. E aí volta para ler outro. Sem mais

adicionado 0 minutos depois

Claro, o código original é a parte que está entre { ... }

arfneto · 26 de março de 2020

Como agora o programa roda para vários números tem um erro no que eu escrevi. É preciso reiniciar a quadrilha no início de cada cálculo. Então logo depois do primeiro do{} seria um bom lugar para escrever

    p1=2; p2=3, p3=5; p4=7; // para um novo N

Também pode só atribuir os valores, usando ',' e não ';' e deixando a declaração onde está.

		p1 = 2, p2 = 3, p3 = 5, p4 = 7;

arfneto · 26 de março de 2020

Então você fez o programa que mostra se um número de até 8 dígitos pode ser escrito como a soma dos quadrados de 4 primos consecutivos. E como testar esse trem?

Bonus: a tabela pra ajudar a testar o programa

Imagine que exista a função

unsigned int   	proximo_primo(unsigned int);

que devolve a cada chamada o próximo primo. E você chama com zero para iniciar a sequência.

Então esse código

	// lista os numeros N da forma N = A*A + B*B + C*C + D*D 
	// onde A B C e D sao primos  consecutivos
	unsigned int p1, p2, p3, p4; // os 4 primeiros
	unsigned int N;
	proximo_primo(0);
	p1 = proximo_primo(1); // 2
	p2 = proximo_primo(1); // 3
	p3 = proximo_primo(1); // 5
	p4 = proximo_primo(1); // 7
	int seq = 1;
	while (1)
	{	
		N = (p1*p1) + (p2*p2) + (p3*p3) + (p4*p4);
		if (N > 10000000) break;
		printf(
			"%3d: %10d = %ld + %ld + %ld + %ld\
\t[%d,%d,%d,%d]\n",
			seq, N, (p1*p1), (p2*p2), (p3*p3), (p4*p4),
			p1, p2, p3, p4 );
		seq += 1;
		p1 = p2;
		p2 = p3;
		p3 = p4;
		p4 = proximo_primo(1);
	};	// while()

Mostra que tem 247 valores, e as parcelas e os primos usados

  1:         87 = 4 + 9 + 25 + 49       [2,3,5,7]
  2:        204 = 9 + 25 + 49 + 121     [3,5,7,11]
  3:        364 = 25 + 49 + 121 + 169   [5,7,11,13]
  4:        628 = 49 + 121 + 169 + 289  [7,11,13,17]
  5:        940 = 121 + 169 + 289 + 361 [11,13,17,19]
  6:       1348 = 169 + 289 + 361 + 529 [13,17,19,23]
  7:       2020 = 289 + 361 + 529 + 841 [17,19,23,29]
  8:       2692 = 361 + 529 + 841 + 961 [19,23,29,31]
  9:       3700 = 529 + 841 + 961 + 1369        [23,29,31,37]
 10:       4852 = 841 + 961 + 1369 + 1681       [29,31,37,41]
...
241:    9443740 = 2319529 + 2343961 + 2380849 + 2399401 [1523,1531,1543,1549]
242:    9536020 = 2343961 + 2380849 + 2399401 + 2411809 [1531,1543,1549,1553]
243:    9622540 = 2380849 + 2399401 + 2411809 + 2430481 [1543,1549,1553,1559]
244:    9697180 = 2399401 + 2411809 + 2430481 + 2455489 [1549,1553,1559,1567]
245:    9765820 = 2411809 + 2430481 + 2455489 + 2468041 [1553,1559,1567,1571]
246:    9847252 = 2430481 + 2455489 + 2468041 + 2493241 [1559,1567,1571,1579]
247:    9922660 = 2455489 + 2468041 + 2493241 + 2505889 [1567,1571,1579,1583]


Listados 247 valores

Pra quando você está com a calculadora na mão e uma tabela de primos e quer conferir as parcelas.

Mas pode ser que você só queira os números mesmo e aí é só mudar a impressão:


	proximo_primo(0);
	p1 = proximo_primo(1);
	p2 = proximo_primo(1);
	p3 = proximo_primo(1);
	p4 = proximo_primo(1);
	printf("Iniciando com [%d,%d,%d,%d]\n",
		p1, p2, p3, p4);
	seq = 0;
	N = 0;
	N = (p1*p1) + (p2*p2) + (p3*p3) + (p4*p4);
	while (N < 10000000)
	{	seq += 1;
		printf("%8ld    ", N);
		if (seq % 8 == 0) printf("\n");
		p1 = p2;
		p2 = p3;
		p3 = p4;
		p4 = proximo_primo(1);
		N = (p1*p1 + p2*p2 + p3*p3 + p4*p4);
	};	// while()
	printf("\n\nListados %d valores\n\n", seq);

E ver a tabela toda

      87         204         364         628         940        1348        2020        2692
    3700        4852        5860        7108        8548       10348       12220       14500
   16732       18580       21100       23500       26380       30460       34420       38140
   41668       44140       46708       52228       57940       64828       71380       77452
   83092       88972       96220      101908      109036      116428      122620      131212
  138532      145300      152140      160180      172660      185380      198220      207988
  215380      221932      232492      244252      256300      270580      281020      291700
  301492      309220      321628      339148      356908      374788      389428      404740
  421588      444028      465340      480388      495700      509980      527308      546340
  564148      580780      599260      616420      637012      661252      680884      705844
  726052      743212      762220      778060      799420      819220      837340      853828
  874420      899068      925780      956692      980260     1002172     1032532     1057060
 1096732     1136860     1175668     1219108     1250188     1277020     1299700     1327300
 1355188     1387948     1416220     1440100     1464220     1486108     1508068     1537780
 1572892     1605652     1641100     1669348     1692748     1716220     1750540     1782460
 1814668     1855228     1893700     1938052     1988524     2039572     2085460     2128900
 2163988     2199460     2235220     2268220     2307532     2341060     2387380     2443468
 2506588     2566780     2621452     2663572     2693020     2722540     2752420     2802700
 2853220     2903860     2944708     2986228     3027940     3069748     3111748     3165268
 3219028     3283900     3360172     3415492     3471052     3523300     3568468     3625588
 3682948     3740668     3798748     3845740     3896908     3960460     4020340     4076620
 4125052     4169932     4210852     4252012     4309972     4351612     4410244     4460692
 4503052     4580020     4644580     4709260     4769908     4804948     4844548     4897588
 4955308     5013340     5108260     5189980     5281420     5378020     5447980     5527540
 5598220     5669380     5745988     5818108     5890588     5958628     6002620     6051700
 6115972     6190612     6305980     6411652     6497740     6574180     6610132     6656500
 6703012     6739300     6780868     6838420     6890860     6953980     7098052     7226980
 7367068     7513300     7618180     7734772     7874572     8003740     8088580     8156788
 8202580     8260060     8323420     8381140     8439100     8509132     8597092     8685172
 8767660     8820940     8856628     8904340     8976292     9078700     9193612     9327460
 9443740     9536020     9622540     9697180     9765820     9847252     9922660

Listados 247 valores

Se alguém precisar o programa está aqui e inclui aquela função gentil. Eu tinha postado isso meses atrás na verdade.

#define _CRT_SECURE_NO_WARNINGS

#include "limits.h"
#include "math.h"
#include "stdio.h"

unsigned int   	proximo_primo(unsigned int);
int				retorna_um_se_primo(unsigned int);

int main()
{
	// lista os numeros N da forma N = A*A + B*B + C*C + D*D 
	// onde A B C e D sao primos  consecutivos
	unsigned int p1, p2, p3, p4; // os 4 primeiros
	unsigned int N;
	proximo_primo(0);
	p1 = proximo_primo(1); // 2
	p2 = proximo_primo(1); // 3
	p3 = proximo_primo(1); // 5
	p4 = proximo_primo(1); // 7
	int seq = 1;
	//if (seq == 0) return 0;
	while (1)
	{	
		N = (p1*p1) + (p2*p2) + (p3*p3) + (p4*p4);
		if (N > 10000000) break;
		printf(
			"%3d: %10d = %ld + %ld + %ld + %ld\
\t[%d,%d,%d,%d]\n",
			seq, N, (p1*p1), (p2*p2), (p3*p3), (p4*p4),
			p1, p2, p3, p4 );
		seq += 1;
		p1 = p2;
		p2 = p3;
		p3 = p4;
		p4 = proximo_primo(1);
	};	// while()
	// tinha passado: soma antes
	printf("\n\nListados %d valores\n\n", seq-1);

	proximo_primo(0);
	p1 = proximo_primo(1);
	p2 = proximo_primo(1);
	p3 = proximo_primo(1);
	p4 = proximo_primo(1);
	printf("Iniciando com [%d,%d,%d,%d]\n",
		p1, p2, p3, p4);
	seq = 0;
	N = 0;
	N = (p1*p1) + (p2*p2) + (p3*p3) + (p4*p4);
	while (N < 10000000)
	{	seq += 1;
		printf("%8ld    ", N);
		if (seq % 8 == 0) printf("\n");
		p1 = p2;
		p2 = p3;
		p3 = p4;
		p4 = proximo_primo(1);
		N = (p1*p1 + p2*p2 + p3*p3 + p4*p4);
	};	// while()
	printf("\n\nListados %d valores\n\n", seq);
};	// main()

int				retorna_um_se_primo(unsigned int n)
{
	if (n < 2)		return 0;
	if (n == 2)		return(1);
	if (n % 2 == 0) return(0);
	unsigned int maior = (unsigned int)sqrt((double)n);
	unsigned int fator = 3;
	while (fator <= maior)
	{
		if (n % fator == 0) return 0;
		fator += 2;
	}	// end while
	return 1;
}	// end retorna_zero_se_primo()

unsigned int	proximo_primo(unsigned int n)
{
	static int	 iniciado = 0;
	static int	 proximo = 0;

	if (n == 0)						// inicia a serie
	{
		iniciado = 1;
		proximo = 2;
		return 1;
	}	// end if

	if (iniciado == 0) return 0;		// erro: tem que chamar com 0 antes

	if (proximo == 2)
	{
		proximo = 1;
		return 2;
	}	// end if

	// normal: a a partir daqui retorna o proximo primo
	for (int i = proximo + 2;; i += 2)
		if (retorna_um_se_primo(i))
		{
			proximo = i;
			return proximo;
		}	// end if
}	// end proximo_primo()

// fim do texto

adicionado 18 minutos depois

Esqueci de postar... como já resolveu o problema, pode comparar com o programa de teste que eu tinha postado, e com a correção de que falei acima, em https://github.com/ARFNeto-CH/chc-4primos ou só ver o programa aqui https://github.com/ARFNeto-CH/chc-4primos/blob/master/cp4.c

A saída é algo assim:

[Max 8 digitos] Entre com N: 87
2^2 + 3^2 + 5^2 + 7^2
[Max 8 digitos] Entre com N: 204
3^2 + 5^2 + 7^2 + 11^2
[Max 8 digitos] Entre com N: 364
5^2 + 7^2 + 11^2 + 13^2
[Max 8 digitos] Entre com N: 628
7^2 + 11^2 + 13^2 + 17^2
[Max 8 digitos] Entre com N: 940
11^2 + 13^2 + 17^2 + 19^2
[Max 8 digitos] Entre com N: 1348
13^2 + 17^2 + 19^2 + 23^2
[Max 8 digitos] Entre com N: 9922660
1567^2 + 1571^2 + 1579^2 + 1583^2
[Max 8 digitos] Entre com N: 9000000
Nao e possivel a representacao
[Max 8 digitos] Entre com N: 41668
97^2 + 101^2 + 103^2 + 107^2
[Max 8 digitos] Entre com N: 0
Encerrando...