N'den sonra en küçük tamsayılar 2, 3 ve 4 ile bölünebilir


22

Kredili olduğu kredisi verin .

Amaç Bir tamsayı N > 0verilirse A, en küçük tamsayıları atar Bve Cböylece:

  1. Tüm A, Bve Cdaha sıkı büyüktür N;
  2. 2böler A;
  3. 3böler B;
  4. ve 4böler C.

Bu bir kod golf, yani bayt cinsinden en kısa cevap kazanır. Bu zorluktan sonra yapılmış / güncellenmiş bir dil kullanabilirsiniz, ancak kesinlikle rekabet etmemektedir.

Test durumları

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

Cevapta C B Aaçıkça belirtilmişse (tutarlı bir şekilde) sonuçları farklı bir sırayla (örneğin ) verebilir miyiz?
Martin Ender

@ MartinBüttner kabul edilebilir
Conor O'Brien

Yanıtlar:


17

Jöle , 8 bayt

~%2r4¤+‘

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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

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

2 ve 4 için bit aritmetik, 3 için modüler aritmetik.

kYukarıdakilerin bir sonraki katları için dört 7-baytlık ifade buldum, nancak daha kısa olmadı:

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

Herhangi biri kopyalandığında 34 bayt k=2,3,4, birleştirildiğinde 33 bayt verir:

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

Ancak, 2 ve 4, bit numaralarının son 1 veya 2 baytı sıfırlamasını sağlayan 2'nin gücüdür.

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

Bu, bir sonraki çarpımı almak için 6 bayt (7 yerine) verir, toplamda 32 bayt için for k in 2,3,4.

Ne yazık ki, umut verici görünen n|1+1ve n|3+1ilk önce yapılan eklemeye sahip, bu yüzden çıktının artırılması parantez alır.


1
Olası değişkenler arasından benim tercihim n+k-n%k.
Neil

n&3+1Ekleme de ilk yapar mı ?
Tim

@Tim Yup, tüm boolean işlemleriyle aynı.
xnor


12

Matl, 15 10 9 bayt

2:4+t5M\-

Çevrimiçi deneyin!

Açıklama:

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
Güzel cevap! Saniyeler 5Myerine (fonksiyon girişlerinin otomatik panosu) kullanarak bir bayt kaydedebilirsiniz 2:4.
David,

@David Tahmininiz için teşekkürler!
DJMcMayhem

12

MATL, 8 bayt

Qt_2:4\+

Denis'in Jelly algoritmasını kullanır, aynı uzunlukta olmasına şaşırdım!

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

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

Kahretsin. 10 baytlık çözümümle gerçekten gurur duyuyordum, ancak bunu yenemiyorum. Ayrıca, eğlenceli trivia: Bu tam olarak benim 300. oyum. = D
DJMcMayhem

Ahh ama bu sadece Agawa / Dennis'in algoritmasını kullanıyordu, benim fikrim değil.
David,

1
bazen kafamı çizerken o unicode mandarinoid temel karakterlerine göz kamaştırıyordum ve sonra "okunabilir her şey uğruna bir çatallama kodunun çalıştırılabilir kod olduğunu" diyorum. lol nice thing var benim olumlu oyum + Ben matl tren sooon katılacağım.
Abr001,

@ Agawa001 Yapmalısın! Matlab'da yolunuzu oldukça iyi biliyorsanız, bunu oldukça basit bulmalısınız, büyük fark MATL'nin yığına dayalı olmasıdır. Bir yoktur Matl chat odası Yardıma ihtiyacın çok olursa!
David,

Yapar Matl o gözleme dayalı doğasını @ David ham matlab kendisi .... onun üst düzey interactability ilişkin bir golf dostu dil, böylece hayal olduğunu daha kötü korkutucu knowignly
Abr001am

6

Matlab, 33 bayt

Biraz daha farklı bir yaklaşım

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

6

05AB1E , 8 bayt

Kod:

