Foro de elhacker.net

Programación => Programación General => Mensaje iniciado por: WHK en 23 Agosto 2016, 01:47 am


Título: Resto de un numero natural de 200 digitos
Publicado por: WHK en 23 Agosto 2016, 01:47 am
Hola, alguien sabe de algún método para calcular el resto de un numero natural de 200 digitos?, he intentado con gmp pero no me da la longitud.

Saludos.

Título: Re: Resto de un numero natural de 200 digitos
Publicado por: + 1 Oculto(s) en 23 Agosto 2016, 01:51 am
no entiendo muy bien, pero parece interesante tu pregunta

Título: Re: Resto de un numero natural de 200 digitos
Publicado por: _TTFH_3500 en 23 Agosto 2016, 02:02 am
Cita de: WHK en 23 Agosto 2016, 01:47 am
Hola, alguien sabe de algún método para calcular el resto de un numero natural de 200 digitos?, he intentado con gmp pero no me da la longitud.

Saludos.

Creo que hay una manera mirando las ultimas cifras pero no estoy seguro de como, por ejemplo


758412364598471254368451126 MOD 2 = 0

ya que el ultimo digito ('6') es par.

La gracia esta en que solo evaluas unos digitos en lugar de todo el número.

Título: Re: Resto de un numero natural de 200 digitos
Publicado por: + 1 Oculto(s) en 23 Agosto 2016, 02:05 am
claro, hace un tiempo hice ese tipo de ejercicios, por aritmetica modular
https://es.khanacademy.org/computing/computer-science/cryptography/modarithmetic/a/what-is-modular-arithmetic
https://es.khanacademy.org/computing/computer-science/cryptography/modarithmetic/a/congruence-modulo

Título: Re: Resto de un numero natural de 200 digitos
Publicado por: bengy en 23 Agosto 2016, 02:24 am
epa programare haber si lo logro

Título: Re: Resto de un numero natural de 200 digitos
Publicado por: WHK en 23 Agosto 2016, 03:37 am
Lo he logrado con php BC Math xD

http://php.net/manual/en/book.bc.php

Creo que gmp tiene un bug que no permite calcular la diferencia y resto de numeros mayores a 50 cifras, pero con bc math si pude :)

http://php.net/manual/en/function.bcmod.php

Título: Re: Resto de un numero natural de 200 digitos
Publicado por: Eleкtro en 23 Agosto 2016, 04:05 am
En .NET podrías haber utilizado la Class BigIntegers para realizar operaciones con números enteros:

Código
  1. Dim bigInt1 As BigInteger = BigInteger.Parse(String.Format("1{0}", New String("0"c, count:=199)))
  2. ' 10000000000000000000000000000000000000000000000000
  3. ' 00000000000000000000000000000000000000000000000000
  4. ' 00000000000000000000000000000000000000000000000000
  5. ' 00000000000000000000000000000000000000000000000000
  6.  
  7. Dim sum As BigInteger = (bigInt1 + 1)
  8. Dim rest As BigInteger = (bigInt1 - 1)
  9. Dim divide As BigInteger = BigInteger.Divide(bigInt1, New BigInteger(2))
  10. Dim remainder As BigInteger = (bigInt1 Mod divide)

