Vous savez ce qu'est un palindrome , un prime et une date .

Votre tâche consiste à répertorier toutes les dates dans 100 milliers d'années qui remplissent les trois caractéristiques.

Nevermind quoi que ce soit , mais les chiffres, utilisez les formats suivants: AAAAMMJJ et YYYYYMMDD .

Les dates comprises entre 0000-01-01 et 9999-12-31 doivent être imprimées sous forme de palindromes à 8 chiffres (s'il y en a?) Et les dates comprises entre 10000-01-01 et 99999-12-31 doivent être imprimées sous forme de palindromes à 9 chiffres .

Il n'est pas obligatoire de lister les dates par ordre chronologique.

Exemple de partie d'une sortie valide.

Trois premières dates palindromiques à 9 chiffres:

...
100111001
100131001
100161001
...

Règles

Des échappatoires standard s'appliquent.

Rubis , 144 141 octets (134 + 7 pour le -rprimedrapeau)

^{Sauvegardé 3 octets grâce à benj2240 !}

('01'..'12').map{|m|('01'..'31').map{|d|(?0..?9).map{|k|q=m+d
y=q.reverse+k
r=y+q
Time.new(y,m,d).day==d.to_i&&r.to_i.prime?&&(p r)}}}

Essayez-le en ligne!

L'algorithme:

• générer toutes les combinaisons MMDD possibles, de "0101" à "1231"
• générer toutes les années pour cette date qui se traduirait par un palindrome, en inversant la chaîne MMDD et en ajoutant au milieu, à son tour, tous les caractères de la plage (0..9)
• vérifier si cette date est valide en créant une Timeinstance avec les données y, m, les dvaleurs. Si l'objet de temps résultant a une #dayvaleur égale à d, puis qui était une date valide. Sinon, cela changerait la date (par exemple, les Time.new 2018,2,30retours 2018-03-02).
• vérifiez si la date de palindrome valide est également un nombre premier et affichez-la si elle l'est.

La boucle interne était initialement une fonction qui était appelée pour chaque élément de la (?0..?9)plage, ainsi que pour la chaîne vide.

Étant donné que la chaîne vide n'a donné aucun résultat (il n'y a pas de palindromes premiers valides à 8 chiffres), j'ai décidé de la supprimer et de refactoriser cette version.

Python 2 , 116 107 128 128 122 119 octets

def g(n=9**8):
 while n<1e9:
  n+=2;m=n/100%100
  if 0<m<13and n%100<31+(m+m/8)%2and`n`[::-1]==`n`and 2**n%n==2:print n

La seconde moitié de la 4ème ligne est inspirée par mxdsp de réponse ici à une autre question de golf .

Explication

La fonction g()prend un argument uniquement pour initialiser la nvariable en utilisant sa valeur par défaut. La valeur initiale est un nombre impair aussi court que possible et aussi grand que possible tout en restant inférieur à la première réponse valide 100111001.

Boucle jusqu'à nla fin de la plage de dates 10 ⁹ . Incrémenter nde 2. mest le mois de la date n.

Si nest une date valide, un palindrome et un nombre premier, imprimez-le:

• Date:
  • 0 < m < 13chèques qui mest un mois valide.
  • n % 100 < 31 + (m+m/8)%2vérifie que nle jour du mois est valide. (m+m/8)%2ajoute 1pour tous les mois avec 31 jours. Le mérite en revient à la réponse d' ArmanX . Il n'y a pas de nombres premiers pour les 29 et 30 février.
• Palindrome: `n`[::-1] == `n`. Les backticks se stringifient n. [::-1]inverse la chaîne.
• Prime: 2**n % n == 2est un test de primalité de Fermat . Ce test n'est que probabiliste. Il existe également des nombres non premiers qui correspondent. Mais pas dans la gamme de chiffres que nous examinons.

APL (Dyalog Unicode) , 155 octets

