Berikan kredit kepada siapa kredit harus dibayar .

Tujuan Mengingat integer N > 0, keluar bilangan bulat terkecil A, Bdan Csehingga:

1. Semua A, B, dan Csecara ketat lebih besar dari N;
2. 2membagi A;
3. 3membagi B;
4. dan 4membagi C.

Ini adalah kode-golf, jadi jawaban tersingkat dalam byte menang. Anda dapat menggunakan bahasa yang dibuat / diperbarui setelah tantangan ini, tetapi ini sangat tidak bersaing.

Uji kasus

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

Jelly , 8 byte

~%2r4¤+‘

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

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

Python 2, 32 byte

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

Aritmatika bit untuk 2 dan 4, aritmatika modular untuk 3.

Saya menemukan empat ekspresi 7-byte untuk kelipatan di katas ntetapi tidak ada yang lebih pendek:

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

Apa saja memberi 34 byte saat salinan untuk k=2,3,4, dan 33 byte jika digabungkan:

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

Tapi, 2 dan 4 adalah kekuatan 2 yang memungkinkan sedikit trik untuk nol 1 atau 2 byte terakhir.

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

Ini memberikan 6 byte (bukan 7) untuk mendapatkan kelipatan berikutnya, untuk keseluruhan 32 byte, mengalahkan for k in 2,3,4.

Sayangnya, yang tampak menjanjikan n|1+1dan n|3+1penambahan sudah dilakukan terlebih dahulu, sehingga penambahan output membutuhkan tanda kurung.

Julia, 16 byte

n->n-n%(r=2:4)+r

Cobalah online!

MATL, 15 10 9 byte

2:4+t5M\-

Cobalah online!

Penjelasan:

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]

MATL, 8 byte

Qt_2:4\+

Menggunakan algoritme Denis 'Jelly, saya terkejut karena panjangnya sama!

Cobalah online , atau verifikasi semua kasus uji .

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

Matlab, 33 byte

Pendekatan lain yang sedikit berbeda

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

05AB1E , 8 byte

Kode:

>D(3L>%+

Cobalah online! .

Ruby, 27 byte

Peta 2, 3, dan 4 untuk kelipatan berikutnya di atas n.

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

CJam, 15 byte

5,2>rif{1$/)*N}

Cobalah online! atau verifikasi semua kasus uji .

Pyke, 11 9 8 byte

3FODQRc+

Coba di sini!

3FODQRc+
         - Q = input()
3F       - for i in range(3): # for i in [0,1,2]
  O      -  i += 2
    Q c  -   Q-(Q%i)
       + -  i+^

Mathematica, 21 byte

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

Ini adalah fungsi tanpa nama yang mengambil integer tunggal sebagai input dan mengembalikan daftar kelipatan.

The Ceilingfungsi mengambil parameter opsional kedua yang mengatakan itu untuk membulatkan ke beberapa berikutnya jumlah yang diberikan. Untungnya, ia juga secara otomatis memasukkan argumen kedua sehingga kami dapat memberikan daftar nilai dan pada gilirannya kami akan mendapatkan kelipatan untuk semua itu.

Oktaf, 20 byte

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

Contoh:

octave:60> f(123)
ans =

   124   126   124

octave:61> f(1081177)
ans =

   1081178   1081179   1081180

octave:62> f(420)
ans =

   422   423   424

Perlu dicatat bahwa kami dapat melakukan ini hingga 9 tanpa menambahkan byte tambahan:

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

Output (2520 adalah bilangan bulat positif terkecil yang habis dibagi oleh semua angka digit tunggal):

octave:83> f(2520)
ans =

   2522   2523   2524   2525   2526   2527   2528   2529

Haskell, 27 byte

f n=[div n d*d+d|d<-[2..4]]

Labirin , 19 byte

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

Cobalah online!

Ini menampilkan hasil dalam urutan yang C, B, Adipisahkan oleh umpan baris.

Penjelasan

Seperti biasa, primer Labirin pendek:

• Labyrinth memiliki dua tumpukan bilangan bulat presisi-arbitrary, main dan aux (iliary), yang awalnya diisi dengan jumlah nol tak terbatas (implisit). Kami hanya akan menggunakan utama untuk jawaban ini.
• Kode sumbernya menyerupai sebuah labirin, tempat penunjuk instruksi (IP) mengikuti koridor ketika bisa (bahkan di sekitar sudut). Kode dimulai pada karakter valid pertama dalam urutan membaca, yaitu di sudut kiri atas dalam kasus ini. Ketika IP datang ke segala bentuk persimpangan (yaitu beberapa sel yang berdekatan selain dari yang berasal dari), ia akan memilih arah berdasarkan bagian atas tumpukan utama. Aturan dasarnya adalah: belok kiri saat negatif, teruskan ke depan ketika nol, belok kanan saat positif. Dan ketika salah satu dari ini tidak mungkin karena ada dinding, maka IP akan mengambil arah yang berlawanan. IP juga berbalik ketika mengenai jalan buntu.

