주어진 값 x 는 모든 원래 숫자를 유지하면서 x 를 곱하고 x 로 나눌 수있는 y 보다 큰 가장 작은 숫자 값을 찾습니다 .

• 새로운 숫자는 숫자를 잃지 않습니다.
• 새로운 숫자는 숫자를 얻지 못합니다.

예를 들면 다음과 같습니다.

입력 : x = 2, y = 250000

• 원본 : 285714
  • 사단 : 142857
  • 곱셈 : 571428

285714 가 y 보다 크기 때문에 이것은 사실입니다 . 다음으로 나누었을 때 의 X 결과 142,857 과 곱한 경우 X의 결과 571,428 . 두 테스트 모두 285714 의 모든 원래 숫자 가 존재하며 추가 숫자는 추가되지 않았습니다.

규칙

• 계산하는 데 시간이 오래 걸리므로 X 는 2 또는 3 이어야합니다 .
• Y 는 0 보다 큰 정수 여야 합니다 .
• 가장 짧은 코드가 승리합니다.

테스트 사례

테스트가 가장 빠르기 때문에 가장 일반적인 테스트 사례입니다.

• 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

설명

• 나누기 유형은 중요하지 않습니다. 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알려진 두 개의 정수 를 사용하면 사용 된 알고리즘은 알고리즘으로 출력 정수와 동일한 정수를 찾을 때까지 해당 정수의 가능한 모든 순열을 생성합니다. "입력 → 자릿수, permute 자릿수 → outdigits, outdigits → output"입니다.보다 효율적인 알고리즘은 우선 자릿수 / 출력 관계를 설정 하여 순열 내의 역 추적이 사용 가능한 자릿수를 고려할 수 있도록하는 것입니다.)

펄 6 , 56 54 바이트

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

온라인으로 사용해보십시오!

흥미로운 대안, k = -1,0,1에 대해 n * x ^k 계산 :

->\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를 증가시키고 다시 가십시오

자바 스크립트 (ES6), 76 73 69 바이트

^{eval()@ShieruAsakoto가 제안한대로을 사용하여 3 바이트 를 절약했습니다.}

로 입력을 (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

하스켈, 76 74 바이트

Lynn의 의견 덕분에 2 바이트가 줄었습니다.

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

apt, 24 바이트

몇 가지 맥주에 대한 순진한 해결책. 더 좋은 방법이 있다고 확신합니다.

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

시도 해봐

파이썬 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 Erik 덕분에 (``make_digits를 사용하므로 D필수는 아닙니다)
버그 수정 +2 (Out-by one 이슈를 지적한 Outgolfer Erik에게 다시 감사드립니다)

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

결과를 인쇄하는 전체 프로그램 (2 진 링크로 길이 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)

나누기가 정확하지 않은 D경우 정렬 전에 적용된 암시 적 십진 명령어 (a와 동등 )는 소수 부분을 생성합니다.
예 : 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,∞}]&

tsh 덕분에 -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 

나는 r이 r에 가까운 r (x와 y가 입력되는 값)로 시작하는 방식으로 r, r * x, r * x * x가 3 인 숫자를 가질 수있는 ra 편리한 숫자로 문제를 생각했습니다. 기본 게시물과 동일한 문자를 사용하는 문제). r의 첫 번째 숫자가 r보다 d 인 경우 r (또는 더 나은 r * x)을 하나의 솔루션으로 만들기 위해 d * x 및 d * x * 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