⎕CY'dfns'
n←⍕x
m←(⍎2↑¯4↑n)
d←(⍎¯2↑n)
:If n≡⌽n
:AndIf 1 pco x
:AndIf m<13
:AndIf d<32
:If m d≡2 29
:AndIf (400|⍎((≢n)-4)↑n)=0
⎕←x
f x+72
:End
⎕←x
:End
f x+1

Essayez-le en ligne!

Ceci est un Tradfn ( trad itional f unctio n ) qui prend un argument arg = yyyymmddou arg = yyyyymmdd. L'utilisation est f arg.

Cela ne produira rien au début de l'argument 10000101car il ne trouvera pas de date palindrome principale dans 60 secondes.

Voici une approche moins golfée qui produira la sortie d'exemple du PO de

100111001
100131001
100161001

( Essayez-le en ligne! )

Notez que les deux codes sont exactement les mêmes jusqu'à ce que juste avant d'appeler la fonction récursivement pour la prochaine date. Alors que la version golfée l'appelle simplement f arg+1, le code le moins golfé saute de jour 31en jour 01et de mois 12en mois 01, ce qui l'accélère un peu.

Comment ça fonctionne:

⎕CY'dfns'                   ⍝ Copy (⎕CY) all dfns to enable the use of pco.
n←⍕x                        ⍝ Assign (←) the input to the variable n.
m←(⍎2↑¯4↑n)                 ⍝ Take (↑) the last 4 (¯4) elements of n, then take the first 2 elements of that and assign to m. 
d←(⍎¯2↑n)                   ⍝ Take the last 2 (¯2) elements of n, and assign to d.
:If n≡⌽n                    ⍝ If n matches (≡) its reverse (⌽) (is a palindrome)
:AndIf 1 pco x              ⍝ And a prime (1 pco)
:AndIf m<13                 ⍝ And month < 13
:AndIf d<32                 ⍝ And day < 32
:If m d≡2 29                ⍝ If it is 2/29
:AndIf (400|⍎((≢n)-4)↑n)=0  ⍝ And the year mod 400 = 0
⎕←x                         ⍝ Print x
f x+72                      ⍝ call f with arg year0301
:End
⎕←x                         ⍝ Print x
:End
f x+1                       ⍝ call f for the next date.

Python 3, 163 octets

r=range
for m in r(1,13):
 for d in r(1,31+(m%2==(m<8))-2*(m==2)):
  t="%02d"*2%(m,d)
  for i in r(10):x=int(t[::-1]+str(i)+t);all(x%i for i in r(2,x))and print(x)

La solution est assez longue (et peut probablement être améliorée), mais n'utilise aucune fonction intégrée pour la vérification prime / date / palindrome. Une version un peu dépourvue de clarté:

for month in range(1,13):
    for day in range(1,31 + (month%2==(month<8)) - 2*(month==2)):
        t = "%02d%02d" % (month, day)
        for i in range(10):
            x = int(t[::-1] + str(i) + t)
            if all(x%i for i in range(2,x)):print(x)

