Les dates surprenantes !

Fred · 26-10-2025 22:56:56

Bonjour,

Souvent, on écrit une date sous la forme JJ.MM.AAAA
Par exemple, ce dimanche 26 octobre 2025 peut s'écrire 26.10.2025

Il y a des dates un peu particulières pour lesquelles tous les chiffres sont distincts. On les appelle les dates surprenantes.
1. Quelle est la prochaine date surprenante ?
2. Quelle était la dernière date surprenante ?

A vous lire !
Fred.

Vassillia · 26-10-2025 23:20:32

Bonjour,

c'est sympa comme énigme, j'ai peut-être raisonné un peu vite mais je dirais

▼Texte caché

Si vous avez mieux, n'hésitez pas.

Edit Fred : j'ai encadré tes réponses par des balises [ spoiler] pour laisser le suspens...

jpp · 30-10-2025 08:56:58

Salut ,

▼une idée

Dernière modification par jpp (30-10-2025 09:19:26)

Fred · 30-10-2025 21:56:43

@jpp : on peut faire un peu mieux pour la prochaine ...

syrac · 31-10-2025 12:24:58

Bonjour,

Le code Python suivant calcule toutes les possibilités dans un intervalle donné. Pour déterminer si tous les chiffres de la date sont uniques, on la convertit en une chaine de caractères dont Python construit un ensemble des éléments uniques ( set() ) :

digits = "27061345"
set(digits) <-- ('2','7','0','6','1','3','4','5')

Si un chiffre est répété, la longueur de l'ensemble ( len(set) ) est donc 7 et non 8 (on ne parle pas de cardinal dans ce contexte).

fromdatetimeimport date, timedelta

def dates_chiffres_uniques(an_deb=1, an_fin=9999):

    d = date(an_deb, 1, 1)

    end = date(an_fin, 12, 31)

    out = []

    while True:

        s = d.strftime("%d.%m.%Y")       # ex: "27.06.1345"

        digits = s.replace('.', '')      # "27061345"

        if len(set(digits)) == 8:        # 8 chiffres tous différents

            out.append(s)

        if d == end:

            break

        d += timedelta(days=1)

    return out

# --- bornes de l’intervalle ---

an_deb = 1900

an_fin = 2099

# --- résultats ---

toutes = dates_chiffres_uniques(an_deb, an_fin)

print(len(toutes), f"dates entre {an_deb} et {an_fin}")

print(toutes[:10])  # aperçu des 10 premières

jpp · 31-10-2025 12:54:22

Salut ,

@ fred

En effet je peux gagner 93 jours il me semble .

Fred · 31-10-2025 13:24:41

Hello,

je crois que cette fois tu l'as JPP.

F.

syrac · 31-10-2025 14:32:15

Je comprends bien que le but du jeu est de trouver ce genre de date par soi-même, mais encore faudrait-il établir une méthode de calcul. Or, d'après Qwen, à qui j'ai posé la question, il n'en existe pas. Voici ce qu'il dit : "Des recherches et programmes informatiques ont montré qu’il existe exactement 684 dates entre l’an 1000 et 9999 où les 8 chiffres sont tous différents."

Ces recherches montrent qu'après 2000 la prochaine date est le 27.06.2345, ce qui va épargner une grosse perte de temps aux chercheurs. Ce que j'ai demandé à Qwen – et qui me semble beaucoup plus intéressant – n'est pas de me fournir un programme Python mais de m'expliquer quelle stratégie appliquer en vue de détecter rapidement les candidates. Il en est incapable, et à défaut m'a proposé un ... programme Python qui procède comme suit :

---------------------------------
Contrairement à une boucle sur chaque jour (trop lente), on itère intelligemment :

Sur les années de 1000 à 9999,
Sur les mois de 1 à 12,
Sur les jours valides du mois (en tenant compte des années bissextiles),
Et on élimine rapidement les cas impossibles grâce à des filtres préliminaires.

Pourquoi c’est optimisé ?

Pré-filtre sur l’année : si elle a des chiffres répétés (ex: 2024 → deux 2), on saute toute l’année.
Pré-filtre année + mois : si les 6 chiffres de aaaa + mm ne sont pas uniques, inutile de tester les jours.
Pas de manipulation de la librairie datetime : on évite la surcharge des objets date (plus rapide), ce qui oblige à gérer correctement soi-même février et les années bissextiles.

