Nel xkcd 1047 , Randall Munroe elenca approssimazioni "leggermente sbagliate" di quantità e numeri assortiti con precisione e complessità variabili, come ad esempio il fatto che il numero di litri in un gallone è molto vicino a 3 + ^π ⁄ ₄ . Nel mezzo del fumetto, dà un intervallo: un modo per stimare la popolazione mondiale (e degli Stati Uniti) in base a un determinato anno.

(Ritagliato da xkcd: approssimazioni di Randall Munroe)

Il tuo compito è di scrivere un programma che implementa queste formule per approssimare il mondo attuale e le popolazioni statunitensi, replicato come segue.

Popolazione mondiale

1. Prendi le ultime due cifre dell'anno in corso.
2. Sottrai il numero di anni bisestili (incluso l'anno corrente) dall'uragano Katrina (2005). A tal fine, ogni anno divisibile per 4 è considerato un anno bisestile.
3. Aggiungi un punto decimale tra i due numeri (lo stesso che dividere per 10).
4. Aggiungi 6. Questo dà il risultato in miliardi di persone.

Popolazione americana

1. Prendi le ultime due cifre dell'anno in corso.
2. Sottrai 10.
3. Moltiplicare per 3.
4. Aggiungi 10.
5. Aggiungi 3 all'inizio (per questa sfida, alcuni numeri saranno negativi, quindi aggiungi 300). In qualche modo non ho notato che il semplice concatenamento non avrebbe funzionato perché il programma che ho usato per generare i risultati ne ha appena aggiunti 300.
6. Questo dà il risultato in milioni di persone.

Dettagli

Questa formula "dovrebbe rimanere aggiornata per un decennio o due", ma devi essere in grado di gestire teoricamente qualsiasi anno 2000-2039 compreso. In alcuni casi, gli anni bisestili da quando Katrina avrà un valore negativo o zero.

Sei libero di semplificare la formula in qualsiasi modo, purché tutti gli output corrispondano a quelli indicati di seguito.

Per l'anno, utilizzare l'anno in base all'orologio del computer. Deve funzionare il prossimo anno e qualsiasi altro anno in questo secolo, quindi non puoi semplicemente hardcode 2015. Per comodità, potresti voler includere un modo per specificare l'anno come variabile o input per testare altri anni.

L'output dovrebbe essere la popolazione mondiale approssimativa (in miliardi di persone), seguita da un delimitatore (ad esempio spazio o virgola), seguito dalla popolazione americana (in milioni di persone). È inoltre possibile scrivere una funzione che restituisce o stampa una stringa o una matrice di numeri o stringhe.

Questo è il codice golf, quindi vince il codice più breve in byte. Tiebreaker è il primo post.

Casi test

Questo è un elenco di tutti gli anni possibili, seguito dai due risultati.

Year   World  U.S.
2000    6.1   280
2001    6.2   283
2002    6.3   286
2003    6.4   289
2004    6.4   292
2005    6.5   295
2006    6.6   298
2007    6.7   301
2008    6.7   304
2009    6.8   307
2010    6.9   310
2011    7     313
2012    7     316
2013    7.1   319
2014    7.2   322
2015    7.3   325
2016    7.3   328
2017    7.4   331
2018    7.5   334
2019    7.6   337
2020    7.6   340
2021    7.7   343
2022    7.8   346
2023    7.9   349
2024    7.9   352
2025    8     355
2026    8.1   358
2027    8.2   361
2028    8.2   364
2029    8.3   367
2030    8.4   370
2031    8.5   373
2032    8.5   376
2033    8.6   379
2034    8.7   382
2035    8.8   385
2036    8.8   388
2037    8.9   391
2038    9     394
2039    9.1   397

Pyth, 21 20 byte

-1 byte di Dennis

c/J-*3.d3C\ᙹ4T+33J

Questi hanno lo stesso numero di byte ma sono solo ASCII:

c/J%*3.d3 523 4T+33J
c/-J%*3.d3*44T33 4TJ

Non conosco Pyth, quindi probabilmente probabilmente golfable. Utilizzando lo stesso algoritmo:

TI-BASIC, 23 byte

max(3getDate-5753
{.1int(Ans/4),Ans+33

getDaterestituisce un elenco di tre float {YYYY,MM,DD}in un certo ordine a seconda dell'impostazione del formato della data (le TI-84 non hanno un vero tipo di dati int); il max(sarà l'anno. Moltiplicare e sottrarre all'interno del max(salva un paren vicino.

Javascript (ES6), 55 54 48 byte

-~((n=Date().substr(13,2)*3+280)/4-9.1)/10+' '+n

Funziona con Firefox 33; supporta teoricamente tutti gli anni dal 2000 al 2099. Se i programmi che scaricano il risultato sulla console non sono consentiti, utilizzare questa funzione a 51 byte:

(n=Date().substr(13,2)*3+280)=>-~(n/4-9.1)/10+' '+n

Programma completo, 55 byte:

n=Date().substr(13,2)*3+280,alert(-~(n/4-9.1)/10+' '+n)

Ottenere l'anno è stato piuttosto costoso, ma dopo aver utilizzato il valore deprecato getYear()anziché getFullYear(), tutti i numeri nell'equazione sono diventati più piccoli, risparmiando molti byte. EDIT: Grazie a un trucco di un eeevil, ho saltato newe del getYear()tutto. >: D

Suggerimenti benvenuti!

Pyth, 30 byte

.R+*.075J%.d3C\d6.105 1+*3J280

Il mio primo programma Pyth!

Grazie @Jakube per alcuni suggerimenti (non avrei mai pensato a quelli!)

Python 2, 80 byte

from datetime import*
y=date.today().year%40
print int(61.55+.75*y)/10.,y*3+280

Adesso tondo!

CJam, 28 byte

et0=100%__4/(-Ad/6+S@3*280+

Provalo online

Per provare anni diversi da quello attuale, sostituisci et0=all'inizio con il valore letterale dell'anno.

Python 3, 134 byte

Funziona bene ma sembra un po 'lungo

from datetime import*
y=str(date.today().year)
z=int(y[2:])
m=str(60+(z-int((int(y)-2005)/4)))
print("%s.%s"%(m[0],m[1]),310+(z-10)*3)

AutoIt - 60 58 56 byte

$_=@YEAR-2e3
ClipPut(($_-Int($_/4-1))/10+6&' 3'&3*$_-20)

L'arrotondamento mangia byte (non più). Ora ho modificato entrambe le formule. Alcuni output di esempio:

7.3 325 // 2015
7.3 328
7.4 331
7.5 334 // 2018
8.4 370 // 2030

Sembrano tutti essere accurati.

Un consiglio: l'ordine di esecuzione salva byte tra parentesi. Ad esempio: (a-4)/4 = a/4-1:-).

PowerShell, 53 45 byte

$n=date -f yy;.1*[int](61.45+.75*$n);280+3*$n

Utilizza un trucco di arrotondamento simile alla risposta Python 2 di muddyfish per semplificare il calcolo della popolazione mondiale, dal momento che PowerShell è implicitamente Round()s quando lanci da a [double]a [int]piuttosto che troncare.

Per l'output, assumiamo che "seguito da delimitatore (ad esempio spazio o virgola)" possa anche significare "newline", quindi eseguiamo un risultato e poi il secondo. PowerShell scrive implicitamente i risultati, quindi non è necessario chiamare esplicitamente alcun comando di stampa.

Mathematica, 50 byte

n=Today["YearShort"];{.1*(61+n-Floor[n/4]),280+3n}

Si noti che ciò dipende dall'avere un motore Wolfram con la versione numero 10+ (rilasciata nel 2014) a causa della dipendenza DateObjects.

R, 64 byte

n=as.numeric(format(Sys.time(),"%y"))
c(.1*(61+n-n%/%4),280+3*n)

Porta diretta del codice Mathematica, penso di avere una soluzione più breve ma dipendente dai pacchetti mentre funziona con la base R.

Java, 180 177 166 152 143 byte

Grazie Thomas per l'aiuto a un noob :)

class D{public static void main(String[]a){int f=java.time.LocalDate.now().getYear();System.out.printf("%.1f %d\n",(3.*f-5755)/40,3*f-5720);}}

Versione non golfata:

class D {
  public static void main(String[]a) {
    int f = java.time.LocalDate.now().getYear();
    System.out.printf("%.1f %d\n",(3.*f-5755)/40,3*f-5720);
  }
}

Richiede Java 8.

JavaScript (ES6) 52

Una funzione che restituisce l'output come un array.

(y=(new Date).getYear())=>[(y+~(y/4)-13)/10,y*3-20]

Solo a scopo di test, la funzione accetta un input uguale all'anno corrente - 1900 (ad esempio 105 per il 2015)

Questo è in linea con la risposta di ETHproductions (la matematica è la matematica), ma a dispetto del trucco malvagio è più portabile in diversi luoghi. E come funzione è più corta di 1 byte.

Snippet di prova:

f=(y=(new Date).getYear())=>[(y+~(y/4)-13)/10,y*3-20]

o=[];
for(a=2000;a<2050;a++)o.push(`<td>${a}</td><td>${f(a-1900)}</td>`);
document.write(`<table><tr>${o.join`</tr><tr>`}</tr></table>`)

td { text-align:right; font-family:monospace }

Rubino, 57 byte

y=Time.now.year%40;puts "#{6+(y-(y-5)/4)*0.1} #{3*y+280}"

Sfortunatamente, Time.now.yearcosta davvero alcuni personaggi.

Desmos , 140 byte

Sto contando una nuova riga per essere un segnale per una nuova equazione. Le cartelle sul collegamento sono solo per l'organizzazione.

Golfato , 140 byte

Fare clic add sliderquando richiesto.

a=6+.1b-.1c
d=280+3b
c=\sum_{n=2005}^q\left\{0=\operatorname{mod}\left(n,4\right),0\right\}
b=100\left|\operatorname{floor}\left(.01q\right)-.01q\right|

Ungolfed , 261 byte

p_{world}=6+\frac{l_{astdig}-l_{eap}}{10}
p_{us}=310+3\left(l_{astdig}-10\right)
y_{ear}=2039
l_{eap}=\sum _{n=2005}^{y_{ear}}\left\{0=\operatorname{mod}\left(n,4\right),0\right\}
l_{astdig}=100\left|\operatorname{floor}\left(\frac{y_{ear}}{100}\right)-\frac{y_{ear}}{100}\right|

Glava, 77 byte

i|f=java.time.LocalDate.now().getYear();F("%.1f %d\n",(3.*f-5755)/40,3*f-5720

Una traduzione della mia risposta Java.

PHP, 45 byte

Il codice:

echo(int)(($x=3*date(y)+247)/4)*.1," ",$x+33;

Poiché y(l'argomento di date()) è una costante indefinita, PHP innesca un avviso (che può essere disattivato) e lo converte in una stringa (di cui abbiamo bisogno); questa cortesia PHP consente di salvare 2 byte.

Per sopprimere l'avviso, è necessario eseguire il programma utilizzando la error_reporting=0direttiva runtime, in questo modo:

$ php -d error_reporting=0 -r 'echo(int)(($x=3*date(y)+247)/4)*.1," ",$x+33;'
7.3 325

Per i test

Sostituendo la chiamata a date(y)con $argv[1](il primo argomento della riga di comando), la lunghezza del programma aumenta di 1 byte ma può ottenere l'anno dalla riga di comando.

L'argomento atteso è l'anno meno 2000; funziona anche per valori negativi (anni prima del 2000) o per valori superiori a 40 (dopo l'anno 2040).

$ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 00
6.1 280

$ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 01
6.2 283

$ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 02
6.3 286

$ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 03
6.4 289

$ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 04
6.4 292

$ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 15
7.3 325

$ php -r 'echo(int)(($x=3*$argv[1]+247)/4)*.1," ",$x+33;' 39
9.1 397

APL, 25 23 29 byte

{(10÷⍨⌊⍵÷4),⍵+33}⊃¯5753+3×⎕TS

TryAPL

Sì, sono 29 byte .