Striscia di divisibilità

31

Possiamo definire la Divisibility Streak kdi un numero ntrovando il numero intero non negativo più piccolo in kmodo che n+knon sia divisibile per k+1.

Sfida

Nella lingua che preferisci, scrivi un programma o una funzione che emetta o restituisca la Divisibility Streak del tuo input.

Esempi:

n=13:
13 is divisible by 1 
14 is divisible by 2 
15 is divisible by 3 
16 is divisible by 4 
17 is not divisible by 5

La Divisibilty Streak di 13è4

n=120:
120 is divisible by 1 
121 is not divisible by 2

La Divisibilty Streak di 120è1

Casi test:

n      DS
2      1
3      2
4      1
5      2
6      1
7      3
8      1
9      2
10     1
2521   10

Altri casi di test sono disponibili qui .

Gli appunti

Regole

  • Si può presumere che l'ingresso sia maggiore di 1.

punteggio

code-golf : vince l'invio con il punteggio più basso.

code-golf  number  division 
— Oliver
fonte
Suggerisco di cambiare "numero intero positivo più piccolo" in "numero intero non negativo più piccolo". Non cambia affatto la sfida, ma con la descrizione attuale, implica che non è necessario verificare la divisibilità per 1 (che tecnicamente non dovremmo aver bisogno). O quello, o potresti rimuovere la divisibilità con 1 assegni dalla descrizione.
— TehPers,
Il numero intero positivo più piccolo è 1 ed k + 1è 2, dove kè il numero intero positivo più piccolo. Ci scusiamo per il nitpick.
— TehPers,
Non è lo stesso di trovare il più piccolo kche non si divide n-1?
— Paŭlo Ebermann,
@ PaŭloEbermann Take n=7where k=3: n-1è divisibile per k.
— Oliver,
Ah, mi mancava il +1.
— Paŭlo Ebermann,

Risposte:

17

Java 8, 44 42 41 39 byte

Cancellato 44 è ancora regolare 44; (

n->{int r=0;for(;~-n%--r<1;);return~r;}

-2 byte grazie a @LeakyNun .
-1 byte grazie a @TheLethalCoder .
-2 byte grazie a @Nevay .

Spiegazione:

Provalo qui.

n->{                 // Method with integer as parameter and return-type
  int r=0;           //  Result-integer (starting at 0)
  for(;~-n%--r<1;);  //  Loop as long as `n-1` is divisible by `r-1`
                     //   (after we've first decreased `r` by 1 every iteration)
  return~r;          //  Return `-r-1` as result integer
}                    // End of method
— Kevin Cruijssen
fonte
1
— Leaky Nun
1
41 byte Ho appena rasato un byte dal suggerimento di LeakyNun.
— TheLethalCoder
2
— Nevay
4

JavaScript (ES6), 28 byte

n=>g=(x=2)=>++n%x?--x:g(++x)

Provalo

o.innerText=(f=

n=>g=(x=2)=>++n%x?--x:g(++x)

)(i.value=2521)();oninput=_=>o.innerText=f(+i.value)()
<input id=i><pre id=o>
Espandi frammento

— ispido
fonte
3

Cubix , 17 byte

)uUqI1%?;)qUO(;/@

Provalo online!

Cubified

    ) u
    U q
