Dalam xkcd 1047 , Randall Munroe daftar perkiraan "sedikit salah" dari berbagai macam jumlah dan angka dengan berbagai presisi dan kompleksitas, seperti bahwa jumlah liter dalam satu galon sangat dekat dengan 3 + ^π ⁄ ₄ . Di tengah-tengah komik, ia memberikan jeda: cara untuk memperkirakan populasi dunia (dan Amerika Serikat) berdasarkan tahun tertentu.

(Dipotong dari xkcd: Perkiraan oleh Randall Munroe)

Tugas Anda adalah menulis program yang mengimplementasikan formula ini untuk memperkirakan populasi dunia dan AS saat ini, direplikasi sebagai berikut.

Populasi dunia

1. Ambil dua digit terakhir tahun ini.
2. Kurangi jumlah tahun kabisat (termasuk tahun ini) sejak Badai Katrina (2005). Untuk tujuan ini, setiap tahun yang dapat habis dibagi 4 dianggap sebagai tahun kabisat.
3. Tambahkan titik desimal antara dua angka (sama dengan membagi dengan 10).
4. Tambahkan 6. Ini memberikan hasil dalam miliaran orang.

Populasi AS

1. Ambil dua digit terakhir tahun ini.
2. Kurangi 10.
3. Kalikan dengan 3.
4. Tambahkan 10.
5. Tambahkan 3 ke awal (untuk tantangan ini, beberapa angka akan negatif, jadi tambahkan 300 sebagai gantinya). Entah bagaimana saya tidak menyadari bahwa hanya menggabungkan tidak akan berhasil karena program yang saya gunakan untuk menghasilkan hasil hanya menambahkan 300.
6. Ini memberikan hasil dalam jutaan orang.

Detail

Formula ini "harus tetap berlaku selama satu atau dua dekade," tetapi Anda harus dapat secara teoritis menangani tahun 2000-2039 inklusif. Untuk beberapa kasus, tahun kabisat sejak Katrina akan memiliki nilai negatif atau nol.

Anda bebas untuk menyederhanakan formula dengan cara apa pun, selama semua output cocok dengan yang di bawah ini.

Untuk tahun ini, gunakan tahun sesuai dengan jam komputer. Ini harus bekerja tahun depan dan tahun lainnya di abad ini, jadi Anda tidak bisa hanya dengan hardcode 2015. Untuk kenyamanan, Anda mungkin ingin memasukkan cara untuk menentukan tahun sebagai variabel atau input untuk menguji tahun lain.

Outputnya haruslah populasi dunia yang diperkirakan (dalam miliaran orang), diikuti oleh beberapa pembatas (misalnya ruang atau koma), diikuti oleh populasi AS (dalam jutaan orang). Anda juga dapat menulis fungsi yang mengembalikan atau mencetak string atau array angka atau string.

Ini adalah kode golf, jadi kode terpendek dalam byte menang. Tiebreaker adalah posting paling awal.

Uji kasus

Ini adalah daftar semua tahun yang mungkin, diikuti oleh dua keluaran.

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 oleh Dennis

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

Ini memiliki jumlah byte yang sama tetapi hanya ASCII:

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

Saya tidak tahu Pyth, jadi mungkin masih bisa golf. Menggunakan algoritma yang sama:

TI-BASIC, 23 byte

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

