Thỉnh thoảng để ngủ, tôi sẽ tính cao nhất có thể, trong khi bỏ qua những con số không vuông . Tôi có một chút hồi hộp khi tôi bỏ qua nhiều số liên tiếp - ví dụ, 48,49,50tất cả đều KHÔNG vuông góc (48 chia hết cho 2 ^ 2, 49 cho 7 ^ 2 và 50 cho 5 ^ 2).

Điều này khiến tôi băn khoăn về ví dụ sớm nhất về các số liền kề chia hết cho một số ước số tùy ý.

Đầu vào

Đầu vào là một danh sách theo thứ tự a = [a_0, a_1, ...]các số nguyên dương hoàn toàn chứa ít nhất 1 phần tử.

Đầu ra

Đầu ra là số nguyên dương nhỏ nhất nvới thuộc tính a_0chia n, a_1chia n+1và a_kchia chung hơn n+k. Nếu không có như vậy n, hành vi của chức năng / chương trình không được xác định.

Các trường hợp thử nghiệm

[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

Chấm điểm

Đây là môn đánh gôn ; kết quả ngắn nhất (theo ngôn ngữ) giành được quyền khoe khoang. Các sơ hở thông thường được loại trừ.

Ngôn ngữ Wolfram (Mathicala) , 51 byte

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

Hãy thử trực tuyến!

Husk , 7 byte

VδΛ¦⁰ṫN

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

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

Không được tối ưu hóa chính xác cho tốc độ ... bản thử nghiệm lớn nhất mất toàn bộ thời gian sử dụng MATL và khoảng 0,03 giây trên MATLAB. Có một khả năng nhỏ MATL có thêm một chút chi phí.

JavaScript, 42 40 byte

Sẽ ném một lỗi đệ quy nếu không có giải pháp (hoặc giải pháp quá lớn).

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

Đã lưu 2 byte với một con trỏ từ Rick Hitchcock

Thử nó

Nhập một danh sách các số được phân tách bằng dấu phẩy.

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)

Hãy thử trực tuyến!

05AB1E , 9 byte

Xµā<N+sÖP

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

Chỉnh sửa: -1 byte nhờ nimi!

Sạch , 61 byte

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

Hãy thử trực tuyến!

Bình thường , 11 byte

f!s.e%+kTbQ 

Hãy thử trực tuyến!

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.*/

Hãy thử trực tuyến!

R , 51 byte

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

Hãy thử trực tuyến!

Việc sử dụng các cảnh báo anyném kvề chuyển đổi ngầm định logical, kgiá trị trả về ở đâu.

Perl 6 , 34 byte

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

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 24 23 22 byte

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

Hãy thử trực tuyến!

Về mặt kỹ thuật, đây là một chức năng ngầm. Tôi phải làm như vậy vì đầu vào duy nhất được phép là danh sách các số nguyên. Sử dụng ⎕IO←0(lập chỉ mục 0)

Điều đáng chú ý là hàm sẽ hết thời gian nếu nkhông tồn tại.

Cảm ơn @ngn và @ H.PWiz cho mỗi 1 byte.

Làm sao?

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

Hãy thử trực tuyến!

Japt, 10 byte

Cuối cùng sẽ xuất ra undefinednếu không có giải pháp nào tồn tại, nếu nó không làm sập trình duyệt của bạn trước.

@e_X°vZÃ}a

Thử nó

Giải trình

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

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

ML chuẩn (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;

Hãy thử trực tuyến!

Ung dung:

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

Hãy thử trực tuyến! Bắt đầu với n=1, hàm ftăng dần ncho đến khi allhoàn thành điều kiện, trong trường hợp nnày được trả về.

tabulate(m,g)với một số nguyên mvà hàm gxây dựng danh sách [g 0, g 1, ..., g m]. Trong điều kiện của chúng tôitabulate được gọi với độ dài của danh sách đầu vào lvà một hàm kiểm tra xem iphần tử thứ lchia n+i. Điều này mang lại một danh sách các booleans, vì vậy allvới hàm nhận dạng fn x=>xkiểm tra xem tất cả các phần tử có đúng không.

Tôi đã tìm thấy một mẹo chơi golf hay để rút ngắn chức năng nhận dạng trong trường hợp này bằng bốn byte: Thay vì lambda (fn x=>x), hàm dựng sẵn hdđược sử dụng, trả về phần tử đầu tiên của danh sách và các bool kết quả tabulateđược bọc trong[ và ]để tạo danh sách đơn.

PowerShell , 65 62 byte

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

Hãy thử trực tuyến!

PowerShell không có tương đương với anyhoặcsome tương tự, vì vậy chúng tôi cần một cách tiếp cận hơi khác.

Điều này nhận đầu vào $args[0]như một mảng, sau đó đi vào một forvòng lặp vô hạn . Mỗi lần lặp chúng ta thiết lập $ođược 1(giải thích sau), và thiết lập $iđược ++$j. Gia số $jgiữ các tab về số đầu tiên của giải pháp được đề xuất là gì, trong khi mức $ităng sẽ so với phần còn lại của giải pháp được đề xuất.

Sau đó chúng tôi gửi từng phần tử của đầu $args[0]vào thành một ForEach-Objectvòng lặp. Trong vòng lặp bên trong, chúng tôi nhân Boolean vào $okết quả của phép tính. Điều này sẽ làm cho nó để nếu tính toán thất bại cho một giá trị, $onó sẽ chuyển sang 0. Tính toán là !($i++%$_), hoặc Boolean - không phải của phép toán modulo. Vì bất kỳ giá trị khác nào là trung thực trong PowerShell, điều này biến mọi phần còn lại thành giá trị falsey, do đó biến$o thành 0.

Bên ngoài vòng lặp bên trong, if $olà khác không, chúng tôi đã tìm thấy một giải pháp gia tăng hoạt động, vì vậy chúng tôi xuất ra $jvà 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

Dòng cuối cùng là một hàm lambda không tên, lấy danh sách và trả về một số nguyên. Hãy thử trực tuyến!

Bị đánh cắp

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

Hãy thử trực tuyến!

Các đầu vào không có solutiosn hợp lệ sẽ gây ra vòng lặp vô hạn ... :)

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 nhờ @Chas Brown

Thạch , 10 byte

1Ḷ+$ọ¥Ạ¥1#

Hãy thử trực tuyến!

APL NARS, 140 byte, 70 ký tự

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

kiểm tra

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

Giải trình:

Hãy thử trực tuyến.

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 byte

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

Hãy thử trực tuyến!

NB: (1..)cú pháp chỉ được hỗ trợ trong ruby ​​2.6, hiện tại TIO chỉ hỗ trợ 2.5 nên liên kết là phiên bản cũ hơn (43 byte).