За даним значенням x знайдіть найменше числове значення, що перевищує y, яке здатне множити і ділити на x , зберігаючи всі вихідні цифри.

• Нові цифри не втрачають цифр.
• Нові цифри не набирають цифр.

Наприклад:

Вхід: x = 2, y = 250000

• Оригінал: 285714
  • Відділ: 142857
  • Множення: 571428

Це вірно, тому що 285714 більше, ніж y ; то при діленні на х результати в 142857, а при множенні на x - в 571428 . В обох тестах присутні всі початкові цифри від 285714 , і додаткові цифри не додані.

Правила

• X має бути 2 або 3, оскільки що-небудь вище потребує занадто багато часу для обчислення.
• Y повинен бути цілим числом більше нуля .
• Виграє найкоротший код.

Випробування

Це мої найпоширеніші тестові випадки, оскільки вони найшвидші для тестування.

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

Роз'яснення

• Тип поділу не має значення. Якщо ви можете якось отримати 2,05, 0,25 і 5,20, тоді почувайтеся вільно.

Успіхів усім вам!

Лушпиння , 14 байт

ḟ§¤=OoDd§¤+d*/

Спробуйте в Інтернеті!

Пояснення

ḟ§¤=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 байт

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

Спробуйте в Інтернеті!

Бере введення у формі [x,y].

Пояснення

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 {.}

Коментар

Тут проявляється слабкість Брахілога при повторному використанні декількох значень; ця програма майже вся сантехніка та дуже мало алгоритму.

Як таке, може здатися більш зручним просто жорстке кодування значення y (є коментар до цього питання, гіпотезуючи, що 2 є єдиним можливим значенням). Однак насправді є рішення для y = 3, це означає, що, на жаль, сантехніка також має обробляти значення y . Найменше, що мені відомо, це наступне:

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

(Метод, який я використовував, щоб знайти це число, не є повністю загальним, тому можливо, що існує менше рішення, використовуючи інший підхід.)

Ви навряд чи це підтвердите за допомогою цієї програми. Brachylog's pнаписаний дуже загальним чином, що не має оптимізації для особливих випадків (наприклад, у випадку, коли і вхід, і вихід вже відомі, це означає, що ви можете проводити перевірку в O ( n log n ) шляхом сортування, а не ніж O ( n !) для жорстокого підходу, який я підозрюю, що він використовує). Як наслідок, потрібно дуже багато часу, щоб перевірити, що 105263157894736842 є перестановкою 315789473684210526 (я залишаю її працювати вже кілька хвилин, не маючи явного прогресу).

(EDIT: Я перевірив джерело Brachylog з причини. Виявляється, що якщо ви використовуєте pдва відомих цілих числа, використовуваний алгоритм генерує всі можливі перестановки цілого числа, доки не знайде таке, яке дорівнює вихідному цілому, як алгоритм є «вхідним → indigits, переставляє indigits → outdigits, outdigits → виходу». ефективніший алгоритм буде налаштувати вихідні відносини / outdigits першими , так що відкат в межах перестановки може прийняти до уваги , що були доступні цифрами.)

Perl 6 , 56 54 байти

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

Спробуйте в Інтернеті!

Цікава альтернатива, обчислення n * x ^k для k = -1,0,1:

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

Чисто , 92 байти

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

Спробуйте в Інтернеті!

Досить просто. Пояснення надходить через деякий час.

q, 65 байт

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

Розділіть число на базі 10, відсортуйте кожне зростання та перевірте, чи рівне воно. Якщо ні, збільшуйте y та йдіть знову

JavaScript (ES6), 76 73 69 байт

^{Збережено 3 байти за допомогою eval(), як запропонував @ShieruAsakoto}

Вводиться як " (x)(y).

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

Спробуйте в Інтернеті!

Рекурсивна версія буде складати 62 байти , але вона не дуже підходить тут через велику кількість необхідних ітерацій.

Як?

$g$

Приклад:

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

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

Додаючи два масиви разом, кожен з них неявно примусований до відокремленої комою рядка. Остання цифра першого масиву буде безпосередньо з'єднана з першою цифрою другого масиву без коми між ними, що робить цей формат однозначним.

Приклад:

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

Але:

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

Прокоментував

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 байт

Два байти відголилися завдяки коментарю Лінни

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

Japt, 24 байти

Досить наївне рішення на кілька пив; Я впевнений, що є кращий спосіб.

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

Спробуй це

Python 2 , 69 байт

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

Спробуйте в Інтернеті!

Желе ,  14  13 байт

-1 спасибі Еріку Outgolfer (`` використовує make_digits, тому Dне потрібно)
+2 виправлення помилки (ще раз дякую Еріку Outgolfer за вказівку на вирішення проблеми, що не стосується)

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

Повна програма, що друкує результат (у вигляді діадичного посилання виводиться список довжиною 1).

Спробуйте в Інтернеті!

Як?

×;÷;⁸Ṣ€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)

Зауважте, що коли поділ не є точним, неявна десяткова інструкція (еквівалентна a D), застосована до сортування, дає дробову частину,
наприклад: 1800÷3D-> [6,0,0]
while 1801÷3D->[6.0,0.0,0.33333333333337123]

Математика, 82 74 байт

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

-8 байт завдяки tsh

Функція, яка приймає аргументи як [x,y]. Ефективно пошук грубої сили, який перевіряє, чи відсортований список цифр для них y, y/xі xyчи однакові.

Спробуйте в Інтернеті!

APL (NARS), 490 символів, 980 байт

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

тест

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

Я подумав, що проблема, як зручне число, яке може змінюватись, так що у 3-х чисел r, r * x, r * x * x у тому, що r починається значення, яке r * x знаходиться біля y (де x і y є вхідними даними проблеми з використанням тих самих листів, що і основний пост). Я використав зауваження, що якщо перша цифра r є d, ніж у r, повинні з'являтися цифри d * x і d * x * x теж, щоб зробити r (або краще r * x) одним рішенням.

05AB1E , 16 байт

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

Спробуйте в Інтернеті. (ПРИМІТКА. Дуже неефективне рішення, тому використовуйте входи, близькі до результату. Він працює як для великих входів, так і локально, але для TIO він закінчиться через 60 секунд.)

Пояснення:

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