A veces, para conciliar el sueño, cuento lo más alto que puedo, mientras salteo los números que no están libres de cuadrados . Me emociona un poco saltar varios números seguidos, por ejemplo, 48,49,50NO están libres de cuadrados (48 es divisible por 2 ^ 2, 49 por 7 ^ 2 y 50 por 5 ^ 2).

Esto me llevó a preguntarme sobre el primer ejemplo de números adyacentes divisibles por alguna secuencia arbitraria de divisores.

Entrada

La entrada es una lista ordenada a = [a_0, a_1, ...]de enteros estrictamente positivos que contiene al menos 1 elemento.

Salida

La salida es el entero positivo más pequeño ncon la propiedad que a_0divide n, a_1divide n+1y, en general, a_kdivide n+k. Si no nexiste, el comportamiento de la función / programa no está definido.

Casos de prueba

[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

Tanteo

Este es el código de golf ; El resultado más corto (por idioma) gana los derechos de fanfarronear. Se excluyen las lagunas habituales.

Wolfram Language (Mathematica) , 51 bytes

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

Pruébalo en línea!

Casco , 7 bytes

VδΛ¦⁰ṫN

Pruébalo en línea!

Explicación

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 bytes

`Gf@q+G\a}@

Pruébalo en línea!

`           % 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.

No está exactamente optimizado para la velocidad ... el caso de prueba más grande toma un minuto completo usando MATL, y aproximadamente 0.03s en MATLAB. Existe una pequeña posibilidad de que MATL tenga un poco más de sobrecarga.

JavaScript, 42 40 bytes

Lanzará un error de recursión si no hay solución (o si la solución es demasiado grande).

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

Guardado 2 bytes con un puntero de Rick Hitchcock

Intentalo

Ingrese una lista de números separados por comas.

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 bytes

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

Pruébalo en línea!

05AB1E , 9 bytes

Xµā<N+sÖP

Pruébalo en línea!

Explicación

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 bytes

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

Pruébalo en línea!

Editar: -1 byte gracias a nimi!

Limpio , 61 bytes

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

Pruébalo en línea!

Pyth , 11 bytes

f!s.e%+kTbQ 

Pruébalo en línea!

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 bytes

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

Pruébalo en línea!

R , 51 bytes

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

Pruébalo en línea!

El uso de advertencias anyarroja ksobre la conversión implícita a logical, donde kestá el valor de retorno.

Perl 6 , 34 bytes

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

Pruébalo en línea!

APL (Dyalog Unicode) , 24 23 22 bytes

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

Pruébalo en línea!

Técnicamente, esta es una función tácita. Tenía que hacerlo así, ya que la única entrada permitida es la lista de enteros. Usos ⎕IO←0(indexación 0)

Vale la pena señalar que la función agota el tiempo de espera si nno existe.

Gracias a @ngn y @ H.PWiz por 1 byte cada uno.

¿Cómo?

{∨/×⍺|⍵+⍳≢⍺:⍺∇⍵+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 bytes

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

Pruébalo en línea!

Japt, 10 bytes

Eventualmente saldrá undefinedsi no existe una solución, si no bloquea su navegador primero.

@e_X°vZÃ}a

Intentalo

Explicación

               :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?

Ruby , 48 bytes

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

Pruébalo en línea!

Python 2 , 80 bytes

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

Pruébalo en línea!

ML estándar (MLton) , 96 bytes

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

Pruébalo en línea!

Sin golf:

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

Pruébalo en línea! Comenzando con n=1, la función se fincrementa nhasta que allse cumple la condición, en cuyo caso nse devuelve.

tabulate(m,g)con algún entero my función gconstruye la lista [g 0, g 1, ..., g m]. En nuestra condición tabulatese llama con la longitud de la lista de entrada ly una función que verifica si el ielemento th se ldivide n+i. Esto produce una lista de booleanos, por lo que allcon la función de identidad se fn x=>xcomprueba si todos los elementos son verdaderos.

Encontré un buen truco de golf para acortar la función de identidad en este caso en cuatro bytes: en lugar de lambda (fn x=>x), hdse utiliza la función incorporada , que devuelve el primer elemento de una lista, y los bools resultantes tabulatese envuelven en [y ]para crear listas singleton.

PowerShell , 65 62 bytes

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

Pruébalo en línea!

PowerShell no tiene el equivalente de un anyo somesimilar, por lo que necesitamos un enfoque ligeramente diferente.

Esto toma la entrada $args[0]como una matriz, luego ingresa un forbucle infinito . Cada iteración establecemos $oser 1(explicado más adelante) y establecemos $iser ++$j. El incremento $jmantiene pestañas sobre cuál es el primer número de la solución propuesta, mientras que $ise incrementará sobre el resto de la solución propuesta.

Luego enviamos cada elemento de la entrada $args[0]a un ForEach-Objectbucle. Dentro del bucle interno, multiplicamos booleanamente en $oel resultado de un cálculo. Esto hará que si el cálculo falla para un valor, $ose convertirá en 0. El cálculo es !($i++%$_), o el booleano, no de la operación de módulo. Dado que cualquier valor distinto de cero es verdadero en PowerShell, esto convierte cualquier resto en un valor falsey, convirtiéndose así $oen 0.

Fuera del ciclo interno, if $oes distinto de cero, hemos encontrado una solución incremental que funciona, por lo que generamos $jy exit.

tinylisp , 108 bytes

(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

La última línea es una función lambda sin nombre que toma una lista y devuelve un entero. Pruébalo en línea!

Sin golf

(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 bytes

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

Pruébalo en línea!

Las entradas sin una solución válida provocarán bucles infinitos ... :)

Python 2, 78 bytes

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

EDITAR: -26 gracias a @Chas Brown

Jalea , 10 bytes

1Ḷ+$ọ¥Ạ¥1#

Pruébalo en línea!

NARS APL, 140 bytes, 70 caracteres

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

prueba

  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 bytes

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

Explicación:

Pruébalo en línea.

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

Ruby , 47 46 43 42 bytes

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

Pruébalo en línea!

NB: la (1..)sintaxis solo es compatible con ruby ​​2.6, por el momento TIO solo es compatible con 2.5, por lo que el enlace es a una versión anterior (43 bytes).