Entrada:
Un entero positivo n que es 1 <= n <= 25000
.
Salida:
- En esta secuencia comenzamos con el número decimal 1 / n .
- Luego tomamos la suma de los dígitos hasta el n -ésimo dígitos después de la coma (indexada 1); seguido de la suma de dígitos hasta el ( n -1) 'th, luego ( n -2)' th, etc. Continúe hasta que n sea 1.
- La salida es la suma de todos estos combinados.
Por ejemplo:
n = 7
1/7 = 0.1428571428...
7th digit-sum = 1+4+2+8+5+7+1 = 28
6th digit-sum = 1+4+2+8+5+7 = 27
5th digit-sum = 1+4+2+8+5 = 20
4th digit-sum = 1+4+2+8 = 15
3rd digit-sum = 1+4+2 = 7
2nd digit-sum = 1+4 = 5
1st digit = 1
Output = 28+27+20+15+7+5+1 = 103
Reglas de desafío:
- Si el decimal de 1 / n no tiene n dígitos después de la coma, los que faltan se contarán como 0 (es decir
1/2 = 0.50 => (5+0) + (5) = 10
). - Toma los dígitos sin redondear (es decir, los dígitos de
1/6
son166666
y no166667
)
Reglas generales:
- Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
- Las lagunas predeterminadas están prohibidas.
- Si es posible, agregue un enlace con una prueba para su código.
- Además, agregue una explicación si es necesario.
Primero 1 - 50 en la secuencia:
0, 10, 18, 23, 10, 96, 103, 52, 45, 10, 270, 253, 402, 403, 630, 183, 660, 765, 819, 95, 975, 1034, 1221, 1500, 96, 1479, 1197, 1658, 1953, 1305, 1674, 321, 816, 2490, 2704, 4235, 2022, 3242, 2295, 268, 2944, 3787, 3874, 4097, 1980, 4380, 4968, 3424, 4854, 98
Últimos 24990 - 25000 en la secuencia:
1405098782, 1417995426, 1364392256, 1404501980, 1408005544, 1377273489, 1395684561, 1405849947, 1406216741, 1142066735, 99984
code-golf
sequence
number-theory
Kevin Cruijssen
fuente
fuente
Respuestas:
Jalea , 9 bytes
Bastante lento, pero corto. Pruébalo en línea! o verificar los primeros 50 casos de prueba .
Cómo funciona
fuente
Mathematica, 42 bytes
o
o
Explicación
Tome el ejemplo de la especificación de desafío. Queremos calcular:
Reorganizando, esto es:
donde
.
es el producto escalar de dos vectores.Eso es prácticamente todo lo que hace la solución.
Esto nos da los primeros
N
dígitos decimales de1/N
(#&@@
extrae el primer elemento delRealDigits
resultado porque eso también devuelve el desplazamiento del primer dígito que no nos importa).Luego obtenemos la lista de
N
abajo a1
usar(#-Range@#+1)
oRange[#,1,-1]
, los cuales son más cortos queReverse@Range@#
, y tomamos el producto escalar.En cambio, la solución alternativa utiliza
Accumulate
para calcular una lista de todas las sumas de prefijos y luego suma esas sumas de prefijos conTr
.Dado que esto es realmente rápido incluso para entradas grandes, aquí hay un diagrama de dispersión de la secuencia
N = 100,000
( aunque hacerlas todas y trazarlas tomó un tiempo):Haga clic para una versión más grande.
La línea azul es el límite superior ingenuo de
9 N (N+1) / 2
(si todos los dígitos decimales lo fueran9
) y la línea naranja es exactamente la mitad de eso. Como era de esperar, esto está justo dentro de la rama principal de la trama, ya que, estadísticamente, esperaríamos que el dígito promedio sea 4.5.La delgada línea de puntos de trazado que puede ver debajo de la rama principal son fracciones que terminan en
...3333...
, ya que todas se encuentran muy cerca3 N (N+1) / 2
.fuente
05AB1E ,
1211 bytesPruébalo en línea! o un conjunto de pruebas para los primeros 50 números.
Explicación
Una versión más eficiente para probar grandes números en TIO
La diferencia con la versión más corta es que aquí sumamos el producto de los dígitos y la inversión de su índice basado en 1 en lugar de sumar dígitos en prefijos.
Pruébalo en línea!
fuente
Java 8,
181169166153142 bytesExplicación:
Pruébalo aquí
fuente
PHP,
6665 bytesAdaptado de esta respuesta (también por mí): División de números no tan pequeños y edición sugerida de Jörg Hülsermann. Usar como:
edit: corrigió un error por +1 bytes y dobló la asignación de $ a en $ argv [1] por -2 bytes por un neto de 1 byte menos.
fuente
Scala, 84 bytes
Sin golf:
Explicación:
Podría guardar algunos bytes explotando la forma en que el compilador se tokeniza: llamando al argumento
&
, puede escribir en1 to&map
lugar de1 to n map
. La misma regla se aplica adef?
.fuente
Jalea , 11 bytes
TryItOnline
First 50
Demasiado lento para los grandes casos de prueba.
¿Cómo?
fuente
R⁵*
equivalente de izquierda a derecha, pero luego vi la bonita línea recta :)PHP, 76 bytes
(Editar -1 byte - Gracias usuario59178 - su solución es aún mejor)
fuente
$c=blah
en la primera parte de lafor(;;)
MATL, 19 bytes
Pruébalo en línea!
Explicación
fuente
Groovy, 87 bytes
Esto fue menos doloroso de lo que esperaba, y se basa en mi respuesta aquí :
Explicación
1.0g
- Utilice la notación BigDecimal para el uno..divide(n, n, 1)+""
- Divide entre n con n precisión (función BigDecimal solamente) y convierte a str.(...)[2..x+1].getChars()
- Obtenga la subcadena de la iteración actual como una matriz de caracteres..sum()-48*(x)
- Suma los valores ASCII de los caracteres y reduce en 48 para cada elemento. Esto convierte el valor de un dígito ASCII en un número entero esencialmente guardando bytes*.toInteger()
.(1..n).collect{...}.sum()
- Iterar sobre cada uno de los dígitos en la división, haciendo esta función, obtenerlos en una sola matriz y sumar.Se guardaron 2 bytes y se sacrificó la eficiencia ...
Esta es una versión más eficiente que no recalcula el BigDecimal en cada iteración.
fuente
J, 27 bytes
Uso
La entrada es un entero extendido.
El rendimiento es bueno y solo requiere unos 3 segundos para calcular los casos de prueba grandes.
Explicación
fuente
Jalea , 10 bytes
No es el enfoque más corto , pero sí bastante eficiente. Pruébalo en línea! o verificar todos los casos de prueba .
Cómo funciona
fuente
Python 2, 90 bytes
No es bonito, pero se hace mediante la división flotante y luego la conversión en una cadena y luego la selección iterativa del índice de cadena para obtener el triángulo de números, luego realizar la comprensión de la lista y convertir cada carácter en un int y finalmente sumarlos todos.
fuente
JavaScript (ES6), 47 bytes
Cómo funciona
Esta respuesta demuestra una técnica para calcular c dígitos decimales de a / b :
Esto será un excelente punto de partida para este desafío. Primero podemos cambiarlo ligeramente para que calcule b dígitos decimales de 1 / b , reordenando los parámetros y configurando los valores predeterminados:
A continuación, podemos cambiar esto para que calcule la suma de los primeros dígitos decimales b , en lugar de concatenarlos (esto elimina el
d
parámetro):Estamos casi en una solución; ahora solo necesitamos hacer que multiplique cada dígito por c + 1 :
Hmm, esto parece un poco largo. ¿Qué pasa si incrementamos c en 1 para empezar?
Eso ahorra un byte. Y aquí hay una manera de guardar uno más:
Y ahora tenemos nuestra respuesta.
f(7)
es 103,f(11)
es 270,f(1)
es ... 2? Oh, olvidamos dar cuenta del caso en el que a / b es 1 en la primera iteración (es decir, b es 1). Hagamos algo al respecto:1 mod b es siempre 1 , a menos que b sea 1 , en cuyo caso será 0 . Nuestro programa ahora es correcto para todas las entradas, a 47 bytes .
fuente
Python 2, 49 bytes
Pruébalo en Ideone .
fuente
C, 53 bytes
Debajo del principal para hacer alguna prueba ...
fuente
f(n,i,x,s){while(i)x=10*(x%n),s+=i--*(x/n);return s;}
tiene solo 53 bytes de longitud.