Meskipun dua no-ops ( ") yang membuat tata letak tampak agak boros, saya cukup senang dengan solusi ini, karena aliran kontrolnya sebenarnya cukup halus.

IP dimulai di sudut kiri atas di sebelah :kanan. Ini akan segera menemui jalan buntu ?dan berbalik, sehingga program sebenarnya dimulai dengan potongan kode linier ini:

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

Itu berarti kita sekarang punya tiga salinan dari ntumpukan utama, tetapi kedalamannya 4. Itu nyaman karena itu berarti kita dapat menumpuk kedalaman untuk mengambil pengganda saat ini sambil bekerja melalui salinan input.

IP sekarang memasuki loop 3x3 (searah jarum jam). Perhatikan bahwa #, yang mendorong kedalaman tumpukan, akan selalu mendorong nilai positif sehingga kita tahu IP akan selalu berbelok ke timur pada saat ini.

Badan loop adalah ini:

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

Setelah loop dilalui (hingga !) tiga kali, semua salinann digunakan dan nol di bawahnya terungkap. Karena "di bagian bawah (yang jika tidak tampak cukup berguna) posisi ini adalah persimpangan. Itu berarti dengan nol di atas tumpukan, IP mencoba untuk terus lurus ke depan (barat), tetapi karena ada dinding itu benar-benar membuat berbelok 180 derajat dan bergerak kembali ke timur seolah-olah itu telah menemui jalan buntu.

Akibatnya, bit berikut sekarang dieksekusi:

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

Matlab, 50 byte

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

Pyth, 11 10 byte

m*dh/QdtS4

Suite uji.

       tS4  generate range [2, 3, 4]
m           for d in range...
 *dh/Qd       d*(1+input/d)

Terima kasih kepada Dennis untuk satu byte!

JavaScript (ES6), 26 byte

Menariknya, jawaban Ruby @ KevinLau atau @ xnor's Python menghasilkan panjang yang sama:

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

Saya memiliki sedikit preferensi untuk port jawaban Ruby karena berfungsi hingga 2 ⁵³ -3 sementara port jawaban Python hanya bekerja hingga 2 ³¹ -5.

C, 50 46 byte

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

Terima kasih kepada Neil dan nwellnhof karena telah menghemat 4 byte!

Sangat panjang. Saya merasa ada sedikit pergantian bit di sini yang belum saya ketahui, tetapi saya belum menemukannya. Mengembalikan pointer ke array yang menahan tiga elemen. Program lengkap:

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

Reng, 40 byte

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

1: init

i1+#i2341ø

i1+#i set input ke 1 + input ; ini karena kita harus bekerja pada angka yang benar-benar lebih besar daripada input. 234menginisialisasi rekaman dengan nilai iterasi kami, dan 1ømelompat ke awal baris berikutnya.

2a: lingkaran

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

i(menempatkan input di STOS, dan 2[membuat tumpukan baru dengan 2 elemen teratas. ¤menduplikasi stack, dan ,melakukan modulus. Jika ada sisa, q!^keluar dari loop untuk menuju ke (b). Kalau tidak, kita boleh mencetak. $menghilangkan hal-hal ekstra, ]menutup tumpukan, dan æmencetaknya dengan baik. l0wq!~berakhir jika tumpukan berisi nol anggota.

2b: loop lainnya

          >(1+)31j
        q!^

(1+)menambahkan 1 ke STOS, dan 31jmelompat ke bagian loop yang tidak mengambil barang dari tumpukan. Dan untung.

Ruang kosong ekstra itu benar-benar mengganggu saya. Ambil GIF.

Retina, 62 43 26 byte

17 byte berkat @Martin Büttner .

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

(Perhatikan baris tambahan.)

Cobalah online!

Input in unary in 1, output in unary in 1dipisahkan oleh baris baru.

Versi 43 byte sebelumnya:

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

Cobalah online!

Input di unary, output di unary dipisahkan oleh semi-colon ( ;).

Versi 62-byte sebelumnya:

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

Cobalah online!

Input di unary, output di unary dipisahkan oleh semi-colon ( ;).

Oktaf, 27 22 20 byte

MATLAB dan Oktaf:

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

Lebih baik (solusinya setara, tetapi yang satu mungkin lebih baik dari yang lain ketika di-pegolf lebih lanjut), MATLAB dan Oktaf:

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

Hanya di Oktaf:

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

Coba di sini .

Minkolang 0,15 , 17 byte

n$z3[zi2+$d%-+N].

Coba di sini!

Penjelasan

n$z                  Take number from input and store in register
   3[                Open for loop that repeats 3 times
     z               Push value in register on stack
      i2+            Loop counter plus 2
         $d          Duplicate stack
           %-+       Mod, subtract, add
              N      Output as number
               ].    Close for loop and stop.

> <> , 31 byte

&2v
:&\&
?!\1+:{:}%
ao\n1+:5=?;

Diharapkan Nuntuk hadir di tumpukan di awal program. Cobalah online!

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

Kasus umum menghasilkan jawaban umum:

f[r]

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

R, 30 26 byte

(Mengurangi 4 byte berkat @Neil)

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

Ini (mirip dengan sisa jawaban saya kira) menambahkan 2: 4 ke input dan mengurangi sisanya setelah menjalankan modulo pada angka yang sama.

UGL , 51 31 25 24 byte

icu$l_u^^/%_u^*ocO$dddd:

Cobalah online!

Versi 25 byte sebelumnya:

iRcu$l_u$r^/%_u*ocO$dddd:

Cobalah online!

Versi 31 byte sebelumnya:

iRcuuulu$cuuuuuu%-r^/%_u*oddcO:

Cobalah online!

Versi 51 byte sebelumnya:

i$$cuuu/%_ucuuu*@cuuuu/%_ucuuuu*@cuu/%_ucuu*ocOocOo

Cobalah online!

Java 70 57

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

Golfscript, 22 byte

~..2/)2*@3/)3*@4/)4*]`

Cobalah online!

Alternatif solusi 22-byte:

~..[4 2 3]{.@@/)*@}/]`

Cobalah online!

Sebenarnya, 22 byte

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

Cobalah online!

Fakta menyenangkan: 3 bug dalam juru bahasa Actually ditemukan dan diperbaiki saat menulis program ini.

Fakta yang tidak terlalu menyenangkan: Ketiga bug itu mencegah solusi ini menjadi lebih pendek.

Penjelasan:

╗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

J, 18 byte

2 3 4&([*>:@<.@%~)

Cobalah online!