Para verificar si un número decimal es divisible por 7:

Borra el último dígito. Multiplique por 2 y reste de lo que queda. Si el resultado es divisible por 7, el número original es divisible por 7.

(también descrito, por ejemplo, aquí )

Esta regla es buena para la verificación manual de divisibilidad. Por ejemplo:

¿Es 2016 divisible por 7?

Restar 6*2de 201; obtenemos 189. ¿Es esto divisible por 7? Para verificarlo, apliquemos la regla nuevamente.

Restar 9*2de 18; obtenemos 0. Por lo tanto, 2016 es divisible por 7.

En este desafío, debe aplicar esta regla hasta que el estado de divisibilidad sea obvio , es decir, el número no sea mayor que 70 (sin embargo, consulte los detalles a continuación). Hacer una función o un programa completo.

Entrada : un entero positivo; su código debe admitir entradas de hasta 32767 (la compatibilidad con enteros de precisión arbitraria es una ventaja; consulte a continuación).

Salida : un número entero (posiblemente negativo), no mayor que 70, que es el resultado de aplicar la regla de divisibilidad por 7 cero o más veces.

Casos de prueba:

Input                   Output      Alternative output

1                       1
10                      10          1
100                     10          1
13                      13          -5
42                      42          0
2016                    0
9                       9
99                      -9
9999                    -3
12345                   3
32767                   28          -14

---------- Values below are only relevant for the bonus

700168844221            70          7
36893488147419103232    32          -1
231584178474632390847141970017375815706539969331281128078915168015826259279872    8

Cuando se especifican dos salidas posibles, cualquiera de los resultados es correcto: el segundo corresponde a aplicar la regla una vez más. Está prohibido aplicar la regla en un número de un solo dígito: si borra el dígito, no queda nada (no 0).

Bonificación : si tu algoritmo

• Admite enteros de precisión arbitraria
• Realiza solo una pasada en la entrada
• Tiene complejidad espacial o(n)(es decir, menor que O(n)); y
• Tiene complejidad de tiempo O(n),

donde nes el número de dígitos decimales:

Resta el 50% del recuento de bytes de tu código.

Bonificación real :

Además, si su algoritmo lee la entrada en la dirección normal, comenzando desde el dígito más significativo, reste 50% una vez más; su puntaje es el 25% de su conteo de bytes (parece posible, pero no estoy absolutamente seguro).

Golfscript, 27 22 bytes

{.9>{.10/\10%2*-f}*}:f

Puedes usarlo de esta manera:

1000f

Explicación

{.9>{.10/\10%2*-f}*}:f
{                  }:f    # Define block 'f' (similar to a function)
 .                        # Duplicate the first value of the stack
  9>{            }*       # If the value on top of the stack is greater than 9 then the block is executed
     .10/\10%2*-          # Same as nb/10 - (nb%10 * 2) with some stack manipulations '.' to duplicate the top of the stack and '\' to swap the the first and second element of the stack
                f         # Execute block 'f'

¡5 bytes guardados gracias a Dennis!

Haskell, 35 bytes

until(<71)(\n->div n 10-2*mod n 10)

Ejemplo de uso: until(<71)(\n->div n 10-2*mod n 10) 36893488147419103232 -> 32.

No hay mucho que explicar, es una implementación directa del algoritmo.

Jalea, 11 bytes

d⁵Uḅ-2µ>9$¿

Pruébalo en línea!

Cómo funciona

d⁵Uḅ-2µ>9$¿  Main link. Input: n

d⁵           Divmod; return [n : 10, n % 10].
  U          Upend; yield [n % 10, n : 10].
   ḅ-2       Convert from base -2 to integer, i.e., yield -2 × (n % 10) + (n : 10).

      µ      Push the previous chain as a link and begin a new, monadic chain.
          ¿  Apply the previous chain while...
       >9$     its return value is greater than 9.

Python 2, 38 bytes

f=lambda x:f(x/10-x%10*2)if x>70else x

Pruébalo aquí !

Enfoque recursivo simple. Imprime x si su <70 aplica la regla de divisibilidad y se llama a sí mismo con el resultado.

Pyth, 13 bytes

.W>H9-/ZTyeZQ

Pruébelo en línea: demostración o pruebas

Esto imprimirá todas las respuestas alternativas.

Explicación:

.W>H9-/ZTyeZQ   
            Q   read a number from input
.W              while
  >H9              the number is greater than 9
                do the following with the number:
      /ZT          divide it by 10
     -             and subtract
         yeZ       2*(number%10)

Julia, 27 26 bytes

f(x)=x>9?f(x÷10-x%10*2):x

Esta es una función recursiva que acepta un número entero y devuelve a BigInt. Si la entrada es un número grande como en el último ejemplo, Julia lo analiza como un BigInt, por lo que no es necesaria la conversión manual.