--------------------------------

J'ai testé son script : en 0.6s il a trouvé 46800 dates, la première étant le 27.06.1345, et la dernière le 30.12.9876. Je lui ai fait remarquer ce nombre étonnant, pensant qu'il avait fait une erreur quelque part. Il s'est mis à réfléchir "à voix haute", passant tout son code en revue, allant jusqu'à se demander si Python étendait le calendrier grégorien aux années précédant 1582, réflexion qui a pris pas mal de temps. Et la réponse finale est tombée (roulements de tambour) :

---------------------------------
Conclusion : 46 800 est le bon nombre !

La croyance populaire de "684 dates" vient de sources qui limitent la plage d’années, par exemple :

Seulement les dates du XXe siècle (1900–1999)
Ou seulement les dates passées jusqu’en 2013
Ou elles excluent les années avec 0 (ce qui n’a pas de sens)

Mais mathématiquement, sur toute la plage 1000–9999, avec des dates valides (jours/mois/année cohérents), il y a bien 46 800 dates où les 8 chiffres de jjmmaaaa sont tous uniques.
---------------------------------

Comment vérifier ce résultat autrement qu'avec l'aide de l'informatique ? Il suffirait de trouver ne serait-ce que 685 dates, soit une de plus, pour invalider le précédent résultat.

PS : cette fois-ci je ne ferai un copier-coller de ce script Python que si on me le demande.

A l'attention de ceux qui douteraient du temps de calcul de 0.6s, je joins une capture du script où il s'affiche (Jupyter Notebook pour VS Code). L'image est trop grande. Comment la force-t-on à 100 % ?
Temps de calcul de 46800 dates valides

EDIT : sur 9000 années (10 000 - 1000) il en existe 4464 incompatibles, soit la moitié, ce qui économise déjà pas mal de temps de calcul, et plus précisément : 365 * 4464 = 1 629 300 dates à tester. Comment calculer le nombre d'années incompatibles ? Toujours pareil, on convertit l'année en ensemble d'éléments uniques et on calcule sa longueur. L'année est incompatible si longueur < 4 :

incompatibles = [y for y in range(1000, 10000) if len(set(str(y))) < 4]

print(f"Nombre d'années incompatibles : {len(incompatibles)}")

On se retrouve donc avec 4536 années compatibles, ce qui fait 46800 / 4536 ≈ 10 dates/an en moyenne, ce qui semble beaucoup plus plausible que 684 dates en 9000 ans.

Dernière modification par syrac (31-10-2025 15:11:17)

yoshi · 31-10-2025 17:32:08

Re,

Syrac a écrit :

L'image est trop grande. Comment la force-t-on à 100 % ?

Il suffit, en amont, de disposer d'un logiciel de retouche d'images...
Inutile d'utiliser Photoshop ou The Gimp.
Il suffit de vérifier qu'il dispose de l'option de modification de la taille de l'image...
Il en existe quelques-uns (en freeware) qu'on peut trouver facilement sur Internet...
Personnellement, je me sers de Photofiltre v. 6.5.3 (version basique) qui date de 2012 : il est "portable" ne nécessite pas d'installation et on peut faire des travaux bluffants pour sa taille : 2 Mo...
Je m'en sers régulièrement pour faire des retouches d'images, de dessins : y supprimer des éléments, les couper pour les déplacer, rajouter d'autres récupérés ailleurs, passer d'une image couleur à une en N&B, diminuer ou augmenter la taille d'une image tout en en augmentant/diminuant leur dpi (dots per inch = nombre de points par pouces)...
Il dispose de menus contextuels...

Pas plus tard que ce matin : ma femme m'a demandé de lui réduire la taille d'un dessin en dimension intermédiaire ente A4 et A3 A3, dessin réalisé par feu son père de la maison du petit village alsacien où il était né...
Problème : mon scanner ne peut recevoir que du A4...
Bin je l'ai scanné en 2 fois, nettoyé les imperfections, puis abouté/collé les morceaux dans photofiltre, corrigé les imperfections...
Puis ramené sa taille à une dimension imprimable en A4.
J'ai déjà par le passé procédé de la même façon pour reproduire un dessin de mon beau-père -dépassant le A3- : je l'avais scanné en 4 fois, recollé les morceau dans photofiltre, l'ai ramené en A3, puis ma femme (qui fait du patchwork) m'en avait demandé une version imprimée à des dimensions précises entrant dans ce A3, je l'avais - avec Photofiltre - redimensionné : mon imprimante n'imprime que du A4 ou inférieur.
Les 4 feuilles A4 ont été ensuite collé ensemble : le dessin final devant être reproduit sur un morceau de tissu via un calque qui servait de gabarit, l'ouvrage de Patchwork avait pu allé à son terme...

