son - ¿Cómo encuentro el siguiente múltiplo de 10 de cualquier número entero?

que son los divisores

Question

El número entero dinámico será cualquier número de 0 a 150.

es decir, el número devuelve 41, necesita devolver 50. Si el número es 10, necesita devolver 10. El número es 1, necesita devolver 10.

¿Estaba pensando que podría usar la función de techo si modifico el número entero como un decimal ...? luego usa la función de techo y vuelve a decimal?
Lo único que también debería saberse es si el número es 1, 2 o 3 dígitos (es decir, 7 contra 94 frente a 136).

¿Hay una mejor manera de lograr esto?

Gracias,

Answer 1

¿Qué pasa con ((n + 9) / 10) * 10 ?

Rendimientos 0 => 0, 1 => 10, 8 => 10, 29 => 30, 30 => 30, 31 => 40

Answer 2

¿Qué tal el uso de matemáticas enteras:

N=41
N+=9 // Add 9 first to ensure rounding.
N/=10 // Drops the ones place
N*=10 // Puts the ones place back with a zero

Answer 3

En pseudo código:

number = number / 10
number = ceil(number)
number = number * 10

En Python:

import math
def my_func(x):
return math.ceil(x / 10) * 10

Deberias hacer eso. Tenga en cuenta que el código anterior arrojará un número entero a un flotante / doble para la aritmética, y se puede cambiar de nuevo a un número entero para el retorno final. Aquí hay un ejemplo con encasillado explícito

En Python (con encasillado):

import math
def my_func(x):
return int(math.ceil(float(x) / 10) * 10)

Answer 4

Podrías hacer el número mod 10. Luego tomar ese resultado restarlo de diez. Luego agrega ese resultado al original.

if N%10 != 0 #added to account for multiples of ten
a=N%10
N+=10-a

Answer 5

Puede hacer esto realizando la división de enteros por 10 redondeando hacia arriba , y luego multiplicando el resultado por 10.

Para dividir A por B redondeando, agregue B - 1 a A y luego divídalo por B usando la división entera "ordinaria"

Q = (A + B - 1) / B

Por lo tanto, para su problema específico, la cosa juntos se verá de la siguiente manera

A = (A + 9) / 10 * 10

Esto "ajustará" A al siguiente mayor múltiplo de 10.

La necesidad de la división y la alineación surge tan a menudo que normalmente en mis programas tendría macros para dividir enteros [sin signo] con redondeo hacia arriba

#define UDIV_UP(a, b) (((a) + (b) - 1) / (b))

y para alinear un entero al siguiente límite

#define ALIGN_UP(a, b) (UDIV_UP(a, b) * (b))

que haría que lo anterior se vea como

A = ALIGN_UP(A, 10);

PD. No sé si necesita que esto se extienda a números negativos. Si lo hace, se debe tener cuidado de hacerlo correctamente, dependiendo de lo que necesite como resultado.

Answer 6

Tenga en cuenta que las respuestas basadas en los operadores div y mod ("/" y "%") no funcionarán para números negativos sin una prueba if, porque C y C ++ implementan esos operadores incorrectamente para números negativos. (-3 mod 5) es 2, pero C y C ++ calculan (-3% 5) como -3.

Puedes definir tus propias funciones div y mod. Por ejemplo,

int mod(int x, int y) {
// Assert y > 0
int ret = x % y;
if(ret < 0) {
ret += y;
}
return ret;
}

Answer 7

en C , one-liner :

int inline roundup10(int n) {
return ((n - 1) / 10 + 1) * 10;
}

Answer 8

tl; dr: ((n + 9) / 10) * 10 compila al mejor código de asm (más rápido) en más casos , y es fácil de leer y entender para las personas que saben lo que hace la división de enteros en C. Es bastante común idioma.

No he investigado cuál es la mejor opción para algo que necesita trabajar con n negativo, ya que es posible que desee redondear desde cero, en lugar de seguir hacia + Infinito, dependiendo de la aplicación.

Al observar las operaciones en C utilizadas por las diferentes sugerencias, la más ligera es la de Mark Dickinson (en comentarios):

(n+9) - ((n+9)%10)

Parece más eficiente que la división / multiplicación directa sugerida por un par de personas (incluyendo @bta): ((n + 9) / 10) * 10 , porque solo tiene un complemento en lugar de un multiplicador. ( n+9 es una subexpresión común que solo debe computarse una vez).

Resulta que ambos compilan código literalmente idéntico, usando el truco del compilador de convertir la división por una constante en una multiplicación y un cambio, consulte esta sección de Preguntas y Respuestas para ver cómo funciona . A diferencia de una instrucción de hardware div que cuesta lo mismo ya sea que use el cociente, el resto o ambos resultados, el método mul / shift toma pasos adicionales para obtener el resto. Entonces el compilador ve que puede obtener el mismo resultado de un cálculo más barato y termina compilando ambas funciones con el mismo código.

Esto es cierto en x86, ppc y ARM , y todas las demás arquitecturas que he visto en el explorador de compiladores Godbolt. En la primera versión de esta respuesta, vi un sdiv para el %10 en Godbolt''s gcc4.8 para ARM64, pero ya no está instalado (¿quizás porque estaba mal configurado?) ARM64 gcc5.4 no hace eso.

