Bạn biết thế nào là một palindrom , một nguyên tố và một ngày .

Nhiệm vụ của bạn là liệt kê tất cả các ngày trong 100 nghìn năm đáp ứng cả ba đặc điểm.

Không bao giờ lấy bất cứ thứ gì ngoại trừ các số, sử dụng các định dạng sau: YYYYMMDD và YYYYYMMDD .

Các ngày trong khoảng từ 0000-01-01 đến 9999-12-31 nên được in dưới dạng ngày palindromes 8 chữ số (Nếu có?) Và ngày giữa 10000-01-01 và 99999-12-31 nên được in dưới dạng palindromes 9 chữ số .

Không bắt buộc phải liệt kê các ngày theo thứ tự thời gian.

Ví dụ một phần của đầu ra hợp lệ.

Ba ngày đầu tiên 9 chữ số palindromic:

...
100111001
100131001
100161001
...

Quy tắc

Tiêu chuẩn áp dụng.

Ruby , 144 141 byte (134 + 7 cho -rprimecờ)

^{Đã lưu 3 byte nhờ 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)}}}

Hãy thử trực tuyến!

Thuật toán:

• tạo tất cả các kết hợp MMDD có thể, từ "0101" đến "1231"
• tạo ra tất cả các năm cho ngày đó sẽ dẫn đến một bảng màu, bằng cách đảo ngược chuỗi MMDD và thêm vào giữa, tất cả các ký tự trong phạm vi (0..9)
• kiểm tra xem đó là một ngày hợp lệ bằng cách tạo ra một Timeví dụ với cho y, m, dgiá trị. Nếu đối tượng thời gian kết quả có #daygiá trị bằng d, thì đó là một ngày hợp lệ. Nếu không, nó sẽ thay đổi ngày (ví dụ, Time.new 2018,2,30trả về 2018-03-02).
• kiểm tra xem ngày palindrom hợp lệ cũng là một số nguyên tố và hiển thị nếu có.

Vòng lặp bên trong ban đầu là một hàm được gọi cho từng phần tử trong (?0..?9)phạm vi, cũng như cho chuỗi rỗng.

Vì chuỗi rỗng tạo ra không có kết quả (không có các số nguyên tố 8 chữ số hợp lệ), tôi quyết định loại bỏ nó và tái cấu trúc lại phiên bản này.

Python 2 , 116 107 128 122 119 byte

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

Phần thứ hai của dòng thứ 4 được lấy cảm hứng từ mxdsp 's trả lời ở đây để một câu hỏi golf .

Giải trình

Hàm chỉ g()lấy một đối số để khởi tạo nbiến bằng giá trị mặc định của nó. Giá trị ban đầu là một số lẻ càng ngắn càng tốt và càng lớn càng tốt trong khi vẫn nhỏ hơn câu trả lời hợp lệ đầu tiên 100111001.

Vòng lặp cho đến khi nkết thúc phạm vi ngày 10 ⁹ . Tăng nthêm 2. mlà tháng của ngày n.

Nếu nlà một ngày hợp lệ, bảng màu và số nguyên tố, hãy in nó:

• Ngày:
  • 0 < m < 13kiểm tra đó mlà một tháng hợp lệ.
  • n % 100 < 31 + (m+m/8)%2kiểm tra nxem ngày của tháng có hợp lệ không (m+m/8)%2thêm 1cho tất cả các tháng với 31 ngày. Tín dụng cho điều đó đi đến câu trả lời của ArmanX . Không có số nguyên tố cho 29-30 tháng 2.
• Palindrom : `n`[::-1] == `n`. Các backticks xâu chuỗi n. [::-1]đảo ngược chuỗi.
• Prime: 2**n % n == 2là một bài kiểm tra nguyên thủy Fermat . Thử nghiệm đó chỉ có xác suất. Cũng có những số nguyên tố không khớp. Nhưng không phải trong phạm vi số chúng ta đang xem xét.

APL (Dyalog Unicode) , 155 byte

⎕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

Hãy thử trực tuyến!

