Biorąc pod uwagę wartość x, znajdź najmniejszą wartość liczbową większą niż y, którą można pomnożyć i podzielić przez x , zachowując wszystkie oryginalne cyfry.

• Nowe liczby nie tracą cyfr.
• Nowe liczby nie zyskują cyfr.

Na przykład:

Dane wejściowe: x = 2, y = 250000

• Oryginał: 285714
  • Rejon: 142857
  • Mnożenie: 571428

To prawda, ponieważ 285714 jest większy niż y ; następnie podzielony przez x daje wynik w 142857 i pomnożony przez x daje wynik w 571428 . W obu testach obecne są wszystkie oryginalne cyfry z 285714 i nie dodano żadnych dodatkowych cyfr.

Zasady

• X powinno wynosić 2 lub 3, ponieważ obliczenie czegoś wyższego zajmuje zbyt dużo czasu.
• Y musi być liczbą całkowitą większą od zera .
• Najkrótszy kod wygrywa.

Przypadki testowe

Są to moje najczęstsze przypadki testowe, ponieważ są najszybsze do przetestowania.

• x = 2, y = 250000 = 285714
• x = 2, y = 290000 = 2589714
• x = 2, y = 3000000 = 20978514
• x = 3, y = 31000000 = 31046895
• x = 3, y = 290000000 = 301046895

Wyjaśnienia

• Rodzaj podziału nie ma znaczenia. Jeśli w jakiś sposób zdobędziesz 2,05, 0,25 i 5,20, poczuj się swobodnie.

Powodzenia wszystkim!

Łuska , 14 bajtów

ḟ§¤=OoDd§¤+d*/

Wypróbuj online!

Wyjaśnienie

ḟ§¤=O(Dd)§¤+d*/  -- example inputs: x=2  y=1
ḟ                -- find first value greater than y where the following is true (example on 285714)
 §               -- | fork
         §       -- | | fork
              /  -- | | | divide by x: 142857
                 -- | | and
             *   -- | | | multiply by y: 571428
                 -- | | then do the following with 142857 and 571428
                 -- | | | concatenate but first take
           +     -- | | | | digits: [1,4,2,8,5,7] [5,7,1,4,2,8]
          ¤ d    -- | | | : [1,4,2,8,5,7,5,7,1,4,2,8]
                 -- | and
       d         -- | | digits: [2,8,5,7,1,4]
      D          -- | | double: [2,8,5,7,1,4,2,8,5,7,1,4]
                 -- | then do the following with [2,8,5,7,1,4,2,8,5,7,1,4] and [1,4,2,8,5,7,5,7,1,4,2,8]
   =             -- | | are they equal
  ¤ O            -- | | | when sorted: [1,1,2,2,4,4,5,5,7,7,8,8] [1,1,2,2,4,4,5,5,7,7,8,8]
                 -- | : truthy
                 -- : 285714

Brachylog v2, 15 bajtów

t<.g,?kA/p.∧A×p

Wypróbuj online!

Pobiera dane wejściowe w formularzu [x,y].

Wyjaśnienie

t<.g,?kA/p.∧A×p
t                  Tail (extract y from the input)
 <                 Brute-force search for a number > y, such that:
  .                  it's the output to the user (called ".");
   g                 forming it into a list,
    ,?               appending both inputs (to form [.,x,y]),
      k              and removing the last (to form [.,x])
       A             gives a value called A, such that:
        /              first ÷ second element of {A}
         p             is a permutation of
          .            .
           ∧         and
            A×         first × second element of {A}
              p        is a permutation of {.}

Komentarz

Pojawia się tutaj słabość Brachyloga w wielokrotnym wykorzystywaniu wielu wartości; ten program to prawie cała hydraulika i bardzo mało algorytmu.

Jako takie, może wydawać się wygodniejsze po prostu zakodować wartość y (w tym pytaniu jest komentarz, który zakłada, że ​​2 jest jedyną możliwą wartością). Istnieją jednak rozwiązania dla y = 3, co oznacza, że ​​niestety hydraulika musi również obsługiwać wartość y . Najmniejszy, o którym wiem, to:

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

(Technika, której użyłem do znalezienia tej liczby, nie jest w pełni ogólna, więc możliwe jest, że istnieje mniejsze rozwiązanie wykorzystujące inne podejście.)

Jednak jest mało prawdopodobne, aby to sprawdzić w tym programie. Brachylog pjest napisany w bardzo ogólny sposób, który nie ma optymalizacji dla specjalnych przypadków (takich jak przypadek, w którym zarówno dane wejściowe, jak i wyjściowe są już znane, co oznacza, że ​​można dokonać weryfikacji w O ( n log n ) poprzez sortowanie, a raczej niż O ( n !) dla podejścia opartego na brutalnej sile, którego, jak podejrzewam, używa). W związku z tym bardzo długo zajmuje sprawdzenie, czy 105263157894736842 jest permutacją 315789473684210526 (pozostawiłem ją uruchomioną od kilku minut bez wyraźnego postępu).