En el código te muestro ejemplos muy básicos, de parsing, de instanciación de la class, de la capacidad de utilización de operadores aritméticos convencionales (+/- Mod/C#: %), y la utilización de métodos aritméticos de la class.

Saludos

Título: Re: Resto de un numero natural de 200 digitos
Publicado por: bengy en 23 Agosto 2016, 04:07 am
pero biginteger internamente es String

Título: Re: Resto de un numero natural de 200 digitos
Publicado por: Eleкtro en 23 Agosto 2016, 04:20 am
Cita de: -rn3w- en 23 Agosto 2016, 04:07 am
pero biginteger internamente es String

...No, en absoluto. BigIntegers no trabaja internamente con Strings, sino mayormente con arrays del tipo Byte (byte[]) como se puede verificar en el código fuente de la class BigInteger y BigNumber:
  • BigInteger.cs Reference Source - .NET Framework 4.6.1 - Microsoft (http://referencesource.microsoft.com/#System.Numerics/System/Numerics/BigInteger.cs)

Obviamente el método BigIntegers.ToString() representará el valor en formato de texto, pues esa es la finalidad de cualquier método que lleve por nombre "ToString", del mismo modo que el método BigIntegers.Parse tomará como parámetro un valor de texto para parsear, pero ese aspecto no tiene nada que ver con el funcionamiento interno del algoritmo, sino con una de las formas que se le facilita al usuario final (el programador) para utilizar la class y representarla. Aparte, el constructor de la class expone varios overloads que aceptan otros datatypes distintos a String, entre ellos los datatypes numéricos convencionales y un array de Byte.

Saludos

Título: Re: Resto de un numero natural de 200 digitos
Publicado por: class_OpenGL en 23 Agosto 2016, 06:22 am
Aquí dejo un programa que hice en C para un problema de Project Euler. El programa calcula la suma total de los dígitos de factorial de 200 (en realidad, el ejercicio pedía de 100, pero puse 200 para que tuviera más de 200 dígitos). En el programa, para obtener los dígitos, tengo que sacar el módulo, así que funciona correctamente (lo digo porque Project Euler dictaminó que mi respuesta era buena).

Código
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3.  
  4. typedef struct {
  5. 	unsigned char *bytes;
  6. 	unsigned int num_bytes;
  7. } big_int;
  8.  
  9. void set_big_int(big_int *result, unsigned char number);
  10. void multiply(big_int *result, unsigned char number);
  11. void divide(big_int *result, unsigned char denominator);
  12. unsigned char get_module(big_int *result, unsigned char denominator);
  13. void factorial(big_int *result, unsigned char number);
  14. int is_zero(big_int *big_integer);
  15.  
  16. int main() {
  17. 	big_int big_integer = {NULL, 0};
  18. 	unsigned char digit;
  19. 	unsigned int num_digits = 0;
  20. 	unsigned int result = 0;
  21.  
  22. 	fprintf(stdout, "Adding all digits of 200!...\n");
  23.  
  24. 	factorial(&big_integer, 200);
  25.  
  26. 	while(is_zero(&big_integer) == 0) {
  27. 		num_digits++;
  28.  
  29. 		digit = get_module(&big_integer, 10);
  30. 		fputc(digit + '0', stdout);
  31. 		result += digit;
  32.  
  33. 		divide(&big_integer, 10);
  34. 	}
  35.  
  36. 	fprintf(stdout, "\n\nDigit sum result: %u\n", result);
  37. 	fprintf(stdout, "Number of digits: %u", num_digits);
  38.  
  39. 	fgetc(stdin);
  40. 	return 0;
  41. }
  42.  
  43. void set_big_int(big_int *result, unsigned char number) {
  44. 	if(result->bytes != NULL)
  45. 		free(result->bytes);
  46.  
  47. 	result->bytes = malloc(sizeof(unsigned char));
  48. 	result->bytes[0] = number;
  49. 	result->num_bytes = 1;
  50. }
  51.  
  52. void multiply(big_int *result, unsigned char number) {
  53. 	register int i;
  54. 	unsigned int rest = 0;
  55.  
  56. 	for(i = 0; i < result->num_bytes; i++) {
  57. 		rest = result->bytes[i] * number + rest;
  58. 		result->bytes[i] = rest & 0x000000FF;
  59. 		rest >>= 8;
  60.  
  61. 		if(rest != 0 && i+1 == result->num_bytes) {
  62. 			result->num_bytes += 1;
  63. 			realloc(result->bytes, result->num_bytes);
  64. 			result->bytes[i+1] = 0;
  65. 		}
  66. 	}
  67. }
  68.  
  69. void divide(big_int *result, unsigned char denominator) {
  70. 	register int i;
  71. 	unsigned int module = 0;
  72. 	unsigned int new_size = result->num_bytes;
  73.  
  74. 	for(i = result->num_bytes-1; i >= 0; i--) {
  75. 		module = (unsigned int)result->bytes[i] + (module << 8);
  76. 		result->bytes[i] = module/denominator;
  77. 		module %= denominator;
  78. 	}
  79.  
  80. 	for(i = result->num_bytes-1; i >= 0 && result->bytes[i] == 0; i--)
  81. 		new_size--;
  82.  
  83. 	if(new_size != result->num_bytes) {
  84. 		result->num_bytes = new_size;
  85. 		realloc(result->bytes, new_size);
  86. 	}
  87. }
  88.  
  89. unsigned char get_module(big_int *result, unsigned char denominator) {
  90. 	register int i;
  91. 	unsigned int module = 0;
  92.  
  93. 	for(i = result->num_bytes-1; i >= 0; i--)
  94. 		module = ((unsigned int)result->bytes[i] + (module << 8))%denominator;
  95.  
  96. 	return module;
  97. }
  98.  
  99. void factorial(big_int *result, unsigned char number) {
  100. 	unsigned char i;
  101.  
  102. 	set_big_int(result, 1);
  103. 	for(i = 2; i <= number; i++)
  104. 		multiply(result, i);
  105. }
  106.  
  107. int is_zero(big_int *big_integer) {
  108. 	register unsigned int i;
  109. 	unsigned int result = 1;
  110.  
  111. 	for(i = 0; result == 1 && i < big_integer->num_bytes; i++)
  112. 		result = big_integer->bytes[i] == 0;
  113.  
  114. 	return result;
  115. }

Además, le he agregado para que imprima los dígitos en Little Endian, así que la salida del programa para calcular el factorial de 200 sería...

Código:
00000000000000000000000000000000000000000000000002747379830732698722222987169785
80071532604230714091306220668659755047521230423093757042424257723584928247221314
68192330452042466154126544229349889693732713367072758264311139928259426629160501
73624209724675203883691983121277140932648911048240302924330436994495344233524749
2362371786779531592260581239312363255305097463768756887

Digit sum result: 1404
Number of digits: 375


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines