Reto en C

Aprende haskell y lo haces en 2 líneas, inútil.

Pues dime más, putot3.

Si logro hacer una función que me calcule los divisores de un número y los sume, tengo el programa hecho.

#8, tu código me da una violación de segmento con el número 1, pero es curioso que solo cuando pongo Divisores(1), pero cuando "i" vale 1 en un bucle, no me falla :S

Lo he sacado ya, pero tengo que adivinar por qué cojones me hace el de 220 y el de 284, cuando supuestamente he hecho una cosa para que solo me saque una vez cada par.

Pos no da errores ni na...
mv.c: En la funció "main":
mv.c:18: error: error sintàctic before "funcion"
mv.c:25: error: error sintàctic before "for"

Hay, estas universidades de pago que no enseñan a programar.. xDDDD

Uso GCC, el compilador de GNU

Yo tengo una parte hecha del programa, xo no acaba de funcionar, osea hace todos los pasos, pero no encuentra numeros, xDDDD

Haber si veis mi error, no es de compilacion, sino de que hace como el proceso, pero no me saca los numeros:

#include <stdio.h>
#define MAX 10000
int contador1=0,contador2=0,contador,z,i;
void main(){
printf("\n\nEls números amics son:\n");
for(z=1;z<=MAX;z++){
for(i=1;i<MAX;i++){
if((z%i==0) && i< (z/2)) {
contador1=contador1+i;
}
}
for(i=1;i<MAX;i++){
if((contador1%i==0) && i< (contador/2)){
contador2=contador2+i;
}
}
if(z==contador2){
printf("%d i %d son nombres amics. \n",z,contador2);
}
}
}

P.D:lolmen, si te copias te mato. xD

// Calculador de números amigos, hecho por kaoD para Media-Vida blahblahblahblah
// Bajo licencia HLQTSDLH, "Haz Lo Que Te Salga De Los Huevos".
// No puedes encontrar la copia de la licencia por ningún lado, así que no la busques.

// Nota: Supuestamente debería mostrar solo una vez cada par, pero lo hace dos veces...
// ¿Por qué? Solo Jesucristo y Superman lo saben.

#define MAX 10000

int printf(const char *format, ...);

int sumaDivisores(int n) // Función por TeKaNeO
{
int i;
int suma=0;

for(i=1;i<n;i++) // Incluye el 1 como divisor.
{
	if(n%i==0) // Si el resto de N/i da 0...
	{
		suma=suma+i;
	}
}
return suma;

}

int main (void)
{
int number[MAX];
int sumai;
int sumaj;
int i;

printf("Calculando numeros amigos...\n");

for (i=1; i<=MAX; i++) // Pasa por todos los número del 1 al MAX
{
	if (number[i] != 1) // Si el número no se ha calculado ya
	{
		sumai = sumaDivisores(i); // Calcula la suma de sus divisores
		if (sumai <= MAX) // Si la suma de sus divisores es menor o igual a MAX
		{
			sumaj = sumaDivisores(sumai); // Calcula la suma de los divisores del número anteriormente obtenido.
			if (sumaj == i) // Muy largo de explicar xD
			{
				number[sumai] == 1;
				printf("%d - %d\n",sumai,sumaj);
			}
		}
	}
}
return 0;

}[/i]

number[sumai] = 1;

Salu2

#18

Si tienes ganas de hacer benchmarks podrías echarme una mano con --> www.ecuacionimposible.tk xDD

Salu2

// Nota: Supuestamente debería mostrar solo una vez cada par, pero lo hace dos veces...
// ¿Por qué? Solo Jesucristo y Superman lo saben.

-> Porque los amigos son mutuos. Si llegas a a y <U>a[/u] es amigo de b, muestra a. Luego llegará a b, calculará su amigo, y lo mostrará (a).

#20

El "único" problemilla para Linux es conio.h, pero claro, para hacerlo más"bonito" casi todas las salidas de consola la usan... En cuanto tenga tiempo lo porto.

Salu2

PD: El problema gordo que veo ahora para portarlo a Linux es que no conozco una función equivalente a KBHIT(), que sirve para detectar si una tecla es pulsada (sin detener la ejecución del programa)

LOL, lo que no venga en Google diectamente no es real ...

Ahora portarlo es sólo cuestión de perrería xD

Salu2

EDITADO: Kaod ¿te compila bien esto?-->

kbhit.c


/* ***************************************************************************
*

• Copyright 1992-2005 by Pete Wilson All Rights Reserved
• 50 Staples Street : Lowell Massachusetts 01851 : USA
• http://www.pwilson.net/ [email protected] +1 978-454-4547
  *
• This item is free software: you can redistribute it and/or modify it as
• long as you preserve this copyright notice. Pete Wilson prepared this item
• hoping it might be useful, but it has NO WARRANTY WHATEVER, not even any
• implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  *
  *************************************************************************** */

/* ***************************************************************************
*

• KBHIT.C
  *
• Based on the work of W. Richard Stevens in "Advanced Programming in
• the Unix Environment," Addison-Wesley; and of Floyd Davidson.
  *
• Contains these functions:
  *
• To set the TTY mode:
• tty_set_raw() Unix setup to read a character at a time.
• tty_set_cooked() Unix setup to reverse tty_set_raw()
  *
• To read keyboard input:
• kb_getc() keyboard get character, NON-BLOCKING. If a char
• has been typed, return it. Else return 0.
• kb_getc_w() kb get char with wait: BLOCKING. Wait for a char
• to be typed and return it.
  *
• How to use:
• tty_set_raw() set the TTY mode to read one char at a time.
• kb_getc() read chars one by one.
• tty_set_cooked() VERY IMPORTANT: restore cooked mode when done.
  *
• Revision History:
  *
• DATE DESCRIPTION
• ----------- --------------------------------------------
• 12-jan-2002 new
• 20-aug-2002 cleanup
  *
• Notes:
• ----------- --------------------------------------------
• 25-nov-2003 notate anomoly in some Unices: termattr.c_cc[VMIN] = 0;
  *************************************************************************** */

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include
#include <errno.h>

