Verwenden Sie die Formel von xkcd, um die Weltbevölkerung zu approximieren

42

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.

Welt- und US-Bevölkerungsformel, unten beschrieben
(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
NinjaBearMonkey
quelle
1
Müssen Sie die Zahlen runden?
Blue
5
@muddyfish Ich bin mir nicht sicher, ob ich das verstehe. Wenn Sie den Anweisungen im Comic genau folgen, gibt es technisch gesehen keine Aufteilung, aber die Weltbevölkerung sollte auf das nächste Zehntel gerundet werden.
NinjaBearMonkey
2
Ich bin ein wenig verwirrt von der amerikanischen Bevölkerung. Wenn Sie eine verketten 3, sollten Sie nicht 2040eine Population von geben 3100? 40 - 10 = 30, 30 * 3 = 90, 90 + 10 = 100Würde das geben"3" + "100" = 3100
cole
2
@Cole Guter Punkt, ich mache es so, dass Sie nur die Jahre bis 2039 unterstützen müssen. Was die Hardcodierung des Jahres angeht, möchte ich keine Hardcodierung zulassen, da dies selbst bei Sprachen, die Datumsangaben unterstützen, fast immer kürzer ist.
NinjaBearMonkey
8
@NinjaBearMonkey Ich schlage vor, dass Sie die Beschreibung von "3 hinzufügen, Verkettung denken" in "300 hinzufügen" ändern, um alle Randfälle abzudecken, die auftreten, wenn das vorherige Ergebnis keine schöne zweistellige positive Zahl ist. (Zum Beispiel gibt Jahr 2000 280als Ergebnis von -20+300=280und nicht 3 . -20= "3-20")
PhiNotPi

Antworten:

22

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.

Lirtosiast
quelle
1
Ich denke, dies ist das erste Mal, dass ich hier eine Antwort von TI-BASIC gesehen habe ....
The_Basset_Hound
7
@The_Basset_Hound TI-BASIC ist hier mit 140 Antworten die 28. häufigste Sprache. Es hat auch eine große und ein paar kleinere Fragen gewonnen .
Lirtosiast
16

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!

ETHproductions
quelle
10

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!)

Blau
quelle
3
Ich habe die Frage nicht gelesen, aber hier sind einige Optimierungen, die ich sofort gesehen habe. Schreiben Sie alles in eine Zeile. Wählen Sie eine andere Reihenfolge von Zahlen und Variablen ( +*3Z280anstatt +*Z3 280zum Beispiel). C\dstatt 100(spart Leerzeichen). Verwenden Sie Janstelle von Z(speichert die =). Inline die Aufgabe. Link
Jakube
10

Python 2, 80 Bytes

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

Jetzt runden!

Blau
quelle
Sie müssen runden, wie OP vor einer Minute geklärt hat. ;-)
Mittwoch,
3
Das Jahr% 100 entspricht dem Jahr% 40.
Lirtosiast
6

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.

Reto Koradi
quelle
2
Da 2000 durch 40 teilbar ist und Sie nur 2000-2039 benötigen, können Sie 40%ein Byte speichern.
Andrea Biondo,
5

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)
Beta-Zerfall
quelle
Zur Verkürzung dazu verwenden from time import*, y=strftime('%Y'). Oder kopieren Sie die andere Python-Antwort: P
FlipTack
5

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:-).

mınxomaτ
quelle
4

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.

AdmBorkBork
quelle
3

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.

Martin John Hadley
quelle
1
(1/10)-> .1?
Lirtosiast
1
Ich denke du brauchst auch keine Klammern um die .1.
Lirtosiast
3

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.

ein Spaghetto
quelle
import java.time.*? 3.0-> 3.? Sie müssen auch nicht das Jahr mit der Ausgabe drucken.
Lirtosiast
Oh, ich wusste nicht, dass Sie das Jahr nicht ausdrucken müssen ...: P
ein Spaghetto
3

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 }

edc65
quelle
2

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.

PotatoOmeletteSandwich
quelle
2

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|
Conor O'Brien
quelle
2

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.

ein Spaghetto
quelle
1

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
Axiac
quelle
1

APL, 25 23 29 Bytes

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

TryAPL

Ja, es sind 29 Bytes .

Shujal
quelle
Speichern Sie zwei Zeichen: (÷ ÷40, + ∘33) ¯5753 + 3 × ⊃⎕TS
Adám