Najmniejsze liczby całkowite po N podzielne przez 2, 3 i 4


22

Podaj, komu należy się kredyt .

Cel Biorąc pod uwagę liczbę całkowitą N > 0, z najmniejszych liczb A, Bi Ctak, że:

  1. Wszystko A, Bi Csą ściśle większe niż N;
  2. 2dzieli A;
  3. 3dzieli B;
  4. i 4dzieli C.

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach. Możesz użyć języka stworzonego / zaktualizowanego po tym wyzwaniu, ale jest on całkowicie niekonkurencyjny.

Przypadki testowe

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

Czy możemy (konsekwentnie) wyprowadzać wyniki w innej kolejności (np. C B A), Jeśli jest to wyraźnie określone w odpowiedzi?
— Martin Ender

@ MartinBüttner, który jest do przyjęcia
— Conor O'Brien

Odpowiedzi:


17

Galaretka , 8 bajtów

~%2r4¤+‘

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

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

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

Arytmetyka bitów dla 2 i 4, arytmetyka modułowa dla 3.

Znalazłem cztery 7-bajtowe wyrażenia dla następnej wielokrotności kpowyższej, nale nie krótszej:

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

Dowolny daje 34 bajty w przypadku kopiowania k=2,3,4i 33 bajty w połączeniu:

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

Ale 2 i 4 są potęgami 2, które pozwalają sztuczkom bitowym wyzerować ostatnie 1 lub 2 bajty.

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

Daje to 6 bajtów (zamiast 7) ​​na uzyskanie następnej wielokrotności, ogółem 32 bajtów, pokonując for k in 2,3,4.

Niestety, wyglądający obiecująco n|1+1i n|3+1najpierw dodany, więc zwiększenie wyjścia wymaga nawiasów.


1
Spośród możliwych wariantów preferuję n+k-n%k.
— Neil

Czy n&3+1to pierwsze też?
— Tim

@Tim tak, wszystkie operacje logiczne.
— xnor


12

MATL, 15 10 9 bajtów

2:4+t5M\-

Wypróbuj online!

Wyjaśnienie:

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
Niezła odpowiedź! Możesz zapisać bajt, używając 5M(automatyczny schowek wejść funkcji) zamiast drugiego 2:4.
— David

@David Dzięki za wskazówkę!
— DJMcMayhem

12

MATL, 8 bajtów

Qt_2:4\+

Korzystam z algorytmu Jelisa „Jelly”, jestem zaskoczony, że ma tę samą długość!

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

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

Cholera. Byłem bardzo dumny ze swojego 10-bajtowego rozwiązania, ale nie mogę tego przebić. Ciekawe ciekawostki: to dokładnie mój 300. głos. = D
— DJMcMayhem

Ach, ale to był tylko algorytm Agawy / Dennisa, to nie jest mój własny pomysł.
— David

1
czasami wpatruję się w te jednorożce mandarinoidów w elementarne postacie, drapiąc się po głowie, a potem mówię „ze względu na wszystko, co można odczytać, czy to nie nadpisujący kod uruchamialny”? lol, miło mi, że mam upvote + dołączę do pociągu matl.
— Abr001am

@ Agawa001 Powinieneś! Biorąc pod uwagę, że znasz się dobrze na Matlabie, powinieneś znaleźć to dość proste, duża różnica polega na tym, że MATL opiera się na stosach. Jest Mátl chat-room też, jeśli potrzebujesz pomocy!
— David

@David, że matl oparty na naleśnikach sprawia, że ​​bardziej przerażające jest to, że sam surowy matlab jest językiem przyjaznym golfowi, jeśli chodzi o jego interaktywność na wysokim poziomie, więc wyobraź sobie ...
— Abr001am

6

Matlab, 33 bajty

Kolejne nieco inne podejście

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

6

05AB1E , 8 bajtów

Kod:

>D(3L>%+

Wypróbuj online! .


Ach, nie zauważyłem, że była już odpowiedź 05AB1E, która jest raczej podobna do mojej. Usunąłem go i zasugeruję tutaj jako -1 golfa: ±D2xŸ%α( 2xŸjest to po prostu alternatywa dla twojego 3L>; dwie inne równe bajty mogą być Ƶ…Slub 4L¦).
— Kevin Cruijssen

5

Rubinowy, 27 bajtów

Mapy 2, 3 i 4 do następnej wielokrotności powyżej n.

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



4

Mathematica, 21 bajtów

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

Jest to funkcja bez nazwy, która przyjmuje jedną liczbę całkowitą jako dane wejściowe i zwraca listę wielokrotności.

CeilingFunkcja przyjmuje opcjonalny drugi parametr, który informuje ją zaokrąglić w górę do najbliższej wielokrotności podanej liczby. Na szczęście, to również automatycznie nici ponad drugi argument taki, że możemy dać mu listę wartości, a z kolei dostaniemy zaokrąglana wielokrotności dla wszystkich tych.


4

Oktawa, 20 bajtów

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

Przykłady:

octave:60> f(123)
ans =

   124   126   124

octave:61> f(1081177)
ans =

   1081178   1081179   1081180

octave:62> f(420)
ans =

   422   423   424

Warto zauważyć, że możemy to zrobić do 9 bez dodawania dodatkowych bajtów:

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

Dane wyjściowe (2520 jest najmniejszą dodatnią liczbą całkowitą równomiernie podzielną przez wszystkie liczby jednocyfrowe):

octave:83> f(2520)
ans =

   2522   2523   2524   2525   2526   2527   2528   2529


4

Labirynt , 19 bajtów

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

Wypróbuj online!

Wyprowadza to wyniki w kolejności C, B, Aoddzielonej liniami.

Wyjaśnienie

Jak zwykle krótki podkład Labiryntowy:

  • Labirynt ma dwa stosy liczb całkowitych o dowolnej precyzji, główną i pomocniczą (iliary), które są początkowo wypełnione (domyślną) nieskończoną liczbą zer. Będziemy używać main do tej odpowiedzi.
  • Kod źródłowy przypomina labirynt, w którym wskaźnik instrukcji (IP) podąża korytarzami, kiedy może (nawet wokół rogów). Kod zaczyna się od pierwszego poprawnego znaku w kolejności czytania, tj. W tym przypadku w lewym górnym rogu. Kiedy IP dojdzie do dowolnej formy połączenia (tj. Kilku sąsiednich komórek oprócz tej, z której pochodzi), wybierze kierunek na podstawie górnej części głównego stosu. Podstawowe zasady to: skręć w lewo, gdy wartość jest ujemna, idź naprzód, gdy zero, skręć w prawo, gdy wartość dodatnia. A jeśli jeden z nich nie jest możliwy, ponieważ istnieje ściana, wówczas IP przyjmie przeciwny kierunek. IP zmienia się również po trafieniu w ślepe zaułki.

Pomimo dwóch no-ops ( "), które sprawiają, że układ wydaje się trochę marnotrawiony, jestem całkiem zadowolony z tego rozwiązania, ponieważ jego kontrola jest w rzeczywistości dość subtelna.

Adres IP zaczyna się w lewym górnym rogu po :prawej stronie. Natychmiast uderzy w ślepy zaułek ?i zawróci, tak że program faktycznie zacznie się od tego liniowego fragmentu kodu:

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

Oznacza to, że mamy teraz trzy kopie nna głównym stosie, ale jego głębokość jest 4. Jest to wygodne, ponieważ oznacza, że ​​możemy głębokość stosu, aby pobrać bieżący mnożnik podczas pracy z kopiami danych wejściowych.

IP wchodzi teraz w pętlę 3x3 (zgodnie z ruchem wskazówek zegara). Zauważ, że to #, co popycha głębokość stosu, zawsze będzie wypychało wartość dodatnią, tak że wiemy, że IP w tym momencie zawsze skręci na wschód.

Ciało pętli jest następujące:

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

Po !trzykrotnym przejściu pętli (do ) trzykrotnie, wszystkie kopie nsą zużyte i odsłania się zero poniżej. Ze względu "na spód (który w innym przypadku wydaje się dość bezużyteczny) ta pozycja jest skrzyżowaniem. Oznacza to, że z zero na szczycie stosu, IP próbuje iść prosto (na zachód), ale ponieważ jest ściana, faktycznie wykonuje obrót o 180 stopni i przesuwa się z powrotem na wschód, jakby uderzyła w ślepy zaułek.

W rezultacie następujący bit jest teraz wykonywany:

"   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 bajtów

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

Przynajmniej możesz użyć 2:4zamiast [2 3 4].
— Suever


3

JavaScript (ES6), 26 bajtów

Co ciekawe, przeniesienie albo odpowiedzi Ruby @ KevinLau lub odpowiedzi Python @ xnor ma tę samą długość:

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

Mam lekką preferencję dla portu odpowiedź Ruby jak to działa do 2 53 -3 natomiast port odpowiedź Python działa tylko do 2 31 -5.


)-> ]jak myślę
— Qwertiy

@Qwertiy Ups, przepraszam za literówkę.
— Neil

3

C, 50 46 bajtów

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

Podziękowania dla Neila i nwellnhofa za oszczędność 4 bajtów!

Rozczarowująco długie. Wydaje mi się, że jest tu trochę zmieniający się hack, o którym nie wiem, ale nie mogę go jeszcze znaleźć. Zwraca wskaźnik do tablicy zawierającej trzy elementy. Pełny 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;
}

