W xkcd 1047 Randall Munroe podaje „nieco błędne” przybliżenia różnych wielkości i liczb z różną precyzją i złożonością, na przykład liczba litrów w galonie jest bardzo bliska 3 + ^π ⁄ ₄ . W środku komiksu przerywa: sposób oszacowania populacji świata (i Stanów Zjednoczonych) na podstawie danego roku.

(Wykadrowane z xkcd: Approximations autorstwa Randall Munroe)

Twoim zadaniem jest napisanie programu, który implementuje te formuły w celu przybliżenia obecnego świata i populacji USA, powielonego w następujący sposób.

Populacja świata

1. Weź dwie ostatnie cyfry bieżącego roku.
2. Odejmij liczbę lat przestępnych (w tym rok bieżący) od huraganu Katrina (2005). Do tych celów każdy rok podzielny przez 4 jest uważany za rok przestępny.
3. Dodaj kropkę dziesiętną między dwiema liczbami (to samo, co dzielenie przez 10).
4. Dodaj 6. Daje to wynik w miliardach ludzi.

Populacja USA

1. Weź dwie ostatnie cyfry bieżącego roku.
2. Odejmij 10.
3. Pomnóż przez 3.
4. Dodaj 10.
5. Dodaj 3 na początek (w tym wyzwaniu niektóre liczby będą ujemne, więc zamiast tego dodaj 300). Jakoś nie zauważyłem, że po prostu konkatenacja nie zadziała, ponieważ program, którego użyłem do wygenerowania wyników, dodał 300.
6. To daje wynik w milionach ludzi.

Detale

Ta formuła „powinna być aktualna przez dekadę lub dwie”, ale musisz być w stanie teoretycznie poradzić sobie z każdym rokiem 2000–2039 włącznie. W niektórych przypadkach lata przestępne od Katriny będą miały wartość ujemną lub zerową.

Możesz dowolnie upraszczać formułę, o ile wszystkie wyniki są zgodne z poniższymi.

Dla roku użyj roku zgodnie z zegarem komputera. Musi działać w przyszłym roku i w każdym innym w tym stuleciu, więc nie można po prostu ustawić na stałe kodu 2015. Dla wygody możesz chcieć podać sposób określania roku jako zmiennej lub danych wejściowych do testowania innych lat.

Wynikiem powinna być przybliżona populacja światowa (w miliardach ludzi), a następnie pewien separator (np. Spacja lub przecinek), a następnie populacja USA (w milionach ludzi). Możesz także napisać funkcję, która zwraca lub drukuje ciąg znaków lub tablicę liczb lub ciągów znaków.

To jest kod golfowy, więc wygrywa najkrótszy kod w bajtach. Tiebreaker jest najwcześniejszym postem.

Przypadki testowe

To jest lista wszystkich możliwych lat, po których następują dwa wyniki.

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 bajtów

-1 bajt Dennisa

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

Te mają tę samą liczbę bajtów, ale są tylko ASCII:

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

Nie znam Pytha, więc prawdopodobnie prawdopodobnie gra w golfa. Używając tego samego algorytmu:

TI-BASIC, 23 bajty

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