Mon seul souci : ta bécane est-elle en Linux ou windows (et lequel?)... J'ignore PF (vu l'âge de la version) fonctionnerait dessus ? (Je bosse encore avec Win 7...).

Donc tu vois, tout ça via un soft qui n'occupe que 2 Mo et ne touche pas à la Base de registres de Windows....
Bien sûr, ce que j'ai décrit ci-dessus nécessite un certain entraînement (pas nécessaire pour réduire la taille d'une image ce qui est assez vite fait)

Questions ?

@+

syrac · 31-10-2025 17:53:22

[suite]

Je comprends mieux la raison du temps d'exécution du script de 0.6 s : voici un script qui compte le nombre de mois+année incompatibles, toujours par la méthode du set(). Par exemple, "012034" l'est du fait de la présence de deux 0. En éliminant ce genre de chaine de caractères on s'épargne le calcul des 28 à 31 dates du mois incompatible :

incompatibles = 0

for year in range(1000, 10000):

    for month in range(1, 13):

        mmaaaa = f"{month:02d}{year}"

        if len(set(mmaaaa)) < 6:

            incompatibles += 1

print(incompatibles)

On obtient 89 730 mois. Ça veut dire que sur les 9 000 années × 12 mois = 108 000 combinaisons possibles de mmaaaa, 89 730 sont à écarter d’emblée sans avoir à tester les jours, car elles ne pourront jamais donner une date jj.mm.aaaa avec 8 chiffres tous uniques. Reste uniquement 108 000 - 89 730 = 18 270 combinaisons à tester. C'est donc l'efficacité de la méthodologie mise en place par Qwen qui a conduit à ces 0.6 s, et pas spécialement la vitesse de mon processeur. Avec un code bourrin, moins intelligemment conçu, on aurait dû tester 9000 * 365 = 3 285 000 combinaisons, soit 180 fois plus, et aboutir à un temps d'exécution de quelque chose comme 110 s.

J'apprécie Qwen de plus en plus, au point d'envisager de me désabonner de ChatGPT, que j'utilise ... de moins en moins. :-)

EDIT : Yoshi, je suis sous Windows 11 25H2.

Dernière modification par syrac (01-11-2025 02:19:14)

Vassillia · 01-11-2025 06:58:53

Et bien Qwen n'est quand même pas très doué. La team humains gagne !

Intuitivement on se dit qu'il faut d'abord optimiser l'année puis le mois puis le jour car c'est ce qui sera le plus impactant. Mais cette optimisation doit être faite de telle sorte de ne pas rendre le choix suivant impossible.

Pour les mois, les possibilités sont : 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 12 donc il faut garder le chiffre 0 ou 1 disponible.

Pour les jours, les possibilités sont : 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 31 donc il faut garder le chiffre 0 ou 1 ou 2 disponible.

Pour la prochaine date,
Optimisons l'année :
On commence par 2 évidemment sinon on s'éloigne énormément donc on ne peut plus choisir 0 ou 1 qui sont nécessaires pour le mois et le jour. Le plus proche est 2345 car il faut prendre les plus petits chiffres encore possible à chaque fois.

Optimisons le mois : le premier encore disponible est 06
Optimisons le jour : le premier encore disponible est 17

Dernière modification par Vassillia (01-11-2025 07:03:58)

Ernst · 01-11-2025 12:39:30

Bonjour,

Oui, normalement, les casse-têtes sont résolubles à la main, avec papier, crayon et ingéniosité, c'est vrai. Maintenant je pense qu’il y a aussi un autre plaisir, celui par exemple de trouver un algorithme efficace pour dénombrer toutes les solutions.