I 1 % ? ; ) q U
O ( ; / @ . . .
    . .
    . .
  • I1 imposta lo stack con input e divisore
  • %? fai mod e test
    • ;)qU)uqUse 0 rimuove il risultato e incrementa l'input e il divisore. Un po 'di un giro sul percorso per tornare%
    • /;(O@ se non 0, elimina il risultato, diminuisce il divisore, emette ed esce

Guarda correre

— MickyT
fonte
2

dc , 28 byte

1si[1+dli1+dsi%0=M]dsMxli1-p

Provalo online!

Questo sembra davvero non ottimale, con l'incremento e il decremento finale, ma non riesco davvero a vedere un modo per migliorarlo. Fondamentalmente incrementiamo solo un contatore ie il nostro valore iniziale fintanto che value mod icontinua a essere zero, e una volta che non è vero sottraggiamo uno ie stampiamo.

— brhfl
fonte
2

Gaia , 8 byte

@1Ė₌)†↺(

Provalo online!

Spiegazione

@         Push input (call it n).
 1        Push 1 (call it i).
      ↺   While...
  Ė₌       n is divisible by i:
    )†     Increment both n and i.
       (  Decrement the value of i that failed this test and print.
— Gatto di affari
fonte
2

J, 17 byte

[:{.@I.>:@i.|i.+]

Provalo online!

Penso che ci sia ancora spazio per giocare a golf qui.

Spiegazione (non golfizzato)

[: {.@I. >:@i. | i. + ]
                 i. + ]  Range [n,2n)
                 i.       Range [0,n)
                    +     Added to each
                      ]   n
         >:@i. | i. + ]  Divisibility test
         >:@i.            Range [1,n+1)
               |          Modulo (in J, the arguments are reversed)
                 i. + ]   Range [n,2n)
    {.@I.                Get the index of the first non-divisible
       I.                 Indices of non-zero values
    {.                    Head

Il tappo ( [:) è lì per assicurarsi che J non tratti l'ultimo verbo ( {.@I.) come parte di un hook.

L'unico tipo di cosa strana in questa risposta è che in I.realtà duplica l'indice di ogni numero diverso da zero tutte le volte che il valore di quel numero. per esempio

   I. 0 1 0 2 3
1 3 3 4 4 4

Ma non importa dal momento che vogliamo comunque il primo indice (e dato che i.fornisce un intervallo crescente, sappiamo che il primo indice sarà il valore più piccolo).

Infine, ecco una breve prova che è valido controllare la divisione solo fino a n.

Iniziamo a controllare la divisibilità con 1 | n, quindi supponendo che la serie si spinga così lontano, una volta che avremo verificato la divisibilità per nnoi, n | 2n - 1che non sarà mai vero ( 2n - 1 ≡ n - 1 (mod n)). Pertanto, la serie finirà qui.

— ravizzone
fonte
2

Codice macchina x86, 16 byte

49                 dec    ecx        ; decrement argument
31 FF              xor    edi, edi   ; zero counter

                Loop:
47                 inc    edi        ; increment counter
89 C8              mov    eax, ecx   ; copy argument to EAX for division
99                 cdq               ; use 1-byte CDQ with unsigned to zero EDX
F7 FF              idiv   edi        ; EDX:EAX / counter
85 D2              test   edx, edx   ; test remainder
74 F6              jz     Loop       ; keep looping if remainder == 0

4F                 dec    edi        ; decrement counter
97                 xchg   eax, edi   ; move counter into EAX for return
C3                 ret               ;  (use 1-byte XCHG instead of 2-byte MOV)

La funzione di cui sopra accetta un singolo parametro n, nel ECXregistro. Calcola la sua serie di divisibilità ke la restituisce tramite il EAXregistro. È conforme alla convenzione di chiamata fastcall a 32 bit , quindi è facilmente richiamabile dal codice C utilizzando compilatori Microsoft o Gnu.

La logica è piuttosto semplice: fa solo un test iterativo a partire da 1. È funzionalmente identico alla maggior parte delle altre risposte qui, ma ottimizzato a mano per le dimensioni. Un sacco di istruzioni 1 byte simpatica, tra cui INC, DEC, CDQ, e XCHG. Gli operandi codificati per la divisione ci fanno un po 'male, ma non così terribilmente.

Provalo online!

— Cody Grey
fonte
2

PHP , 34 byte

for(;$argv[1]++%++$r<1;);echo$r-1;

Provalo online!

Abbastanza semplice. Controlla il resto della divisione (mod) ogni ciclo mentre aumenta ogni valore, emette quando il numero non è più divisibile.

— Xanderhall
fonte
1

SOGL V0.12 , 8 byte

]e.-ē⁴I\

Provalo qui!

Non male per una lingua che è fatta per un tipo completamente diverso di sfide.

Spiegazione:

]         do .. while top of the stack is truthy
 e          push the variable E contents, by default user input
  .-        subtract the input from it
    ē       push the value of the variable E and then increase the variable
     ⁴      duplicate the item below one in the stack
      I     increase it
       \    test if divides
            if it does divide, then the loop restarts, if not, outputs POP which is `e-input`
— dzaima
fonte
1

Mathematica, 40 byte

Min@Complement[Range@#,Divisors[#-1]-1]&

Provalo online! (Mathics)

Approccio matematico, n + k è divisibile per k + 1 se e solo se n-1 è divisibile per k + 1. E n-1 non è divisibile per n, quindi Range@#è sufficiente numeri.

Inizialmente ho intenzione di usare Min@Complement[Range@#,Divisors[#-1]]-1&, ma anche questo funziona.

— user202729
fonte
Perché il captcha appare quando uso l'invio da tio?
— user202729
1
Perché l'hai digitato (copiato e incollato) troppo rapidamente. Non si tratta di TIO.
— Leaky Nun,
1

Julia 0.6.0 (47 byte) (38 byte)

n->(i=1;while isinteger(n/i) i+=1;n+=1 end;i-1)

n->(i=1;while n%i<1 i+=1;n+=1end;i-1)

Provalo online!

9 byte sono stati tagliati grazie a Mr.Xcoder

— Goysa
fonte
2
Normalmente un link "Provalo online" consente alle persone di provare effettivamente il codice definendo una combinazione di intestazione, piè di pagina e argomenti, il che significa che premendo il pulsante di riproduzione si ottiene un output.
— Peter Taylor,
@PeterTaylor Per pura ipotesi, ho provato a gestirlo come tale , e con mia sorpresa ha funzionato. Consiglio all'OP di modificarlo con la versione testabile.
— Mr. Xcoder,
46 byte (rimuovendo uno spazio):n->(i=1;while isinteger(n/i) i+=1;n+=1end;i-1)
— Mr. Xcoder
Un'altra ipotesi pura ha permesso di giocare a golf fino a 38 byte:n->(i=1;while n%i<1 i+=1;n+=1end;i-1)
— Mr. Xcoder
@PeterTaylor Siamo spiacenti di averlo dimenticato!
— Goysa,
1

Lotto, 70 byte

@set/an=%1-1,i=0
:l
@set/ai+=1,r=n%%~i
@if %r%==0 goto l
@echo %i%

Tutto ciò che sta facendo è trovare il più grande itale che LCM(1..i)divide n-1.

— Neil
fonte
1

Aceto , 28 27 byte

[;`%
I)@]
iIk2I(D(
rk[(&Xpu

Potrei salvare un byte se non devo uscire.

Spiegazione:

Utilizziamo tre pile: la pila sinistra contiene un contatore che inizia da 2, quella destra contiene il numero dato (o i suoi incrementi), la pila centrale viene utilizzata per eseguire le operazioni del modulo. Ovviamente, potremmo fare tutto in uno stack, ma in questo modo possiamo impostare gli stack esterni in modo che siano "appiccicosi" (i valori che vengono saltati non vengono realmente rimossi) e salviamo molte operazioni di duplicazione. Ecco il metodo in dettaglio:

Leggi un numero intero, incrementalo, rendi lo stack corrente appiccicoso e "spostalo" (e noi stessi) nello stack a sinistra:

iI
rk[

Vai un altro stack a sinistra, spingi letteralmente 2, rendi anche questo stack appiccicoso. Ricorda questa posizione nel codice ( @) e "sposta" di nuovo un valore e noi stessi nello stack centrale.

  @]
  k2
   (

Ora testiamo: il modulo dei primi due numeri non è 0? In tal caso, salta alla fine, altrimenti vai di uno stack a destra, incrementa e spingi il valore e noi al centro. Quindi vai allo stack di sinistra, incrementalo anche tu, e torna indietro al segno che abbiamo impostato in precedenza.

[;`%
I)
    I(
    &

Quando il risultato del modulo non è zero, invertiamo la posizione dell'IP, spostiamo uno stack a sinistra (dove vive il nostro contatore), diminuiamo e stampiamo il valore, quindi usciamo.

      D(
     Xpu
— L3viathan
fonte
1

Rubino, 34 32 31 byte

f=->n,d=1{n%d<1?1+f[n+1,d+1]:0}

Una lambda ricorsiva. Ancora nuovo su Ruby, quindi i suggerimenti sono benvenuti!

Provalo online!

— Yytsi
fonte
1

F #, 86 byte 84 byte

let s n = 
    let rec c n1 d r=if n1%d=0 then c(n1+1)(d+1)(r+1)else r
    c n 1 0

Provalo online!

Modifica: -2 personaggi di Oliver

— Vladislav Khapin
fonte
Benvenuti in PPCG! Il tuo programma prende stdin? Puoi usare TIO , che ha un interprete F # online. Inoltre, è possibile rimuovere gli spazi bianchi in r = if?
— Oliver,
1
@Oliver Grazie, ho cambiato il link in TIO, quindi ora puoi effettivamente passare l'argomento per testarlo. :)
— Vladislav Khapin,
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.