À l'école primaire, les enfants apprennent les fractions appropriées, où le numérateur est inférieur au dénominateur, et donc la valeur de la fraction est inférieure à un. Plus tard, ils apprennent les fractions où la valeur de la fraction est supérieure à un et deux façons différentes d'exprimer ces fractions: les fractions mixtes et les fractions impropres.

Étant donné une fraction mixte, déterminez si elle est équivalente à la fraction impropre où la valeur entière et le numérateur sont concaténés ensemble. Par exemple, pour la saisie 1 3/4, la fraction incorrecte est 13/4.

Cas de test

1 3/4        -> falsey
1 3/10       -> truthy
6 6/7        -> falsey
55 55/100    -> truthy
4 9/100      -> falsey
40 9/100     -> falsey
7 49/1000    -> falsey
9 1/2        -> falsey
999 999/1000 -> truthy
1 21/200     -> falsey
1 21/101     -> falsey

Pour l'entrée, vous pouvez prendre la partie entière et la partie fraction comme des entrées distinctes, mais vous ne pouvez pas prendre la fraction comme entrée en deux parties et vous ne pouvez pas la prendre comme une valeur décimale. Vous pouvez supprimer la partie entière (ne pas la prendre comme entrée) si vous n'avez pas besoin de l'utiliser.

MATL , 7 octets

UsGXzU=

L'entrée est une chaîne. La sortie est 1pour truey, 0pour falsey.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

U     % Implicit input. Convert to number(s): gives a vector of two numbers
s     % Sum of that vector
G     % Push input again
Xz    % Remove spaces
U     % Convert to number
=     % Equal? Implicit display

Perl 6 , 16 12 octets

{1+$_==1~$_}

Essayez-le en ligne!

Prend l'entrée comme une chaîne représentant la fraction. Il s'avère que le typage dynamique de Perl 6 peut gérer les chaînes en fractions rationnelles, qui savait? Ainsi, la chaîne "1/10"lorsqu'elle est contrainte à un nombre, renvoie0.1

Le bloc de code anonyme vérifie simplement si la fraction plus un est égale à une concaténée avec la fraction. Merci à la réponse Python de xnor pour m'avoir montré que la partie entière n'a pas d'importance.

Ancienne solution, 27 26 octets

{.nude[0]==.Int~[%] .nude}

Essayez-le en ligne!

Prend l'entrée comme une fraction mixte rationnelle et renvoie vrai ou faux. Renvoie false pour le quatrième cas de test car il peut être simplifié.

Explication:

.nuderenvoie une liste de [numerator, denominator].

{                        } # Anonymous code block
 .nude[0]    # Check if the numerator of the mixed fraction
         ==  # Is equal to
           .Int  # The integer part of the fraction
               ~ # Concatenated to
                [%] .nude  # The numerator modulo the denominator
                           # And return implicitly

Retina 0.8.2 , 17 16 octets

(.)+/1(?<-1>0)*$

Essayez-le en ligne! Nécessite uniquement la partie fraction, de sorte que la suite de tests liée supprime l'entier des cas de test. Explication: La concaténation incorrecte est égale au nombre mixte uniquement si le dénominateur est une puissance de 10 et que le numérateur a un chiffre pour chaque zéro du dénominateur. Les groupes d'équilibrage de .NET sont utilisés pour vérifier qu'il existe suffisamment de chiffres. Edit: 1 octet enregistré grâce à @sundar.

Husk , 8 octets

§·=r¤+r+

Essayez-le en ligne!

Explication

§(·=r)(¤+r)(+)  -- example arguments: "1" "3/10"
§               -- fork both arguments
      (¤ r)     -- | read both: 1 3/10
      ( + )     -- | and add them: 13/10
           (+)  -- | concatenate: "13/10"
                -- and do
 (· r)          -- | read the second argument: 13/10
 ( = )          -- | and compare: 13/10 == 13/10
                -- : 1

Python 2 , 43 octets

lambda k:k.split('/')[1]==`10**k.find('/')`

Essayez-le en ligne!

R , 78 65 octets

function(n,e=function(a)eval(parse(t=sub(" ",a,n))))e("")==e("+")

Essayez-le en ligne!

-13 octets grâce à Giuseppe et JayCe!

Stax , 5 octets