>D(3L>%+

Çevrimiçi deneyin! .


Ah, zaten sahip olduğumdakine benzer bir 05AB1E cevabı olduğunu fark etmedim. Onu sildim ve bunun yerine burada -1 golf olarak önereceğim: ±D2xŸ%α(bu 2xŸsadece sizin için bir alternatif 3L>; ve diğer iki eşit baytlık alternatif olabilir Ƶ…Sveya 4L¦).
Kevin Cruijssen

5

Ruby, 27 bayt

Yukarıdaki 2 ile 3, 4 ve 4 numaralı haritalara eşleyin n.

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


4

Pyke, 11 9 8 bayt

3FODQRc+

Burada dene!

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 bayt

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

Bu, giriş olarak tek bir tam sayı alan ve katların listesini döndüren adsız bir işlevdir.

Ceilingİşlev belirtilen bir numaranın bir sonraki katına kadar yuvarlak anlatır isteğe bağlı ikinci bir parametre alır. Neyse ki, aynı zamanda otomatik olarak ikinci argümanını kullanarak, bir değer listesi verebileceğimizi ve sırayla bunların hepsi için katları toplayacağımızı otomatik olarak çevirir.


4

Oktav, 20 bayt

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

Örnekler:

octave:60> f(123)
ans =

   124   126   124

octave:61> f(1081177)
ans =

   1081178   1081179   1081180

octave:62> f(420)
ans =

   422   423   424

Fazladan bayt eklemeden 9'a kadar yapabileceğimizi not etmek gerekirse:

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

Çıktı (2520, tüm tek basamaklı sayılarla eşit şekilde bölünebilen en küçük pozitif tam sayıdır):

octave:83> f(2520)
ans =

   2522   2523   2524   2525   2526   2527   2528   2529


4

Labirent , 19 bayt

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

Çevrimiçi deneyin!

Bu, sonuçları C, B, Asatır beslemeleri ile ayrılmış sırayla verir .

açıklama

Her zamanki gibi, kısa bir Labyrinth primer:

  • Labirentte, başlangıçta (örtük) sonsuz miktarda sıfır ile dolu , ana ve aux (iliary) olmak üzere iki rasgele hassas tam sayı yığını vardır . Biz sadece kullanarak olacak ana Bu yanıt için.
  • Kaynak kod, bir labirenti andırır, burada talimat göstergesinin (IP) olabildiğince koridorları takip ettiği (hatta köşelerinde). Kod, okuma sırasındaki ilk geçerli karakterde başlar, yani bu durumda sol üst köşede. IP herhangi bir birleşme şekline geldiğinde (yani, geldiğine ek olarak birkaç bitişik hücre), ana yığının tepesine dayalı bir yön seçecektir. Temel kurallar şunlardır: negatifken sola dönün, sıfırda ilerlemeye devam edin, pozitifken sağa dönün. Ve bunlardan biri mümkün olmadığında, çünkü bir duvar var, o zaman IP ters yön alır. IP ayrıca ölü uçlara çarptığında da döner.

"Düzeni biraz israflı yapan iki no-op'a ( ) rağmen, bu çözümden oldukça memnunum, çünkü kontrol akışı aslında oldukça ince.

IP, :sağdaki sol üst köşede başlar . Derhal bir çıkmaza girecek ?ve geri dönecek, böylece program aslında bu doğrusal kod parçasıyla başlayacak:

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

Bu, şimdi nana yığında üç kopyaya sahip olduğumuz anlamına geliyor , ancak derinliği 4. Bu uygundur, çünkü girişin kopyaları boyunca çalışırken mevcut çarpanı almak için yığın derinliğini alabileceğimiz anlamına gelir.

IP şimdi (saat yönünde) 3x3 döngüsüne giriyor. Not #yığın derinliğini iter ki, her zaman IP hep bu noktada doğu dönecek biliyorum öyle ki pozitif bir değer itecektir.

Döngü gövdesi şudur:

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

Döngü !üç defa (en fazla ) travers edildikten sonra , tüm kopyaları ntükenir ve altındaki sıfır açığa çıkar. Nedeniyle "(Aksi oldukça yararsız görünüyor) altındaki bu pozisyon bir kavşak olduğunu. Bu, yığının üstündeki sıfır ile, IP dümdüz ilerlemeye çalışır (batı), ancak bir duvar olduğu için aslında 180 derecelik bir dönüş yapar ve bir çıkmaza çarpmış gibi doğuya geri döner.

Sonuç olarak, aşağıdaki bit şimdi yürütülür:

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

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

En azından, 2:4yerine kullanabilirsiniz [2 3 4].
Suever


3

JavaScript (ES6), 26 bayt

@ KevinLau'nun Ruby cevabını ya da @ xnor'ın Python cevabını aynı uzunlukta ilginç bir şekilde aktarın:

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

Ruby cevabının limanı için 2 53 -3'e kadar çalıştığım için hafif bir tercihim varken Python cevabının limanı sadece 2 31 -5'e kadar çalışıyor .


)-> ]
sandığım

@Qwertiy Whoops, yazım hatası için üzgünüm.
Neil,

3

C, 50 46 bayt

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

Neil ve nwellnhof'a 4 byte tasarruf ettiğin için teşekkürler!

Hayal kırıklığıyla uzun. Burada bilmediğim bir miktar değişen kesmek var gibi hissediyorum, ancak henüz bulamıyorum. Üç öğeyi tutan bir diziye işaretçi döndürür. Tam program:

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

@ Xnor'ın bit bükme bölümüne baktım ancak bu döngüyü çözmeniz gerekiyor, bu da size genel olarak bir bayta mal oluyor.
Neil,