getDatezwraca listę trzech liczb zmiennoprzecinkowych {YYYY,MM,DD}w określonej kolejności w zależności od ustawienia formatu daty (TI-84 nie mają prawdziwego typu danych int); max(będzie rokiem. Mnożenie i odejmowanie wewnątrz max(zapisuje bliski paren.

JavaScript (ES6), 55 54 48 bajtów

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

Działa w przeglądarce Firefox 33; teoretycznie obsługuje wszystkie lata od 2000 do 2099. Jeśli programy, które zrzucają wynik na konsolę, nie są dozwolone, użyj tej 51-bajtowej funkcji:

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

Pełny program, 55 bajtów:

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

Uzyskanie roku było dość drogie, ale po użyciu przestarzałej getYear()zamiast getFullYear(), wszystkie liczby w równaniu zmniejszyły się, oszczędzając wiele bajtów. EDYCJA: Dzięki sztuczce eeevila pominąłem newi getYear()całkowicie. >: D

Sugestie mile widziane!

Pyth, 30 bajtów

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

Mój pierwszy program w języku Pyth!

Dzięki @Jakube za wskazówki (nigdy bym o nich nie pomyślał!)

Python 2, 80 bajtów

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

Teraz rundy!

CJam, 28 bajtów

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

Wypróbuj online

Aby wypróbować lata inne niż obecny, zastąp et0=na początku literalną wartością roku.

Python 3, 134 bajty

Działa dobrze, ale wydaje się nieco długi

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 bajtów

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

Zaokrąglenie zjada bajty (już nie). Teraz poprawiłem obie formuły. Niektóre przykładowe wyniki:

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

Wszystkie wydają się dokładne.

Wskazówka: Kolejność wykonywania zapisuje bajty w nawiasach. Na przykład: (a-4)/4 = a/4-1:-).

PowerShell, 53 45 bajtów

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

Używa podobnej sztuczki zaokrąglania, jak odpowiedź Python 2 błotniaka, aby uprościć obliczanie populacji na świecie, ponieważ PowerShell domyślnie Round()s przy rzutowaniu z a [double]na [int]zamiast obcinania.

W przypadku danych wyjściowych zakładamy, że „po którym następuje jakiś separator (np. Spacja lub przecinek)” może również oznaczać „nowy wiersz”, więc wykonujemy jeden wynik, a następnie drugi. PowerShell domyślnie zapisuje wyniki, więc nie musimy jawnie wywoływać żadnych poleceń drukowania.

Mathematica, 50 bajtów

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

Pamiętaj, że jest to zależne od posiadania silnika Wolfram z wersją 10+ (wydaną w 2014 r.) Z powodu zależności DateObjects.

R, 64 bajty

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

Bezpośredni port kodu Mathematica, myślę, że miałem krótsze rozwiązanie, ale zależne od pakietów, podczas gdy działa to z bazą R.

Java, 180 177 166 152 143 143 bajty

Dzięki Thomas za pomoc noobowi :)

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

Wersja bez golfa:

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

Wymaga Java 8.

JavaScript (ES6) 52

Funkcja zwracająca dane wyjściowe jako tablicę.

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

Dla celów testowych funkcja przyjmuje wartość wejściową równą bieżącemu rokowi - 1900 (np. 105 dla 2015 r.)

Jest to zgodne z odpowiedzią ETHproductions (matematyka jest matematyką), ale skłaniając się ku złej sztuczce , jest bardziej przenośna w różnych lokalizacjach. I jako funkcja jest o 1 bajt krótszy.

Fragment testowy:

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 }

Rubinowy, 57 bajtów

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

Niestety, Time.now.yearnaprawdę kosztuje niektóre postacie.

Desmos , 140 bajtów

Liczę, że nowa linia będzie sygnałem dla nowego równania. Foldery w linku służą wyłącznie do organizacji.

Gra w golfa , 140 bajtów

Kliknij add sliderpo wyświetleniu monitu.

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|

Niegolfowany , 261 bajtów

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 bajtów

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

Tłumaczenie mojej odpowiedzi Java.

PHP, 45 bajtów

Kod:

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

Ponieważ y(argument date()) jest nieokreśloną stałą, PHP wyzwala powiadomienie (które można wyciszyć) i konwertuje je na ciąg znaków (w razie potrzeby); ta uprzejmość PHP pozwala zaoszczędzić 2 bajty.

Aby pominąć powiadomienie, program musi być uruchamiany przy użyciu error_reporting=0dyrektywy wykonawczej:

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

Dla testów

Poprzez zastąpienie wywołanie date(y)z $argv[1](pierwszy wiersz poleceń argument), długość programu wzrasta z 1 bajt, ale może dostać roku z linii poleceń.

Oczekiwanym argumentem jest rok minus 2000; działa również w przypadku wartości ujemnych (lata przed 2000 r.) lub wartości większych niż 40 (po roku 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 bajtów

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

TryAPL

Tak, to 29 bajtów .