Đây là một Tradfn ( trad itional f unctio n ) mà phải mất một đối số arg = yyyymmddhay arg = yyyyymmdd. Cách sử dụng là f arg.

Điều này sẽ không xuất ra bất cứ điều gì khi đối số bắt đầu tại 10000101vì nó không tìm thấy ngày chính trong 60 giây.

Đây là một cách tiếp cận ít chơi hơn sẽ tạo ra đầu ra ví dụ của OP là

100111001
100131001
100161001

( Dùng thử trực tuyến! )

Lưu ý rằng cả hai mã đều giống hệt nhau cho đến khi đúng trước khi gọi hàm đệ quy cho ngày tiếp theo. Trong khi phiên bản golf chỉ gọi nó là f arg+1, mã ít golf hơn nhảy từ ngày này 31sang ngày khác 01và từ tháng này 12sang tháng khác 01, điều này làm tăng tốc nó lên một chút.

Làm thế nào nó hoạt động:

⎕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 byte

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)

Giải pháp khá dài (và có thể có thể được cải thiện), nhưng không sử dụng bất kỳ chức năng tích hợp nào để kiểm tra số nguyên tố / ngày / palindrom. Một phiên bản hơi vô căn cứ cho rõ ràng:

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)

Ngày hợp lệ được tạo bằng cách chọn một tháng và ngày. Như đã nhận xét trước đây, chỉ cần xem xét kích thước 9. Cũng lưu ý rằng năm nhuận không được xem xét. Điều này là không bắt buộc vì sự trùng hợp may mắn là các số nguyên tố palindrom có ​​độ dài 9 kết thúc vào 0229 đơn giản là không tồn tại (các dị thường ngày khác như ngày 30 tháng 2 năm 1712 có thể bị loại bỏ vì lý do tương tự).

Tiếp theo, chữ số giữa được chọn tự do và một bài kiểm tra chính được thực hiện. Bởi vì bài kiểm tra chính phải càng ngắn càng tốt, nó rất ngây thơ và do đó làm tê liệt chậm. Sử dụng một thư viện bên ngoài có thể giải quyết điều này (và lưu một số byte), nhưng như đã đề cập trước khi tôi không muốn sử dụng bất kỳ.

WolframL Language (Mathicala) 187 byte

Có thể có một số giảm kích thước được tìm thấy. Giải thích để làm theo ...

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]&

Các trường hợp thử nghiệm

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"} *)

Giải thích mã

DayRange[d@#,d@#2]trả về tất cả các ngày giữa {10011, 10, 1}và {10017, 1, 1}. Trong trường hợp này, nó trả về khoảng 5 năm, 4 tháng ngày (chính xác là 1920 ngày). Năm nhuận được tính đến.

Ngày được trả về theo định dạng chuẩn của Wolfram. Ví dụ: ngày đầu tiên sẽ xuất hiện dưới dạng DateObject[List[1,1,1],"Day","Gregorian",-5.] `

#[[1]] & /@sẽ loại bỏ một phần của ngày, trong mỗi ngày, liên quan đến chúng tôi. Trong ví dụ, DateObject[List[1,3,7],"Day","Gregorian",-5.]trả về ngày viết tắt , {1,3,7}.

t/@p[#3,2]}hoặc ToString/@Padleft[#3,2]đệm phần tử thứ ba, cụ thể là 7 chữ "trong ngày thứ 7 của tháng" như "07". Phần đệm tương tự được cung cấp cho ký hiệu một chữ số cho tháng 3, cụ thể, 3được trả về là "03".

p[#, If[Length@# < 5, 4, 5]]đệm năm với số không để đạt đến độ dài của chuỗi 4 hoặc 5 chữ số. Trong trường hợp này, tháng một, cụ thể 1, được trả về là `" 00001 "'.

"" <>...nối các chuỗi. Trong trường hợp này, nó trở lại "000010307".

Cases[...x_ /; PalindromeQ@x && PrimeQ@ToExpression@x] trả về những trường hợp đó, trong số 1920 ngày, đó là palindromes và primes.

Javascript , 187 177

Giả định: không khớp 4 năm chữ số; không có ngày phù hợp trong tháng hai giữa 29-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)}}

