A volte per addormentarmi, conto più in alto che posso, saltando i numeri che non sono quadrati liberi . Provo un po 'di brivido quando riesco a saltare più numeri di fila - per esempio, 48,49,50NON sono tutti quadrati (48 è divisibile per 2 ^ 2, 49 per 7 ^ 2 e 50 per 5 ^ 2).

Questo mi ha portato a chiedermi quale sia il primo esempio di numeri adiacenti divisibili per una sequenza arbitraria di divisori.

Ingresso

L'input è un elenco ordinato a = [a_0, a_1, ...] di numeri interi assolutamente positivi contenente almeno 1 elemento.

Produzione

L'output è il numero intero positivo più piccolo ncon la proprietà che a_0divide n, a_1divide n+1e più in generale a_kdivide n+k. In caso contrarion esiste, il comportamento della funzione / del programma non è definito.

Casi test

[15] -> 15
[3,4,5] -> 3
[5,4,3] -> 55
[2,3,5,7] -> 158
[4,9,25,49] -> 29348
[11,7,5,3,2] -> 1518

punteggio

Questo è code-golf ; il risultato più breve (per lingua) vince i diritti di vantarsi. Le solite scappatoie sono escluse.

Wolfram Language (Mathematica) , 51 byte

Mod[ChineseRemainder[1-Range@Length@#,#],LCM@@#,1]&

Provalo online!

Buccia , 7 byte

VδΛ¦⁰ṫN

Provalo online!

Spiegazione

VδΛ¦⁰ṫN  Input is a list x.
      N  The list [1,2,3...
     ṫ   Tails: [[1,2,3...],[2,3,4...],[3,4,5...]...
V        Index of first tail y satisfying this:
  Λ       Every element
    ⁰     of x
   ¦      divides
 δ        the corresponding element of y.

MATL , 11 byte

`Gf@q+G\a}@

Provalo online!

`           % Do ....
 Gf         %   Convert input to [1,2,...,]
   @q+      %   Add current iteration index minus one, to get [n, n+1, ....]
      G\    %   Elementwise mod([n,n+1,...],[a_0,a_1,...])
        a   % ...while any of the modular remainders is nonzero.
         }  % Finally:
          @ %   Output the iteration index.

Non esattamente ottimizzato per la velocità ... il testcase più grande impiega un minuto intero usando MATL e circa 0,03 secondi su MATLAB. C'è una piccola possibilità che MATL abbia un po 'più di costi generali.

JavaScript, 42 40 byte

Genererà un errore di ricorsione se non c'è soluzione (o se la soluzione è troppo grande).

a=>(g=y=>a.some(x=>y++%x)?g(++n):n)(n=1)

Salvato 2 byte con un puntatore da Rick Hitchcock

Provalo

Immettere un elenco di numeri separato da virgole.

o.innerText=(f=
a=>(g=y=>a.some(x=>y++%x)?g(++n):n)(n=1)
)(i.value=[5,4,3]);oninput=_=>o.innerText=f(i.value.split`,`.map(eval))

<input id=i><pre id=o>

Python 3 , 62 byte

f=lambda x,n=1:all(j%k<1for j,k in enumerate(x,n))or-~f(x,n+1)

Provalo online!

05AB1E , 9 byte

Xµā<N+sÖP

Provalo online!

Spiegazione

Xµ          # loop until counter equals 1
  ā         # push range [1 ... len(input)]
   <        # decrement
    N+      # add current iteration index N (starts at 1)
      sÖ    # elementwise evenly divisible by
        P   # product
            # if true, increase counter
            # output N

Haskell , 45 44 byte

f a=[n|n<-[1..],1>sum(zipWith mod[n..]a)]!!0

Provalo online!

Modifica: -1 byte grazie a nimi!

Pulito , 61 byte

import StdEnv
$l=hd[n\\n<-[1..]|and[i/e*e==i\\i<-[n..]&e<-l]]

Provalo online!

Pyth , 11 byte

f!s.e%+kTbQ 

Provalo online!

f!s.e%+kTbQ         Full program - inputs list from stdin and outputs to stdout
f                   First number T such that
   .e     Q         The enumerated mapping over the Input Q
      +kT           by the function (elem_value+T)
     %   b          mod (elem_index)
 !s                 has a false sum, i.e. has all elements 0

J , 23 byte

[:I.0=]+/@:|"1#]\[:i.*/

Provalo online!

R , 51 byte

function(l){while(any((F+1:sum(l|1))%%l))F=F+1
F+1}

Provalo online!

L'uso di anylancia kavvisi sulla conversione implicita in logical, dove kè il valore restituito.

Perl 6 , 34 byte

->\a{first {all ($_..*)Z%%a},^∞}

Provalo online!

APL (Dyalog Unicode) , 24 23 22 byte

{∨/×⍺|⍵+⍳⍴⍺:⍺∇⍵+1⋄⍵}∘1

Provalo online!

Tecnicamente, questa è una funzione tacita. Ho dovuto farlo in quanto l'unico input consentito è l'elenco di numeri interi. Usi ⎕IO←0(indicizzazione 0)

Vale la pena notare che la funzione scade se nnon esiste.

Grazie a @ngn e @ H.PWiz per 1 byte ciascuno.

Come?

{∨/×⍺|⍵+⍳≢⍺:⍺∇⍵+1⋄⍵}∘1 ⍝ Main function. ⍺=input; ⍵=1.
{                   }∘1 ⍝ Using 1 as right argument and input as left argument:
           :            ⍝ If
        ⍳≢⍺             ⍝ The range [0..length(⍺)]
      ⍵+                ⍝ +⍵ (this generates the vector ⍵+0, ⍵+1,..., ⍵+length(⍺))
    ⍺|                  ⍝ Modulo ⍺
   ×                    ⍝ Signum; returns 1 for positive integers, ¯1 for negative and 0 for 0.
 ∨/                     ⍝ Logical OR reduction. Yields falsy iff the elements of the previous vector are all falsy.
            ⍺∇⍵+1       ⍝ Call the function recursively with ⍵+1.
                 ⋄⍵     ⍝ Else return ⍵.

Perl 5 , 49 + 2 ( -pa) = 51 byte

$i=!++$\;($\+$i)%$_&&last,$i++for@F;$i<@F&&redo}{

Provalo online!

Japt, 10 byte

Alla fine verrà emesso undefinedse non esiste alcuna soluzione, se non si blocca prima il browser.

@e_X°vZÃ}a

Provalo

Spiegazione

               :Implicit input of array U
@       }a     :Loop and output the first integer X that returns true.
 e_    Ã       :For every element Z in U
   X°          :X, postfix increcemnted
     vZ        :Is it divisible by Z?

Rubino , 48 byte

->l{1+(1..1/0.0).find{|x|l.all?{|y|(x+=1)%y<1}}}

Provalo online!

Python 2 , 80 byte

def f(l,n=1):
 while n:
	n+=1
	if all((n+i)%v<1for i,v in enumerate(l)):return n

Provalo online!

ML standard (MLton) , 96 byte

open List;fun$n% =if all hd(tabulate(length%,fn i=>[1>(n+i)mod nth(%,i)]))then n else$(n+1)%;$1;

Provalo online!

Ungolfed:

open List
fun f n l = 
    if all (fn x=>x)
           (tabulate ( length l
                     , fn i => (n+i) mod nth(l,i) = 0))
    then n 
    else f (n+1) l
val g = f 1

Provalo online! A partire da n=1, la funzione faumenta nfino a quando allnon viene soddisfatta la condizione, nel qual cason viene restituita.

tabulate(m,g)con un numero intero me la funzione gcrea l'elenco [g 0, g 1, ..., g m]. Nella nostra condizione tabulateviene chiamato con la lunghezza della lista di input le una funzione che controlla se l' ielemento th ldivide n+i. Questo produce un elenco di valori booleani, quindi allcon la funzione di identità fn x=>xcontrolla se tutti gli elementi sono veri.

Ho trovato un bel trucco golf per accorciare la funzione identità, in questo caso da quattro byte: invece di lambda (fn x=>x), il build-in funzione hdè usato, che restituisce il primo elemento di una lista, e le Caccio conseguenti tabulatesono avvolti in [e ]per creare elenchi singleton.

PowerShell , 65 62 byte

for(){$o=1;$i=++$j;$args[0]|%{$o*=!($i++%$_)};if($o){$j;exit}}

Provalo online!

PowerShell non ha l'equivalente di uno anyo somesimili, quindi abbiamo bisogno di un approccio leggermente diverso.

Questo prende l'input $args[0]come un array, quindi entra in un forciclo infinito . Ogni iterazione che impostiamo $oper essere 1(spiegata più avanti), e impostata $iper essere ++$j. L'incremento $jtiene traccia di quale sia il primo numero della soluzione proposta, mentre il$i incremento aumenterà rispetto al resto della soluzione proposta.

Quindi inviamo ogni elemento dell'input $args[0]in un ForEach-Objectciclo. All'interno del ciclo interno, moltiplichiamo in booleano $oil risultato di un calcolo. Questo farà sì che se il calcolo fallisce per un valore, $osi trasformerà in 0. Il calcolo è !($i++%$_)o il valore booleano dell'operazione modulo. Poiché qualsiasi valore diverso da zero è vero in PowerShell, ciò trasforma i resti in un valore falso, trasformando così$o in 0.

Al di fuori del ciclo interno, if $oè diverso da zero, abbiamo trovato una soluzione incrementale che funziona, quindi produciamo $je exit.

tinylisp , 108 byte

(load library
(d ?(q((L N)(i L(i(mod N(h L))0(?(t L)(inc N)))1
(d S(q((L N)(i(? L N)N(S L(inc N
(q((L)(S L 1

L'ultima riga è una funzione lambda senza nome che accetta un elenco e restituisce un numero intero. Provalo online!

Ungolfed

(load library)

(comment Function to check a candidate n)
(def sequentially-divisible?
 (lambda (divisors start-num)
  (if divisors
   (if (divides? (head divisors) start-num)
    (sequentially-divisible? (tail divisors) (inc start-num))
    0)
   1)))

(comment Function to check successive candidates for n until one works)
(def search
 (lambda (divisors start-num)
  (if (sequentially-divisible? divisors start-num)
   start-num
   (search divisors (inc start-num)))))

(comment Solution function: search for candidates for n starting from 1)
(def f
 (lambda (divisors)
  (search divisors 1)))

Julia 0.6 , 79 byte

f(s,l=length(s),n=s[])=(while !all(mod.(collect(0:l-1).+n,s).==0);n+=s[];end;n)

Provalo online!

Gli input senza solutiosn validi causeranno un loop infinito ... :)

Python 2, 78 byte

def f(a,c=0):
 while [j for i,j in enumerate(a) if(c+i)%j<1]!=a:c+=1
 return c

EDIT: -26 grazie a @Chas Brown

Gelatina , 10 byte

1Ḷ+$ọ¥Ạ¥1#

Provalo online!

APL NARS, 140 byte, 70 caratteri

r←f w;i;k
i←r←1⊃,w⋄k←¯1+⍴w⋄→0×⍳k=0
A:→0×⍳0=+/(1↓w)∣(k⍴r)+⍳k⋄r+←i⋄→A

test

  f 15
15
  f 3 4 5
3
  f 5 4 3
55
  f 2 3 5 7
158
  f 4 9 25 49
29348
  f 11 7 5 3 2 
1518

Java 8, 82 75 byte

a->{for(int r=1,i,f;;r++){i=f=0;for(int b:a)f+=(r+i++)%b;if(f<1)return r;}}

Spiegazione:

Provalo online.

a->{                 // Method with integer-array parameter and integer return-type
  for(int r=1,       //  Return-integer, starting at 1
          i,         //  Index-integer
          f;         //  Flag-integer
      ;r++){         //  Loop indefinitely, increasing `r` by 1 after every iteration
    i=f=0;           //   Reset both `i` and `f` to 0
    for(int b:a)     //   Inner loop over the input-array
      f+=(r+i++)%b;  //    Increase the flag-integer by `r+i` modulo the current item
    if(f<1)          //   If the flag-integer is still 0 at the end of the inner loop
      return r;}}    //    Return `r` as result

Rubino , 47 46 43 42 byte

->a{(1..).find{|i|a.all?{|v|i%v<1&&i+=1}}}

Provalo online!

NB: la (1..)sintassi è supportata solo in ruby ​​2.6, per il momento TIO supporta solo 2.5, quindi il collegamento è a una versione precedente (43 byte).