On va faire un code Python le plus efficace possible, et qu’on le fasse avec un assistant numérique n’importe pas. Pour ne pas dépendre de bibliothèques spécialisées ou de puissance d’ordinateur, j’utilise Basthon (on colle le code dans le cadre de gauche et on clique en bas sur ‘Exécuter’). Quand ça dépasse la quinzaine de secondes j’ai une alerte navigateur, mais on peut laisser et le calcul continue tout de même.

Je me suis amusé à le faire et c’est rigolo de voir comment, au fil des améliorations, on peut gagner un temps considérable.

===== 1 =====
Le programme parcourt toutes les dates valides du calendrier grégorien entre les années 0001 et 9999, et compte celles dont les huit chiffres (JJMMAAAA) sont tous distincts — les « dates surprenantes ». Il vérifie l’unicité des chiffres, ainsi que les classes date et timedelta du module datetime pour avancer d’un jour à la fois.

Nombre total de dates surprenantes : 46800
Durée : 8 s

===== 2 =====
Le programme génère toutes les permutations possibles de 8 chiffres distincts et teste pour chacune si elle forme une date valide au format JJ.MM.AAAA. Il utilise une fonction basée sur datetime.date() pour vérifier l’existence réelle de la date. L’optimisation consiste à éviter de parcourir jour par jour le calendrier complet, en ne testant que les combinaisons de chiffres distincts — soit environ 1,8 million de cas au lieu de plus de 3,6 millions de jours.

Nombre total de dates surprenantes : 46800
Durée : 2 s

===== 3 =====
Maintenant le programme parcourt uniquement les années aux chiffres distincts et génère pour chacune uniquement les combinaisons de jours et mois utilisant les chiffres restants, en validant manuellement la date (mois à 30 jours, février et années bissextiles). L’amélioration clé est de réduire drastiquement l’espace de recherche : au lieu de tester 1,8 million de permutations, on ne considère plus que quelques centaines de milliers de combinaisons réellement possibles, ce qui explique le gain spectaculaire de vitesse.

Nombre total de dates surprenantes : 46800
Durée : 0.35 s

===== 4 =====
Cette fois le programme effectue un pré-calcul : pour chaque ensemble de 4 chiffres possibles, on génère toutes les paires jour/mois valides et on les stocke dans un dictionnaire.
- Ensuite, on ne conserve que les années aux 4 chiffres distincts, réduisant fortement l’espace de recherche.
- Pour chaque année, on identifie les chiffres restants qui peuvent être utilisés pour le jour et le mois.
- On récupère dans le dictionnaire toutes les paires JJ/MM possibles parmi ces chiffres restants, sans recalculer toutes les permutations.
- On vérifie la validité des dates (mois à 30 jours, février, années bissextiles) et on compte les dates surprenantes.

Nombre total de dates surprenantes : 46800
Durée : 0.06 s

===== 5 =====
Pour aller encore plus vite, le programme utilise maintenant des pré-calculs et des masques binaires (chaque bit représente un chiffre 0–9, ce qui permet de tester en une seule opération si les chiffres d’une paire JJ/MM sont disponibles dans l’année). Les paires jour/mois valides (JJ/MM) sont pré-calculées pour chaque ensemble de 4 chiffres et sélectionnées via un simple test bit à bit pour chaque année. La validité des dates est vérifiée avec un tableau des jours par mois, incluant février et les années bissextiles.

Nombre total de dates surprenantes : 46800
Durée : 0.04 s

Pour la petite histoire, je n’ai utilisé que ChatGPT. Il n’allait certes pas trouver cela tout seul, mais il a été capable, au fil des demandes et des corrections, de pondre des codes fonctionnels et efficaces.

▼code Python final

import time
from itertools import permutations, combinations

# Tableau du nombre de jours par mois [0-index non utilisé], pour années non-bissextiles et bissextiles
MAX_JOURS = [[0,31,28,31,30,31,30,31,31,30,31,30,31],
[0,31,29,31,30,31,30,31,31,30,31,30,31]] # 0: non-bissextile, 1: bissextile

def est_bissextile(annee):
return 1 if annee % 4 == 0 and (annee % 100 != 0 or annee % 400 == 0) else 0

def chiffres_en_masque(s):
"""Convertit une chaîne de chiffres en masque binaire (10 bits pour 0-9)"""
mask = 0
for c in s:
mask |= 1 << int(c)
return mask

