Bilangan bulat terkecil setelah N dapat dibagi 2, 3, dan 4


22

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

Bisakah kita (secara konsisten) menampilkan hasilnya dalam urutan yang berbeda (misalnya C B A) jika itu ditentukan dengan jelas dalam jawabannya?
Martin Ender

@ MartinBüttner yang dapat diterima
Conor O'Brien

Jawaban:


17

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.

26

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.


1
Dari kemungkinan varian yang saya sukai n+k-n%k.
Neil

Apakah n&3+1penambahannya juga dulu?
Tim

@Tim Yup, sama dengan semua operasi boolean.
xnor


12

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]

3
Jawaban bagus! Anda dapat menyimpan byte dengan menggunakan 5M(clipboard otomatis input fungsi) bukan yang kedua 2:4.
David

@ David Terima kasih atas tipnya!
DJMcMayhem

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

Sialan. Saya sangat bangga dengan solusi 10 byte saya, tetapi saya tidak bisa mengalahkan ini. Juga, hal-hal sepele yang menyenangkan: Ini adalah suara saya yang ke 300. = D
DJMcMayhem

Ahh tapi ini hanya mengambil algoritma Agawa / Dennis, itu bukan ide saya sendiri.
David

1
kadang-kadang saya terus memelototi karakter-karakter dasar unicode mandarinoid sambil menggaruk-garuk kepala saya kemudian saya katakan "demi segala sesuatu yang dapat dibaca adalah bahwa kode runnable forking"? lol hal yang menyenangkan ada upvote saya + saya akan bergabung dengan soun kereta matl.
Abr001am

@ Agawa001 Anda harus! Mengingat Anda mengetahui Matlab dengan cukup baik, Anda harus menemukannya cukup mudah, perbedaan besar adalah bahwa MATL's berbasis stack. Ada juga ruang obrolan MATL jika Anda membutuhkan bantuan!
David

@Menyatakan bahwa sifat berbasis pancake dari matl membuatnya lebih jahat menakutkan mengetahui bahwa matlab mentah itu sendiri adalah bahasa ramah-golf mengenai interaktivitas tingkat tinggi, jadi bayangkan ....
Abr001am

6

Matlab, 33 byte

Pendekatan lain yang sedikit berbeda

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

6

05AB1E , 8 byte

Kode:

>D(3L>%+

Cobalah online! .


Ah, tidak memperhatikan sudah ada jawaban 05AB1E yang agak mirip dengan yang saya miliki. Saya telah menghapusnya, dan akan menyarankannya sebagai golf -1 di sini sebagai gantinya: ±D2xŸ%α( 2xŸini hanya sebuah alternatif untuk Anda 3L>; dan dua alternatif byte-sama lainnya bisa Ƶ…Satau 4L¦).
Kevin Cruijssen

5

Ruby, 27 byte

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

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


4

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+^

4

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.


4

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


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.

3

Matlab, 50 byte

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

Paling tidak, Anda dapat menggunakan 2:4bukan [2 3 4].
Suever


3

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 53 -3 sementara port jawaban Python hanya bekerja hingga 2 31 -5.


)-> ]Seperti yang saya pikirkan
Qwertiy

@Qwertiy Whoops, maaf atas kesalahan ketiknya.
Neil

3

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

Saya melihat twiddling @ xnor tetapi Anda perlu membuka gulungan untuk apa yang akhirnya dikenakan biaya satu byte secara keseluruhan.
Neil

Tidak n + i - n % i++menghasilkan perilaku yang tidak terdefinisi?
nwellnhof

Juga s/a[i-2]/*a++/untuk menyimpan dua byte.
nwellnhof

@nwellnhof Bah, saya memikirkan hal itu ketika saya membuka gulungannya tetapi tidak terpikir oleh saya bahwa dia bisa menggunakannya juga.
Neil

2
@Neil Tetapi perilaku tidak terdefinisi dapat diselesaikan tanpa membuat kode lebih besar. Berikut ini adalah versi yang lebih pendek menggunakan deklarasi fungsi 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 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 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.

REENNNNNGGG


3

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


26 jika output dalam urutan sebaliknya diperbolehkan: retina.tryitonline.net/ ... ... Kalau tidak 33 saya pikir pasti ada cara yang lebih pendek untuk menghindari penyortiran terbalik: retina.tryitonline.net/…
Martin Ender

Itu cukup untuk memenuhi syarat sebagai jawaban terpisah?
Leaky Nun

Saya tidak tahu, itu masih ide yang sama, saya hanya mengganti pembuatan daftar secara manual dengan menggunakan pertandingan yang tumpang tindih.
Martin Ender

Conor mengkonfirmasi bahwa solusi 26-byte itu valid.
Martin Ender

3

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 .


Jawaban akhir saya pada dasarnya adalah yang di sini :( codegolf.stackexchange.com/a/80028/52795
bers

3

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.

+ adalah pembagian ??
Downgoat

@Downgoat: Whoops. > _>
El'endia Starman


2

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


2

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.


1
Karena saya tidak tahu bahasanya, apakah ada alasan mengapa Anda tidak menggunakannya N+2:4-N%%2:4?
Neil

@Neil Karena saya belum memikirkannya, saya kira. Terimakasih Meskipun.
David Arenburg


2

Java 70 57

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

Saya tidak tahu Java, tapi mungkin Anda bisa menghapus ruang putih =di sekitarint a = new Integer(z[0]);
Conor O'Brien


1

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

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.