Dans xkcd 1047 , Randall Munroe cite des approximations "légèrement fausses" de quantités et de nombres assortis avec une précision et une complexité variables, telles que le nombre de litres dans un gallon est très proche de 3 + ^π ⁄ ₄ . Au milieu de la bande dessinée, il donne un entracte: un moyen d’estimer la population mondiale (et américaine) pour une année donnée.

(Recadré de xkcd: approximations de Randall Munroe)

Votre tâche consiste à écrire un programme qui implémente ces formules pour se rapprocher des populations mondiales et américaines actuelles, reproduit comme suit.

Population mondiale

1. Prenez les deux derniers chiffres de l'année en cours.
2. Soustrayez le nombre d'années bissextiles (y compris l'année en cours) depuis l' ouragan Katrina (2005). À ces fins, toute année divisible par 4 est considérée comme une année bissextile.
3. Ajoutez une virgule décimale entre les deux nombres (identique à la division par 10).
4. Ajoutez 6. Cela donne le résultat en milliards de personnes.

Population américaine

1. Prenez les deux derniers chiffres de l'année en cours.
2. Soustrayez 10.
3. Multiplier par 3.
4. Ajoutez 10.
5. Ajoutez 3 au début (pour ce défi, certains nombres seront négatifs, ajoutez donc 300 à la place). D'une manière ou d'une autre, je n'ai pas remarqué que le simple fait de concaténer ne fonctionnerait pas car le programme avec lequel j'avais l'habitude de générer les résultats en ajoutait 300.
6. Cela donne le résultat en millions de personnes.

Détails

Cette formule "devrait rester d'actualité pendant une décennie ou deux", mais vous devez être en mesure de gérer théoriquement toute année 2000-2039 incluse. Dans certains cas, les années bissextiles depuis Katrina auront une valeur négative ou nulle.

Vous êtes libre de simplifier la formule de quelque manière que ce soit, à condition que toutes les sorties correspondent à celles ci-dessous.

Pour l'année, utilisez l'année en fonction de l'horloge de l'ordinateur. Cela doit fonctionner l'année prochaine et toute autre année du siècle, vous ne pouvez donc pas simplement coder 2015 en dur. Pour plus de commodité, vous pouvez inclure un moyen de spécifier l'année en tant que variable ou en tant qu'entrée pour tester d'autres années.

Le résultat devrait être la population mondiale approximative (en milliards de personnes), suivie d'un délimiteur (par exemple, l'espace ou une virgule), suivie de la population américaine (en millions de personnes). Vous pouvez également écrire une fonction qui renvoie ou imprime une chaîne ou un tableau de nombres ou de chaînes.

C'est le code de golf, donc le code le plus court en octets gagne. Tiebreaker est le premier post.

Cas de test

Ceci est une liste de toutes les années possibles, suivie des deux sorties.

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 octets

-1 octet par Dennis

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

Ceux-ci ont le même nombre d'octets mais sont uniquement en ASCII:

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

Je ne connais pas Pyth, donc probablement encore golfable. En utilisant le même algorithme:

TI-BASIC, 23 octets

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

getDaterenvoie une liste de trois flottants {YYYY,MM,DD}dans un ordre quelconque en fonction du format de date (les TI-84 n'ont pas de type de données true int); le max(sera l'année. Multiplier et soustraire à l'intérieur de l' max(enregistre un proche-paren.

Javascript (ES6), 55 54 48 octets

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

Fonctionne dans Firefox 33; prend en charge théoriquement toutes les années de 2000 à 2099. Si les programmes qui affichent le résultat sur la console ne sont pas autorisés, utilisez cette fonction à 51 octets:

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

Programme complet, 55 octets:

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

Obtenir l’année coûtait assez cher, mais après avoir utilisé l’option obsolète getYear()au lieu de getFullYear(), tous les chiffres de l’équation sont devenus plus petits, ce qui a permis d’économiser beaucoup d’octets. EDIT: Merci à un tour eeevil, j'ai sauté newet getYear()tout à fait. >: D

Suggestions bienvenues!

Pyth, 30 octets

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

Mon premier programme Pyth!

Merci @Jakube pour quelques conseils (je n'aurais jamais pensé à ceux-là!)

Python 2, 80 octets

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

Maintenant les tours!

CJam, 28 octets

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

Essayez-le en ligne

Pour essayer des années autres que celle en cours, remplacez la et0=valeur initiale par la valeur littérale de l'année.

Python 3, 134 octets

Fonctionne bien mais semble un peu long

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 octets

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

L'arrondi mange des octets (plus maintenant). J'ai maintenant modifié les deux formules. Quelques exemples de sorties:

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

Ils semblent tous être précis.

Un conseil: L'ordre d'exécution enregistre les octets entre parenthèses. Par exemple: (a-4)/4 = a/4-1:-).

PowerShell, 53 à 45 octets

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

Utilise une astuce d’arrondi similaire à celle de la réponse Python 2 de muddyfish pour simplifier le calcul de la population mondiale, étant donné que PowerShell est implicitement utilisé Round()lorsque vous passez d’un élément [double]à un [int]plutôt que de le tronquer.

Pour la sortie, nous supposons que "suivi d'un certain délimiteur (par exemple, espace ou virgule)" peut également signifier "nouvelle ligne", nous exécutons donc un résultat, puis le second. PowerShell écrit implicitement les résultats. Il n'est donc pas nécessaire d'appeler explicitement les commandes d'impression.

Mathematica, 50 octets

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

Notez que cela dépend du fait que Wolfram Engine avec la version 10+ (publiée en 2014) dépend de DateObjects.

R, 64 octets

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

Port direct du code Mathematica, je pense avoir une solution plus courte mais dépendante des packages alors que cela fonctionne avec la base R.

Java, 180 177 166 152 143 octets

Merci Thomas d'avoir aidé 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);}}

Version non-golfée:

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

Nécessite Java 8.

JavaScript (ES6) 52

Une fonction renvoyant la sortie sous forme de tableau.

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

Juste à des fins de test, la fonction accepte une entrée égale à l'année en cours - 1900 (par exemple, 105 pour 2015)

C'est dans la ligne de la réponse d'ETHproductions (le calcul est le calcul), mais éviter le truc du mal est plus portable dans différents endroits. Et en tant que fonction, il est plus court d'un octet.

Extrait de test:

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 octets

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

Malheureusement, Time.now.yearça coûte vraiment quelques personnages.

Desmos , 140 octets

Je compte une nouvelle ligne comme un signal pour une nouvelle équation. Les dossiers sur le lien sont uniquement pour l'organisation.

Golfé , 140 octets

Cliquez add sliderlorsque vous y êtes invité.

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 octets

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

Une traduction de ma réponse Java.

PHP, 45 octets

Le code:

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

Parce que y(l'argument de date()) est une constante non définie, PHP déclenche une notification (qui peut être mise en sourdine) et la convertit en chaîne (selon nos besoins). Cette courtoisie PHP permet de sauver 2 octets.

Pour supprimer la notification, le programme doit être exécuté à l'aide de la error_reporting=0directive d'exécution, comme ceci:

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

Pour tester

En remplaçant l'appel à date(y)avec $argv[1](le premier argument de la ligne de commande), la longueur du programme augmente d'un octet, mais il peut obtenir l'année à partir de la ligne de commande.

L'argument attendu est l'année moins 2000; cela fonctionne également pour les valeurs négatives (années avant 2000) ou supérieures à 40 (après 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 octets

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

TryAPL

Oui, c'est 29 octets .