Divisible séquentiellement

24

Parfois, pour m'endormir, je compterai aussi haut que possible, tout en sautant les nombres qui ne sont pas sans carré . Je ressens un peu de frisson quand je peux sauter plusieurs chiffres d'affilée - par exemple, ils ne 48,49,50sont PAS tous sans carré (48 est divisible par 2 ^ 2, 49 par 7 ^ 2 et 50 par 5 ^ 2).

Cela m'a amené à m'interroger sur le premier exemple de nombres adjacents divisibles par une séquence arbitraire de diviseurs.

Contribution

L'entrée est une liste ordonnée a = [a_0, a_1, ...]d'entiers strictement positifs contenant au moins 1 élément.

Sortie

La sortie est le plus petit entier positif navec la propriété qui a_0divise n, a_1divise n+1et plus généralement a_kdivise n+k. S'il n'en nexiste pas, le comportement de la fonction / du programme n'est pas défini.

Cas de 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

Notation

C'est du golf de code ; le résultat le plus court (par langue) gagne des droits de vantardise. Les failles habituelles sont exclues.

code-golf 
— Chas Brown
source
— alephalpha

Réponses:

6

Husk , 7 octets

VδΛ¦⁰ṫN

Essayez-le en ligne!

Explication

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
source
5

MATL , 11 octets

