Use la fórmula de xkcd para aproximar la población mundial

42

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 + π4 . 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.

Fórmula de población mundial y estadounidense, descrita a continuación
(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
NinjaOsoMono
fuente
1
¿Tienes que redondear los números?
Azul
55
@muddyfish No estoy seguro de entender. Si sigue exactamente las instrucciones en el cómic, técnicamente no hay división, pero la población mundial debería redondearse a la décima más cercana.
NinjaBearMonkey
2
Estoy un poco confundido por la población de los Estados Unidos. Si está concatenando a 3, ¿no debería 2040dar una población de 3100? 40 - 10 = 30, 30 * 3 = 90, 90 + 10 = 100, Lo que daría"3" + "100" = 3100
cole
2
@Cole Buen punto, lo haré para que solo tenga que soportar años hasta 2039. Acerca de la codificación dura del año, no quiero permitir la codificación rígida porque eso casi siempre será más corto, incluso en idiomas que admitan fechas.
NinjaBearMonkey
8
@NinjaBearMonkey Le sugiero que cambie la descripción de "agregar 3, concatenación de pensamiento" a un literal "agregar 300" para cubrir todos los casos límite que ocurren cuando el resultado anterior no es un buen número positivo de 2 dígitos. (Por ejemplo, el año 2000 da 280como resultado -20+300=280y no 3 . -20= "3-20")
PhiNotPi

Respuestas:

22

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.

lirtosiast
fuente
1
Creo que esta es la primera vez que veo una respuesta de TI-BASIC aquí ...
The_Basset_Hound
77
@The_Basset_Hound TI-BASIC es el 28º lenguaje más común aquí con 140 respuestas; También ha ganado uno principales y un par de pequeñas preguntas .
lirtosiast
16

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!

ETHproducciones
fuente
10

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

Azul
fuente
3
No he leído la pregunta, pero aquí hay algunas optimizaciones que vi de inmediato. Escribe todo en una línea. Elija un orden diferente de números y variables (en +*3Z280lugar de, +*Z3 280por ejemplo). C\den lugar de 100(ahorra espacios). Usar en Jlugar de Z(guarda el =). En línea la tarea. Enlace
Jakube
10

Python 2, 80 bytes

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

Ahora rondas!

Azul
fuente
Tienes que redondear, como OP aclaró hace un minuto. ;-)
mınxomaτ
3
año% 100 es lo mismo que año% 40.
lirtosiast
6

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.

Reto Koradi
fuente
2
Como 2000 es divisible por 40, y solo necesita 2000-2039, puede usar 40%para guardar un byte.
Andrea Biondo
5

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)
Decaimiento Beta
fuente
Para acortar esto, utilizar from time import*, y=strftime('%Y'). O copie la otra respuesta de Python: P
FlipTack
5

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

mınxomaτ
fuente
4

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.

AdmBorkBork
fuente
3

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.

Martin John Hadley
fuente
1
(1/10)-> .1?
lirtosiast
1
Creo que tampoco necesitas paréntesis alrededor del .1.
lirtosiast
3

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.

un espagueti
fuente
import java.time.*? 3.0-> 3.? Tampoco necesita imprimir el año con la salida.
lirtosiast
Oh, no me di cuenta de que no necesitabas el año impreso ...: P
un espagueti
3

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 }

edc65
fuente
2

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.

PatataOmeletteSandwich
fuente
2

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

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.

un espagueti
fuente
1

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
axiac
fuente
1

APL 25 23 29 bytes

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

TryAPL

Sí, son 29 bytes .

Shujal
fuente
Guarde dos caracteres: (÷ ∘40, + ∘33) ¯5753 + 3 × ⊃⎕TS
Adám