Implementare la regola divisibilità per 7


25

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

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


1
@DenkerAffe La restituzione dell'input così com'è è accettabile. Ho aggiornato il test-case di input = 10 per riflettere questo; questa era l'idea fin dall'inizio.
Anatolyg

4
Non vorrei usare quella regola 1000000000000000000001.
Neil,

1
E se la tua lingua avesse long longincorporato qualche tipo equivalente?
SuperJedi224,

1
Quello che stavo dicendo era che, in alcune implementazioni, è un numero intero a 128 bit, che è più che abbastanza grande per l'ultimo caso di test.
SuperJedi224,

7
-1. Non tutte le lingue supportano precisione arbitraria.
Ho marzo

Risposte:


23

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!


1
Benvenuti in Programming Puzzle and Code Golf. Questa è una buona risposta, tuttavia è possibile migliorarla aggiungendo una suddivisione del codice e una spiegazione, come le domande precedenti. Per rispondere a questo commento, digita @wizzwizz4( @quindi il mio nome utente) all'inizio di (o ovunque) un commento.
wizzwizz4,

1
@ wizzwizz4 Meglio? Non sono sicuro di aver capito cosa intendi per "suddivisione del codice" (non mi spiace il madrelingua)
Dica,

8
Credo che per "suddivisione del codice" intendesse una spiegazione, che hai aggiunto. Questa è davvero una bella prima risposta. Benvenuti nel sito!
Alex A.

1
È possibile riscrivere la {...}{}ifparte come {...}*, che applicherà il blocco di codice zero di una volta, a seconda del valore inserito >. Inoltre, siamo autorizzati a eseguire un'altra iterazione (quindi sostituendo 70con 9salva un byte), e non credo che sia necessario pop il blocco con ;.
Dennis,

3
@Dica, questa è una prima risposta abbastanza buona per ottenere 12+ voti positivi su una domanda con solo 624 visualizzazioni e per ottenere elogi da due moderatori. Se continui così, presto raggiungerai Dennis!
wizzwizz4,

13

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.


9

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.

E come sempre vince Jelly. Dennis, quanti byte ci vorrebbe per implementare un interprete di gelatina in Jelly?
Bálint,

6

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.


non è necessario lo spazio dopo il)
Maltysen,

@Maltysen True. Copia incollata quella sbagliata, grazie per il suggerimento!
Denker,

2
L'if è troppo dettagliato. f=lambda x:x*(x<70)or f(x/10-x%10*2)
Seequ,

1
@Seeq Bel trucco, grazie! Questo dovrebbe funzionare in teoria, ma raggiunge la massima profondità di ricorsione con il 2016 come input mentre la mia versione no. Qualche idea sul perché?
Denker,

Ah, giusto, non l'ho preso in considerazione. Questo trucco considera x*(x<70) != 0la condizione finale. Se x arriva a 0 - come nel 2016 - la condizione finale non si verifica mai.
Seequ,

6

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)

5

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!


Ci è consentito eseguire un'altra iterazione, quindi sostituendo 70con 9salva un byte.
Dennis,

@Dennis Buona chiamata, grazie!
Alex A.

4

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

Hai un refuso nella tua spiegazione, 17 dovrebbero essere 70: P
FryAmTheEggman

4

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

3

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;

3

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.


Intendevo che il bonus fosse per il normale ordine delle cifre. Ma non l'ho mai detto, quindi è giusto ottenere il bonus per l'ordine inverso, anche se è meno divertente. Ad ogni modo, anche l'ordine inverso è più difficile di quanto pensassi, quindi è abbastanza divertente!
Anatolyg,

@anatolyg: Grazie! Non sono sicuro che sia possibile eseguire un'implementazione O (1) a singolo passaggio dell'ordine normale ... la regola dipende dalle cifre meno significative, quindi in teoria l'applicazione diretta della regola è impossibile se non in ordine inverso. L'unica altra cosa a cui riesco a pensare è trovare una forma matematicamente equivalente - per esempio Mod[18 - Quotient[n, 10] - 2*n, 21] - 18 + Quotient[n, 10]funziona empiricamente per n tra 10 e 99, ma diventa più complicato più cifre n ha ...
nitro

Hmm ci ho pensato e sembrava che ci potesse essere un modo mantenendo le prime 2 cifre e applicando ogni cifra successiva, ma moltiplicando per (-2) ^ n per tener conto del suo "filtraggio" ... per quanto posso dire se non c'è modo di farlo funzionare senza tenere tutte le cifre in memoria e sacrificare la O (1) 'ness o addirittura o (n)' ness ... Penso che l'ordine normale sia decisamente impossibile :(
nitro

1
Temo che tu debba contare i byte dell'iniziale anche 0quando chiami !, ad es. Come una sezione (0!)(+ una nuova riga), cioè +5 byte. Dall'altro lato puoi accorciare il primo per modellare le corrispondenze di !a p![d]=e p![d,e]=. Inoltre, l'uso modello custodisce al posto del let: p!(d:e:f)|(b,a)<-quotRem(2*d)10,(q,r)<-h$e-a-p=(b+q)!(r:f).
nimi,

1
@nitrous: oh, mi (0!)riferisco a una sua linea. (0!)è la funzione che dai come risposta. Il 0è necessario, ma non ha nulla a che fare con l'ingresso, quindi non è possibile esternalizzare al chiamante. Ovviamente potresti anche usare f x=0!x, ma questo è più lungo.
nimi,

3

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

2

Mathematica, 47 44 byte

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

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


#0[{1,-2}.QuotientRemainder[#,10]]salva un byte.
njpipeorgan,

2

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

1

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>


Ricevo due Fail... 70 e 32
Conor O'Brien,

@ CᴏɴᴏʀO'Bʀɪᴇɴ Sì, mi chiedo ancora perché ...
andlrc

Perché il tipo di numero JavaScript non gestisce l'ultimo caso, almeno.
Conor O'Brien,

1
f=n=>n>70?f((n-n%10*21)/10):nè una versione più breve ma funziona ancora solo fino a 2**56.
Neil,

@Neil vedi la mia risposta per una precisione arbitraria, e sentiti libero di giocare a golf, molto apprezzato.
Patrick Roberts,

1

Mathematica, 33 byte

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

Caso di prova

%[9999]
(* -3 *)

1

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!


1

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.


@PatrickRoberts Spiacenti, supervisione durante la riformattazione per l'invio.
Neil,

1

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


Bello, ma potrebbe non funzionare 1000000000000000000001.
Neil,

1
Prova s.replace(/.$/,'-$&*2'). Per il resto non ho idee ovvie per il resto.
Neil,

1

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

1

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:

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

1

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.


Grazie per il bonus: per C diventa davvero competitivo! Attualmente battuto solo da Jelly (11) e Pyth (13). :-)
Toby Speight,

1

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;

0

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);
    }
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.