Discussion :

[wow1296]

Bonjour à tous !

Voila j'ai besoin de votre aide pour un petit programme que j'ai réalisé en amateur. En fait je voudrais résoudre une énigme et pour cela, j'ai voulu faire appel à mes petites connaissances sur le langage C. Le but est de trouver un multiple de 2013 contenant moins de 250 chiffres et dont la somme est 2013.

Voici ce que j'ai fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
int somme(double n);
 
int main()
{
    double multiple = 0;
    int x = 0;
 
    do
    {
        multiple = multiple + 2013; // La variable "multiple" prend successivement pour valeur les différents multiples de 2013
        x = somme(multiple); // Le résulat x est la somme des chiffres du multiple en question
        printf("%d avec %f\n", x, multiple); // On affiche x ainsi que le multiple qui lui correspond
 
    } while (x != 2013);  // La boucle continue tant que x est diffférent de 2013
 
    printf("\n\n\n\n\nLe resultat est %f\n\n\n\n\n\n\n\n\n\n", multiple);  // On affiche le résultat
 
    return 0;
}
 
int somme (double n)
{
    int  /*compteur = 0,*/ d = 0, longueur_du_nombre = 250, n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0, n6 = 0, n7 = 0, n8 = 0, n9 = 0;
    double /*image = n,*/ image2 = n;
 
    /*
    do
    {
        compteur = image / 10;
        longueur_du_nombre++;
    } while (compteur > 1);
 
    Je ne sais pas ce qui n'a pas fonctionné ici... c'était censé calculer la longueur de chaque nombre avant.. du coup, j'ai mis 250 un peu plus haut à la place de 0 */
 
    while(longueur_du_nombre != 0)
    {
        d = image2/pow(10,longueur_du_nombre-1); // On divise le nombre par 10^250, puis 10^249..., puis 100 puis 10 puis 1
        d = floor(d); // A chaque fois, on ne garde que la partie entière
        d = d%10; // On récupère seulement le chiffre des entiers
 
        switch(d) // Selon la valeur de d, autrement dit du chiffre, on incrémente l'une des variables de n1 à n9
        {
        case 1 :
            n1++;
            break;
        case 2 :
            n2++;
            break;
        case 3 :
            n3++;
            break;
        case 4 :
            n4++;
            break;
        case 5 :
            n5++;
            break;
        case 6 :
            n6++;
            break;
        case 7 :
            n7++;
            break;
        case 8 :
            n8++;
            break;
        case 9 :
            n9++;
            break;
        }
 
        longueur_du_nombre--; // On décrémente la variable "longueur du nombre" puis on recommence...jusqu'à ce que celle-ci soit égale à 0
    }
 
    return (n1) + (2*n2) + (3*n3) + (4*n4) + (5*n5) + (6*n6) + (7*n7) + (8*n8) + (9*n9); // On renvoie la somme des chiffres
}

Au début, le programme marche très bien, mais à partir d'environ 2,5 millards, la somme x est fausse...
Si vous pouviez me dire d'où vient le problème, sans pour autant me donner la réponse toute faite, je vous en serais très reconnaissant. J'ai beau chercher mais je ne trouve pas la source du problème mais je veux réfléchir un peu aussi
Merci d'avance !

[ram-0000]

Peut être (et même probablement) que le type double n'est pas le type qu'il faut utiliser pour ce genre de travail.

En effet, les type float ou double permettent de représenter des grands nombres mais il y a toujours une question de précision et là, il est probable qu'à partir de 2 milliard, la précision ne soit plus au rendez vous.

Une autre idée, faire tes calcul sur des strings et non plus des nombres. Il va falloir apprendre à faire des opérations du genre "4026" + "2013" = "6039". Par contre, l'avantage immédiat est que tu as la longueur du nombre immédiatement (avec strlen()).

[droggo]

Jao,

Il vaudrait mieux utiliser une bibliothèque de calcul multi-précision, GMP étant la plus connue.