def precompute_jj_mm():
"""Pré-calculer toutes les paires JJ/MM valides et leur masque binaire pour chaque ensemble de 4 chiffres"""
table = {}
for comb in combinations(range(10), 4):
valid_pairs = []
for perm in permutations(comb, 4):
j = perm[0]*10 + perm[1]
m = perm[2]*10 + perm[3]
if 1 <= j <= 31 and 1 <= m <= 12:
mask = (1 << perm[0]) | (1 << perm[1]) | (1 << perm[2]) | (1 << perm[3])
valid_pairs.append((j, m, mask))
if valid_pairs:
table[sum(1 << d for d in comb)] = valid_pairs # clé = masque des 4 chiffres
return table

def main():
t0 = time.time()
nb = 0
jj_mm_table = precompute_jj_mm()

for a in range(1, 10000):
str_a = f"{a:04d}"
if len(set(str_a)) != 4:
continue
mask_annee = chiffres_en_masque(str_a)
bissextile = est_bissextile(a)
chiffres_restants = 0b1111111111 & ~mask_annee

# Pour chaque clé de JJ/MM pré-calculée, vérifier si tous ses chiffres sont dans les chiffres restants
for key_mask, pairs in jj_mm_table.items():
if key_mask & chiffres_restants != key_mask:
continue # certains chiffres sont déjà dans l'année
for j, m, mask_jjmm in pairs:
max_j = MAX_JOURS[bissextile][m]
if j <= max_j:
nb += 1

print("Nombre total de dates surprenantes :", nb)
print("Durée :", round(time.time() - t0, 3), "s")

if __name__ == "__main__":
main()

syrac · 01-11-2025 12:54:43

@Yoshi,

L'image ci-dessous prouve que le bbcode 'img' agrandit l'image. Procédé de fabrication :

Création dans Photoshop du carré de 200 pixels de côté avec bordure de 10 pixels en gris moyen.
Importation dans Bibmath via
[img=test] ... [/img]
Placement côte à côte de Photoshop et de Bibmath.
Capture de l'écran.
Recadrage dans Photoshop.

L'image affichée par Bibmath est clairement agrandie (non, ce n'est pas un effet d'optique). C'est pourquoi je demandais plus haut s'il était possible de la ramener à 100 %. D'ailleurs, il est étonnant qu'elle soit agrandie puisqu'on trouve la règle CSS suivante, qui la force à 98 % :

.pun .postmsg .postimg img {

    max-width: 98%;

    vertical-align: middle;

    margin: 7px 0.5em 7px 0;

}

Mais bon, ça ne met pas non plus le feu au lac ! :-)
test

syrac · 01-11-2025 13:41:19

@Ernst,

Bravo pour l'efficacité de ton code (ou celui de chatGPT, ce qui m'étonnerait fortement parce qu'il ne correspond pas à son style). Temps d'exécution : 0,037 s pour obtenir le même résultat que le mien, à savoir 48 600 dates valides trouvées en 0,6 s.

