In xkcd 1047 listet Randall Munroe "leicht falsche" Näherungen verschiedener Mengen und Zahlen mit unterschiedlicher Genauigkeit und Komplexität auf, z. B. dass die Anzahl der Liter in einer Gallone sehr nahe bei 3 + ^π ⁄ _{4 liegt} . In der Mitte des Comics gibt er eine Pause: eine Möglichkeit, die Weltbevölkerung (und die Bevölkerung der Vereinigten Staaten) basierend auf einem bestimmten Jahr zu schätzen.

(Aus xkcd beschnitten : Annäherungen von Randall Munroe)

Ihre Aufgabe ist es, ein Programm zu schreiben, das diese Formeln implementiert, um die aktuelle Welt und die US-Bevölkerung anzunähern.

Weltbevölkerung

1. Nimm die letzten beiden Ziffern des laufenden Jahres.
2. Subtrahieren Sie die Anzahl der Schaltjahre (einschließlich des aktuellen Jahres) seit dem Hurrikan Katrina (2005). Für diese Zwecke wird jedes durch 4 teilbare Jahr als Schaltjahr betrachtet.
3. Fügen Sie einen Dezimalpunkt zwischen den beiden Zahlen ein (das gleiche wie beim Teilen durch 10).
4. Addieren Sie 6. Dies ergibt Milliarden von Menschen.

US-Bevölkerung

1. Nimm die letzten beiden Ziffern des laufenden Jahres.
2. Subtrahiere 10.
3. Mit 3 multiplizieren.
4. Addiere 10.
5. Fügen Sie am Anfang 3 hinzu (für diese Herausforderung sind einige Zahlen negativ, also fügen Sie stattdessen 300 hinzu). Irgendwie habe ich nicht bemerkt, dass das Verketten nicht funktioniert, weil das Programm, mit dem ich die Ergebnisse generiert habe, gerade 300 hinzugefügt hat.
6. Dies führt bei Millionen von Menschen zum Ergebnis.

Einzelheiten

Diese Formel "sollte ein oder zwei Jahrzehnte lang aktuell bleiben", aber Sie müssen theoretisch in der Lage sein, jedes Jahr von 2000 bis einschließlich 2039 zu verarbeiten. In einigen Fällen haben die Schaltjahre seit Katrina einen negativen Wert oder Null.

Es steht Ihnen frei, die Formel in irgendeiner Weise zu vereinfachen, solange alle Ausgaben mit den folgenden übereinstimmen.

Verwenden Sie für das Jahr das Jahr gemäß der Uhr des Computers. Es muss nächstes Jahr und jedes andere Jahr in diesem Jahrhundert funktionieren, sodass Sie 2015 nicht einfach fest codieren können. Aus Gründen der Benutzerfreundlichkeit möchten Sie möglicherweise eine Möglichkeit einschließen, das Jahr als Variable oder Eingabe anzugeben, um andere Jahre zu testen.

Die Ausgabe sollte die ungefähre Weltbevölkerung (in Milliarden von Menschen) sein, gefolgt von einem Begrenzungszeichen (z. B. Leerzeichen oder Komma), gefolgt von der US-Bevölkerung (in Millionen von Menschen). Sie können auch eine Funktion schreiben, die eine Zeichenfolge oder ein Array von Zahlen oder Zeichenfolgen zurückgibt oder druckt.

Dies ist Codegolf, also gewinnt der kürzeste Code in Bytes. Tiebreaker ist der früheste Beitrag.

Testfälle

Dies ist eine Liste aller möglichen Jahre, gefolgt von den beiden Ausgaben.

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 bis 20 Bytes

-1 Byte von Dennis

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

Diese haben die gleiche Byteanzahl, sind jedoch nur ASCII-fähig:

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

Ich kenne Pyth nicht, also wahrscheinlich noch golfen. Mit dem gleichen Algorithmus:

TI-BASIC, 23 Bytes

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

