Wenn ein Wert x gegeben ist, finden Sie den kleinsten numerischen Wert größer als y , der multipliziert und mit x geteilt werden kann, während alle ursprünglichen Ziffern beibehalten werden.

• Die neuen Nummern verlieren keine Ziffern.
• Die neuen Nummern erhalten keine Ziffern.

Zum Beispiel:

Eingabe: x = 2, y = 250000

• Original: 285714
  • Abteilung: 142857
  • Multiplikation: 571428

Dies ist wahr, weil 285714 größer als y ist ; dann , wenn sie durch unterteilt x Ergebnisse in 142857 und wenn multipliziert mit x führt zu 571.428 . In beiden Tests sind alle Originalziffern von 285714 vorhanden und es wurden keine zusätzlichen Ziffern hinzugefügt.

Die Regeln

• X sollte 2 oder 3 sein, da die Berechnung zu hoch ist.
• Y muss eine ganze Zahl größer als Null sein .
• Der kürzeste Code gewinnt.

Testfälle

Dies sind meine häufigsten Testfälle, da sie am schnellsten zu testen sind.

• 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

Klarstellungen

• Die Art der Aufteilung spielt keine Rolle. Wenn Sie irgendwie 2,05, 0,25 und 5,20 bekommen können, dann fühlen Sie sich frei.

Viel glück, euch allen!

Schale , 14 Bytes

ḟ§¤=OoDd§¤+d*/

Probieren Sie es online aus!

Erläuterung

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

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

Probieren Sie es online aus!

Nimmt Eingaben in das Formular vor [x,y].

Erläuterung

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

Kommentar

Hier zeigt sich die Schwäche von Brachylog, mehrere Werte mehrmals wiederzuverwenden. Dieses Programm ist fast alles Sanitär und sehr wenig Algorithmus.

Daher erscheint es möglicherweise bequemer, den Wert von y einfach fest zu codieren (es gibt einen Kommentar zu dieser Frage, in dem angenommen wird, dass 2 der einzig mögliche Wert ist). Es gibt jedoch tatsächlich Lösungen für y = 3, was bedeutet, dass die Installation leider auch den Wert von y verarbeiten muss . Das kleinste, das mir bekannt ist, ist das Folgende:

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

(Die Technik, mit der ich diese Zahl gefunden habe, ist nicht ganz allgemein, daher ist es möglich, dass es eine kleinere Lösung mit einem anderen Ansatz gibt.)

Es ist jedoch unwahrscheinlich, dass Sie dies mit diesem Programm überprüfen . Brachylog's pist sehr allgemein geschrieben und enthält keine Optimierungen für Sonderfälle (z. B. für den Fall, dass sowohl die Eingabe als auch die Ausgabe bereits bekannt sind). Dies bedeutet, dass Sie die Überprüfung in O ( n log n ) eher durch Sortieren durchführen können als das O ( n !) für den Brute-Force-Ansatz, von dem ich vermute, dass er verwendet wird). Infolgedessen dauert es sehr lange, bis überprüft wird, ob 105263157894736842 eine Permutation von 315789473684210526 ist (ich habe es jetzt einige Minuten lang ohne offensichtlichen Fortschritt laufen lassen).

(BEARBEITEN: Ich habe die Brachylog-Quelle aus diesem Grund überprüft. Wenn Sie pzwei bekannte Ganzzahlen verwenden, generiert der verwendete Algorithmus alle möglichen Permutationen der betreffenden Ganzzahl, bis eine gefunden wird, die der Ausgabe-Ganzzahl als Algorithmus entspricht ist „Eingang → indigits, permute indigits → outdigits, outdigits → Ausgang“. Ein effizienter Algorithmus wäre, die outdigits / Ausgangs - Beziehung einzurichten zuerst , so dass die Rückverfolgung innerhalb der Permutation berücksichtigen könnte , die Ziffern zur Verfügung stehen.)

