Dato un valore x trova il valore numerico più piccolo maggiore di y che può essere moltiplicato e diviso per x mantenendo tutte le cifre originali.

• I nuovi numeri non perdono cifre.
• I nuovi numeri non guadagnano cifre.

Per esempio:

Ingresso: x = 2, y = 250000

• Originale: 285714
  • Divisione: 142857
  • Moltiplicazione: 571428

Questo è vero perché 285714 è maggiore di y ; quindi quando diviso per x risulta in 142857 e quando moltiplicato per x risulta in 571428 . In entrambi i test sono presenti tutte le cifre originali del 285714 e non sono state aggiunte cifre aggiuntive.

Le regole

• X dovrebbe essere 2 o 3 poiché qualsiasi cosa superiore richiede troppo tempo per essere calcolata.
• Y deve essere un numero intero maggiore di zero .
• Vince il codice più corto.

Casi test

Questi sono i miei casi di test più comuni in quanto sono i più veloci da testare.

• 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

chiarimenti

• Il tipo di divisione non ha importanza. Se riesci a ottenere 2,05, 0,25 e 5,20 in qualche modo, sentiti libero.

Buona fortuna a tutti voi!

Buccia , 14 byte

ḟ§¤=OoDd§¤+d*/

Provalo online!

Spiegazione

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

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

Provalo online!

Accetta input nel modulo [x,y].

Spiegazione

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

Commento

La debolezza di Brachylog nel riutilizzare più valori più volte appare qui; questo programma è quasi interamente idraulico e molto poco algoritmo.

Pertanto, potrebbe sembrare più conveniente semplicemente codificare il valore di y (c'è un commento su questa domanda ipotizzando che 2 sia l'unico valore possibile). Tuttavia, esistono infatti soluzioni per y = 3, il che significa che purtroppo anche l'impianto idraulico deve gestire il valore di y . Il più piccolo di cui sono a conoscenza è il seguente:

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

(La tecnica che ho usato per trovare questo numero non è del tutto generale, quindi è possibile che ci sia una soluzione più piccola usando un altro approccio.)

È improbabile che tu lo verifichi con questo programma. Brachylog pè scritto in un modo molto generale che non ha ottimizzazioni per casi speciali (come il caso in cui sia già noto sia l'input che l'output, il che significa che è possibile effettuare la verifica in O ( n log n ) tramite l'ordinamento, piuttosto rispetto alla O ( n !) per l'approccio a forza bruta che sospetto stia usando). Di conseguenza, ci vuole molto tempo per verificare che 105263157894736842 sia una permutazione di 315789473684210526 (l'ho lasciato in esecuzione per diversi minuti ora senza evidenti progressi).

(EDIT: Ho controllato l'origine Brachylog per il motivo. Si scopre che se si utilizza psu due numeri interi noti, l'algoritmo utilizzato genera tutte le possibili permutazioni dell'intero in questione fino a quando non trova uno uguale all'intero di output, come l'algoritmo è "ingresso → indigits, permute indigits → outdigits, outdigits → uscita". Un algoritmo più efficace sarebbe di impostare la relazione outdigits / uscita prima , in modo che il backtracking entro la permutazione potrebbe tenere conto che le cifre erano disponibili.)

Perl 6 , 56 54 byte

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

Provalo online!

Alternativa interessante, calcolo n * x ^k per k = -1,0,1:

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

Pulito , 92 byte

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

Provalo online!

Abbastanza semplice. Spiegazione in arrivo tra un po '.

q, 65 byte

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

Dividi il numero sulla base 10, ordina ogni ordine crescente e controlla se è uguale. In caso contrario, incrementa ye riprova

JavaScript (ES6), 76 73 69 byte

^{Salvato 3 byte utilizzando eval(), come suggerito da @ShieruAsakoto}

Accetta input come (x)(y).

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

Provalo online!

Una versione ricorsiva sarebbe di 62 byte , ma qui non è adatta a causa dell'elevato numero di iterazioni richieste.

Come?

$g$

Esempio:

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

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

Quando si sommano due matrici insieme, ognuna di esse viene implicitamente forzata in una stringa separata da virgola. L'ultima cifra del primo array verrà concatenata direttamente con la prima cifra del secondo array senza virgola, il che rende questo formato inequivocabile.

Esempio:

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

Ma:

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

Commentate

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 byte

Due byte rasati grazie al commento di Lynn

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

Japt, 24 byte

Soluzione abbastanza ingenua su alcune birre; Sono sicuro che c'è un modo migliore.

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

Provalo

Python 2 , 69 byte

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

Provalo online!

Gelatina ,  14  13 byte

-1 grazie a Erik the Outgolfer (`` usa make_digits, quindi Dnon era necessario)
+2 correzione di un bug (grazie ancora a Erik the Outgolfer per aver segnalato il problema off-by)

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

Un programma completo che stampa il risultato (come collegamento diadico viene fornito un elenco di lunghezza 1).

Provalo online!

Come?

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

Si noti che quando la divisione non è esatta l'istruzione decimale implicita (equivalente a a D) applicata prima dell'ordinamento produce una parte frazionaria,
ad esempio: 1800÷3D-> [6,0,0]
while 1801÷3D->[6.0,0.0,0.33333333333337123]

Mathematica, 82 74 byte

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

-8 byte grazie a tsh

Funzione che accetta argomenti come [x,y]. Effettivamente una forza bruta ricerca che controlla se la lista ordinata di cifre per y, y/xe xysono gli stessi.

Provalo online!

APL (NARS), 490 caratteri, 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

test

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

Ho pensato che il problema fosse un numero conveniente che può variare, quindi uno ha i 3 numeri r, r * x, r * x * x nel modo in cui r inizia a un valore che r * x è vicino a y (dove xey sono input del problema utilizzando le stesse lettere del post principale). Ho usato l'osservazione che se la prima cifra di r è d che in r deve apparire anche le cifre d * x e d * x * x, per rendere r (o meglio r * x) una soluzione.

05AB1E , 16 byte

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

Provalo online. (NOTA: soluzione molto inefficiente, quindi usa input vicini al risultato. Funziona per input più grandi anche localmente, ma su TIO scadrà dopo 60 secondi.)

Spiegazione:

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