[wow1296]

Merci de m'avoir répondu si rapidement

A vrai dire mon niveau en programmation est vraiment très bas... en fait quand j'ai le temps j'apprends un peu plus, mais pour le moment je n'en suis qu'aux variables et aux fonctions... mais pas aux chaines de caractères
Je pense qu'il va falloir que j'en apprenne plus si je veux résoudre cette énigme à temps
C'est vraiment dommage que le type double manque de précision... avec un int je n'aurais surement pas pu aller jusqu'à 10^249 !

En tout cas je tient à vous remercier une nouvelle fois pour avoir pris le temps de m'apporter votre aide

Merci à vous droggo

Donc si je comprends bien, il suffit de télécharger cette biliothèque, de l'inclure dans mon code source et le problème serait réglé ?

[ram-0000]

Ne pas oublier non plus la periode d apprentissage de la librairie

[droggo]

Joe,

Ne pas oublier non plus la periode d apprentissage de la librairie

Qui n'est pas négligeable, surtout pour un débutant.

À mon avis, avant de se lancer dans ce genre de programme, qui est d'abord un problème d'algorithme, il vaudrait mieux bien apprendre les bases de la programmation, et suffisamment progresser dans l'utilisation du langage désiré.

[Franck.H]

Déjà que le C on l'apprend pas en claquant des doigts non plus

[chrtophe]

Travailles déjà sur la façon de faire cela mathématiquement parlant

[Bysbobo]

Bonjour à tous !

Voila j'ai besoin de votre aide pour un petit programme que j'ai réalisé en amateur. En fait je voudrais résoudre une énigme et pour cela, j'ai voulu faire appel à mes petites connaissances sur le langage C. Le but est de trouver un multiple de 2013 contenant moins de 250 chiffres et dont la somme est 2013.

Voici ce que j'ai fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#include <stdio.h>
...
return (n1) + (2*n2) + (3*n3) + (4*n4) + (5*n5) + (6*n6) + (7*n7) + (8*n8) + (9*n9); // On renvoie la somme des chiffres
}

Au début, le programme marche très bien, mais à partir d'environ 2,5 millards, la somme x est fausse...
Si vous pouviez me dire d'où vient le problème, sans pour autant me donner la réponse toute faite, je vous en serais très reconnaissant. J'ai beau chercher mais je ne trouve pas la source du problème mais je veux réfléchir un peu aussi
Merci d'avance !

Salut!

Ou as-tu trouvé ton exercice?

De plus, dans le meilleur des cas, pour que la somme de chaque chiffre fasse 2013, dans le meilleur des cas, il te faut à la suite 2013/9 soit 223 chiffres 9 et 1 chiffre 6.
Or 99999999999999999.....999999999996 n'est surement pas un multiple de 2013.

EDIT2: Autant pour moi, j'ai foiré entre diviseurs et multiplieurs! Je modifie en conséquence

[deletme]

Oui, je rejoins ton avis sur la définition des multiples

[alyma]

@ram-0000 : Les calculs demandent une trop grande précision, je suis d'accord avec toi, il faudrait essayer avec des chaînes de caractères.


@Bysbobo : La quastion est la recherche d'un multiple de 2013 et non d'un diviseur. La liste que tu as entamée est celle de ses diviseurs.
wow1296 a bien interprété le problème dans son code.
Par contre, je suis d'accord avec toi sur le fait que le nombre devra comporter au moins 223 chiffres.

[wow1296]

Merci à tous !

Globalement, ce que je retient de vos messages, c'est que je n'ai pas le niveau suffisant pour réaliser ce programme
Je pensais qu'avec ce que je savais je pourrais quand même y arriver... apparemment je me suis trompé !
Et dire que c'est juste un problème de précision qui me pousse à tout refaire... je m'attendais à tout sauf ça !

envoyé par Bysbobo :

Ou as-tu trouvé ton exercice?

