Divisível sequencialmente

24

Às vezes, para adormecer, contarei o mais alto que puder, ignorando números que não são quadrados . Fico um pouco emocionado ao pular vários números seguidos - por exemplo, 48,49,50todos NÃO são livres de quadrados (48 é divisível por 2 ^ 2, 49 por 7 ^ 2 e 50 por 5 ^ 2).

Isso me levou a pensar sobre o exemplo mais antigo de números adjacentes divisíveis por alguma sequência arbitrária de divisores.

Entrada

Input é uma lista ordenada a = [a_0, a_1, ...]de números inteiros estritamente positivos contendo pelo menos 1 elemento.

Saída

A saída é o menor número inteiro positivo ncom a propriedade que a_0divide n, a_1divide n+1e mais geralmente a_kdivide n+k. Se não nexistir, o comportamento da função / programa não está definido.

Casos de teste

[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

Pontuação

Isso é código-golfe ; o resultado mais curto (por idioma) ganha direito de se gabar. As brechas usuais são excluídas.

code-golf 
— Chas Brown
fonte
— alephalpha

Respostas:

6

Casca , 7 bytes

VδΛ¦⁰ṫN

Experimente online!

Explicação

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.
— Zgarb
fonte
5

MATL , 11 bytes

`Gf@q+G\a}@

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

Não exatamente otimizado para velocidade ... o maior caso de teste leva um minuto inteiro usando MATL e aproximadamente 0,03s no MATLAB. Há uma pequena possibilidade de o MATL ter um pouco mais de sobrecarga.

— Sanchises
fonte
ah, eu tinha n:q`QtG\a]1)12 bytes, mas n:é obviamente o mesmo que faqui. Eu sempre esqueço disso, então você pode adicioná-lo como um 11 byter alternativo.
— Giuseppe
11
@ Giuseppe Muito ruim fq`QtG\a}@retorna uma cópia estranha da entrada.
— Sanchises
5

JavaScript, 42 40 bytes

Irá gerar um erro de recursão se não houver solução (ou a solução for muito grande).

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

2 bytes salvos com um ponteiro de Rick Hitchcock

Tente

Digite uma lista de números separados por vírgula.

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>
Expandir snippet

— Shaggy
fonte
Boa abordagem, mas falha ao exceder os limites de recursão com, por exemplo [4,9,25,49],.
— quer
11
@ChasBrown, para os propósitos do código golf, podemos assumir memória infinita.
— Salsicha
Eu acho que isso funcionará para 38 bytes: (a,y=n=0)=>a.some(x=>y++%x)?f(a,++n):n
— Rick Hitchcock
Oo, bom, @ RickHitchcock - obrigado. Não esqueça o f=, no entanto.
— Shaggy
Ah, claro. São 40 bytes.
— Rick Hitchcock
3

05AB1E , 9 bytes

Xµā<N+sÖP

Experimente online!

Explicação

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
— Emigna
fonte
Demole minha resposta de 17 bytes, ai.
— Magic Octopus Urn
3

Pitão , 11 bytes

f!s.e%+kTbQ

Experimente 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
— Dave
fonte
Você precisa 2do final? Tenho certeza de que há mais a ser salvo aqui, mas não conheço Pyth.
— Salsicha
@Shaggy e @Giuseppe, tanto de você está certo, e soltando o final 2corrige o problema
— Dave
2

J , 23 bytes

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

Experimente online!

— Galen Ivanov
fonte
Agradável. Qual é o fato matemático que permite verificar apenas o produto das entradas? Como sabemos que não pode haver uma solução além disso? Além disso, como sabemos I.que retornará apenas 1 resultado? Não é possível que haja vários?
— Jonah
11
@ Jonah - não sei se funciona sempre; apenas todos os testes que fiz foram dentro desses limites.
— Galen Ivanov
2

R , 51 bytes

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

Experimente online!

O uso de anylança kavisos sobre conversão implícita para logical, onde ké o valor de retorno.

— Giuseppe
fonte
— plannapus
@ plannapus eu considerei isso, mas infelizmente falha l=c(15), pois seq(l)==1:lnesse caso. seqé chato assim!
— Giuseppe
arf de fato e depois forçar seq_alongé muito longo.
— plannapus
Então, mas usando em sumvez de anyse livrar desses avisos, FYI.
— plannapus
2

APL (Dyalog Unicode) , 24 23 22 bytes

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

Experimente online!

Tecnicamente, essa é uma função tácita. Eu tive que fazê-lo, uma vez que a única entrada permitida é a lista de números inteiros. Usos ⎕IO←0(indexação 0)

Vale a pena notar que a função atinge o tempo limite, se nnão existir.

Obrigado a @ngn e @ H.PWiz por 1 byte cada.

Quão?

{∨/×⍺|⍵+⍳≢⍺:⍺∇⍵+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 ⍵.
— J. Sallé
fonte
1

Japonês, 10 bytes

Eventualmente, produzirá undefinedse não houver solução, se não travar o navegador primeiro.

@e_X°vZÃ}a

Tente

Explicação

               :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?
— Shaggy
fonte
1

ML padrão (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;

Experimente 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

Experimente online! Começando com n=1, a função é fincrementada naté que a allcondição-seja cumprida; nesse caso, né retornada.

tabulate(m,g)com algum número inteiro me função gcria a lista [g 0, g 1, ..., g m]. Em nossa condição tabulateé chamada com o comprimento da lista de entrada le uma função que verifica se o ith elemento de se ldivide n+i. Isso gera uma lista de booleanos, portanto, allcom a função de identidade, fn x=>xverifica se todos os elementos são verdadeiros.

Encontrei um bom truque de golfe para encurtar a função de identidade nesse caso em quatro bytes: em vez do lambda (fn x=>x), hdé usada a função interna, que retorna o primeiro elemento de uma lista, e os bools resultantes tabulatesão agrupados em [e ]para crie listas singleton.

— Laikoni
fonte
1

PowerShell , 65 62 bytes

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

Experimente online!

O PowerShell não tem o equivalente a um anyou algo someparecido, por isso precisamos de uma abordagem ligeiramente diferente.

Isso recebe a entrada $args[0]como uma matriz e entra em um forloop infinito . Cada iteração configurada $opara ser 1(explicada mais adiante) e configurada $ipara ser ++$j. O incremento $jmantém um controle sobre qual é o primeiro número da solução proposta, enquanto o $iincremento será feito sobre o restante da solução proposta.

Em seguida, enviamos cada elemento da entrada $args[0]para um ForEach-Objectloop. Dentro do loop interno, multiplicamos booleanos no $oresultado de um cálculo. Isso fará com que, se o cálculo falhar para um valor, $oele retornará para 0. O cálculo é !($i++%$_), ou o Boolean-not da operação do módulo. Como qualquer valor diferente de zero é verdadeiro no PowerShell, isso transforma qualquer restante em um valor falsey, transformando-o $oem 0.

Fora do loop interno, if $oé diferente de zero, encontramos uma solução incremental que funciona, portanto, produzimos $je exit.

— AdmBorkBork
fonte
1

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

A última linha é uma função lambda sem nome que pega uma lista e retorna um número inteiro. Experimente 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)))
— DLosc
fonte
1

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

EDIT: -26 graças a @Chas Brown

— sonrad10
fonte
Agradável! Eu virei sua condição de saída de loop e sua idéia pode ser aprimorada para obter 78 bytes .
— quer
@ChasBrown obrigado, não pensei em fazer dessa maneira. Changed!
— sonrad10
0

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

teste

  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
— RosLuP
fonte
0

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

Explicação:

Experimente 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
— Kevin Cruijssen
fonte
0

Ruby , 47 46 43 42 bytes

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

Experimente online!

Nota: a (1..)sintaxe é suportada apenas no ruby ​​2.6, no momento o TIO suporta apenas 2.5, portanto o link é para uma versão mais antiga (43 bytes).

— Asone Tuhid
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.