getDategibt eine Liste mit drei Gleitkommazahlen {YYYY,MM,DD}in einer bestimmten Reihenfolge zurück, abhängig von der Einstellung des Datumsformats (TI-84s haben keinen echten int-Datentyp); Das max(wird das Jahr sein. Das Multiplizieren und Subtrahieren innerhalb des max(spart eine enge Paren.

Javascript (ES6), 55 54 48 Bytes

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

Funktioniert in Firefox 33; Unterstützt theoretisch alle Jahre von 2000 bis 2099. Wenn Programme, die das Ergebnis auf der Konsole speichern, nicht zulässig sind, verwenden Sie diese 51-Byte-Funktion:

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

Volles Programm, 55 Bytes:

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

Das Jahr zu bekommen war ziemlich teuer, aber nach der Verwendung der veralteten getYear()anstelle von getFullYear()wurden alle Zahlen in der Gleichung kleiner, was eine Menge Bytes sparte. EDIT: Dank eines bösen Tricks habe ich übersprungen newund getYear()insgesamt. >: D

Vorschläge willkommen!

Pyth, 30 Bytes

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

Mein erstes Pyth-Programm!

Danke @Jakube für ein paar Hinweise (daran hätte ich nie gedacht!)

Python 2, 80 Bytes

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

Jetzt runden!

CJam, 28 Bytes

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

Probieren Sie es online aus

Wenn Sie andere als die aktuellen Jahre ausprobieren möchten, ersetzen Sie den et0=Wert am Anfang durch den wörtlichen Wert des Jahres.

Python 3, 134 Bytes

Funktioniert gut, scheint aber etwas lang zu sein

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 Bytes

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

Die Rundung frisst Bytes (nicht mehr). Ich habe jetzt beide Formeln optimiert. Einige Beispielausgaben:

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

Sie scheinen alle genau zu sein.

Ein Tipp: Die Ausführungsreihenfolge spart Bytes in Klammern. Zum Beispiel: (a-4)/4 = a/4-1:-).

PowerShell, 53 - 45 Byte

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

Verwendet einen ähnlichen Rundungstrick wie die Python 2-Antwort von Muddyfish , um die Berechnung der Weltbevölkerung zu vereinfachen, da PowerShell implizit verwendet wird, Round()wenn Sie von A [double]nach A umwandeln [int], anstatt abzuschneiden.

Für die Ausgabe gehen wir davon aus, dass "gefolgt von einem Trennzeichen (z. B. Leerzeichen oder Komma)" auch "Zeilenumbruch" bedeuten kann. Daher führen wir ein Ergebnis und dann das zweite aus. PowerShell schreibt implizit Ergebnisse aus, sodass wir keine Druckbefehle explizit aufrufen müssen.

Mathematica, 50 Bytes

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

Beachten Sie, dass dies abhängig von einer Wolfram Engine mit der Versionsnummer 10+ (veröffentlicht 2014) ist DateObjects.

R, 64 Bytes

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

Direkte Portierung von Mathematica-Code, denke ich hatte eine kürzere Lösung, aber abhängig von Paketen, während dies mit Basis R funktioniert.

Java, 180 177 166 152 143 Bytes

Danke Thomas, dass du einem Noob geholfen hast :)

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

Ungolfed-Version:

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

Benötigt Java 8.

JavaScript (ES6) 52

Eine Funktion, die die Ausgabe als Array zurückgibt.

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

Nur zu Testzwecken akzeptiert die Funktion eine Eingabe, die dem aktuellen Jahr - 1900 entspricht (z. B. 105 für 2015).

Das entspricht der Antwort von ETHproductions (die Mathematik ist die Mathematik), aber abgesehen von dem bösen Trick ist es an verschiedenen Orten portabler. Und als Funktion ist es 1 Byte kürzer.

Testschnipsel:

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 Bytes

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

Kostet leider Time.now.yearwirklich einige Charaktere.

Desmos , 140 Bytes

Ich zähle eine neue Zeile, um ein Signal für eine neue Gleichung zu sein. Ordner auf dem Link dienen nur der Organisation.

Golf , 140 Bytes

Klicken Sie auf, add sliderwenn Sie dazu aufgefordert werden.

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

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

Eine Übersetzung meiner Java-Antwort.

PHP, 45 Bytes

Der Code:

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

Da y(das Argument von date()) eine undefinierte Konstante ist, löst PHP einen Hinweis aus (der stummgeschaltet werden kann) und konvertiert ihn in einen String (wie wir ihn benötigen). Diese PHP-Höflichkeit erlaubt das Speichern von 2 Bytes.

Um den Hinweis zu unterdrücken, muss das Programm mit der error_reporting=0Runtime-Direktive wie folgt ausgeführt werden:

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

Zum Prüfen

Durch Ersetzen des Aufrufs von date(y)durch $argv[1](das erste Befehlszeilenargument) erhöht sich die Programmlänge um 1 Byte, es kann jedoch das Jahr von der Befehlszeile abgerufen werden.

Das erwartete Argument ist das Jahr minus 2000; Es funktioniert auch für negative Werte (Jahre vor 2000) oder Werte über 40 (nach 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 Bytes

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

TryAPL

Ja, es sind 29 Bytes .