Perl 6 , 56 54 Bytes

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

Probieren Sie es online aus!

Interessante Alternative, Berechnung von n * x ^k für k = -1,0,1:

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

Sauber , 92 Bytes

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

Probieren Sie es online aus!

Ziemlich einfach. Erklärung kommt in einer Weile.

q 65 Bytes

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

Teilen Sie die Zahl auf Basis 10, sortieren Sie jede aufsteigende Zahl und prüfen Sie, ob sie gleich ist. Wenn nicht, erhöhen Sie y und gehen Sie erneut

JavaScript (ES6), 76 73 69 Byte

^{3 Bytes wurden mithilfe eval()von gespeichert, wie von @ShieruAsakoto vorgeschlagen}

Nimmt Eingabe als (x)(y).

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

Probieren Sie es online aus!

Eine rekursive Version wäre 62 Byte , aber hier ist sie wegen der hohen Anzahl erforderlicher Iterationen nicht gut geeignet.

Wie?

$g$

Beispiel:

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

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

Wenn Sie zwei Arrays zusammenfügen, wird jedes davon implizit zu einer durch Kommas getrennten Zeichenfolge gezwungen. Die letzte Ziffer des ersten Arrays wird direkt mit der ersten Ziffer des zweiten Arrays ohne Komma verkettet, wodurch dieses Format eindeutig ist.

Beispiel:

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

Aber:

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

Kommentiert

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 Bytes

Dank Lynns Kommentar wurden zwei Bytes rasiert

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

Japt, 24 Bytes

Ziemlich naive Lösung bei ein paar Bieren; Ich bin sicher, es gibt einen besseren Weg.

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

Versuch es

Python 2 , 69 Bytes

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

Probieren Sie es online aus!

Gelee ,  14  13 Bytes

-1 danke an Erik den Outgolfer (`` verwendet make_digits, Dwar also nicht erforderlich)
+2 behebt einen Fehler (nochmals danke an Erik den Outgolfer für den Hinweis auf das Off-by-One-Problem)

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

Ein vollständiges Programm, das das Ergebnis druckt (als dyadischer Link wird eine Liste der Länge 1 erhalten).

Probieren Sie es online aus!

Wie?

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

Beachten Sie, dass, wenn die Division nicht genau ist, die implizite Dezimalanweisung (äquivalent zu a D), die vor der Sortierung angewendet wird, einen Bruchteil ergibt,
z. B.: 1800÷3D-> [6,0,0]
while 1801÷3D->[6.0,0.0,0.33333333333337123]

Mathematica, 82 74 Bytes

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

-8 Bytes dank tsh

Funktion, die Argumente als akzeptiert [x,y]. Effektiv eine Brute - Force, die überprüft , ob die sortierten Liste von Ziffern suchen y, y/xund xyist gleich.

Probieren Sie es online aus!

APL (NARS), 490 Zeichen, 980 Byte

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

Prüfung

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

Ich dachte, das Problem sei eine bequeme Zahl, die variieren kann, so dass man die 3 Zahlen r, r * x, r * x * x so hat, wie r zu einem Wert beginnt, dass r * x in der Nähe von y liegt (wobei x und y Eingaben sind des Problems mit den gleichen Buchstaben wie der Hauptbeitrag). Ich habe die Beobachtung verwendet, dass, wenn die erste Ziffer von r d ist als in r, auch die Ziffern d * x und d * x * x erscheinen müssen, um r (oder besser r * x) zu einer Lösung zu machen.

05AB1E , 16 Bytes

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

Probieren Sie es online aus. (HINWEIS: Sehr ineffiziente Lösung. Verwenden Sie daher Eingaben in der Nähe des Ergebnisses. Dies funktioniert auch lokal für größere Eingaben, bei TIO tritt jedoch nach 60 Sekunden eine Zeitüberschreitung auf.)

Erläuterung:

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