При заданном значении x найдите наименьшее числовое значение, большее y , которое можно умножить и разделить на x , сохранив при этом все исходные цифры.

• Новые номера не теряют цифр.
• Новые номера не набирают цифры.

Например:

Ввод: х = 2, у = 250000

• Оригинал: 285714
  • Отдел: 142857
  • Умножение: 571428

Это правда, потому что 285714 больше, чем у ; затем при делении на х получается 142857, а при умножении на х получается 571428 . В обоих тестах присутствуют все оригинальные цифры от 285714 , и никакие дополнительные цифры не были добавлены.

Правила

• Х должно быть 2 или 3, так как для вычисления чего-либо более высокого требуется слишком много времени.
• Y должен быть целым числом больше нуля .
• Самый короткий код выигрывает.

Тестовые случаи

Это мои самые распространенные тестовые случаи, так как они являются самыми быстрыми для тестирования.

• х = 2, у = 250000 = 285714
• х = 2, у = 290000 = 2589714
• х = 2, у = 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 {.}

Комментарий

Слабость Brachylog в повторном использовании нескольких значений проявляется здесь; в этой программе почти все слесарное дело и очень маленький алгоритм.

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

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

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

Однако вряд ли вы подтвердите это с помощью этой программы. Brachylog pнаписан очень общим способом, который не имеет оптимизаций для особых случаев (например, в случае, когда и вход, и выход уже известны, что означает, что вы можете выполнить проверку в O ( n log n ) с помощью сортировки, а не чем O ( n !) для подхода грубой силы, который я подозреваю, он использует). Как следствие, требуется очень много времени, чтобы проверить, что 105263157894736842 - это перестановка 315789473684210526 (я оставляю его работающим в течение нескольких минут без видимого прогресса).

(РЕДАКТИРОВАТЬ: я проверил источник Brachylog по причине. Оказывается, что если вы используете pдва известных целых числа, используемый алгоритм генерирует все возможные перестановки рассматриваемого целого числа, пока не найдет тот, который равен выходному целому числу, в качестве алгоритма это «вход → индексы, перестановка индексов → выходы, выходы → выход». Более эффективным алгоритмом было бы сначала установить отношение «выход / выход» , чтобы обратное отслеживание в перестановке могло учитывать, какие цифры были доступны.)

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 спасибо Эрику Искателю (`` использует make_digits, поэтому Dне требуется)
+2 исправление ошибки (еще раз спасибо Эрику Искателю за то, что он указал на одну проблему)

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

Mathematica, 82 74 байта

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

-8 байт благодаря тш

Функция, которая принимает аргументы как [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 

Я думал, что проблема в том, что ra удобное число, которое может меняться, так что у каждого есть 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