getDatemengembalikan daftar tiga float {YYYY,MM,DD}dalam beberapa urutan tergantung pada pengaturan format tanggal (TI-84 tidak memiliki datatype int sebenarnya); yang max(akan menjadi tahun. Mengalikan dan mengurangi di dalam max(menghemat jarak dekat.

Javascript (ES6), 55 54 48 byte

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

Bekerja di Firefox 33; secara teoritis mendukung semua tahun dari 2000 hingga 2099. Jika program yang membuang hasilnya ke konsol tidak diizinkan, gunakan fungsi 51-byte ini:

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

Program lengkap, 55 byte:

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

Mendapatkan tahun itu cukup mahal, tetapi setelah menggunakan yang sudah getYear()tidak digunakan lagi getFullYear(), semua angka dalam persamaan menjadi lebih kecil, menghemat banyak byte. EDIT: Berkat trik eeevil, saya melewatkan newdan getYear()sekaligus. >: D

Saran diterima!

Pyth, 30 byte

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

Program Pyth pertama saya!

Terima kasih @ Jakube untuk beberapa petunjuk (saya tidak akan pernah memikirkan itu!)

Python 2, 80 byte

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

Sekarang bulat!

CJam, 28 byte

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

Cobalah online

Untuk mencoba tahun selain yang sekarang, ganti et0=di awal dengan nilai literal tahun.

Python 3, 134 byte

Bekerja dengan baik tetapi agak lama

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)

Pembulatan memakan byte (tidak lagi). Saya sekarang telah men-tweak kedua formula. Beberapa output sampel:

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

Mereka semua tampaknya akurat.

Kiat: Urutan eksekusi menyimpan byte pada tanda kurung. Misalnya: (a-4)/4 = a/4-1:-).

PowerShell, 53 45 Bytes

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

Menggunakan trik pembulatan serupa dengan jawaban Python 2 muddyfish untuk menyederhanakan perhitungan populasi dunia, karena PowerShell secara implisit Round()adalah ketika Anda melakukan cast dari a [double]ke a [int], alih-alih memotong.

Untuk output, kami menganggap bahwa "diikuti oleh beberapa pembatas (misalnya spasi atau koma)" juga bisa berarti "baris baru", jadi kami menjalankan satu hasil dan kemudian yang kedua. PowerShell secara implisit menuliskan hasil, jadi kita tidak perlu secara eksplisit memanggil perintah pencetakan.

Mathematica, 50 byte

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

Perhatikan bahwa ini tergantung pada memiliki Mesin Wolfram dengan Versi nomor 10+ (dirilis 2014) karena ketergantungan pada DateObjects.

R, 64 byte

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

Port langsung kode Mathematica, berpikir saya punya solusi yang lebih pendek tetapi tergantung pada paket sedangkan ini bekerja dengan basis R.

Java, 180 177 166 152 143 byte

Terima kasih Thomas telah membantu 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);}}

Versi tidak disatukan:

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

Membutuhkan Java 8.

JavaScript (ES6) 52

Fungsi yang mengembalikan output sebagai array.

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

Hanya untuk tujuan pengujian, fungsi menerima input yang sama dengan tahun berjalan - 1900 (mis. 105 untuk 2015)

Itu sesuai dengan jawaban ETHproductions '(matematika adalah matematika) tetapi menghindari trik jahat itu lebih portabel di berbagai daerah. Dan sebagai fungsi itu 1 byte lebih pendek.

Cuplikan uji:

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 }

Ruby, 57 byte

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

Sayangnya, Time.now.yearbenar-benar menghabiskan beberapa karakter.

Desmos , 140 Bytes

Saya menghitung baris baru untuk menjadi sinyal untuk persamaan baru. Folder pada tautan hanya untuk organisasi.

Golf , 140 Bytes

Klik add slidersaat diminta.

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|

Tidak Digubah , 261 Bytes

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

Terjemahan dari jawaban Java saya.

PHP, 45 byte

Kode:

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

Karena y(argumen date()) adalah konstanta yang tidak terdefinisi, PHP memicu pemberitahuan (yang dapat diredam) dan mengubahnya menjadi string (seperti yang kita butuhkan); kesopanan PHP ini memungkinkan penghematan 2 byte.

Untuk menekan pemberitahuan, program harus dijalankan menggunakan error_reporting=0arahan runtime, seperti ini:

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

Untuk pengujian

Dengan mengganti panggilan ke date(y)dengan $argv[1](argumen baris perintah pertama), panjang program meningkat dengan 1 byte tetapi bisa mendapatkan tahun dari baris perintah.

Argumen yang diharapkan adalah tahun minus 2000; ini juga berfungsi untuk nilai negatif (tahun sebelum 2000) atau nilai lebih besar dari 40 (setelah tahun 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

Ya, ini 29 byte .