`Gf@q+G\a}@

Essayez-le en ligne!

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

Pas exactement optimisé pour la vitesse ... le plus grand cas de test prend une minute entière en utilisant MATL, et environ 0,03 s sur MATLAB. Il y a une petite possibilité que MATL ait un peu plus de surcharge.

— Sanchises
source
ah, j'avais n:q`QtG\a]1)12 octets mais n:c'est évidemment le même fqu'ici. J'oublie toujours cela, vous pouvez donc l'ajouter comme alternative à 11 octets.
— Giuseppe
1
@Giuseppe Too bad fq`QtG\a}@renvoie une copie superflue de l'entrée.
— Sanchises
5

JavaScript, 42 40 octets

Lance une erreur de récursivité s'il n'y a pas de solution (ou si la solution est trop grande).

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

Enregistré 2 octets avec un pointeur de Rick Hitchcock

Essayez-le

Entrez une liste de nombres séparés par des virgules.

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>
Développer l'extrait

— Hirsute
source
Approche Nice, mais ne en dépassant les limites de récursion avec, par exemple, [4,9,25,49].
— Chas Brown
1
@ChasBrown, aux fins du code golf, nous pouvons supposer une mémoire infinie.
— Shaggy
Je pense que cela fonctionnera pour 38 octets: (a,y=n=0)=>a.some(x=>y++%x)?f(a,++n):n
— Rick Hitchcock
Oo, chouette, @RickHitchcock - merci. N'oubliez pas le f=, cependant.
— Shaggy
Ah, bien sûr. C'est 40 octets.
— Rick Hitchcock
3

05AB1E , 9 octets

Xµā<N+sÖP

Essayez-le en ligne!

Explication

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
source
Démolit ma réponse de 17 octets, aïe.
— Urne de poulpe magique
3

Pyth , 11 octets

f!s.e%+kTbQ

Essayez-le en ligne!

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
source
Avez-vous besoin du 2à la fin? Je suis sûr qu'il y a plus à sauver ici mais je ne connais pas Pyth.
— Shaggy
@Shaggy et @Giuseppe, vous avez tous les deux raison, et la suppression de la fin 2corrige le problème
— Dave
2

J , 23 octets

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

Essayez-le en ligne!

— Galen Ivanov
source
Agréable. Quel est le fait mathématique qui vous permet de vérifier uniquement le produit des entrées? Comment savons-nous qu'il ne peut y avoir de solution au-delà de cela? De plus, comment savons-nous I.qu'il ne renverra qu'un seul résultat? N'est-il pas possible qu'il y en ait plusieurs?
— Jonah
1
@Jonah - Je ne sais pas si cela fonctionne toujours; juste tous les tests que j'ai faits étaient dans ces limites.
— Galen Ivanov
2

R , 51 octets

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

Essayez-le en ligne!

L'utilisation de anyjette des kavertissements sur la conversion implicite vers logical, où kest la valeur de retour.

— Giuseppe
source
— plannapus
@plannapus J'ai considéré cela, mais cela échoue malheureusement l=c(15), car seq(l)==1:ldans ce cas. seqc'est ennuyeux comme ça!
— Giuseppe
arf en effet et puis forcer seq_alongest tout simplement trop long.
— plannapus
Donc, mais en utilisant sumau lieu de anyse débarrasser de ces avertissements, FYI.
— plannapus
2

APL (Dyalog Unicode) , 24 23 22 octets

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

Essayez-le en ligne!

Techniquement, c'est une fonction tacite. J'ai dû le faire car la seule entrée autorisée est la liste des entiers. Utilisations ⎕IO←0(0-indexation)

Il convient de noter que la fonction expire si elle nn'existe pas.

Merci à @ngn et @ H.PWiz pour 1 octet chacun.

Comment?

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

Japt, 10 octets

Sortira éventuellement undefinedsi aucune solution n'existe, si elle ne plante pas d'abord votre navigateur.

@e_X°vZÃ}a

Essayez-le

Explication

               :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?
— Hirsute
source
1

ML standard (MLton) , 96 octets

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

Essayez-le en ligne!

Non 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

Essayez-le en ligne! À partir de n=1, la fonction fincrémente njusqu'à ce que la condition all-c soit remplie, auquel cas elle nest renvoyée.

tabulate(m,g)avec un entier met une fonction gconstruit la liste [g 0, g 1, ..., g m]. Dans notre condition tabulateest appelée avec la longueur de la liste d'entrée let une fonction qui vérifie si le ie élément des ldivisions n+i. Cela donne une liste de booléens, donc allavec la fonction d'identité fn x=>xvérifie si tous les éléments sont vrais.

J'ai trouvé un truc de golf agréable de réduire la fonction d'identité dans ce cas par quatre octets: Au lieu du lambda (fn x=>x), l'accumulation de la fonction hdest utilisée, qui renvoie le premier élément d'une liste, et les bools résultant en tabulatesont enveloppés dans [et ]à créer des listes singleton.

— Laikoni
source
1

PowerShell , 65 62 octets

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

Essayez-le en ligne!

PowerShell n'a pas l'équivalent d'un anyou someou similaire, nous avons donc besoin d'une approche légèrement différente.

Cela prend l'entrée $args[0]comme un tableau, puis entre dans une forboucle infinie . Chaque itération que nous avons définie $opour être 1(expliquée plus loin) et définie $ipour être ++$j. L'incrémentation $jgarde un œil sur le premier numéro de la solution proposée, tandis que l' $iincrémentation sur le reste de la solution proposée.

Nous envoyons ensuite chaque élément de l'entrée $args[0]dans une ForEach-Objectboucle. À l'intérieur de la boucle intérieure, nous multiplions par booléen $ole résultat d'un calcul. Cela fera en sorte que si le calcul échoue pour une valeur, le $odeviendra 0. Le calcul est !($i++%$_), ou le booléen-pas de l'opération modulo. Étant donné que toute valeur non nulle est truthy dans PowerShell, cela transforme tout en une valeur reliquats de Falsey, transformant ainsi $oen 0.

En dehors de la boucle interne, if $on'est pas nul, nous avons trouvé une solution d'incrémentation qui fonctionne, nous avons donc sorti $jet exit.

— AdmBorkBork
source
1

tinylisp , 108 octets

(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 dernière ligne est une fonction lambda sans nom qui prend une liste et retourne un entier. Essayez-le en ligne!

Non 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)))
— DLosc
source
1

Python 2, 78 octets

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 grâce à @Chas Brown

— sonrad10
source
Agréable! J'ai changé votre condition de sortie de boucle et votre idée peut être améliorée pour obtenir 78 octets .
— Chas Brown
@ChasBrown merci, je n'ai pas pensé à le faire de cette façon. Modifié!
— sonrad10
0

APL NARS, 140 octets, 70 caractères

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

tester

  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
source
0

Java 8, 82 75 octets

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

Explication:

Essayez-le en ligne.

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
source
0

Rubis , 47 46 43 42 octets

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

Essayez-le en ligne!

NB: la (1..)syntaxe n'est supportée que dans ruby ​​2.6, pour l'instant TIO ne supporte que 2.5 donc le lien est vers une version plus ancienne (43 octets).

— Asone Tuhid
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.