Per verificare se un numero decimale è divisibile per 7:

Cancella l'ultima cifra. Moltiplicalo per 2 e sottrai da ciò che resta. Se il risultato è divisibile per 7, il numero originale è divisibile per 7.

(descritto anche ad esempio qui )

Questa regola è valida per il controllo manuale della divisibilità. Per esempio:

È 2016 divisibile per 7?

Sottrai 6*2da 201; otteniamo 189. È divisibile per 7? Per verificarlo, applichiamo di nuovo la regola.

Sottrai 9*2da 18; otteniamo 0. Pertanto, 2016 è divisibile per 7.

In questa sfida, è necessario applicare questa regola fino a quando lo stato di divisibilità non è evidente , ovvero il numero non è maggiore di 70 (tuttavia, vedere di seguito per i dettagli). Crea una funzione o un programma completo.

Input : un numero intero positivo; il tuo codice dovrebbe supportare input fino a 32767 (supportare numeri interi di precisione arbitraria è un bonus; vedi sotto).

Output : un numero intero (possibilmente negativo), non maggiore di 70, che è il risultato dell'applicazione della regola di divisibilità per 7 zero o più volte.

Casi test:

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

Laddove sono specificati due possibili output, entrambi i risultati sono corretti: il secondo corrisponde all'applicazione della regola ancora una volta. È vietato applicare la regola su un numero a una cifra: se si cancella la cifra, non viene lasciato nulla (non 0).

Bonus : se il tuo algoritmo

• Supporta numeri interi di precisione arbitraria
• Esegue solo un passaggio sull'ingresso
• Ha complessità spaziale o(n)(cioè inferiore a O(n)); e
• Ha complessità temporale O(n),

dove nè il numero di cifre decimali:

Sottrai il 50% dal conteggio dei byte del tuo codice.

Bonus reale :

Inoltre, se il tuo algoritmo legge l'input in direzione normale, partendo dalla cifra più significativa, sottrai nuovamente il 50%: il tuo punteggio è il 25% del conteggio dei byte (sembra possibile, ma non ne sono assolutamente sicuro).

Golfscript, 27 22 byte

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

Puoi usarlo in questo modo:

1000f

Spiegazione