Godbolt tiene MSVC (CL) instalado ahora, y algunas de estas funciones se compilan de forma diferente, pero no me he tomado el tiempo para ver cuál compila mejor.

Tenga en cuenta que en la salida de gcc para x86, multiplicar por 10 se realiza de forma económica con lea eax, [rdx + rdx*4] para hacer n * 5, luego add eax,eax para duplicar eso. imul eax, edx, 10 tendrían 1 ciclo de latencia más alta en Intel Haswell, pero serían más cortos (uno menos uop). gcc / clang no lo use incluso con -Os -mtune=haswell : /

La respuesta aceptada ( n + 10 - n % 10 ) es aún más barata de calcular: n+10 puede ocurrir en paralelo con n%10 , por lo que la cadena de dependencia es un paso más corta. Compila una instrucción menos.

Sin embargo , da la respuesta incorrecta para múltiplos de 10: por ejemplo, 10 -> 20 . La solución sugerida usa un if(n%10) para decidir si hacer algo. Esto se compila en un cmov , por lo que es más largo y peor que el código de @ Bta. Si vas a usar un condicional, hazlo para obtener resultados sanos para las entradas negativas.

Así es como se comportan todas las respuestas sugeridas, incluidas las entradas negativas :

./a.out | awk -v fmt=''/t%4s'' ''{ for(i=1;i<=NF;i++){ a[i]=a[i] sprintf(fmt, $i); } } END { for (i in a) print a[i]; }''
i -22 -21 -20 -19 -18 -12 -11 -10 -9 -8 -2 -1 0 1 2 8 9 10 11 12 18 19 20 21 22
mark -10 -10 -10 -10 0 0 0 0 0 0 0 0 0 10 10 10 10 10 20 20 20 20 20 30 30
igna -10 -10 -10 0 0 0 0 0 10 10 10 10 10 10 10 10 10 20 20 20 20 20 30 30 30
utaal -20 -20 -20 -10 -10 -10 -10 -10 0 0 0 0 0 10 10 10 10 10 20 20 20 20 20 30 30
bta -10 -10 -10 -10 0 0 0 0 0 10 10 10 10 10 10 10 10 10 20 20 20 20 20 30 30
klatchko -10 -10 -10 -10 0 0 0 0 0 0 0 0 0 10 10 10 10 10 20 20 20 20 20 30 30
branch -10 -10 -20 0 0 0 0 -10 10 10 10 10 0 10 10 10 10 10 20 20 20 20 20 30 30

( programa de transposición awk )

La n + (((9 - (n % 10)) + 1) % 10) Ignacio n + (((9 - (n % 10)) + 1) % 10) funciona "correctamente" para enteros negativos, redondeando hacia + Infinito, pero es mucho más costoso de computar. Requiere dos operaciones de módulo, por lo que es esencialmente el doble de costoso. Compila aproximadamente el doble de instrucciones x86, haciendo aproximadamente el doble del trabajo de las otras expresiones.

Programa de impresión de resultados (igual que los enlaces de godbolt arriba)

#include <stdio.h>
#include <stdlib.h>
int f_mark(int n) { return (n+9) - ((n+9)%10); } // good
int f_bta(int n) { return ((n + 9) / 10) * 10; } // compiles to literally identical code
int f_klatchko(int n) { return n + 10 - n % 10; } // wrong, needs a branch to avoid changing multiples of 10
int f_ignacio(int n) { return n + (((9 - (n % 10)) + 1) % 10); } // slow, but works for negative
int roundup10_utaal(int n) { return ((n - 1) / 10 + 1) * 10; }
int f_branch(int n) { if (n % 10) n += (10 - n % 10); return n; } // gcc uses cmov after f_accepted code
int main(int argc, char**argv)
{
puts("i/tmark/tigna/tutaal/tbta/tklatch/tbranch");
for (int i=-25 ; i<25 ; i++)
if (abs(i%10) <= 2 || 10 - abs(i%10) <= 2) // only sample near interesting points
printf("%d/t%d/t%d/t%d/t%d/t%d/t%d/n", i, f_mark(i), f_accepted(i),
f_ignacio(i), roundup10_utaal(i), f_bta(i), f_branch(i));
}

Answer 9

int n,res;
...
res = n%10 ? n+10-(n%10) : n;

o

res = (n / 10)*10 + ((n % 10) ? 10:0);

Answer 10

n + (((9 - (n % 10)) + 1) % 10)

Answer 11

n + (10 - n % 10)

Cómo funciona esto El operador% evalúa el resto de la división (por lo que el 41 % 10 evalúa a 1, mientras que el 45 % 10 evalúa a 5). Restar eso de 10 evalúa cuánto cuánto necesita para llegar al siguiente múltiplo.

El único problema es que esto convertirá 40 en 50. Si no lo desea, deberá agregar un cheque para asegurarse de que no sea un múltiplo de 10.

if (n % 10)
n = n + (10 - n % 10);

Answer 12

round_up(int i)
{
while(i%10) {
i++;
}
return(i);
}