Sur l’île des mathématiques, il y'a un forum réservé à des énigmes mathématiques auxquelles il faut répondre avant 2 ou 3 semaines environ. C'est pour ça que je ne veux pas trop d'aide, pour ne pas être avantagé par rapport aux autres participants^^

Voici le lien pour cette énigme http://www.ilemaths.net/forum-sujet-561579.html

encore à vous tous, je vais essayer de résoudre le problème d'une autre façon. Si j'y parviens, je vous tiendrais au courant

[Sve@r]

De plus, dans le meilleur des cas, pour que la somme de chaque chiffre fasse 2013, dans le meilleur des cas, il te faut à la suite 2013/9 soit 223 chiffres 9 et 1 chiffre 6.

Salut
Et pourquoi pas 222 chiffres 9, un chiffre 8 et un chiffre 7 ???

Or 99999999999999999.....999999999996 n'est surement pas un multiple de 2013.

Le terme "sûrement" n'a absolument pas lieu en mathématiques et généralement pas beaucoup plus en informatique...

Globalement, ce que je retient de vos messages, c'est que je n'ai pas le niveau suffisant pour réaliser ce programme
Je pensais qu'avec ce que je savais je pourrais quand même y arriver... apparemment je me suis trompé !
Et dire que c'est juste un problème de précision qui me pousse à tout refaire... je m'attendais à tout sauf ça !