(EDYCJA: Z tego powodu sprawdziłem źródło Brachylog. Okazuje się, że jeśli używasz pdwóch znanych liczb całkowitych, zastosowany algorytm generuje wszystkie możliwe kombinacje danej liczby całkowitej, dopóki nie znajdzie takiej, która jest równa wyjściowej liczbie całkowitej, jak algorytm to „wejście → pobudzane, permute pobudzone → przestarzałe, przestarzałe → wyjście”. Bardziej wydajnym algorytmem byłoby ustawienie relacji przestarzałe / wyjściowe w pierwszej kolejności , tak aby powrót do wewnątrz permutacji mógł wziąć pod uwagę, które cyfry były dostępne.)

Perl 6 , 56 54 bajtów

->\x,\y{(y+1...{[eqv] map *.comb.Bag,$_,$_*x,$_/x})+y}

Wypróbuj online!

Ciekawa alternatywa, obliczanie n * x ^k dla k = -1,0,1:

->\x,\y{first {[eqv] map ($_*x***).comb.Bag,^3-1},y^..*}

Czysty , 92 bajty

import StdEnv
$n m=hd[i\\i<-[m..],[_]<-[removeDup[sort[c\\c<-:toString j]\\j<-[i,i/n,i*n]]]]

Wypróbuj online!

Dość proste. Wyjaśnienie już za chwilę.

q, 65 bajtów

{f:{asc 10 vs x};while[not((f y)~f y*x)&(f y*x)~f"i"$y%x;y+:1];y}

Podziel liczbę na podstawie 10, posortuj rosnąco i sprawdź, czy jest równa. Jeśli nie, zwiększ y i idź ponownie

JavaScript (ES6), 76 73 69 bajtów

^{Zaoszczędzono 3 bajty eval(), zgodnie z sugestią @ShieruAsakoto}

Pobiera dane wejściowe jako (x)(y).

x=>y=>eval("for(;(g=x=>r=[...x+''].sort())(y*x)+g(y/x)!=g(y)+r;)++y")

Wypróbuj online!

Wersja rekurencyjna miałaby 62 bajty , ale nie nadaje się tutaj dobrze ze względu na dużą liczbę wymaganych iteracji.

W jaki sposób?

$g$

Przykład:

g(285714) = [ '1', '2', '4', '5', '7', '8' ]

$y\times x$$y/x$$y$$g(y\times x)$$g(y/x)$$g(y)$

Podczas dodawania dwóch tablic razem, każda z nich jest domyślnie przymuszana do łańcucha rozdzielanego przecinkami. Ostatnia cyfra pierwszej tablicy będzie bezpośrednio powiązana z pierwszą cyfrą drugiej tablicy bez przecinków, co czyni ten format jednoznacznym.

Przykład:

g(123) + g(456) = [ '1', '2', '3' ] + [ '4', '5', '6' ] = '1,2,34,5,6'

Ale:

g(1234) + g(56) = [ '1', '2', '3', '4' ] + [ '5', '6' ] = '1,2,3,45,6'

Skomentował

x => y =>                   // given x and y
  eval(                     // evaluate as JS code:
    "for(;" +               //   loop:
      "(g = x =>" +         //     g = helper function taking x
        "r =" +             //       the result will be eventually saved in r
          "[...x + '']" +   //       coerce x to a string and split it
          ".sort() + ''" +  //       sort the digits and coerce them back to a string
      ")(y * x) +" +        //     compute g(y * x)
      "g(y / x) !=" +       //     concatenate it with g(y / x)
      "g(y) + r;" +         //     loop while it's not equal to g(y) concatenated with
    ")" +                   //     itself
    "++y"                   //   increment y after each iteration
  )                         // end of eval(); return y

Haskell, 76 74 bajtów

Dwa bajty wygolono dzięki komentarzowi Lynn

import Data.List
s=sort.show
x#y=[n|n<-[y+1..],all(==s n)[s$n*x,s$n/x]]!!0

Japt, 24 bajty

Dość naiwne rozwiązanie na kilka piw; Jestem pewien, że jest lepszy sposób.

@[X*UX/U]®ì nÃeeXì n}a°V

Spróbuj

Python 2 , 69 bajtów

S=sorted
x,y=input()
while(S(`y`)==S(`y*x`)==S(`y/x`))<1:y+=1
print y

Wypróbuj online!

Galaretka ,  14  13 bajtów

-1 dzięki Erik the Outgolfer (`` używa make_digits, więc Dnie było to wymagane)
+2 naprawiając błąd (ponownie dzięki Erik the Outgolfer za zwrócenie uwagi na jeden problem)

×;÷;⁸Ṣ€E
‘ç1#

Pełny program wypisujący wynik (jako diadadowy link powstaje lista o długości 1).

Wypróbuj online!