{.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 byte salvati grazie a Dennis!

Haskell, 35 byte

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

Esempio di utilizzo: until(<71)(\n->div n 10-2*mod n 10) 36893488147419103232-> 32.

Non c'è molto da spiegare, è un'implementazione diretta dell'algoritmo.

Gelatina, 11 byte

d⁵Uḅ-2µ>9$¿

Provalo online!

Come funziona

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 byte

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

Provalo qui !

Semplice approccio ricorsivo. Stampa x se <70 altrimenti applica la regola di divisibilità e si chiama con il risultato.

Pyth, 13 byte

.W>H9-/ZTyeZQ

Provalo online: Dimostrazione o Test Suite

Questo stamperà tutte le risposte alternative.

Spiegazione:

.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 byte

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

Questa è una funzione ricorsiva che accetta un numero intero e restituisce a BigInt. Se l'input è un numero elevato come nell'ultimo esempio, Julia lo analizza come un BigInt, quindi non è necessaria alcuna conversione manuale.

L'approccio è solo un'implementazione diretta dell'algoritmo. Produrrà le uscite alternative. Prendendo il modulo quando si divide per 10 si ottiene l'ultima cifra e il quoziente di divisione intera per 10 produce tutto tranne l'ultima cifra.

Salvataggio di un byte grazie a Dennis!

Pyth, 17 byte

L?<b70by-/bT*%bT2

Provalo qui!

Stesso approccio ricorsivo come nella mia risposta di Python . Definisce un lambda yche si chiama in questo modo: y12345.
Il contatore di byte nell'interprete online mostra 19 byte perché ho aggiunto la chiamata lambda ad esso, quindi puoi semplicemente provarlo premendo il pulsante di esecuzione.

Spiegazione

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 byte

Versione Do-while:

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

Provalo online o Mentre la versione # 1:

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

Provalo online o Mentre versione # 2:

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

Provalo online .

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 byte

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;

Un-golfed

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 byte - 50% = 71,5 byte

O (1) spazio, O (n) tempo, single-pass!

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

Utilizzare as 0![6,1,0,2]per applicare la regola al 2016, ovvero passare un numero in forma di flusso con prima la cifra meno significativa. In questo modo, passerà sopra il numero cifra per cifra, applicando la regola con la complessità dello spazio O (1).

Il codice non salvato è qui:

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

L'essenza di come funziona è che implementa un algoritmo di sottrazione cifra per cifra , ma sfrutta il fatto che ogni numero da sottrarre è al massimo di 2 cifre, quindi possiamo sottrarre una quantità arbitraria di questi 1- o numeri a 2 cifre da quello principale (oltre a mangiare le cifre meno significative).

L'algoritmo di sottrazione è O (1) e memorizza solo il valore "prestito" corrente. Ho modificato questo per aggiungere la cifra aggiuntiva (0 o 1) e notiamo che questo valore di prestito è limitato (all'interno dell'intervallo [-2,2], quindi abbiamo bisogno di solo 3 bit per memorizzarlo).

Gli altri valori archiviati in memoria sono variabili temporanee che rappresentano il numero di 2 cifre corrente da aggiungere, un singolo look-stream nel flusso e per applicare un passaggio dell'algoritmo di sottrazione (ovvero richiede due cifre e un valore di prestito e restituisce una cifra e un nuovo valore di prestito).

Alla fine, elabora contemporaneamente le ultime due cifre nello stream per restituire un numero a una cifra anziché un elenco di cifre.

NB La sevfunzione nella versione non golfata funzionerà su un Integer, convertendola in forma di flusso inverso.

GNU dc, 20 15 byte

[10~2*-d70<F]sF

Questo definisce il mio primo (sempre) la funzione CC, F. Prende input in cima allo stack e lascia il suo output in cima allo stack. Esempio di utilizzo:

36893488147419103232
lFxp
32

Mathematica, 47 44 byte

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

Semplice approccio ricorsivo. Probabilmente potrebbe essere ulteriormente giocato a golf.

R, 43 byte

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

Spiegazione:

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

Esecuzioni campione:

> 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 byte

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

Non funziona 36893488147419103232e utilizza~~(1/10) anche fallire per700168844221

Test:

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 byte

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

Caso di prova

%[9999]
(* -3 *)

Perl 5, 47 46 byte

Ho dovuto usare bigintper l'ultimo caso di test. (Restituisce 20 senza)

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

Non sono sicuro che sia un candidato per il bonus, quindi non ne ho tenuto conto. (Penso di si, ma non sono molto abituato ai concetti)

Provalo qui!

ES6, 108 byte

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

Funziona per 2²⁵⁷ e 1000000000000000000001, ma potrebbe utilizzare ulteriori golf.

JavaScript ES6, 140 142 byte

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

Questa è vera matematica di precisione arbitraria, funziona anche sul più grande caso di test.

Questa funzione rimuove in modo ricorsivo l'ultima cifra dalla stringa, quindi sottrae 2 * l'ultima cifra dalla stringa numerica rimanente incrementando iterativamente la quantità di cifre da applicare al minuend fino a quando la differenza è positiva. Quindi aggiunge tale differenza alla fine della stringa con 0s opportunamente riempiti e si chiama ricorsivamente fino a quando il suo valore numerico è inferiore o uguale a 9.

• Golfato 7 byte grazie a @Neil (sì, lo so, ho guadagnato 2 byte, ma ho corretto alcuni bug che hanno causato il blocco della funzione o la restituzione di output errati in alcuni casi).

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 #, 111 104 byte

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 byte

Provalo online!

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

Spiegazione

Per iniziare tutto il codice è in un ciclo che viene eseguito fino a quando la parte superiore dello stack è inferiore a zero:

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

All'interno del ciclo eseguiamo il divisibile per sette algoritmi:

Duplica la parte superiore della pila

(({}))

Prendi il mod 10 della parte superiore dello stack (ultima cifra)

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

Questo è un po 'un casino, ma fa il resto dell'algoritmo che potrei spiegarlo in seguito ma non ricordo del tutto come funziona:

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

C, 56 byte - 75% = 14

Sebbene questo non fornisca gli stessi numeri dei casi di test, soddisfa lo spirito della domanda (e probabilmente anche di più). Identifica correttamente multipli esatti di 7 e fornisce il resto esatto per altri numeri (poiché non usa mai numeri negativi).

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

Non ci sono moltiplicazioni o divisioni nell'algoritmo, solo addizioni e sottrazioni e le cifre vengono elaborate in un unico passaggio da sinistra a destra. Funziona come segue, iniziando con 0 nell'accumulatore:

1. Sottrai 7 se necessario, e ancora se ancora necessario
2. Moltiplicare il totale parziale per tre e aggiungere la cifra successiva

Il passaggio "moltiplica per tre" è scritto n-=-n-nper salvare un byte ed evitare l'operatore di moltiplicazione.

Quando arriviamo alla fine, non sottraggiamo i sette, quindi il risultato sarà compreso tra 0 e 24; se si desidera un modulo rigoroso (0-7), sostituire *ccon *c||n>6infor condizione di loop.

Si qualifica per il bonus avanzato, perché

• supporta numeri interi di precisione arbitraria
• esegue un solo passaggio sull'input, nell'ordine da sinistra a destra
• ha complessità spaziale O (1)
• ha complessità temporale O (n).

Programma di test e risultati

#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

Versione alternativa

Eccone uno che recluta (ti consigliamo di abilitare le ottimizzazioni del compilatore per eseguire la trasformazione delle chiamate in coda o potresti sovraccaricare il tuo stack; ho usato 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;}

Chiamalo con '0' come secondo argomento.

Entrambe le versioni calcolano il resto-modulo-sette di un numero di 60.000 cifre in meno di 50 millisecondi sulla mia macchina.

PHP, 50 byte

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

utilizza output alternativi; funziona fino aPHP_INT_MAX

versione stringa, funziona per qualsiasi numero (positivo) (64 byte):

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

Java, 133 byte

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 quanto Integer.parseIntè prolisso . Ungolfed:

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