Un reproche cependant : tu calcules les dates à partir de l'an 1. Or, aucune date jusqu'à l'an 1000 ne peut satisfaire aux exigences de l'énoncé, à savoir des dates de 8 chiffres. Tu compenses en ajoutant des zéros (comme l'année 0042), mais ça rend la découverte de dates valides d'autant plus improbables. C'est du reste la raison pour laquelle tu obtiens le même résultat que le mien : ton script n'a trouvé aucune date valide avant l'an 1000.

Ernst · 01-11-2025 14:33:26

Hello syrac,

Ah mais oui, bravo, bien vu ! Si je commence l'année avec un 0, par exemple 0789, me reste uniquement 1 et 2 pour le mois, et le 3 pour le jour, or comme le 0 et le 1 sont pris, plus de jour possible. Comme on doit garder le 0 dispo, l'année commence par 1234 forcément. Sauf qu'une fois encore, l'usage du 1 et du 2 va manger le 0 pour le mois, et on sera de nouveau bloqué pour le jour. Je commence donc la boucle à 1345 et là ça marche !

Une seule ligne à changer, for a in range(1345, 10000) et on passe à 0.036 s, yé !

syrac · 01-11-2025 16:29:20

Ernst a écrit :

... on passe à 0.036 s, yé !

Oui Ernst, c'est toi qui a la plus grosse.

[j'ai retiré ce passage, que je trouvais finalement débile]

Dernière modification par syrac (01-11-2025 18:17:19)

syrac · 02-11-2025 16:54:54

En termes de temps d'exécution, et en utilisant le précalcul + masques binaires, il semblerait que ce soit finalement Qwen qui ait la plus grosse. A cette échelle de temps le résultat est quelque peu fluctuant, mais il se situe entre 0.016 et 0.033 s. Par rapport aux 0.6 s de l'approche naïve, c'est vraiment impressionnant !

J'ai ensuite posé la question suivante à DeepSeek, GPT-5, Gemini et Mistral :

"Sur un forum j'ai été confronté au problème suivant : entre l'an 1000 et l'an 9999, quelles sont les dates au format 'jj.mm.aaaa' dont tous les chiffres sont distincts ? Il existe une approche naïve, qui consiste à parcourir les 9000 * 365 dates en convertissant chacune d'elles en set() puis en calculant sa longueur, mais en existe-t-il une autre plus efficiente ? Quelle devrait être la méthodologie mise en œuvre pour accélérer ce calcul ?"

DeepSeek a répondu la même chose que Qwen au début, et je n'ai pas insisté car il s'accrochait à sa solution. GPT-5 aussi, mais à mon grand étonnement, après lui avoir demandé s'il n'existait pas une approche du problème qui réduirait les 12 s d'exécution de sa solution, il a répondu : "Le truc qui change tout : représenter les chiffres par un bitmask (10 bits pour 0–9) et pré-filtrer les combinaisons (mois, jour) avec chiffres uniques, puis les croiser avec les années à chiffres uniques. Les tests d’“intersection de chiffres” deviennent alors de simples & binaires". Et son code s'exécutait en 0.067 s !

Gemini n'est pas tombé dans le piège de l'approche naïve mais m'a immédiatement proposé une solution consistant à identifier d'abord toutes les séquences de 8 chiffres distincts pouvant produire des dates valides. Son code, distinct de celui de Qwen (le second), parvient à trouver les 48 600 dates en 1.8 s, soit 3 fois plus que la méthode naïve. Je ne l'ai pas poussé plus loin.

Et enfin Mistral. C'est lui qui m'a le plus étonné. Son approche peut toujours être qualifiée de naïve mais elle se distingue néanmoins des autres, et il parvient à trouver les 48 600 dates en 0.324 s, ce qui selon mes critères est un excellent résultat, le tout dans un code très compact. D'ailleurs je le joins ci-dessous. Morale de l'histoire : ne jamais préjuger d'une IA (comme moi de GPT-5) mais s'en faire une idée au cas par cas. En tout cas, en matière de programmation web je trouve GPT-5 trop brouillon et lui préfère Qwen :

# Mistral

import time

def est_bissextile(annee):

    return (annee % 400 == 0) or (annee % 100 != 0 and annee % 4 == 0)

def jours_dans_mois(mois, annee):

    if mois == 2:

        return 29 if est_bissextile(annee) else 28

    elif mois in [4, 6, 9, 11]:

        return 30

    else:

        return 31

compteur = 0

t0 = time.time()

for aaaa in range(1000, 10000):

    annee_chiffres = set(str(aaaa))

    if len(annee_chiffres) != 4:

        continue  # Année invalide (chiffres répétés)

    for mm in range(1, 13):

        mois_chiffres = set(str(mm).zfill(2))

        if len(mois_chiffres) != 2 or not mois_chiffres.isdisjoint(annee_chiffres):

            continue  # Mois invalide

        max_jj = jours_dans_mois(mm, aaaa)

        for jj in range(1, max_jj + 1):

            jour_chiffres = set(str(jj).zfill(2))

            if len(jour_chiffres) != 2 or not jour_chiffres.isdisjoint(mois_chiffres | annee_chiffres):

                continue  # Jour invalide

            compteur += 1

print(f"⏱️  Calcul effectué en {time.time() - t0:.3f} secondes")

print(f"Nombre total de dates valides : {compteur}")

Dernière modification par syrac (02-11-2025 16:55:42)

Ernst · 03-11-2025 01:10:54

Bonsoir,

Les IA ne sont ni fiables ni crédibles. Je m'en sers comme assistants numériques, ni plus ni moins. À les entendre mon code est toujours au maximum de ce que permettrait le langage utilisé. ChatGPT me l'a dit quand j'étais à 0.15 s, puis quand j'étais à 0.041 s, et il me le confirme maintenant que je suis à 0.036 s.

Oui, bon, ok, mais y a-t-il quand même moyen de faire mieux, d'aller plus vite ? Nenni mon bon ami, qu’ils me disent tous.

Pourtant ce qui m'amuse dans ce genre de chose, c'est d’améliorer. Par exemple ici, puisque je pré-calcule les jours et les mois acceptables, eh bien pour trouver les années rien ne m'empêche de leur associer les chiffres restants disponibles, et m’en servir pour construire toutes les permutations de 4 chiffres parmi les 6 restants et de ne valider le couple 29/02 que si l'année est bissextile...

Nombre total de dates surprenantes : 46800
Durée : 0.022 s

Tadaa !

Oui, mais sauf que sur ce coup, c’est débile. D’une part parce que le 29/02 est invalide, donc pas la peine de tester les années bissextiles, ce que je fais pourtant depuis le début – honte à moi – et d’autre part parce qu’il est dès lors inutile de construire les 360 permutations de 4 chiffres parmi 6 vu qu'elles sont valides par construction.

Résumé : donc en fait pour avoir le nombre de solutions, il suffit d’ajouter 360 chaque fois qu'un couple JJ/MM est valide , et c’est terminé.

Nombre de solutions : 46800
Temps (ms) : 1.0

▼code final

On notera la concision de la ligne qui teste que les quatre chiffres sont distincts en éliminant les doublons grâce à set.

Une fois encore, merci à @Fred pour ce genre de casse-tête qui se prêtait vraiment bien à l’expérimentation je trouve.

syrac · 03-11-2025 01:27:17

Belle performance, mais personnellement je préfère le code proposé par Mistral. Il me paraît plus "humain", on peut le lire et le comprendre comme de la prose. Ton truc non, il me fait penser à ces robots pathétiques programmés pour faire croire qu'ils sont comme nous, alors qu'en réalité ils sont froids comme la mort.

syrac · 03-11-2025 17:52:19

Visualisation

Histogramme du nombre d'années (en ordonnée) comptant le nombre de dates surprenantes sur un an (en abscisse), de l'an 1 à l'an 9999. Le maximum est de 33 dates sur 1 an. Environ 75 % des années n'en comptent aucune.
Graphique à barres du nombre de dates surprenantes par siècle, du 1er au 99ème.
Fichier Excel contenant les données du graphique à barres.

Dernière modification par syrac (04-11-2025 00:43:17)

Forum de mathématiques - Bibm@th.net

#1 26-10-2025 22:56:56

Les dates surprenantes !

#2 26-10-2025 23:20:32

Re : Les dates surprenantes !

#3 30-10-2025 08:56:58

Re : Les dates surprenantes !

#4 30-10-2025 21:56:43

Re : Les dates surprenantes !

#5 31-10-2025 12:24:58

Re : Les dates surprenantes !

#6 31-10-2025 12:54:22

Re : Les dates surprenantes !

#7 31-10-2025 13:24:41

Re : Les dates surprenantes !

#8 31-10-2025 14:32:15

Re : Les dates surprenantes !

#9 31-10-2025 17:32:08

Re : Les dates surprenantes !

#10 31-10-2025 17:53:22

Re : Les dates surprenantes !

#11 01-11-2025 06:58:53

Re : Les dates surprenantes !

#12 01-11-2025 12:39:30

Re : Les dates surprenantes !

#13 01-11-2025 12:54:43

Re : Les dates surprenantes !

#14 01-11-2025 13:41:19

Re : Les dates surprenantes !

#15 01-11-2025 14:33:26

Re : Les dates surprenantes !

#16 01-11-2025 16:29:20

Re : Les dates surprenantes !

#17 02-11-2025 16:54:54

Re : Les dates surprenantes !

#18 03-11-2025 01:10:54

Re : Les dates surprenantes !

#19 03-11-2025 01:27:17

Re : Les dates surprenantes !

#20 03-11-2025 17:52:19

Re : Les dates surprenantes !

Réponse rapide

Pied de page des forums