Annulation anormale (de Wolfram Alpha):

L'annulation anormale est une "annulation" des chiffres de a et b dans le numérateur et le dénominateur d'une fraction a / b qui se traduit par une fraction égale à l'original. Notez que s'il existe des comptages multiples mais différents d'un ou plusieurs chiffres dans le numérateur et le dénominateur, il y a ambiguïté sur les chiffres à annuler, il est donc plus simple d'exclure de tels cas de la considération. Lien

En termes simples, disons que vous avez une fraction a / b. Si vous pouvez annuler les chiffres de la fraction pour créer une autre fraction c / dégale à l'original ( a / b = c / d), une annulation anormale peut être utilisée pour simplifier la fraction.

Votre défi consiste à créer un programme ou une fonction qui saisit une chaîne de fraction sous la forme a/bet génère ou renvoie une valeur vraie si la fraction peut être simplifiée à l'aide d'une annulation anormale, et une valeur fausse dans le cas contraire. aet bseront toujours des entiers positifs non nuls. aet baura toujours deux ou plusieurs chiffres. De plus, tous les chiffres de l'un aou de l'autre bne seront pas annulés (vous n'obtiendrez pas l'entrée 12/21), au moins un chiffre de aet bsera annulé à chaque fois (vous n'obtiendrez pas l'entrée 43/21), et le résultat final ne sera jamais 0pour l'un ou l'autre aou b. Votre programme doit annuler tous les chiffres communs entre aet b(c.-à-d. Dans1231/1234, vous devez annuler a 1, a 2et a 3). S'il y a plusieurs possibilités d'annulation, choisissez d'abord le chiffre le plus à gauche (515/25 devient 15/2 et non 51/2).

Exemples:

Input      Output    Why

1019/5095  true      Remove the 0 and the 9 from both sides of the fraction to get 11/55, which is equivalent.
16/64      true      Remove the 6 from both sides, and get 1/4.
14/456     false     Remove the 4s. 14/456 is not equal to 1/56.
1234/4329  false     Remove the 2s, 3s, and 4s. 1234/4329 is not equal to 1/9.
515/25     false     Remove the first 5 from each side. 15/2 is not equal to 515/25.

C'est le code-golf , donc le code le plus court en octets gagne!

Pyth, 22 19 octets

Merci à @isaacg pour trois octets!

qFcMsMM,Jcz\/.-M_BJ

Explication:

qFcMsMM,Jcz\/.-M_BJ      Implicit: z=input().
       ,                 two-element list
        Jcz\/              J = split z on ','
                _BJ      Bifurcate reverse: [J,reversed(J)]
             .-M         map multiset difference of elements in both lists
                             this gives the multiset difference both ways
       ,Jcz\/.-M_BJ      On input 1019/5095: [['1019','5095'], ['11','55']]
    sMM                  convert all strings to numbers
  cM                     map by float division
qF                       fold equality

Essayez-le ici .

𝔼𝕊𝕄𝕚𝕟, 17 caractères / 34 octets

ïČ⍘/⎖0ⓢⓈë(ïę$)≔ëï

Try it here (Firefox only).

Explication

ïČ⍘/⎖0ⓢⓈë(ïę$)≔ëï // implicit: ï = input fraction
ïČ⍘/⎖0              // get the numerator...
      ⓢ            // split it...
        Ⓢ          // and check if any of its items satisfy the condition:
          ë(ïę$)    // When the item is removed from ï,
                ≔ëï // does its fractional value still equal the original fractional value?
                    // implicit output

Rubis, 95 76 octets

->a{x,y=a.split(?/).map &:chars;eval a+".0=="+(x-y).join+?/+(y-x).join+".0"}

Explication

->a{                                                    # start of lambda
      a.split(?/)                                       # splits input fraction into numerator and denominator
                 .map &:chars;                          # converts them both into arrays of digits
  x,y=                                                  # assigns the numerator to x and the denominator to y

  eval                                                  # Evaluate...
       a+".0                                            # Original fraction with a .0 attached -- this forces floating-point division
            =="                                         # Equals...
               +(x-y).join                              # Numerator: Takes the relative complement of y in x (all elements in x that are not in y) and joins the resulting array into a string
                          +?/+(y-x).join                # Denominator: Takes the relative complement of x in y and joins the resulting array
                                        +".0"           # Add a .0 to force floating-point division
}

Un grand merci à Doorknob pour avoir joué au golf à 19 octets.

TeaScript, 22 octets

xs`/`[0]M#E(xg(l))⌐E(x

Maintenant que tous les bogues ont été résolus dans TeaScript 3, cela fonctionne bien

Essayez-le en ligne

Suite de tests

MATL , 35 octets

jtXUw'\d+'XXZ)2$XKtbm~)Kwtbm~)UwU/=

Exemples

>> matl
 > jtXUw'\d+'XXZ)2$XKtbm~)Kwtbm~)UwU/=
 > 
> 1019/5095
1

>> matl
 > jtXUw'\d+'XXZ)2$XKtbm~)Kwtbm~)UwU/=
 >
> 14/456
0

Explication

j              % input string
tXUw           % duplicate, convert to number, swap
'\d+'XX        % apply regexp to split at '/'
Z)             % separate cell array of strings into two strings
2$XK           % copy those two strings to clipboard K
tbm~)          % remove from denominator all chars present in the numerator
Kw             % paste both strings and swap      
tbm~)          % remove from numerator all chars present in the denoninator
UwU/=          % obtain value of "simplified" fraction and compare with original

Javascript ES6, 73 octets

a=>[...a.split`/`[0]].some(x=>(e=eval)(a.replace(e(`/${x}/g`),``))==e(a))