Nó hoạt động như thế này:

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!

Lịch sử:

• 187 đến 177: Không có ngày palindrom chính rơi vào ngày 29 hoặc 30 tháng 2, vì vậy chúng tôi có thể giả vờ là tháng hai có 30 ngày và lưu 10 ký tự.

Ghi chú:

Qua thử nghiệm, tôi thấy không có kết quả hợp lệ nào là 4 năm chữ số hoặc rơi vào ngày 29 hoặc 30 tháng Hai. Thật không may, vì lợi ích của mã, chính xác là năm kết quả (không hợp lệ) rơi vào ngày 31 của nhiều tháng khác nhau chỉ có 31 ngày.

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

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 byte nhờ @assylias .

Giải trình:

Hãy thử trực tuyến (lưu ý: phần kiểm tra chính đã được thay thế bằng phương pháp tách hiệu quả hơn, mặc dù ngay cả khi nó vẫn hết sau 60 giây, chỉ xuất ra các ngày đầu tiên ~ 115 palindromic đầu tiên).
Pastebin của tất cả 197 đầu ra từ một hoạt động địa phương.

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

Sạch , 262 ... 213 byte

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]]

Hãy thử trực tuyến!

Javascript , 234 229 byte

Một chút cồng kềnh, nhưng đăng nó để có được bóng JS lăn. Mọi góp ý đều được chào đón!

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)}}

Ung dung:

// 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)
            }
}

Làm thế nào nó hoạt động:

Phép thuật lật chữ số chủ yếu dựa trên thử nghiệm.
Tôi bắt đầu bằng cách tìm ra số nào để trừ đi để có được phiên bản lật. Tôi chỉ quan tâm đến hai chữ số cuối cùng.
Vì vậy, nếu chúng ta thực hiện n, tìm thấy knhư vậy n+k=flip(n). Để 10<n<20 kbắt đầu ở 101 và tăng theo gia số 9. Tuy nhiên, với n<10con số này là 100. Tôi giả sử ktăng lên cho mỗi lần nhảy là 10, và sau một chút lo lắng tôi đã hiểu rằng điều đó là chính xác.
Vì vậy, k=100+9*n+n//10trong đó // có nghĩa là chia số nguyên.

Như vậy, chúng ta có được n+k = n+(100+9*n+n//10) = 100+10*n+n//10 = flipped(n).

Tôi không thể chứng minh, cũng không cho rằng điều này hoạt động với bất kỳ số nào, nhưng nó tạo ra kết quả chính xác cho các số được sử dụng ở đây.

Đối với bài kiểm tra tính nguyên thủy, ghi có vào câu trả lời của Kevin Cruijssen . Tôi đã có một phiên bản ngắn hơn một chút, nhưng tôi không thể hiểu đúng:

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

Tôi đã bỏ qua bài kiểm tra palindrom, bằng cách lặp qua nhiều tháng, ngày và một chữ số ở giữa để tôi có thể xây dựng các chuỗi như dDmMxMmDd, Dchữ số đầu tiên trong ngày, dlà số thứ hai, v.v.

Lịch sử

Đã lưu 5 byte bằng cách loại bỏ phần có điều kiện của q

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

APL NARS 626 byte, 313 ký tự

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

Điều này in những gì tìm thấy trong 50 giây, hơn là dừng chính nó (vì nếu không tôi không thể dừng chương trình để sao chép dán kiểm tra, vì tôi không biết làm thế nào để dừng chương trình mà không đóng cửa sổ trình thông dịch) kiểm tra:

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

Julia 0,6 , 109 byte

Liên kết đến phiên bản dài hơn với hai điểm khác biệt:

1. Kiểm tra các số nguyên tố có chức năng viết tay, vì gói Số nguyên tố không có sẵn trên TIO.
2. Lặp lại trong một phạm vi ngày khác nhau để không hết thời gian.

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

Hãy thử trực tuyến!