Les dates valides sont générées en choisissant un mois et un jour. Comme indiqué précédemment, seule la taille 9 doit être prise en compte. Notez également que les années bissextiles ne sont pas prises en compte. Cela n'est pas nécessaire en raison de la coïncidence chanceuse que les nombres premiers de palindrome de longueur 9 qui se terminent sur 0229 n'existent tout simplement pas (d'autres anomalies de date comme le 30 février 1712 peuvent être écartées pour la même raison).

Ensuite, le chiffre du milieu est choisi librement et un premier test est effectué. Étant donné que le test principal devait être aussi court que possible, il est très naïf et donc extrêmement lent. L'utilisation d'une bibliothèque externe pourrait résoudre ce problème (et économiser quelques octets), mais comme mentionné précédemment, je ne voulais pas en utiliser.

WolframLanguage (Mathematica) 187 octets

Il peut y avoir une certaine réduction de taille à trouver. Explication à suivre ...

t=ToString;p=PadLeft;d=DateObject;Cases[""<>{t/@p[#,If[Length@#<5,4, 5]],t/@ p[#2,2],t/@p[#3,2]}&@@@(IntegerDigits/@#[[1]]&/@DayRange[d@#,d@#2]),x_/;PalindromeQ@x&&PrimeQ@ToExpression@x]&

Cas de test

t = ToString; p = PadLeft; d = DateObject;
Cases["" <> {t /@ p[#, If[Length@# < 5, 4, 5]], t /@ p[#2, 2], 
   t /@ p[#3, 2]} & @@@ (IntegerDigits /@ #[[1]] & /@ DayRange[d@#, d@#2]), 
   x_ /; PalindromeQ@x && PrimeQ@ToExpression@x] &[{10011, 10, 1}, {10017, 1, 1}]

(* {"100111001", "100131001", "100161001"} *)

Explication du code

DayRange[d@#,d@#2]renvoie toutes les dates entre {10011, 10, 1}et {10017, 1, 1}. Dans ce cas, il renvoie environ 5 ans, 4 mois de dates (précisément 1920 dates). Les années bissextiles sont prises en compte.

Les dates sont renvoyées au format standard Wolfram. Par exemple, la première date apparaîtra comme DateObject[List[1,1,1],"Day","Gregorian",-5.] `

#[[1]] & /@supprimera la partie de la date, à chaque date, qui nous concerne. Dans l'exemple, DateObject[List[1,3,7],"Day","Gregorian",-5.]renvoie la date abrégée {1,3,7}.

t/@p[#3,2]}ou ToString/@Padleft[#3,2]garnit le troisième élément, à savoir, le 7 debout "pour le 7e jour du mois" comme "07". Un rembourrage similaire est fourni pour le symbole à un chiffre du mois de mars, à savoir, 3est renvoyé sous la forme "03".

p[#, If[Length@# < 5, 4, 5]]remplit l'année de zéros pour atteindre la longueur d'une chaîne de 4 ou 5 chiffres. Dans ce cas, janvier, à savoir 1, est renvoyé sous la forme "" 00001 "".

"" <>...rejoint les cordes. Dans ce cas, il revient "000010307".

Cases[...x_ /; PalindromeQ@x && PrimeQ@ToExpression@x] renvoie les cas, parmi les 1920 dates, qui sont des palindromes et des nombres premiers.

Javascript , 187 177

Hypothèses: aucune année correspondante à 4 chiffres; aucun jour correspondant en février entre le 29 et le 30

p=n=>(n<10?'0':'')+n;f=n=>n[3]+n[2]+n[1]+n[0];for(m=13;--m;)for(d=31+(m+(0|m/8))%2;--d;){for(y=10;y--;){z=p(m)+p(d);Y=+(f(z)+y+z);for(i=2;Y%i&&i*i<Y;i++);if(Y%i)console.log(Y)}}

Cela fonctionne comme ceci:

p=n=>(n<10?'0':'')+n;       //Prepend a 0 for 1-digit numbers and convert to a string
f=n=>n[3]+n[2]+n[1]+n[0];   //Flip four digits
for(m=13;--m;)              //Month loop, from 12 to 1
 for(d=
       31+(m+(0|m/8))%2     //Calculate the days in the month, allowing  Feb. 29 & 30
                       ;--d;){ //Day loop
  for(y=10;y--;){           //Middle digit loop
   z=p(m)+p(d);             //Prepend zeros to the month and day
   Y=+(f(z)+y+z);           //Flip the digits; append the middle digit,
                            //month, and day; convert back to an integer
   for(i=2;Y%i&&i*i<Y;i++); //Check if it's a prime
    if(Y%i)console.log(Y)}} //If it doesn't divide evenly, it's not prime. Print it!

Histoire:

• 187 à 177: Il n'y a pas de dates de palindrome principales qui tombent le 29 ou le 30 février, nous pouvons donc prétendre que février a 30 jours et enregistrer 10 caractères.

Remarques:

Grâce aux tests, j'ai trouvé qu'il n'y a pas de correspondances valides qui sont des années à 4 chiffres ou qui tombent le 29 ou le 30 février. Malheureusement, pour le code, il y a exactement cinq résultats (invalides) qui tombent le 31 du mois. qui n'ont que 31 jours.

Java 10, 329 327 320 318 312 308 307 264 octets

v->{for(int y=9999,m,d;++y<1e5;)for(m=0;++m<13;)for(d=0;++d<32;)try{java.time.LocalDate.of(y,m,d);var t=y+"".format("%02d%02d",m,d);long n=new Long(t),x=1;for(;n%++x%n>0;);if(t.contains(new StringBuffer(t).reverse())&n==x)System.out.println(t);}finally{continue;}}

-1 octet grâce à @assylias .

Explication:

Essayez-le en ligne (remarque: la partie de vérification de prime a été remplacée par une méthode séparée plus efficace, même si elle expire toujours après 60 secondes, ne produisant que les 115 premières dates palindromiques).
Pastebin des 197 sorties d'une exécution locale.

v->{                           // Method without empty unused parameter and no return-type
  for(int y=9999,m,d;++y<1e5;) //  Loop over the years in the range [1000,9999]:
    for(m=0;++m<13;)           //   Inner loop over the months in the range [1,12]:
      for(d=0;++d<32;){        //    Inner loop over the days in the range [1,31]:
        try{java.time.LocalDate.of(y,m,d);
                               //     If it's a valid date:
          var t=y+"".format("%02d%02d",m,d);
                               //      Convert the numbers to a String in format "yyyyyMMdd"
          long n=new Long(t),  //      Convert this String to a long
          x=1;for(;n%++x%n>0;);//      Prime-checking loop
          if(t.contains(new StringBuffer(t).reverse())
                               //      If the string is palindromic
             &n==x)            //      and the long is a prime:
            System.out.println(t);
                               //       Print the string with trailing newline
        }finally{              //     If it isn't a valid date:
          continue;}}}         //      Continue to the next iteration of the inner-most loop

VBA, 347

Sub PalindromeDate()
Dim DateString As String
For i = 0 To 9999
    For j = 1 To 12
        For k = 1 To 31
        DateString = Format(i, "0000") & Format(j, "00") & Format(k, "00")
        If DateString = StrReverse(DateString) Then
        Debug.Print DateString
        Else
        End If
        Next k
        Next j
        Next i

End Sub

Nettoyer , 262 ... 213 octets

import StdEnv
@ =(rem)
f=[d\\d<-[a*10^4+b*100+c\\a<-[10^4..99999],b<-[1..12],c<-[1..28+[0,3,if(@a 400<1|| @a 4<1&& @a 100>0)1 0,3,2,3,2,3,3,2,3,2,3]!!b]]|(\k=k==reverse k)[p\\p<-:toString d]&&all((<)0o@d)[2..d-1]]

Essayez-le en ligne!

Javascript , 234 229 octets

Un peu volumineux, mais le poster pour faire rouler la balle JS. Toutes les suggestions sont les bienvenues!

f=n=>100+10*n+n/10|0
p=n=>{for(i=2;i<n;n=n%i++<1?0:n);return n>1}
q=n=>(''+(100+n)).slice(-2)
r=_=>{for(m=13;--m;)for(d=32;--d;)for(x=10;--x+1;){s=q(f(d))+q(f(m))+x+q(m)+q(d);if(p(s|0)&&d<(m==2?29:31+(m+m/8|0)%2))console.log(s)}}

Non golfé:

// Flip a one- or two-digit number
f=n=>100+10*n+n/10|0

// Primality test
// For initial testing, you can replace this line with:
//      p=require('primality')
// This uses the primality npm module and is way faster
p=n=>{for(i=2;i<n;n=n%i++<1?0:n);return n>1}

// Convert number to string, pad with zeroes if necessary
q=n=>(''+(100+n)).slice(-2)

r=_=>{
    // Loop months
    for(m=13;--m;)
        // Loop days
        for(d=32;--d;)
            // Loop middle digit
            for(x=10;--x+1;) {
                // Construct 'date'
                s = 
                    // Start with day and month, each flipped
                    q(f(d))+q(f(m)) + 
                    // Add middle digit ( will be casted to string since the previous expression is also a string)
                    x + 
                    // Add month and date as they are
                    q(m)+q(d);

                if(
                    // Check for primality
                    p(s|0) && 
                    // Check if it's a valid date by validating day ( month and year will always be valid)
                    d<(
                        // For February, we always assume 28 days ( check for 29 because we use less than)
                        m==2?29 : 
                        // For other months, it alternates between 31 and 30
                        // EXCEPT July and August both have 31 days, then continues alternating
                        31+(m+m/8|0)%2))
                    console.log(s)
            }
}

Comment ça fonctionne:

La magie du retournement des chiffres est basée principalement sur l'expérimentation.
J'ai commencé par trouver le nombre à soustraire pour obtenir la version inversée. Je ne me souciais que des deux derniers chiffres.
Donc, si nous prenons n, trouvez k-le n+k=flip(n). Pour 10<n<20 kcommencé à 101 et augmenté par incréments de 9. Cependant, pour n<10, c'était 100. J'ai supposé kaugmenté pour chaque saut de 10, et après un peu de tripotage, je me suis dit que c'était correct.
Ainsi, k=100+9*n+n//10où // signifie une division entière.

Ainsi, nous obtenons n+k = n+(100+9*n+n//10) = 100+10*n+n//10 = flipped(n).

Je ne peux pas prouver ni prétendre que cela fonctionne pour n'importe quel nombre, mais cela a produit des résultats corrects pour les nombres utilisés ici.

Pour le test de primalité, crédit à la réponse de Kevin Cruijssen . J'avais une version un peu plus courte, mais je ne pouvais pas faire les choses correctement:

p=n=>{for(i=n;--i-1;)if(!(n%i))return 1;}

J'ai sauté le test du palindrome, en bouclant sur des mois, des jours et un chiffre du milieu pour pouvoir construire des chaînes comme dDmMxMmDd, où Dest le premier chiffre du jour, dest le deuxième, etc.

Histoire

Enregistré 5 octets en se débarrassant de la partie conditionnelle de q

q=n=>n<10?'0'+n:(''+n).slice(-2) // from
q=n=>(''+(100+n)).slice(-2)      // to

APL NARS 626 octets, 313 caractères

f;y;m;d;i;k;v;x;t
t←{60⊥3↑3↓⎕TS}⋄t0←50+t
x←2 12⍴v,v←31 28 31 30 31 30 31 31 30 31 30 31
x[2;2]←29⋄m←d←1⋄y←10000
X:  i←{(0=4∣⍵)∧0≠100∣⍵:1⋄0=400∣⍵:1⋄0}y
A:  →0×⍳y≥1e5
    →0×⍳t≥t0
    k←d+100×m+y×100
    →B×⍳∼k=⍎⌽⍕k⋄→B×⍳∼0πk⋄⎕←k
B:  d+←1
    →A×⍳d≤x[1+i;m]
    d←1⋄→C×⍳∼m=12⋄m←1⋄y+←1⋄→X
C:  m+←1⋄→A

cette impression ce que trouver en 50 secondes, que s'arrêter lui-même (car sinon je ne peux pas arrêter le programme pour copier coller le test, car je ne sais pas comment arrêter le programme sans fermer les fenêtres de l'interpréteur) test:

  f
100111001
100131001
100161001
101030101
101060101
101141101
101171101
102040201
102070201
103000301
103060301
104000401
104030401
104040401

Julia 0,6 , 109 octets

Le lien passe à une version plus longue avec deux différences:

1. Vérifie les nombres premiers avec une fonction manuscrite, car le package Primes n'est pas disponible sur TIO.
2. Itère sur une plage de dates différente pour ne pas expirer.

[s for s in Dates.format(Date(0,1,1):Date(100000,1,1),"YYYYmmdd") if Primes.isprime(parse(s))&&s==reverse(s)]

Essayez-le en ligne!