n + i - n % i++Tanımlanmamış davranışa neden olmaz mı ?
nwellnhof

Ayrıca s/a[i-2]/*a++/iki bayt kaydetmek için.
nwellnhof

@nwellnhof Bah, onun döngüsünü açtığımda düşündüm ama yine de kullanabileceği aklıma gelmedi.
Neil,

2
@Neil Ancak tanımsız davranış, kodu daha büyük hale getirmeden çözülebilir. İşte K&R işlev bildirimlerini kullanan daha kısa bir sürüm:f(a,n,i)int*a;{for(i=1;++i<5;)*a++=n+i-n%i;}
nwellnhof 16:16

3

Reng, 40 bayt

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

1: init

i1+#i2341ø

i1+#igirişi ayarlar 1 + input; Bunun nedeni girdilerden kesinlikle daha büyük sayılar üzerinde çalışmamız gerektiğidir. 234Kaseti yineleme değerlerimizle başlatır ve bir sonraki satırın başına atlar.

2a: döngü

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

i(girişi STOS'a yerleştirir ve 2[ilk 2 öğeyle yeni bir yığın oluşturur. ¤yığını çoğaltır ve ,modül yapar. Bir geri kalan varsa, q!^(b) 'ye gitmek için döngüden kopar. Aksi takdirde, yazdırmaya hazırız. $fazla olanı kaldırır, ]yığını kapatır ve ægüzel yazdırır. l0wq!~Yığın sıfır üyeler içeriyorsa sona erer.

2b: diğer döngü

          >(1+)31j
        q!^

(1+)STOS'a 1 ekler 31jve döngünün yığından bir şey almayan kısmına atlar. Ve kar.


Bu fazladan boşluk, beni gerçekten rahatsız ediyor. Bir GIF al.

REENNNNNGGG


3

Retina, 62 43 26 bayt

@Martin Büttner sayesinde 17 bayt .

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

(Sondaki yeni satırı not edin.)

Çevrimiçi deneyin!

Tek girişli giriş, tek hatlı 1çıkış 1yeni satırlarla ayrılmış olarak.

Önceki 43 bayt sürümü:

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

Çevrimiçi deneyin!

Tekli giriş, yarı-kolon ( ;) ile ayrılmış tekli çıkış .

Önceki 62 bayt sürümü:

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

Çevrimiçi deneyin!

Tekli giriş, yarı-kolon ( ;) ile ayrılmış tekli çıkış .


26 Ters sıradaki çıktıya izin verilirse: retina.tryitonline.net/… ... Aksi takdirde 33, tersine sıralamayı engellemenin
Martin Ender

Ayrı bir cevap olarak nitelendirmek için yeterli mi?
Sızdıran Rahibe

Bilmiyorum, hala aynı fikir, ben sadece el ile üst üste gelen kibrit kullanarak liste oluşturma yerine.
Martin Ender

Conor 26 baytlık çözümün geçerli olduğunu doğruladı.
Martin Ender

3

Octave, 27 22 20 bayt

MATLAB ve Octave:

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

Daha iyi (çözümler eşdeğerdir, ancak biri daha golf oynadığında diğerinden daha iyi performans gösterebilir), MATLAB ve Octave:

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

Sadece Octave dilinde:

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

Burada dene .


Benim son cevap burada tek :( o temelde codegolf.stackexchange.com/a/80028/52795
BERS

3

Minkolang 0.15 , 17 bayt

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

Burada dene!

açıklama

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.

+ bölünmedir ??
Downgoat

@Downgoat: Vuruyor > _>
El'endia Starman


2

Mathematica 28 bayt

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)


Genel durum genel bir cevap üretir:

f[r]

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


2

R, 30 26 bayt

(@Neil sayesinde 4 bayt azaltıldı)

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

Bu (sanırım cevapların geri kalanına benzer şekilde) girişe 2: 4 ekler ve aynı numaraları modulo çalıştırdıktan sonra kalanı azaltır.


1
Dili bilmediğim için kullanmadığın bir sebep var N+2:4-N%%2:4mı?
Neil

@Neil Çünkü sanırım bunu düşünmedim. Yine de teşekkürler.
David Arenburg


2

Java 70 57

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

Ben Java bilmiyorum ama belki etrafında beyaz boşluk kaldırabilirsiniz =içindeint a = new Integer(z[0]);
Conor O'Brien


1

Aslında, 22 bayt

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

Çevrimiçi deneyin!

Eğlenceli gerçek: Bu program yazılırken Aslında tercüman 3 hata bulundu ve düzeltildi.

Çok eğlenceli değil: Bu 3 böcek, bu çözümün çok daha kısa olmasını engelledi.

Açıklama:

╗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

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.