W jaki sposób?

×;÷;⁸Ṣ€E - Link 1, checkValidity: n, x               e.g. n=285714,  x=2
×        -     multiply -> n×x                       571428
  ÷      -     divide -> n÷x                         142857
 ;       -     concatenate -> [n×x,n÷x]              [571428,142857]
    ⁸    -     chain's left argument = n             285714
   ;     -     concatenate -> [n×x,n÷x,n]            [571428,142857,285714]
     Ṣ€  -     sort €ach (implicitly make decimals)  [[1,2,4,5,7,8],[1,2,4,5,7,8],[1,2,4,5,7,8]]
        E    -     all equal?                        1

‘ç1# - Main link: y, x
‘    - increment -> y+1
   # - count up from n=y+1 finding the first...
  1  - ...1 match of:
 ç   -   the last link (1) as a dyad i.e. f(n, x)

Zauważ, że gdy podział nie jest dokładny, niejawna instrukcja dziesiętna (równoważna a D) zastosowana przed sortowaniem daje część ułamkową,
np .: 1800÷3D-> [6,0,0]
while 1801÷3D->[6.0,0.0,0.33333333333337123]

Mathematica, 82 74 bajty

x=Sort@*IntegerDigits;Do[If[x[i#]==x@Floor[i/#]==x@i,Break@i],{i,#2,∞}]&

-8 bajtów dzięki tsh

Funkcja, która przyjmuje argumenty jako [x,y]. Skutecznie brute force wyszukiwania, która sprawdza czy posortowanej listy cyfr y, y/xi xysą takie same.

Wypróbuj online!

APL (NARS), 490 znaków, 980 bajtów

T←{v←⍴⍴⍵⋄v>2:7⋄v=2:6⋄(v=1)∧''≡0↑⍵:4⋄''≡0↑⍵:3⋄v=1:5⋄⍵≢+⍵:8⋄⍵=⌈⍵:2⋄1}
D←{x←{⍵≥1e40:,¯1⋄(40⍴10)⊤⍵}⍵⋄{r←(⍵≠0)⍳1⋄k←⍴⍵⋄r>k:,0⋄(r-1)↓⍵}x}
r←c f w;k;i;z;v;x;y;t;u;o ⍝   w  cxr
   r←¯1⋄→0×⍳(2≠T c)∨2≠T w⋄→0×⍳(c≤1)∨w<0⋄→0×⍳c>3
   r←⌊w÷c⋄→Q×⍳w≤c×r⋄r←r+c
Q: u←D r⋄x←1⊃u⋄y←c×x⋄t←c×y⋄o←↑⍴u⋄→0×⍳o>10⋄→A×⍳∼t>9
M:                     r←10*o⋄⍞←r⋄→Q
A: u←D r⋄→M×⍳x≠1⊃u⋄→B×⍳∼(t∊u)∧y∊u⋄z←r×c⋄v←D z⋄→C×⍳(⍳0)≡v∼⍦u
B: r←r+1⋄→A
C: k←z×c⋄⍞←'x'⋄→B×⍳(⍳0)≢v∼⍦D k
   ⎕←' '⋄r←z

test

  2 f¨250000 290000 3000000
xxxx 
1000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 
10000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 
285714 2589714 20978514 
 3 f¨ 31000000 290000000 
xxxxxxxxx 
100000000xxxxxxxxxxxxxxxxxxxxxxxxxx 
31046895 301046895 

Pomyślałem, że problemem jest ra dogodna liczba, która może się różnić, więc jedna ma 3 liczby r, r * x, r * x * x w ten sposób, że r zaczyna się od wartości, że r * x jest bliskie y (gdzie x i y są wejściami problemu przy użyciu tych samych liter, co główny post). Wykorzystałem spostrzeżenie, że jeśli pierwsza cyfra r jest d, to in r musi się też pojawić cyfry d * x i d * x * x, aby uczynić r (lub lepiej r * x) jednym rozwiązaniem.

05AB1E , 16 bajtów

[>©Ð²÷s²*)€{Ë®s#

Wypróbuj online. (UWAGA: Bardzo nieefektywne rozwiązanie, więc używaj danych wejściowych zbliżonych do wyniku. Działa to również w przypadku większych danych wejściowych, ale w przypadku TIO upłynie limit czasu po 60 sekundach).

Wyjaśnienie:

[                   # Start an infinite loop
 >                  #  Increase by 1 (in the first iteration the implicit input is used)
  ©                 #  Store it in the register (without popping)
   Ð                #  Triplicate it
    ²÷              #  Divide it by the second input
      s             #  Swap so the value is at the top of the stack again
       ²*           #  Multiply it by the second input
         )          #  Wrap all the entire stack (all three values) to a list
          €{        #  Sort the digits for each of those lists
             ®s     #  Push the value from the register onto the stack again
            Ë       #  If all three lists are equal:
               #    #   Stop the infinite loop