#ifndef STDIN_FILENO
#define STDIN_FILENO 0
#endif

extern int errno;

static struct termios termattr, save_termattr;
static int ttysavefd = -1;
static enum
{
RESET, RAW, CBREAK
} ttystate = RESET;

/* ***************************************************************************
*

• set_tty_raw(), put the user's TTY in one-character-at-a-time mode.

• returns 0 on success, -1 on failure.
  *
  *************************************************************************** */
  int
  set_tty_raw(void)
  {
  int i;

  i = tcgetattr (STDIN_FILENO, &termattr);
  if (i < 0)
  {
  printf("tcgetattr() returned %d for fildes=%d\n",i,STDIN_FILENO);
  perror ("");
  return -1;
  }
  save_termattr = termattr;

  termattr.c_lflag &= _{ECHO | ICANON | IEXTEN | ISIG};
  termattr.c_iflag &= _{BRKINT | ICRNL | INPCK | ISTRIP | IXON};
  termattr.c_cflag &= _{CSIZE | PAREN};
  termattr.c_cflag |= CS8;
  termattr.c_oflag &= _OPOST;

  
  

  termattr.c_cc[VMIN] = 1; /* or 0 for some Unices; see note 1 */
  termattr.c_cc[VTIME] = 0;

  i = tcsetattr (STDIN_FILENO, TCSANOW, &termattr);
  if (i < 0)
  {
  printf("tcsetattr() returned %d for fildes=%d\n",i,STDIN_FILENO);
  perror("");
  return -1;
  }

  
  

  ttystate = RAW;
  ttysavefd = STDIN_FILENO;

  return 0;
  }

/* ***************************************************************************
*

• set_tty_cbreak(), put the user's TTY in cbreak mode.

• returns 0 on success, -1 on failure.
  *
  *************************************************************************** */
  int
  set_tty_cbreak()
  {
  int i;

  i = tcgetattr (STDIN_FILENO, &termattr);
  if (i < 0)
  {
  printf("tcgetattr() returned %d for fildes=%d\n",i,STDIN_FILENO);
  perror ("");
  return -1;
  }

  save_termattr = termattr;

  termattr.c_lflag &= _{ECHO | ICANON};
  termattr.c_cc[VMIN] = 1;
  termattr.c_cc[VTIME] = 0;

  
  

  i = tcsetattr (STDIN_FILENO, TCSANOW, &termattr);
  if (i < 0)
  {
  printf("tcsetattr() returned %d for fildes=%d\n",i,STDIN_FILENO);
  perror ("");
  return -1;
  }
  ttystate = CBREAK;
  ttysavefd = STDIN_FILENO;

  return 0;
  }

/* ***************************************************************************
*

• set_tty_cooked(), restore normal TTY mode. Very important to call
• the function before exiting else the TTY won't be too usable.
• returns 0 on success, -1 on failure.
  *
  *************************************************************************** */
  int
  set_tty_cooked()
  {
  int i;
  if (ttystate != CBREAK && ttystate != RAW)
  {
  return 0;
  }
  i = tcsetattr (STDIN_FILENO, TCSAFLUSH, &save_termattr);
  if (i < 0)
  {
  return -1;
  }
  ttystate = RESET;
  return 0;
  }

/* ***************************************************************************
*

• kb_getc(), if there's a typed character waiting to be read,

• return it; else return 0.
  *
  *************************************************************************** */
  unsigned char
  kb_getc(void)
  {
  unsigned char ch;
  ssize_t size;

  size = read (STDIN_FILENO, &ch, 1);
  if (size == 0)
  {
  return 0;
  }
  else
  {
  return ch;
  }
  }

/* ***************************************************************************
*

• kb_getc_w(), wait for a character to be typed and return it.
  *
  *************************************************************************** */
  unsigned char
  kb_getc_w(void)
  {
  unsigned char ch;
  size_t size;

  while (1)
  {

  usleep(20000); /* 1/50th second: thanks, Floyd! */

  size = read (STDIN_FILENO, &ch, 1);
  if (size > 0)
  {
  break;
  }
  }
  return ch;
  }

#define TEST
#ifdef TEST

void echo(unsigned char ch);

static enum
{
CH_ONLY, CH_HEX
} how_echo = CH_ONLY;

int
main(int argc, char * argv[])
{
unsigned char ch;

printf("Test Unix single-character input.\n");

set_tty_raw(); /* set up character-at-a-time */

while (1) /* wait here for a typed char /
{
usleep(20000); / 1/50th second: thanks, Floyd! /
ch = kb_getc(); / char typed by user? /
if (0x03 == ch) / might be control-C /
{
set_tty_cooked(); / control-C, restore normal TTY mode /
return 1; / and get out /
}
echo(ch); / not control-C, echo it */
}
}

void
echo(unsigned char ch)
{
switch (how_echo)
{
case CH_HEX:
printf("%c,0x%x ",ch,ch);
break;
default:
case CH_ONLY:
printf("%c", ch);
break;
}

fflush(stdout); /* push it out */
}

#endif /* test */

#ifdef __cplusplus
}
#endif

[/i]

Salu2

W0w!! In-creible
Mu currado estan todos.
Muchas gracias a todos por la ayuda!

Salu2

No es por nada, pero le habéis hecho los deberes...