Bir değer verilen X daha küçük sayısal değer daha yüksek bulmak y çarpılır ve bölünmesi olma yeteneğine sahip x orijinal basamak koruyarak.

• Yeni sayılar rakamları kaybetmez.
• Yeni sayılar rakam kazanmaz.

Örneğin:

Giriş: x = 2, y = 250000

• Orijinal: 285714
  • Bölüm: 142857
  • Çarpma: 571428

Çünkü bu durum geçerlidir 285.714 daha büyük olan y ; Daha sonra bölündüğü zaman X sonuçların 142857 ve ile çarpıldığında x sonuçları 571428 . Her iki testte de 285714 orijinal basamakların tümü mevcuttur ve fazladan basamak eklenmemiştir.

Kurallar

• Daha yüksek bir şeyin hesaplanması çok uzun sürdüğü için X 2 veya 3 olmalıdır .
• Y , sıfırdan büyük bir tam sayı olmalıdır .
• En kısa kod kazanır.

Test Durumları

Bunlar en yaygın test senaryolarım, çünkü test etmek en hızlı olanlar.

• 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

Açıklamalar

• Bölümün türü önemli değil. Eğer bir şekilde 2.05, 0.25 ve 5.20 alabilirsiniz , o zaman çekinmeyin.

Hepinize iyi şanslar!

Kabuk , 14 bayt

ḟ§¤=OoDd§¤+d*/

Çevrimiçi deneyin!

açıklama

ḟ§¤=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 bayt

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

Çevrimiçi deneyin!

Formda girdi alır [x,y].

açıklama

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

yorum

Brachylog'un birden çok değeri birden çok kez tekrar kullanmadaki zayıflığı burada görünür; Bu program neredeyse tüm sıhhi tesisat ve çok az algoritma.

Bu nedenle, y'nin değerini basitçe kodlamak daha uygun görünebilir (bu soruda, 2'nin tek olası değer olduğu varsayımı vardır). Bununla birlikte, aslında y = 3 için çözümler vardır, bu da maalesef sıhhi tesisatın y değerini de ele alması gerektiği anlamına gelir . Farkında olduğum en küçük şey şudur:

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

(Bu sayıyı bulmak için kullandığım teknik tamamen genel değil, bu nedenle başka bir yaklaşım kullanarak daha küçük bir çözüm olması mümkündür.)

Ancak bunu bu programla doğrulamanız pek olası değildir . Brachylog'lar p, özel durumlar için (hem giriş hem de çıktının zaten bilindiği gibi) optimizasyona sahip olmayan çok genel bir şekilde yazılır, yani O ( n log n ) ' de doğrulamayı sıralama yoluyla yapabilirsiniz. kullandığından şüphelendiğim kaba kuvvet yaklaşımı için O ( n !) Sonuç olarak, 105263157894736842'nin 315789473684210526'nın bir permütasyonu olduğunu doğrulamak çok uzun zaman alıyor (açık bir ilerleme olmadan birkaç dakika çalışıyorum.)

(EDIT: Brachylog kaynağını bu nedenle kontrol ettim. pBilinen iki tamsayı kullanırsanız, kullanılan algoritmanın algoritma olarak çıkış tamsayıya eşit olanı bulana kadar söz konusu tamsayı için olası tüm permütasyonları ürettiği ortaya çıkar. "girdi → indigits, permüde indigits → outdigits, outdigits → çıktı" dır. İlk önce outdigits / çıktı ilişkisini kurmak için daha verimli bir algoritma olacaktır , böylece permütasyon içindeki geri takip hangi basamakların mevcut olduğunu hesaba katabilir .)

Perl 6 , 56 54 bayt

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

Çevrimiçi deneyin!

İlginç bir alternatif, k = -1,0,1 için n * x ^k hesaplaması :

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

Temiz , 92 bayt

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

Çevrimiçi deneyin!

Gayet basit. Bir süre sonra açıklama geliyor.

q, 65 bayt

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

Sayıyı 10 tabanına ayırın, her artan değeri sıralayın ve eşit olup olmadığını kontrol edin. Değilse, y'yi artırın ve tekrar gidin

JavaScript (ES6), 76 73 69 bayt

^{eval()@ShieruAsakoto tarafından önerildiği gibi, kullanılarak 3 bayt kaydedildi}

Girişi alır (x)(y).

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

Çevrimiçi deneyin!

Özyinelemeli sürüm 62 bayt olur , ancak çok sayıda gerekli yineleme nedeniyle burada uygun değildir.

Nasıl?

yardımcı işlevi girdi olarak bir tamsayıyı alır, onu bir dizi karakter dizisine dönüştürür ve bu diziyi sıralar.$g$

Misal:

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

Rakamlarını karşılaştırmak ve bu kişilerce karşı , biz birleştirme olmadığını test ile arasında birleştirme eşittir kendisi ile.$y\times x$$y/x$$y$$g(y\times x)$$g(y/x)$$g(y)$

İki dizi birlikte eklenirken, her biri örtük olarak virgülle ayrılmış bir dizeye zorlanır. İlk dizinin son basamağı, aralarında virgül olmadan ikinci dizinin ilk basamağıyla doğrudan birleştirilecek ve bu da bu biçimi açık hale getirecektir.

Misal:

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

Fakat:

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

Yorumlananlar

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 bayt

Lynn'in yorumu sayesinde iki bayt tıraş oldu

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

Japt, 24 bayt

Birkaç bira üzerinde oldukça naif bir çözüm; Eminim daha iyi bir yol vardır.

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

Dene

Python 2 , 69 bayt

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

Çevrimiçi deneyin!

Jöle ,  14  13 bayt

-1 Outgolfer Erik sayesinde (`` make_digits kullanıyor, bu yüzden Dgerekli değildi)
+2 bir hatayı düzeltiyor (Outgolfer'a Erik bir konuyu işaret ettiği için tekrar teşekkürler)

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

Sonucu basan tam bir program (ikili bir bağlantı olarak 1 uzunluğunun bir listesi verilir).

Çevrimiçi deneyin!

Nasıl?

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

Bölme kesin olmadığında D, sıralamadan önce uygulanan örtülü ondalık komutunun (a'ya eşdeğer ) kesirli bir parça verdiğini unutmayın,
örneğin: 1800÷3D-> [6,0,0]
while 1801÷3D->[6.0,0.0,0.33333333333337123]

Mathematica, 82 74 bayt

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

Tsh sayesinde -8 bayt

Bağımsız değişkenleri olarak alan işlev [x,y]. Etkili bir kaba kuvvet için rakamları sıralama listesinin eğer kontrolleri arama y, y/xve xyaynıdır.

Çevrimiçi deneyin!

APL (NARS), 490 karakter, 980 bayt

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

Ölçek

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

Ben bir r 3 r r, r * x, r * x * x r * x y y yakın bir değere başlar (burada x ve y girdi ana yazı ile aynı harfleri kullanarak sorunun). R'nin ilk basamağı d'den r'den daha fazlaysa, r (veya daha iyi r * x) bir çözüm yapmak için de d * x ve d * x * x basamaklarının görünmesi gerektiği gözlemini kullandım.

05AB1E , 16 bayt

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

Çevrimiçi deneyin. (NOT: Çok verimsiz bir çözüm, bu nedenle sonuca yakın girişleri kullanın. Yerel olarak da daha büyük girişler için çalışır, ancak TIO'da 60 saniye sonra zaman aşımına uğrar.)

Açıklama:

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