Số nguyên nhỏ nhất sau N chia hết cho 2, 3 và 4


22

Cung cấp tín dụng cho người đến hạn .

Mục tiêu Với một số nguyên N > 0, các số nguyên nhỏ nhất A, BCdo đó:

  1. Tất cả A, BClà nghiêm chỉnh lớn hơn N;
  2. 2chia A;
  3. 3chia B;
  4. 4chia C.

Đây là một môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng. Bạn có thể sử dụng một ngôn ngữ được tạo / cập nhật sau thử thách này, nhưng nó hoàn toàn không cạnh tranh.

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

N => A, B, C
1 => 2, 3, 4
4 => 6, 6, 8
43 => 44, 45, 44
123 => 124, 126, 124
420 => 422, 423, 424
31415 => 31416, 31416, 31416
1081177 => 1081178, 1081179, 1081180

Chúng ta có thể (nhất quán) xuất kết quả theo một thứ tự khác (ví dụ C B A) nếu nó được chỉ định rõ ràng trong câu trả lời không?
Martin Ender

@ MartinBüttner chấp nhận được
Conor O'Brien

Câu trả lời:


17

Thạch , 8 byte

~%2r4¤+‘

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

~%2r4¤+‘  Main link. Argument: n (integer)

~         Bitwise NOT; yield ~n = -(n + 1).
     ¤    Combine the three links to the left into a niladic chain:
  2         Yield 2.
   r4       Yield the range from 2 to 4, i.e., [2, 3, 4].
 %        Yield the remainder of the division of ~n by 2, 3 and 4.
          In Python/Jelly, -(n + 1) % k = k - (n + 1) % k if n, k > 0.
       ‘  Yield n + 1.
      +   Add each modulus to n + 1.

26

Python 2, 32 byte

lambda n:[n+2&-2,n/3*3+3,n+4&-4]

Số học bit cho 2 và 4, số học mô-đun cho 3.

Tôi đã tìm thấy bốn biểu thức 7 byte cho bội số tiếp theo kở trên nnhưng không ngắn hơn:

n-n%k+k
~n%k-~n
n/k*k+k
~n/k*-k

Bất kỳ cung cấp 34 byte khi sao chép k=2,3,4và 33 byte nếu được kết hợp:

[n/2*2+2,n/3*3+3,n/4*4+4]
[n/k*k+k for k in 2,3,4]

Nhưng, 2 và 4 là lũy thừa của 2 cho phép các thủ thuật bit loại bỏ 1 hoặc 2 byte cuối cùng.

n+2&-2
n+4&-4

Điều này cung cấp 6 byte (thay vì 7) để lấy bội số tiếp theo, cho tổng số 32 byte, đánh bại for k in 2,3,4.

Thật không may, giao diện đầy hứa hẹn n|1+1n|3+1được thực hiện bổ sung trước, vì vậy việc tăng sản lượng sẽ có dấu ngoặc đơn.


1
Trong số các biến thể có thể, sở thích của tôi là cho n+k-n%k.
Neil

Làm n&3+1bổ sung đầu tiên quá?
Tim

@Tim Yup, giống với tất cả các hoạt động boolean.
xnor


12

MATL, 15 10 9 byte

2:4+t5M\-

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

Giải trình:

2:4          #The array [2, 3, 4]
   +         #Add the input to each element, giving us [12, 13, 14]
    t        #Duplicate this array
     5M      #[2, 3, 4] again
       \     #Modulus on each element, giving us [0, 1, 2]
        -    #Subtract each element, giving us [12, 12, 12]

3
Câu trả lời tốt đẹp! Bạn có thể lưu một byte bằng cách sử dụng 5M(bảng tạm tự động của các đầu vào chức năng) thay vì thứ hai 2:4.
David

@David Cảm ơn vì tiền boa!
DJMcMayhem

12

MATL, 8 byte

Qt_2:4\+

Sử dụng thuật toán Jelly của Denis, tôi ngạc nhiên khi nó có cùng độ dài!

Hãy thử trực tuyến , hoặc, xác minh tất cả các trường hợp thử nghiệm .

Q    % takes implicit input and increments by one
t_   % duplicate, and negate top of stack (so it's -(n+1))
2:4  % push vector [2 3 4]
\    % mod(-(n+1),[2 3 4])
+    % add result to input+1
     % implicit display

Vâng chết tiệt. Tôi thực sự tự hào về giải pháp 10 byte của mình, nhưng tôi không thể đánh bại điều này. Ngoài ra, câu đố vui: Đây chính xác là phiếu bầu thứ 300 của tôi. = D
DJMcMayhem

À nhưng đây chỉ là thuật toán của Agawa / Dennis, đó không phải là ý tưởng của riêng tôi.
David

1
đôi khi tôi cứ nhìn chằm chằm vào những nhân vật cơ bản mandarinoid trong khi gãi đầu sau đó tôi nói "vì mọi thứ có thể đọc được là một mã có thể chạy được"? lol điều tốt đẹp có upvote của tôi + tôi sẽ tham gia matl train sooon.
Abr001am

@ Agawa001 Bạn nên! Được biết cách của bạn xung quanh Matlab khá tốt, bạn sẽ thấy nó khá đơn giản, sự khác biệt lớn là dựa trên ngăn xếp của MATL. Cũng có một phòng chat MATL nếu bạn cần bất kỳ sự giúp đỡ nào!
David

@David rằng bản chất dựa trên bánh kếp của matl làm cho nó trở nên xấu xa hơn đáng sợ khi biết rằng bản thân matlab thô là một ngôn ngữ thân thiện với golf về khả năng tương tác cấp cao của nó, vì vậy hãy tưởng tượng ....
Abr001am 17/05/2016

6

Matlab, 33 byte

Một cách tiếp cận khác

@(a)feval(@(x)a+1+mod(-a-1,x),2:4)

6

05AB1E , 8 byte

Mã số:

>D(3L>%+

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


À, không nhận thấy đã có câu trả lời 05AB1E khá giống với câu trả lời của tôi. Tôi đã xóa nó và thay vào đó sẽ đề xuất nó như một sân golf -1: ±D2xŸ%α( 2xŸđây chỉ là một giải pháp thay thế cho bạn 3L>; và hai lựa chọn thay thế bằng byte khác có thể Ƶ…Shoặc 4L¦).
Kevin Cruijssen

5

Ruby, 27 byte

Bản đồ 2, 3 và 4 cho nhiều mục tiếp theo ở trên n.

->n{(2..4).map{|e|n+e-n%e}}



4

Toán học, 21 byte

Ceiling[#+1,{2,3,4}]&

Đây là một hàm không tên, lấy một số nguyên làm đầu vào và trả về một danh sách các bội số.

Các Ceilingchức năng phải mất một tham số tùy chọn thứ hai mà nói với nó để làm tròn lên đến nhiều tiếp theo của số cho sẵn. Rất may, nó cũng tự động xử lý các đối số thứ hai của nó để chúng ta có thể cung cấp cho nó một danh sách các giá trị và đến lượt chúng ta sẽ làm tròn bội số cho tất cả các giá trị đó.


4

Octave, 20 byte

@(n)n-mod(n,d=2:4)+d

Ví dụ:

octave:60> f(123)
ans =

   124   126   124

octave:61> f(1081177)
ans =

   1081178   1081179   1081180

octave:62> f(420)
ans =

   422   423   424

Đáng lưu ý rằng chúng ta có thể làm điều này tới 9 mà không cần thêm bất kỳ byte nào:

@(n)n-mod(n,d=2:9)+d

Đầu ra (2520 là số nguyên dương nhỏ nhất chia hết cho tất cả các số có một chữ số):

octave:83> f(2520)
ans =

   2522   2523   2524   2525   2526   2527   2528   2529


4

Mê cung , 19 byte

:?
:
#/)
\ #
!"*@
"

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

Điều này xuất ra các kết quả theo thứ tự được C, B, Aphân tách bằng các nguồn cấp.

Giải trình

Như thường lệ, một đoạn mồi Labyrinth ngắn:

  • Labyrinth có hai ngăn xếp các số nguyên tùy ý chính xác, chínhaux (iliary), được điền ban đầu với một (ngầm) số lượng vô hạn các số không. Chúng tôi sẽ chỉ sử dụng chính cho câu trả lời này.
  • Mã nguồn giống như một mê cung, trong đó con trỏ lệnh (IP) đi theo hành lang khi nó có thể (thậm chí quanh các góc). Mã bắt đầu ở ký tự hợp lệ đầu tiên theo thứ tự đọc, tức là ở góc trên cùng bên trái trong trường hợp này. Khi IP đến bất kỳ hình thức giao nhau nào (tức là một số ô liền kề ngoài một ô mà nó xuất phát), nó sẽ chọn một hướng dựa trên đỉnh của ngăn xếp chính. Các quy tắc cơ bản là: rẽ trái khi âm, tiếp tục đi về phía trước khi số 0, rẽ phải khi dương. Và khi một trong những điều này là không thể bởi vì có một bức tường, thì IP sẽ đi theo hướng ngược lại. IP cũng quay vòng khi nhấn vào ngõ cụt.

Mặc dù hai không-op (" ) làm cho bố cục có vẻ hơi lãng phí, tôi khá hài lòng với giải pháp này, bởi vì luồng điều khiển của nó thực sự khá tinh tế.

IP bắt đầu ở góc trên cùng bên trái ở :bên phải. Nó sẽ ngay lập tức đi vào ngõ cụt ?và quay lại, để chương trình thực sự bắt đầu với đoạn mã tuyến tính này:

:   Duplicate top of main stack. This will duplicate one of the implicit zeros
    at the bottom. While this may seem like a no-op it actually increases
    the stack depth to 1, because the duplicated zero is *explicit*.
?   Read n and push it onto main.
:   Duplicate.
:   Duplicate.

Điều đó có nghĩa là bây giờ chúng tôi đã có ba bản sao ntrên ngăn xếp chính, nhưng độ sâu của nó là 4. Điều đó thuận tiện vì điều đó có nghĩa là chúng ta có thể lấy chiều sâu ngăn xếp để lấy hệ số nhân hiện tại trong khi làm việc thông qua các bản sao của đầu vào.

Bây giờ IP đi vào một vòng 3x3 (theo chiều kim đồng hồ). Lưu ý rằng #, việc đẩy độ sâu ngăn xếp, sẽ luôn đẩy giá trị dương sao cho chúng ta biết IP sẽ luôn quay về hướng đông tại thời điểm này.

Cơ thể vòng lặp là thế này:

#   Push the stack depth, i.e. the current multiplier k.
/   Compute n / k (rounding down).
)   Increment.
#   Push the stack depth again (this is still k).
*   Multiply. So we've now computed (n/k+1)*k, which is the number
    we're looking for. Note that this number is always positive so
    we're guaranteed that the IP turns west to continue the loop.
"   No-op.
!   Print result. If we've still got copies of n left, the top of the 
    stack is positive, so the IP turns north and does another round.
    Otherwise, see below...
\   Print a linefeed.
    Then we enter the next loop iteration.

Sau khi vòng lặp được duyệt qua (tối đa !) ba lần, tất cả các bản sao nđược sử dụng hết và số 0 bên dưới được tiết lộ. Bởi vì" ở phía dưới (mà mặt khác có vẻ khá vô dụng), vị trí này là một ngã ba. Điều đó có nghĩa là với số 0 trên đỉnh của ngăn xếp, IP cố gắng đi thẳng về phía trước (phía tây), nhưng vì có một bức tường, nó thực sự quay 180 độ và di chuyển về phía đông như thể nó đã đi vào ngõ cụt.

Kết quả là, bit sau đây được thực thi:

"   No-op.
*   Multiply two zeros on top of the stack, i.e. also a no-op.
    The top of the stack is now still zero, so the IP keeps moving east.
@   Terminate the program.

3

Matlab, 50 byte

@(a)arrayfun(@(k)find(~rem(a+1:a+k,k))+a,[2 3 4])

Ít nhất, bạn có thể sử dụng 2:4thay vì [2 3 4].
Suever


3

JavaScript (ES6), 26 byte

Điều thú vị là chuyển câu trả lời @ KevinLau Ruby hoặc câu trả lời Python của @ xnor có cùng độ dài:

n=>[2,3,4].map(d=>n+d-n%d)
n=>[n+2&-2,n+3-n%3,n+4&-4]

Tôi có một sở thích nhẹ cho cổng của câu trả lời Ruby như nó hoạt động lên đến 2 53 -3 trong khi cổng của câu trả lời Python chỉ hoạt động lên đến 2 ngày 31 -5.


)-> ]như tôi nghĩ
Qwertiy

@Qwertiy Rất tiếc, xin lỗi vì lỗi đánh máy.
Neil

3

C, 50 46 byte

i;f(int*a,int n){for(i=1;++i<5;*a++=n+i-n%i);}

Cảm ơn Neil và nwellnhof vì đã tiết kiệm 4 byte!

Thất vọng dài. Tôi cảm thấy như có một số hack thay đổi ở đây mà tôi không biết, nhưng tôi chưa thể tìm thấy nó. Trả về một con trỏ tới một mảng chứa ba phần tử. Chương trình đầy đủ:

i;f(int*a,int n){for(i=1;++i<5;*a++=n+i-n%i);}

int main()
{
    int array[3];
    int n=10;
    f(array, n);
    printf("A:%d\tB:%d\tC:%d\n",array[0],array[1],array[2]);
    return 0;
}

Tôi đã xem xét twiddling của @ xnor nhưng bạn cần hủy kiểm soát vòng lặp để kết thúc chi phí cho bạn một byte tổng thể.
Neil

Không n + i - n % i++dẫn đến hành vi không xác định?
nwellnhof

Ngoài ra s/a[i-2]/*a++/để tiết kiệm hai byte.
nwellnhof

@nwellnhof Bah, tôi đã nghĩ đến điều đó khi tôi không kiểm soát vòng lặp của anh ấy nhưng điều đó không xảy ra với tôi rằng anh ấy có thể sử dụng nó bằng mọi cách.
Neil

2
@Neil Nhưng hành vi không xác định có thể được xử lý xung quanh mà không làm cho mã lớn hơn. Đây là phiên bản thậm chí còn ngắn hơn bằng cách sử dụng khai báo hàm K & R:f(a,n,i)int*a;{for(i=1;++i<5;)*a++=n+i-n%i;}
nwellnhof

3

Reng, 40 byte

i1+#i2341ø>(1+)31j
i(2[¤,  q!^$]æl0eq!~

1: init

i1+#i2341ø

i1+#iđặt đầu vào thành 1 + input; điều này là do chúng ta phải làm việc với những con số lớn hơn đầu vào. 234khởi tạo băng với các giá trị lặp của chúng tôi và nhảy đến đầu dòng tiếp theo.

2a: vòng lặp

i(2[¤,  q!^$]æl0eq!~

i(đặt đầu vào ở STOS và 2[tạo một ngăn xếp mới với 2 phần tử hàng đầu.¤nhân đôi ngăn xếp, và ,không mô đun. Nếu có một phần còn lại, q!^thoát ra khỏi vòng lặp để đi đến (b). Nếu không, chúng tôi ổn để in. $loại bỏ những thứ thừa thãi, ]đóng ngăn xếp và æin nó một cách độc đáo. l0wq!~chấm dứt iff ngăn xếp chứa không thành viên.

2b: vòng lặp khác

          >(1+)31j
        q!^

(1+)thêm 1 vào STOS và 31jnhảy vào phần của vòng lặp không lấy nội dung từ ngăn xếp. Và lợi nhuận.


Khoảng trắng thêm đó thực sự làm phiền tôi. Chụp ảnh GIF

REENNNNNGGG


3

Võng mạc, 62 43 26 byte

17 byte nhờ @Martin Büttner .

^
1111:
M! & `(11 +): (\ 1 *)
:

(Lưu ý dòng mới.)

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

Đầu vào trong unary in 1, đầu ra trong unary trong 1phân tách bằng dòng mới.

Phiên bản 43 byte trước:

.+
11:$&;111:$&;1111:$&
\b(1+):(\1*)1*
$1$2

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

Đầu vào trong unary, đầu ra trong unary được phân tách bằng dấu chấm phẩy ( ;).

Phiên bản 62 byte trước:

.+
$&11;$&111;$&1111
((11)+)1*;((111)+)1*;((1111)+)1*
$1;$3;$5

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

Đầu vào trong unary, đầu ra trong unary được phân tách bằng dấu chấm phẩy ( ;).


26 nếu đầu ra theo thứ tự ngược lại được cho phép: retina.tryitonline.net/ mài ... Nếu không thì 33 mặc dù tôi nghĩ rằng phải có một cách ngắn hơn để tránh sắp xếp ngược lại: retina.tryitonline.net/
Ender

Điều đó đủ để đủ điều kiện là một câu trả lời riêng biệt?
Nữ tu bị rò rỉ

Tôi không biết, đó vẫn là ý tưởng tương tự, tôi chỉ thay thế việc tạo danh sách theo cách thủ công bằng cách sử dụng các kết quả trùng lặp.
Martin Ender

Conor xác nhận rằng giải pháp 26 byte là hợp lệ.
Martin Ender

3

Octave, 27 22 20 byte

MATLAB và Octave:

f=2:4;@(x)f.*ceil((x+1)./f)

Tốt hơn (các giải pháp là tương đương, nhưng một giải pháp có thể vượt trội so với giải pháp khác khi chơi gôn tiếp theo), MATLAB và Octave:

@(x)x-rem(x,2:4)+(2:4)
f=2:4;@(x)x+f-rem(x,f)

Chỉ trong Octave:

@(x)x-rem(x,h=2:4)+h

Hãy thử ở đây .


Câu trả lời cuối cùng của tôi là cơ bản mà ai ở đây :( codegolf.stackexchange.com/a/80028/52795
BERs



2

Toán học 28 byte

f@n_:=n-n~Mod~#+#&/@{2,3,4}

f[1]
f[4]
f[43]
f[123]
f[420]
f[31415]
f[1081177]

{2, 3, 4}

{6, 6, 8}

{44, 45, 44}

{124, 126, 124}

{422, 423, 424}

{31416, 31416, 31416}

{1081178, 1081179, 1081180}


Trường hợp chung tạo ra một câu trả lời chung:

f[r]

{2 + r - Mod [r, 2], 3 + r - Mod [r, 3], 4 + r - Mod [r, 4]}


2

R, 30 26 byte

(Giảm 4 byte nhờ @Neil)

N=scan();cat(N+2:4-N%%2:4)

Điều này (tương tự với phần còn lại của câu trả lời tôi đoán) thêm 2: 4 vào đầu vào và phần còn lại giảm sau khi chạy modulo trên cùng một số.


1
Vì tôi không biết ngôn ngữ, có lý do gì bạn không sử dụng N+2:4-N%%2:4không?
Neil

@Neil Vì tôi không nghĩ về nó. Cảm ơn mặc dù.
David Arenburg


2

Java 70 57

a->System.out.print(a/2*2+2+" "+(a/3*3+3)+" "+(a/4*4+4))

Tôi không biết Java, nhưng có lẽ bạn có thể xóa khoảng trắng xung quanh =trongint a = new Integer(z[0]);
Conor O'Brien


1

Trên thực tế, 22 byte

╗52x"╝1`;╛@%Y@╜<*`╓"£M

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

Sự thật thú vị: 3 lỗi trong trình thông dịch Trên thực tế đã được tìm thấy và sửa trong khi viết chương trình này.

Thực tế không vui lắm: 3 lỗi đó đã ngăn giải pháp này ngắn hơn nhiều.

Giải trình:

╗52x"╝1`;╛@%Y@╜<*`╓"£M
╗                       push input to reg0
 52x                    push range(2,5) ([2,3,4])
    "╝1`;╛@%Y@╜<*`╓"£M  map (for n in [2,3,4]):
     ╝                    push n to reg1
      1`;╛@%Y@╜<*`╓       find the smallest integer k where:
        ;╛@%Y               k is divisible by n and...
             @╜<*           is greater than the input

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.