Nel calendario tailandese l'anno 2017 corrisponde a 2560. Il calendario tailandese è sempre 543 anni avanti rispetto al calendario gregoriano.

I programmatori osservanti noteranno che 2560 è uguale a 2^9 * 5, in altre parole ha 10 fattori primi. Ciò non accadrà più per altri 896 anni! Chiamiamo un anno tenace se ha esattamente dieci fattori primi.

Scrivi un programma che emette un valore veritiero se l'anno corrente usando il calendario tailandese, basato sull'orologio di sistema, è tenace e un valore falso altrimenti.

Casi test:

• Se il programma viene eseguito durante il 2017, true
• Se il programma viene eseguito durante uno qualsiasi degli anni dal 2018 al 2912, false
• Se il programma viene eseguito durante il 2913, true(2913 + 543 = 2^7 * 3^3)

Bash + coreutils, 35 byte

factor $[`date +%Y`+543]|awk NF==11

L'output è una stringa non vuota (verità) o una stringa vuota (falsa).

Provalo online!

Versione alternativa: 37 byte.

date -d 543year +%Y|factor|awk NF==11

Non così da golf, ma mi piace questo.

Provalo online!

Come funziona

La $[data di espansione aritmetica +% Y+543] viene eseguita date +%Yper ottenere l'anno (completo) corrente e aggiunge 543 all'anno.

Factor prende la somma come argomento e la stampa la scomposizione in fattori primi: prima il numero da considerare, quindi un elenco di singoli fattori primi.

Infine, awk filtra l'input, stampando solo righe con esattamente 11 campi (il numero più 10 fattori primi).

05AB1E , 10 byte

žg543+ÒgTQ

Provalo online! o come una suite di test

Spiegazione

      Òg     # the number of primefactors with duplicates of
žg           # the current year
  543+       # plus 543
        TQ   # equals 10

CJam , 13 byte

et0=543+mf,A=

Provalo online!

Spiegazione

et0=  e# Get current year.
543+  e# Add 543.
mf    e# Get prime factors with multiplicity.
,     e# Get length.
A=    e# Equals 10?

Mathematica, 37 31 byte

^{5 byte salvati grazie a lanlock4 .}

PrimeOmega[#&@@Date[]+543]==10&

Funzione anonima. Non accetta input e restituisce Trueo Falsecome output.

Pyth, 11 byte

qlP+543.d3T

Interprete online disponibile qui.

Spiegazione

       .d3   get current year
   +543      add 543
  P          get prime factors of result
 l           count number of prime factors
q         T  check if equal to 10 (result is implicitly printed)

Japt , 18 14 13 byte

543+Ki¹k l ¥A

Risparmiato 4 byte grazie a ETHproductions. Salvato 1 byte grazie a obarakon.

Provalo online!

Python 2 , 92 89 byte

^{-3 byte grazie a Jonathan Allan}

import time
y=time.gmtime()[0]+543
c=i=1
exec"i+=1\nwhile 1>y%i:y/=i;c-=1\n"*y
print-9==c

Provalo online!
Scorrere fino all'anno, estraendo (e couting) i fattori primi.
La riga exec equivale a:

for i in range(2,y):
 while not(y%i):
  y=y/i
  c=c-1

Ottava , 31 byte

nnz(factor(clock()(1)+543))==10

Provalo online!

Due trucchi usati qui:

• clock()(1)indicizzare direttamente nell'output di clock( clock(1)non funziona)
• nnzinvece di numel, poiché tutte le voci sono garantite come diverse da zero.

Versione alternativa, stesso conteggio byte

nnz(factor(max(clock)+543))==10

Questa versione può essere utilizzata solo per anni che superano 30, ma ovviamente trascurando i viaggi nel tempo questo include tutti gli anni in cui il programma può essere eseguito. Funziona anche in Matlab.

PHP, 111 68 66

$a=date(Y)+543;for($i=2;$i<$a;)$b+=$a%$i?!++$i:!!$a/=$i;echo$b==9;

conta direttamente il numero di fattori primi.

$a=date(Y)+543;             // current year
for($i=2;$i<$a;)            // while $i lower than the year
$b+=$a%$i?!++$i:!!$a/=$i;   // if $i divides $a: $a/=$i and ++$b | if not: ++$i
echo$b==9;                  // output if it has 10 prime factors

Vecchia idea: 111 90

for($i=1;++$i<1e3;)for($j=1;++$j<1e3;)${$i*$j}=($$i?:1)+($$j?:1);echo${date('Y')+543}==10;

Questo non utilizza un fattore di factoring primario incorporato, ma fondamentalmente un setaccio conteggio iniziale per ottenere il numero di fattori primi di un numero <10000. Questo è mappato sull'anno a 4 cifre che PHP fornisce utilizzando date('Y'):

for($i=1;++$i<1e3;)          // for each number smaller sqrt(1e4)
for($j=1;++$j<1e3;)          // do sqrt(1e4) times
${$i*$j}=($$i?:1)+($$j?:1);  // n_factors[i*j] = n_factors[i] + n_factors[j]
echo${date('Y')+543}==10;          // output 1 if the current year has 10 prime factors or nothing if it doesn't

MATL , 14 byte

1&Z'543+Yfn10=

Provalo online!

1&Z'   % Current year
543+   % Add 543
Yf     % Prime factor decomposition
n      % Number of elements
10=    % Equal to 10? Implicitly display

Lotto, 123 byte

@set/ay=%date:~-4%+543,n=d=2
:l
@set/ar=y%%d,d+=1
@if %r%==0 set/ay/=d-=1,n+=1
@if %y% gtr 1 goto l
@if %n%==12 echo 1

È possibile falsificare lo script sostituendo manualmente la datevariabile prima di eseguirla.

J , 18 byte

Ente del programma:

10=#q:543+{.6!:0''

Provalo online!

10= è dieci uguale a

# il conteggio di

q: i fattori primi di

543+ questo numero è stato aggiunto a

{. la testa (primo oggetto, ovvero l'anno) di

6!:0'' la data (come YMD hms)

JavaScript (ES6), 79 75 byte

f=(y=+Date().slice(11,15)+543,d=2,n=10)=>y>1?y%d?f(y,d+1,n):f(y/d,d,n-1):!n

La risposta di Port of my Batch. Passa nell'anno solare tailandese se desideri eseguire un test specifico. Modifica: salvato 4 byte grazie a @dandavis.