En fait il y a deux problèmes ici
Tout d'abord le choix du langage. Un langage bas niveau comme le C t'obligera à faire toi-même beaucoup de choses alors que dans un langage de plus haut niveau, beaucoup de choses élémentaires sont déjà intégrées. Prends par exemple Python (dispo en natif sous Linux et téléchargeable pour Windows ici). Dans ce langage (très accessibles même aux débutants), tu as une foule de choses intégrées (comme par exemple la gestion des très grands nombres ou la transformation d'un nombre en chaine).

Voici en Python un code permettant de chercher ce nombre multiple de 2013 ayant moins de 250 chiffres dans son écriture et dont la somme de ces chiffres fait 2013. Tu verras que ce code n'est pas compliqué à écrire ni à relire

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
def somme(n):
	# Déjà juste pour te montrer les possibilités de Python
	return reduce(lambda x, y: x+y, [int(x) for x in str(n)])
 
	# La même chose de façon plus classique (ne sera pas exécuté vu le return du dessus mais c'est pour montrer)
	res=0
	for x in str(n):		# str(n): Transforme un nombre 123 en chaine "123"
		res+=int(x)		# int(x): Transforme une chaine "123" en nombre 123
	return res
#somme ()
 
# Recherche du nombre		
base=2013
i=0
while somme(base) != 2013 and len(str(base)) <= 250:
	# Affichage de contrôle (tous les 1000000 multiples)
	if i == 1000000:
		print base, somme(base), len(str(base))
		i=0
	# if
	base+=2013
	i+=1
# while
 
print base, somme(base), len(str(base))

Toutefois on arrive au second problème: c'est que même avec un ordinateur, la recherche est trop longue. Réfléchis une seconde: il faut 5 multiples à 2013 pour passer de 4 à 5 chiffres (2013; 4026; 6039; 8052; 10065). Pour passer à 6 chiffres il en faudra 50; puis 500 pour passer à 7 chiffres et etc etc jusqu'au final où il faudra 5 * 10^245. Or mon code Python évalue 10^6 multiples en 25 secondes. Admettons que le C soit 10000 fois plus rapide (ce n'est pas du tout le cas mais c'est pour illustrer), il évaluera donc 10^10 multiples en 25 secondes. Il lui faudra donc (25 * 5 * 10^245) / 10^10 soit 125 * 10^235 secondes soit 144 * 10^230 années pour trouver. Quand on sait que les dinosaures n'ont duré que 300 * 10^9 années, ça laisse rêveur.

Et donc généralement les challenges mathématiques font appel à autre chose qu'une recherche "brute force" qui n'a pas assez de temps pour aboutir...

PS: mon code Python tourne depuis 1h30 et il n'en n'est qu'à 12 chiffres avec 39 pour somme de ces chiffres. On est bien bien loin de 2013...

C'est pour ça que je ne veux pas trop d'aide, pour ne pas être avantagé par rapport aux autres participants^^

Bah, les autres ont sûrement leurs aides de leurs cotés...

[wow1296]

Salut Sve@r

envoyé par Sve@r :

En fait il y a deux problèmes ici
Tout d'abord le choix du langage. Un langage bas niveau comme le C t'obligera à faire toi-même beaucoup de choses alors que dans un langage de plus haut niveau, beaucoup de choses élémentaires sont déjà intégrées

A vrai dire je sais que le C est un langage de bas niveau contrairement à Python ou Visual Basic (enfin je crois ), mais je m'étais dis que je pourrais apprendre plus de choses sur la programmation en apprenant ce langage et qu'il me serait ensuite plus simple d'apprendre d'autres langages de plus haut niveau...

envoyé par Sve@r :

Toutefois on arrive au second problème: c'est que même avec un ordinateur, la recherche est trop longue. Réfléchis une seconde: il faut 5 multiples à 2013 pour passer de 4 à 5 chiffres (2013; 4026; 6039; 8052; 10065). Pour passer à 6 chiffres il en faudra 50; puis 500 pour passer à 7 chiffres et etc etc jusqu'au final où il faudra 5 * 10^245. Or mon code Python évalue 10^6 multiples en 25 secondes. Admettons que le C soit 10000 fois plus rapide (ce n'est pas du tout le cas mais c'est pour illustrer), il évaluera donc 10^10 multiples en 25 secondes. Il lui faudra donc (25 * 5 * 10^245) / 10^10 soit 125 * 10^235 secondes soit 144 * 10^230 années pour trouver. Quand on sait que les dinosaures n'ont duré que 300 * 10^9 années, ça laisse rêveur.

Ah oui en effet... j'y avais pensé aussi mais je ne pensais pas que ça prendrait plus de temps que les années qui se sont écoulées depuis la naissance de notre Univers !
Peut être que je devrais commencer le programme directement à partir de 223 chiffres... ou alors sans programme, après tout cette énigme n'est pas uniquement réservé à ceux qui savent programmer non ?... je ne sais pas...

[Bktero]

Un simple ne suffisait pas, il fallait que je poste pour signaler que je tape des mains (enfin, dés que j'aurai lâché mon clavier) !

Prends par exemple Python [...]. Dans ce langage (très accessibles même aux débutants), tu as une foule de choses intégrées (comme par exemple la gestion des très grands nombres ou la transformation d'un nombre en chaine).

Je n'osais le dire !

[I_believe_in_code]

Sve@r a très bien expliqué que tester toutes les possibilités jusqu'à trouver la bonne n'était pas raisonnable...

Donc il faut s'attaquer à ce problème à l'aide d'outils mathématiques avant tout, même s'il n'est pas exclu qu'un programme informatique intervienne à un moment.

[Sve@r]

Peut être que je devrais commencer le programme directement à partir de 223 chiffres...

Oui mais te faudra tester les 5x10^219 multiples contenant 223 chiffres...
(j'ai écrit 10^219 au pif, peut-être c'est 10^218 ou 10^220 mais à ce niveau cela importe peu...)

ou alors sans programme, après tout cette énigme n'est pas uniquement réservé à ceux qui savent programmer non ?

En effet, elle est plus réservées aux matheux qu'aux programmeurs (bien que généralement être programmeur implique souvent être un peu matheux).
Par exemple voici ma base de réflexion: 2013 est un multiple de 2013. Ensuite, il y en a 9999 autres puis on arrive à 20130000.
A partir de là, on est certains que ces 10000 multiples vont se répéter et se combiner. Par exemple on a 4026 puis 6039 donc on aura forcément 20134026 puis 20136039 puis plus tard 40262013 puis 60392013 puis 60394026 et etc etc etc.
Toutefois, certains multiples auront beau se répéter, cela ne suffira pas. Par exemple 4026 (total des chiffres: 12) ne pourra se répéter que 62 fois (sinon le nombre formé dépasse 250 chiffres). Or 12 * 62 font 744 ce qui est très loin de 2013.

Donc à partir de là, il n'est plus ni très long, ni très compliqué, de prendre chacun de ces 10000 multiples, le répéter autant de fois que possible sans que le nombre formé dépasse 250 chiffres ; calculer la somme de ces chiffres puis regarder s'il n'y aurait pas un autre multiple qui permettrait d'atteindre 2013 sans dépasser l'espace restant. Et là dedans, Python a son rôle à jouer...

D'où le code suivant (qui est un hymne aux possibilités qu'offre Python)

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
def somme(n):
	return reduce(lambda x, y: x+y, [int(x) for x in str(n)])
#somme ()
 
# Recherche des multiples candidats
multiple=[]
base=2013
while base <= 20130000:
	sum=somme(base)
	lg=len(str(base))
	rep=250/lg
	reste=250 - rep * lg
	total=rep * sum	
	multiple.append(
		{
			"valeur" : base,		# La valeur du nombre
			"somme" : sum,			# La somme de ses chiffres
			"len" : lg,			# Sa longueur
			"rep" : rep,			# Le nb de répétitions max pour 250
			"total" : total,		# Le total que donnera sa somme répétée autant de fois que possible
			"reste" : reste,		# La place qui reste pour un autre nombre avant 250
		}
	)
	base+=2013
# while
 
# Recherche des appariements possibles
for m in multiple:
	for k in multiple:
		if m["total"] + k["somme"] == 2013 and k["len"] <= m["reste"]:
			res=int(
				"%s%s" % (
					str(m["valeur"]) * m["rep"],
					k["valeur"]
				)
			)
			print "%d (%d, %d, %d)" % (
				res,
				somme(res),
				len(str(res)),
				res % 2013,
			)
		# if
	# for
# for

Et un ensemble des résultats possibles (je dis "un" ensemble car j'ai cherché "n - 1" multiples et un multiple final mais j'aurais pu chercher "n - k" multiples et "k" autres multiples etc etc
Le premier nombre est le multiple et les nombres entre parenthèses sont

• la somme des chiffres (théoriquement toujours 2013)
• le nombre de chiffres (au plus 250)
• le reste de la division du nombre par 2013 (théoriquement toujours 0)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969996039 (2013, 249, 0)
7896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699912078 (2013, 250, 0)
7896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699918117 (2013, 250, 0)
7896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699924156 (2013, 250, 0)
7896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699930195 (2013, 250, 0)
7896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699936234 (2013, 250, 0)
7896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699942273 (2013, 250, 0)
7896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699948312 (2013, 250, 0)
7896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699954351 (2013, 250, 0)
7896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699978969997896999789699960390 (2013, 250, 0)
959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999976039 (2013, 249, 0)
9599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999712078 (2013, 250, 0)
9599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999718117 (2013, 250, 0)
9599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999724156 (2013, 250, 0)
9599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999730195 (2013, 250, 0)
9599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999736234 (2013, 250, 0)
9599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999742273 (2013, 250, 0)
9599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999748312 (2013, 250, 0)
9599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999754351 (2013, 250, 0)
9599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999795999979599997959999760390 (2013, 250, 0)
988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898696039 (2013, 249, 0)
9889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986912078 (2013, 250, 0)
9889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986918117 (2013, 250, 0)
9889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986924156 (2013, 250, 0)
9889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986930195 (2013, 250, 0)
9889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986936234 (2013, 250, 0)
9889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986942273 (2013, 250, 0)
9889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986948312 (2013, 250, 0)
9889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986954351 (2013, 250, 0)
9889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986998898699889869988986960390 (2013, 250, 0)