El enfoque es solo una implementación directa del algoritmo. Producirá las salidas alternativas. Tomar el módulo cuando se divide por 10 produce el último dígito y el cociente de la división de enteros por 10 produce todo menos el último dígito.

¡Ahorré un byte gracias a Dennis!

Pyth, 17 bytes

L?<b70by-/bT*%bT2

Pruébalo aquí!

El mismo enfoque recursivo que en mi respuesta de Python . Define un lambda yque se llama así: y12345.
El contador de bytes en el intérprete en línea muestra 19 bytes porque le agregué la llamada lambda, por lo que puede intentarlo presionando el botón de ejecución.

Explicación

L?<b70by-/bT*%bT2

L                  # Defines the lambda y with the parameter b
 ?<b70             # if b < 70:
      b            # return b, else:
       -/bT*%bT2   # calculate b/10 - b%10*2 and return it

CJam - 19 bytes

Versión Do-while:

r~A*{`)]:~~Y*-_9>}g

Pruébelo en línea o mientras que la versión # 1:

r~{_9>}{`)]:~~Y*-}w

Pruébelo en línea o mientras que la versión # 2:

r~{_9>}{_A/\A%Y*-}w

Pruébalo en línea .

r~                     | Read and convert input
  A*                   | Multiply by 10 to get around "if" rule
     `                 | Stringify
      )                | Split last character off
       ]               | Convert stack to array
        :~             | Foreach in array convert to value
          ~            | Dump array
           Y*          | Multiply by 2
             -         | Subtract
              _        | Duplicate
               9>      | Greater than 9?
    {            }g    | do-while

Oracle SQL 11.2, 116 bytes

WITH v(i)AS(SELECT:1 FROM DUAL UNION ALL SELECT TRUNC(i/10)-(i-TRUNC(i,-1))*2 FROM v WHERE i>70)SELECT MIN(i)FROM v;

Sin golf

WITH v(i) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
  SELECT TRUNC(i/10)-(i-TRUNC(i,-1))*2 FROM v WHERE i>70
)
SELECT MIN(i) FROM v;

Haskell, 157 192 184 167 159 147 138 + 5 bytes - 50% = 71.5 bytes

O (1) espacio, O (n) tiempo, un solo paso!

h d=d%mod d 10
d%r=(quot(r-d)10,r)
p![d]=d-p*10
p![d,e]=d#(e-p)
p!(d:e:f)|(b,a)<-quotRem(2*d)10,(q,r)<-h$e-a-p=(b+q)!(r:f)
m#0=m
m#n=n-2*m
(0!)

Use como 0![6,1,0,2]para aplicar la regla a 2016, es decir, pasarle un número en forma de flujo con la cifra menos significativa primero. De esta manera, pasará el número dígito por dígito, aplicando la regla con O (1) complejidad de espacio.

El código sin golf está aquí:

import Data.Char

{- sub a b = sub2 0 a b
  where
    sub2 borrow (a:as) (b:bs) = res : sub2 borrow2 as bs
      where
        (borrow2, res) = subDig borrow a b
    sub2 borrow (a:as) [] = sub2 borrow (a:as) (0:[])
    sub2 _ [] _ = [] -}

--subDig :: Int -> Int -> Int -> (Int, Int)
subDig borrow a b = subDig2 (a - b - borrow)
  where
    subDig2 d = subDig3 d (d `mod` 10)
    subDig3 d r = ((r-d) `quot` 10, r)

seven ds = seven2 0 ds
seven2 borrow (d:e:f:gs) = seven2 (b + borrow2) (res:f:gs)
  where
    (a, b) = double d
    (borrow2, res) = subDig borrow e a
seven2 borrow (d:e:[]) = finalApp d (e-borrow)
seven2 borrow (d:[]) = d - borrow*10

double d = ((2*d) `mod` 10, (2*d) `quot` 10)

finalApp m 0 = m
finalApp m n = n - 2*m

num2stream :: Int -> [Int]
num2stream = reverse . map digitToInt . show
sev = seven . num2stream

La esencia de cómo funciona esto es que implementa un algoritmo de resta dígito a dígito , pero aprovecha el hecho de que cada número que se restará es como máximo de 2 dígitos, por lo que podemos restar una cantidad arbitraria de estos 1- o números de 2 dígitos del principal (además de comer los dígitos menos significativos).

El algoritmo de resta es O (1) y solo almacena el valor actual de 'préstamo'. Modifiqué esto para agregar el dígito adicional (ya sea 0 o 1), y notamos que este valor de préstamo está limitado (dentro del rango [-2,2] por lo que necesitamos solo 3 bits para almacenar esto).

Los otros valores almacenados en la memoria son variables temporales que representan el número actual de 2 dígitos para agregar, una sola vista anticipada en la secuencia y aplicar un paso del algoritmo de resta (es decir, toma dos dígitos y un valor de préstamo, y devuelve un dígito y un nuevo valor de préstamo).

Finalmente, al final, procesa los dos últimos dígitos de la secuencia a la vez para devolver un número de un solo dígito en lugar de una lista de dígitos.

NB La sevfunción en la versión sin golf funcionará en una Integer, convirtiéndola en la forma de flujo inverso.

GNU dc, 20 15 bytes

[10~2*-d70<F]sF

Esto define mi primer (nunca) la función de corriente continua, F. Toma entrada en la parte superior de la pila y deja su salida en la parte superior de la pila. Ejemplo de uso:

36893488147419103232
lFxp
32

Mathematica, 47 44 bytes

If[#>70,#0[{1,-2}.{⌊#/10⌋,#~Mod~10}],#]&

Enfoque recursivo simple. Probablemente podría jugar más golf.

R, 43 bytes

x=scan();while(x>70)x=floor(x/10)-x%%10*2;x

Explicación:

x=scan()                                      # Takes input as a double
        ;                                     # Next line
         while(x>70)                          # While-loop that runs as long x > 70
                      floor(x/10)             # Divide x by 10 and round that down
                                 -x%%10*2     # Substract twice the last integer
                    x=                        # Update x
                                         ;    # Next line once x <= 70
                                          x   # Print x

Ejecuciones de muestra:

> x=scan();while(x>70)x=floor(x/10)-x%%10*2;x
1: 9999
2: 
Read 1 item
[1] -3

> x=scan();while(x>70)x=floor(x/10)-x%%10*2;x
1: 32767
2: 
Read 1 item
[1] 28

JavaScript ES6, 38 bytes

a=i=>i>70?a(Math.floor(i/10)-i%10*2):i

Falla con 36893488147419103232y usando ~~(1/10)también fallará por700168844221

Prueba:

a=i=>i>70?a(Math.floor(i/10)-i%10*2):i
O.textContent = O.textContent.replace(/(-?\d+) +(-?\d+)/g, (_,i,o) =>
  _+": "+(a(+i)==o?"OK":"Fail")
);

<pre id=O>1                       1
10                      10
100                     10
13                      13
42                      42
2016                    0
9                       9
99                      -9
9999                    -3
12345                   3
700168844221            70
36893488147419103232    32</pre>

Mathematica, 33 bytes

#//.a_/;a>70:>⌊a/10⌋-2a~Mod~10&

Caso de prueba

%[9999]
(* -3 *)

Perl 5, 47 46 bytes

Tuve que usar bigintpara el último caso de prueba. (Devuelve 20 sin)

use bigint;$_=<>;while($_>9){$_-=2*chop;}print

No estoy realmente seguro de que sea un candidato para el bono, así que no lo tomé en cuenta. (Creo que sí, pero no estoy acostumbrado a los conceptos)

Pruébalo aquí!

ES6, 108 bytes

f=(s,n=0)=>s>1e9?f(s.slice(0,-1),((1+s.slice(-1)-n%10)%10*21+n-s.slice(-1))/10):s>9?f(((s-=n)-s%10*21)/10):s

Funciona para 2²⁵⁷ y 1000000000000000000001, pero podría usar más golf.

JavaScript ES6, 140 142 bytes

f=s=>s>9?eval("t=s.replace(/.$/,'-$&*2');for(i=-1;0>(n=eval(u=t[c='slice'](i-4)))&&u!=t;i--);n<0?n:f(t[c](0,i-4)+('0'.repeat(-i)+n)[c](i))"):s

Esta es una verdadera matemática de precisión arbitraria, incluso funciona en el caso de prueba más grande.

Esta función elimina de forma recursiva el último dígito de la cadena, luego resta 2 * el último dígito de la cadena numérica restante incrementando iterativamente la cantidad de dígitos que se aplicarán al minuendo hasta que la diferencia sea positiva. Luego agrega esa diferencia al final de la cadena con 0s apropiadamente rellenada y se llama recursivamente hasta que su valor numérico sea menor o igual a 9.

• Golfé 7 bytes gracias a @Neil (sí, sé que gané 2 bytes, pero solucioné algunos errores que causaban que la función se congelara o devolviera resultados incorrectos en algunos casos).

f=s=>s>9?eval("t=s.replace(/.$/,'-$&*2');for(i=-1;0>(n=eval(u=t[c='slice'](i-4)))&&u!=t;i--);n<0?n:f(t[c](0,i-4)+('0'.repeat(-i)+n)[c](i))"):s;[['1',1],['10',1],['100',1],['13',-5],['42',0],['2016',0],['9',9],['99',-9],['9999',-3],['12345',3],['700168844221',7],['36893488147419103232',-1],['231584178474632390847141970017375815706539969331281128078915168015826259279872',8]].map(a=>document.write(`<pre>${f(a[0])==a[1]?'PASS':'FAIL'} ${a[0]}=>${a[1]}</pre>`))

C #, 111104 bytes

int d(int n){var s=""+n;return n<71?n:d(int.Parse(s.Remove(s.Length-1))-int.Parse(""+s[s.Length-1])*2);}

Brain-Flak , 368 360 bytes

Pruébalo en línea!

([([({})]<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>){{}(({}))(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>([([([(({}<{}><>)<([{}]{})(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)>){}]{})]<(())>)(<>)]){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>)}{}

Explicación

Para comenzar, todo el código está en un bucle que se ejecuta hasta que la parte superior de la pila sea inferior a cero:

([([({})]<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>)
{{}
 ...
 ([([({})]<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}({}<>)
}{}

Dentro del bucle ejecutamos el algoritmo divisible por siete:

Duplicar la parte superior de la pila.

(({}))

Tome el mod 10 de la parte superior de la pila (último dígito)

(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}><>)

Esto es un poco complicado, pero hace el resto del algoritmo. Podría explicarlo más tarde, pero no recuerdo completamente cómo funciona:

([(({})<([{}]{})(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)>){}]{})

C, 56 bytes - 75% = 14

Aunque esto no da exactamente los mismos números que los casos de prueba, satisface el espíritu de la pregunta (y posiblemente más). Identifica correctamente múltiplos exactos de 7 y proporciona el resto exacto para otros números (ya que nunca usa números negativos).

n;f(char*c){for(n=0;*c;)n-=n>6?7:'0'-n-n-*c++;return n;}

No hay multiplicación o división en el algoritmo, solo suma y resta, y los dígitos se procesan en una sola pasada de izquierda a derecha. Funciona de la siguiente manera, comenzando con 0 en el acumulador:

1. Resta 7 si es necesario, y nuevamente si aún es necesario
2. Multiplique el total acumulado por tres y agregue el siguiente dígito

El paso "multiplicar por tres" se escribe n-=-n-npara guardar un byte y evitar el operador de multiplicación.

Cuando llegamos al final, no restamos sietes, por lo que el resultado estará en el rango de 0-24; si desea un módulo estricto (0-7), sustitúyalo *cpor *c||n>6enfor condición de bucle.

Califica para la bonificación mejorada, porque

• admite enteros de precisión arbitraria
• realiza solo una pasada en la entrada, en orden de izquierda a derecha
• tiene complejidad espacial O (1)
• tiene complejidad de tiempo O (n).

Programa de prueba y resultados

#include <stdio.h>
int main(int argc, char **argv) {
    while (*++argv)
        printf("%s -> %d\n", *argv, f(*argv));
    return 0;
}

540 -> 15
541 -> 16
542 -> 17
543 -> 18
544 -> 19
545 -> 20
546 -> 21
547 -> 22
548 -> 23
549 -> 24
550 -> 18
99 -> 15
999 -> 12
12345 -> 11
32767 -> 7
700168844221 -> 7
36893488147419103232 -> 11
231584178474632390847141970017375815706539969331281128078915168015826259279872 -> 11

Versión alternativa

Aquí hay uno que se repite (querrá habilitar las optimizaciones del compilador para realizar una transformación de cola o puede desbordar su pila; yo solía gcc -std=c89 -O3):

f(c,n)char*c;{return n>6?f(c,n-7):*c?f(c+1,n+n+n+*c-'0'):n;}

Llámalo con '0' como segundo argumento.

Ambas versiones calculan el resto-módulo-siete de un número de 60,000 dígitos en menos de 50 milisegundos en mi máquina.

PHP, 50 bytes

for($n=$argv[1];$n>9;)$n=$n/10|0-2*($n%10);echo$n;

usa salida alternativa; funciona hastaPHP_INT_MAX

versión de cadena, funciona para cualquier número (positivo) (64 bytes):

for($n=$argv[1];$n>9;)$n=substr($n,0,-1)-2*substr($n,-1);echo$n;

Java, 133 bytes

int d(int n){String s=""+n;return n<71?n:d(Integer.parseInt(s.replaceFirst(".$",""))-Integer.parseInt(""+s.charAt(s.length()-1))*2);}

Odio lo detallado que Integer.parseIntes. Sin golf:

static int div(int n) {
    if (n <= 70) {
        return n;
    } else {
        String num = ("" + n);
        int last = Integer.parseInt("" + num.charAt(num.length() - 1));
        int k = Integer.parseInt(num.replaceFirst(".$", "")) - last * 2;
        return div(k);
    }
}