Spojrzałem na kręcenie się bitów @ xnor, ale musisz rozwinąć pętlę dla tego, co ostatecznie kosztuje cię bajt.
— Neil

Nie n + i - n % i++powoduje niezdefiniowanego zachowania?
— nwellnhof

Również, s/a[i-2]/*a++/aby zapisać dwa bajty.
— nwellnhof

@nwellnhof Bah, pomyślałem o tym, kiedy rozwinąłem jego pętlę, ale nie przyszło mi do głowy, że i tak może z niego skorzystać.
— Neil

2
@Neil Ale niezdefiniowane zachowanie można obejść bez powiększania kodu. Oto jeszcze krótsza wersja z deklaracjami funkcji K&R:f(a,n,i)int*a;{for(i=1;++i<5;)*a++=n+i-n%i;}
— nwellnhof

3

Reng, 40 bajtów

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

1: init

i1+#i2341ø

i1+#iustawia wejście na 1 + input; dzieje się tak, ponieważ mamy pracować nad liczbami ściśle większymi niż dane wejściowe. 234inicjuje taśmę naszymi wartościami iteracji i 1øprzeskakuje na początek następnego wiersza.

2a: pętla

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

i(umieszcza dane wejściowe w STOS i 2[tworzy nowy stos z górnymi 2 elementami. ¤powiela stos i ,robi moduł. Jeśli pozostała część, q!^przerywa pętlę, aby przejść do (b). W przeciwnym razie możemy wydrukować. $usuwa dodatkowe rzeczy, ]zamyka stos i æładnie go drukuje. l0wq!~kończy się, jeśli stos zawiera zero elementów.

2b: ta druga pętla

          >(1+)31j
        q!^

(1+)dodaje 1 do STOS i 31jprzeskakuje do części pętli, która nie bierze rzeczy ze stosu. I zysk.


Ta dodatkowa spacja naprawdę mnie niepokoi. Zrób GIF.

REENNNNNGGG


3

Siatkówka, 62 43 26 bajtów

17 bajtów dzięki @Martin Büttner .

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

(Zwróć uwagę na końcowy znak nowej linii).

Wypróbuj online!

Wejście unarne w 1, wyjście unarne w 1oddzielone znakami nowej linii.

Poprzednia 43-bajtowa wersja:

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

Wypróbuj online!

Wejście w unary, wyjście w unary oddzielone średnikiem ( ;).

Poprzednia 62-bajtowa wersja:

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

Wypróbuj online!

Wejście w unary, wyjście w unary oddzielone średnikiem ( ;).


26, jeśli dane wyjściowe w odwrotnej kolejności są dozwolone: retina.tryitonline.net/ ... ... W przeciwnym razie 33, chociaż myślę, że musi istnieć krótsza droga, która pozwala uniknąć odwrotnego sortowania: retina.tryitonline.net/...
— Martin Ender

To wystarczy, aby zakwalifikować się jako osobna odpowiedź?
— Leaky Nun

Nie wiem, to wciąż ten sam pomysł, właśnie zastąpiłem ręczne generowanie listy za pomocą nakładających się dopasowań.
— Martin Ender

Conor potwierdził, że 26-bajtowe rozwiązanie jest prawidłowe.
— Martin Ender

3

Oktawa, 27 22 20 bajtów

MATLAB i Octave:

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

Lepsze (rozwiązania są równoważne, ale jedno może przewyższać inne, gdy dalej gra się w golfa), MATLAB i Octave:

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

Tylko w Octave:

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

Spróbuj tutaj .


Moja ostateczna odpowiedź jest w zasadzie taka: tutaj codegolf.stackexchange.com/a/80028/52795
— bers



2

Mathematica 28 bajtów

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}


Ogólny przypadek daje ogólną odpowiedź:

f[r]

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


2

R, 30 26 bajtów

(Zmniejszone 4 bajty dzięki @Neil)

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

To (podobnie jak pozostałe odpowiedzi, jak sądzę) dodaje 2: 4 do wejścia i zmniejsza resztę po uruchomieniu modulo na tych samych liczbach.


1
Ponieważ nie znam języka, czy istnieje powód, dla którego go nie używasz N+2:4-N%%2:4?
— Neil

@Neil Bo chyba o tym nie myślałem. W każdym razie dzięki.
— David Arenburg




1

Właściwie 22 bajty

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

Wypróbuj online!

Ciekawostka: podczas pisania tego programu znaleziono i naprawiono 3 błędy w tłumaczu Actually.

Niezbyt zabawny fakt: te 3 błędy zapobiegły skróceniu tego rozwiązania.

Wyjaśnienie:

╗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

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.