En xkcd 1047 , Randall Munroe enumera aproximaciones "ligeramente incorrectas" de cantidades y números variados con precisión y complejidad variables, como que el número de litros en un galón es muy cercano a 3 + ^π ⁄ ₄ . En el medio del cómic, da un intermedio: una forma de estimar la población mundial (y de los Estados Unidos) en función de un año determinado.

(Recortado de xkcd: Aproximaciones de Randall Munroe)

Su tarea es escribir un programa que implemente estas fórmulas para aproximarse al mundo actual y a las poblaciones de los Estados Unidos, replicado de la siguiente manera.

Población mundial

1. Tome los dos últimos dígitos del año actual.
2. Reste el número de años bisiestos (incluido el año actual) desde el huracán Katrina (2005). Para estos fines, cualquier año divisible por 4 se considera un año bisiesto.
3. Agregue un punto decimal entre los dos números (lo mismo que dividir por 10).
4. Agregue 6. Esto da el resultado en miles de millones de personas.

Población estadounidense

1. Tome los dos últimos dígitos del año actual.
2. Restar 10.
3. Multiplica por 3.
4. Añadir 10.
5. Agregue 3 al principio (para este desafío, algunos números serán negativos, así que agregue 300 en su lugar). De alguna manera, no me di cuenta de que la concatenación no funcionaría porque el programa que usé para generar los resultados acaba de agregar 300.
6. Esto da el resultado en millones de personas.

Detalles

Esta fórmula "debería mantenerse actualizada durante una década o dos", pero debe ser capaz de manejar teóricamente cualquier año 2000-2039 inclusive. En algunos casos, los años bisiestos desde Katrina tendrán un valor negativo o cero.

Usted es libre de simplificar la fórmula de cualquier manera, siempre que todas las salidas coincidan con las siguientes.

Para el año, use el año de acuerdo con el reloj de la computadora. Debe funcionar el próximo año y cualquier otro año de este siglo, por lo que no puede simplemente codificar el 2015. Para su comodidad, es posible que desee incluir una forma de especificar el año como una variable o entrada para probar otros años.

El resultado debería ser la población mundial aproximada (en miles de millones de personas), seguida de algún delimitador (por ejemplo, espacio o coma), seguida de la población de los Estados Unidos (en millones de personas). También puede escribir una función que devuelva o imprima una cadena o una matriz de números o cadenas.

Este es el código de golf, por lo que gana el código más corto en bytes. Tiebreaker es la primera publicación.

Casos de prueba

Esta es una lista de todos los años posibles, seguida de los dos resultados.

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 bytes

-1 byte por Dennis

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

Estos tienen el mismo recuento de bytes pero son solo ASCII:

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

No conozco a Pyth, así que probablemente aún sea golfable. Usando el mismo algoritmo:

TI-BASIC, 23 bytes

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

getDatedevuelve una lista de tres flotantes {YYYY,MM,DD}en algún orden dependiendo de la configuración del formato de fecha (las TI-84 no tienen un tipo de datos int verdadero); El max(será el año. Multiplicar y restar dentro de las max(partidas guarda un paren cercano.

Javascript (ES6), 55 54 48 bytes

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

Funciona en Firefox 33; teóricamente es compatible con todos los años desde 2000 hasta 2099. Si los programas que vuelcan el resultado en la consola no están permitidos, use esta función de 51 bytes:

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

Programa completo, 55 bytes:

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

Obtener el año fue bastante costoso, pero después de usar el en desuso en getYear()lugar de getFullYear(), todos los números en la ecuación se hicieron más pequeños, ahorrando muchos bytes. EDITAR: Gracias a un truco malvado, me salté newy por getYear()completo. >: D

Sugerencias bienvenidas!

Pyth, 30 bytes

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

Mi primer programa Pyth!

Gracias @Jakube por algunas sugerencias (¡nunca habría pensado en eso!)

Python 2, 80 bytes

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

Ahora rondas!

CJam, 28 bytes

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

Pruébalo en línea

Para probar años que no sean el actual, reemplace et0=al principio con el valor literal del año.

Python 3, 134 bytes

Funciona bien pero parece un poco largo

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)

El redondeo come bytes (ya no). Ahora he ajustado ambas fórmulas. Algunas salidas de muestra:

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

Todos parecen ser precisos.

Un consejo: el orden de ejecución ahorra bytes entre paréntesis. Por ejemplo: (a-4)/4 = a/4-1:-).

PowerShell, 53 45 bytes

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

Utiliza un truco de redondeo similar al de la respuesta Python 2 de muddyfish para simplificar el cálculo de la población mundial, ya que PowerShell implícitamente Round()s cuando se lanza de a [double]a an [int], en lugar de truncar.

Para la salida, suponemos que "seguido de algún delimitador (por ejemplo, espacio o coma)" también puede significar "nueva línea", por lo que ejecutamos un resultado y luego el segundo. PowerShell escribe implícitamente los resultados, por lo que no necesitamos llamar explícitamente ningún comando de impresión.

Mathematica, 50 bytes

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

Tenga en cuenta que esto depende de tener un Wolfram Engine con la versión número 10+ (lanzado en 2014) debido a la dependencia de DateObjects.

R, 64 bytes

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

Puerto directo del código de Mathematica, creo que tenía una solución más corta pero dependiente de los paquetes, mientras que esto funciona con la base R.

Java, 180 177 166 152 143 bytes

Gracias Thomas por ayudar a un novato :)

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ón sin golf:

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

Requiere Java 8.

JavaScript (ES6) 52

Una función que devuelve la salida como una matriz.

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

Solo para fines de prueba, la función acepta una entrada igual al año actual - 1900 (por ejemplo, 105 para 2015)

Eso está en la línea de la respuesta de ETHproductions (la matemática es la matemática), pero evitando el malvado truco , es más portátil en diferentes lugares. Y como función es 1 byte más corto.

Fragmento de prueba:

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}"

Lamentablemente, Time.now.yearrealmente cuesta algunos personajes.

Desmos , 140 bytes

Estoy contando una nueva línea como señal para una nueva ecuación. Las carpetas en el enlace son solo para la organización.

Golfizado , 140 bytes

Haga clic add slidercuando se le solicite.

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|

Sin Golf , 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

Una traducción de mi respuesta Java.

PHP, 45 bytes

El código:

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

Debido a que y(el argumento de date()) es una constante indefinida, PHP activa un aviso (que puede silenciarse) y lo convierte en una cadena (según sea necesario); Esta cortesía de PHP permite guardar 2 bytes.

Para suprimir el aviso, el programa debe ejecutarse utilizando la error_reporting=0directiva de tiempo de ejecución, así:

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

Para las pruebas

Al reemplazar la llamada a date(y)con $argv[1](el primer argumento de la línea de comando), la longitud del programa aumenta con 1 byte pero puede obtener el año desde la línea de comando.

El argumento esperado es el año menos 2000; También funciona para valores negativos (años anteriores a 2000) o valores superiores a 40 (después del año 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

Sí, son 29 bytes .