╡ÄLσ`

Exécuter et déboguer

Explication:

+yj$e= Full program, implicit input
+      Add integer and fraction part
 y     Push unparsed input
  j$   Split on spaces and flatten, i.e. Remove spaces
    e  Evaluate
     = Check for equality

Python 3 , 26 octets

lambda k:eval(k+'+1==1'+k)

Essayez-le en ligne!

Par exemple, l'entrée 3/4donne 3/4+1==13/4. Au lieu de prendre la partie entière de la fraction, nous la configurons simplement 1pour tester l'égalité de la fraction mixte. Cas de test de Chas Brown.

Brachylog , 15 octets

ḍ{lᵛ&ht¬ị&t↔ị1}

Essayez-le en ligne!

Prend la partie fractionnaire seule comme entrée de chaîne.

Utilise indirectement la même idée que ma réponse Julia - "le dénominateur est 10 ^ {longueur du numérateur}" peut être dit comme "le dénominateur est une puissance de dix, et la longueur du dénominateur est égale à la longueur du numérateur + la longueur de "/" (ie 1).

ḍ                   % split the input in half
 {            }     % and verify that
  lᵛ                % each half has the same length (i.e. the string had even length)
    &ht¬ị           % and the last character of the first half is 
                    %  not a number (it should be "/")
         &t↔ị1      % and the second half when reversed is the number 1
                    %  i.e. the denominator should be a power of 10

Ancienne réponse:

15 20 octets

a₀ᶠịˢtl;10↺^.&a₁ᶠịˢh

Essayez-le en ligne!

(-1 octet grâce à @Fatalize, mais malheureusement +6 octets depuis que j'ai découvert des bugs dans l'ancienne méthode.)

Même idée que ma réponse Julia .

Julia 0.6 , 29 octets

r->10^ndigits(num(r))==den(r)

Essayez-le en ligne!

Basé sur l'idée que la sortie ne devrait être vraie que lorsque le dénominateur est une puissance de dix avec autant de zéros qu'il y a de chiffres dans le numérateur. Prend l'entrée comme un Rationaltype, vérifie que le dénominateur est égal à 10 élevé au nombre de chiffres du numérateur.

Nettoyer , 57 octets

import StdEnv,Text
$b#[u,v:_]=split"/"b
=v==""<+10^size u

Essayez-le en ligne!

Celui-ci est un peu plus court mais rompt pour les grands numérateurs / dénominateurs.

Propre , 77 61 60 58 octets

-1 grâce au conseil de l' OMᗺ sur mon autre réponse

import StdEnv,Text
$b#[u,v:_]=split"/"b
=1<+[48\\_<-:u]==v

Essayez-le en ligne!

Cela utilise la méthode de Neil , c'est un peu plus court que de le faire directement.
Il y a une astuce avec la surcharge de conversion, où se 1<+[48\\_<-:u]convertit [Int]en [Char]puis en {#Char} (:== String), mais Intdirectement enString .

Nettoyer , 91 89 octets

import StdEnv,Text
t=toInt
$a b#[b,c:_]=map t(split"/"b)
#d=t(a<+b)
=d/c==t a&&d-d/c*c==b

Essayez-le en ligne!

Définit une fonction $ :: String String -> Boolqui extrait le numérateur et le dénominateur, concatène en chaîne la partie entière et le numérateur et vérifie l'équivalence.

05AB1E , 7 octets

'/¡ćg°Q

Prend uniquement les fractions en entrée.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

'/¡        # Split the input by '/'
           #  i.e. '3/10' → ['3', '10']
   ć       # Head extracted:
           #  i.e. ['3', '10'] → 10 and 3
    g      # Take the length of the numerator
           #  i.e. '3' → 1
     °     # Take 10 to the power of this length
           #  1 → 10**1 → 10
      Q    # Check if that value equals the denominator
           #  10 and 10 → 1 (truthy)

Ou une explication plus générale:

Nous devons valider deux choses:

• Le dénominateur est-il un facteur 10 ( 1, 10, 100, 1000, etc.)?
• La longueur du numérateur + 1 est-elle égale à la longueur du dénominateur?
  • Cette deuxième partie se fait en vérifiant si le dénominateur tel quel est égal à 10 à la puissance de la longueur du numérateur, ce qui économise 2 octets

PS: Si nous pouvions prendre le numérateur et le dénominateur comme des entrées séparées, à seulement 3 octets aurait été suffisant: g°Q.

JavaScript, 26 octets

Prend l'entrée dans currying syntax ( f(x)(y)) où xest l'entier et yest la fraction sous forme de chaîne.

x=>y=>x==eval(x+y)-eval(y)

Essayez-le en ligne

Java 10, 107 70 67 57 octets

f->new Long(f.split("/")[1])==Math.pow(10,f.indexOf("/"))

Bienvenue dans le monde sans eval..

-40 octets en créant un port de réponse Python 2 @ChasBrown .
-10 octets grâce à @Shaggy (j'aurais dû mieux lire la réponse de @ChasBrown et son utilisation de find( indexOf) ..)

Essayez-le en ligne.

Explication:

f->                         // Method with String parameter and boolean return-type
  new Long(f.split("/")[1]) //  Take the denominator as integer
  ==Math.pow(10,            //  And check whether it is equal to 10 to the power of:
                f.indexOf("/"))
                            //   the length of the numerator-String

Haskell , 47 40 octets

-7 grâce à OMᗺ

f b|(u,v)<-span('/'<)b="/1"++('0'<$u)==v

Essayez-le en ligne!

Un portage de ma réponse Clean utilisant la méthode de Neil.

Perl 5 -p, 23 octets

$_=eval=~s/..//r eq$_+0

Essayez-le en ligne!

Prend la partie fractionnaire seule comme entrée (comme autorisé par OP), sort 1 pour vrai et rien pour faux.

$_=       # assign to be printed by -p
eval      # evaluate fraction to get 0.something, for eg. 0.54
=~s/..//r # remove the 0. part, giving 54
 eq       # string equality check
$_+0      # after first coercing input to number to remove / and denominator

La partie décimale prise en elle-même ne serait exactement égale au numérateur que lorsque le dénominateur est la puissance immédiatement supérieure de dix supérieure au numérateur, qui est la condition que nous devons vérifier.

Noether, 17 octets

I#I"/"^WL1-%WL_=P

Essayez-le en ligne!

Explication

$10^a$$a$$a = \lfloor \log_{10} n \rfloor + 1$$n$$\lfloor x \rfloor$

I#                - Push the first input then pop it off the stack
  I"/"^           - Push the second input and split the string at "/"
       W          - Convert the top (the denominator) of the stack from a string to a number
        L1-       - Take the log 10 of the top of the stack and subtract 1 (a)
           %      - Rotate the stack
            WL_   - Convert the top of the stack (the numerator) to a number, take the log10 and floor the result (b)
               =  - Check if a and b are equal
                P - Print the top of the stack

TeaScript , 25 octets

La première entrée est la fraction, la seconde est l'entier.

Je viens de commencer dans TeaScript donc ça pourrait être beaucoup joué

s"/")▒⌐ep(xs"/")░.n

Essayez-le en ligne!

R , 53 octets

function(n,x=el(strsplit(n,"/")))x[2]==10^nchar(x[1])

Essayez-le en ligne!

Prend uniquement la partie fractionnaire en entrée. Comme mentionné par xnor dans un commentaire:

Cela semble être équivalent à "étant donné une entrée qui n'a pas d'importance et deux nombres sous forme de chaîne séparés par une barre oblique, déterminez si le deuxième nombre est égal à 10 à la puissance de la longueur du premier nombre".

La réponse de Robert S. est moins golfique mais beaucoup plus intéressante que la mienne.

C (gcc) , 67 56 55 octets

• Onze octets enregistrés grâce à OOBalance .
• Enregistré un octet grâce au plafond .

m;x(char*_){for(m=1;*_++;m*=10)*_*=*_^47;m=m==atoi(_);}

Essayez-le en ligne!

Excel, 52 octets

=10^FIND("/",B1)/10-MID(B1,FIND("/",B1)+1,LEN(B1))=0

Ignore l'entrée entière. Fondamentalement:IS Denominator = 10^LEN(Numerator)

Pour les dénominateurs limités à <10^9: 48 octets:

=10^FIND("/",B1)/10-MID(B1,FIND("/",B1)+1,1E9)=0

La masse de la logique se divise /. Si l'entrée peut être prise séparément, 16 octets:

=10^LEN(B1)-C1=0

Elixir , 81 octets

fn b->[n,d]=String.split b,"/";String.to_integer(d)==:math.pow 10,byte_size n end

Essayez-le en ligne!

Pourrait être en mesure d'aller quelque part avec {n,"/"<>d}=Integer.parse b, mais je ne sais pas comment.

2DFuck , 86 octets

..!x..!...,,,,[>,,,,,,,,],,,,,,,,,[v!],[v!],[v!],![v!],,,[,,[v!],[v!],[v!],[v!]<,,,]r.

Essayez-le en ligne!

Prend l'entrée sans partie entière.

C (gcc / clang), 59 49 47 octets

f(a,b){a=atoi(b=strchr(a,47)+1)==pow(10,b+~a);}

Réponse de Python 2 du Port de Chas Brown . Essayez-le en ligne ici .

Ignore la partie entière de l'entrée. Merci à Jonathan Frech d' avoir joué au golf 2 octets.

Non golfé:

f(a, b) { // function returning an int and taking a string as input; also declaring another string variable
          // this abuses the parameters as much as possible, omitting the type int and implicitly converting it to char *
    a =                             // return a truthy or falsey value based on
        atoi(b = strchr(a, 47) + 1) // the denominator (as integer; 47 is the ASCII code for '/')
        == pow(10, b + ~a);         // is equal to 10 to the power of the length of the numerator-string
}

ForceLang, 86 78 octets

set a io.readnum()
set b io.readnum()
set d number.parse a+b+""
io.write d=a+b