Égalité des fractions mixtes

15

À 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.

code-golf  number  decision-problem  rational-numbers 
— Stephen
source
La fraction devrait-elle ou peut-elle être simplifiée? Comme le quatrième cas de test serait faux car 54/100simplifie27/50
— Jo King
1
La sortie devrait-elle être deux valeurs distinctes et cohérentes ou toute valeur, éventuellement incohérente, véridique / falsey?
— Luis Mendo
1
Soit dit en passant, fixer le 4ème cas de test à 55 ne changerait pas le problème - 55/100peut également être simplifié 11/20, de sorte que la même question soulevée par @JoKing se pose là.
— sundar
3
"vous ne pouvez pas prendre la fraction en entrée en deux parties" - pourquoi? C'est exactement ce que /fait: /
— Jonathan Allan
11
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".
— xnor

Réponses:

8

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
— Luis Mendo
source
8

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
— Jo King
source
7
Je suppose que cela .nudeporte le nom de nu merator + de nominator, mais quelqu'un a probablement pris un grand plaisir à pouvoir l'appeler ainsi.
— 2018 23urous
1
J'allais aller avec quelque chose qui le prenait comme une seule chaîne'1 3/10' {S/\s//==.words.sum}
— Brad Gilbert b2gills
6

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.

— Neil
source
Ne fonctionne pas pour 1 11/10. Cela semble être un problème avec votre implémentation, pas avec la méthode
— H.PWiz
1
Notez que "Vous pouvez supprimer la partie entière (ne pas la prendre comme entrée) si vous n'avez pas besoin de l'utiliser." - ainsi l'espace de tête peut être inutile si vous changez l'entrée pour avoir seulement la fraction.
— sundar
1
@ H.PWiz Je ne pense pas que nous ayons à traiter des entrées où le numérateur est supérieur au dénominateur (car celles-ci sont censées être des fractions mixtes avec uniquement la partie décimale non intégrale exprimée en fraction). Mais je vais demander au PO de le confirmer.
— sundar
@sundar Je devrais le changer à la ^place, donc ça n'aide pas.
— Neil
Le /rend sans ambiguïté ce que vous êtes correspondant, donc je ne pense pas que vous avez besoin de l'ancre là - bas ( en passant par les règles de correspondance habituels regex, aucune expertise Retina ici). Semble fonctionner quand même: essayez-le en ligne! .
— sundar
6

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
— ბიმო
source
5

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!

— Robert S.
source
1
C'est subbien ici. En outre, vous pouvez utiliser t=au lieu detext=
— Giuseppe
1
Que puis-je dire? Brillant! il simplifie bien à 65 octets
— JayCe
@JayCe Heureux de voir que j'étais sur la bonne page! Merci!
— Robert
Vous pouvez essayer de porter la réponse Python 3 de xnor pour probablement 20 octets ...
— JayCe
— Giuseppe
4

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
— wastl
source
4

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.

— xnor
source
4

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 .

— Sundar - Rétablir Monica
source
1
Vous pouvez le raccourcir de 1 octet en remplaçant la variable Apar la variable de sortie .(et ainsi supprimer la dernière Acar la variable de sortie est implicitement là à la fin)
— Fatalize
@Fatalize Merci, j'oublie que la sortie est à peu près disponible comme variable libre dans ces problèmes de décision. Malheureusement, j'ai trouvé des bogues dans le code que j'avais: puisqu'il ne demandait que n'importe quel préfixe numérique et n'importe quel suffixe numérique, il passait des choses comme 61/10(en utilisant seulement 6 comme numérateur / préfixe) 2/110(en utilisant seulement 10 comme dénominateur / suffixe). J'ai essayé de le réparer, mais je ne sais pas si c'est la meilleure façon de le faire.
— sundar
Je ne suis pas sûr de pouvoir vous aider car je ne comprends pas du tout les spécifications de ce défi, même après l'avoir lu 3 fois. Je ne sais pas comment on appelle "fractions mixtes et fractions impropres" dans mon pays, ou si c'est même enseigné dans les écoles élémentaires ici.
— Fatalize
1
@Fatalize Assez juste. Souhaitez-vous réactiver la salle de chat? J'ai un tas de questions à vous harceler, si vous êtes intéressé et que vous avez le temps.
— sundar
Bien sûr, il suffit de demander à un mod de raviver la pièce et de me taguer lorsque vous posez des questions
— Fatalize
3

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.

— Sundar - Rétablir Monica
source
3

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.

— Οurous
source
3

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.

— Kevin Cruijssen
source
3

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

— Hirsute
source
3

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
— Kevin Cruijssen
source
1
— Shaggy
@Shaggy Ah, Chas Brown a même le même dans la réponse Python 2 que j'ai lié .. Je ne sais pas pourquoi je ne l'ai pas déjà utilisé .. Merci!
— Kevin Cruijssen
2

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.

— Sundar - Rétablir Monica
source
2

Noether, 17 octets

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

Essayez-le en ligne!

Explication

dixuneuneune=⌊Journaldix⁡n⌋+1n⌊X⌋

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
— Beta Decay
source
2

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.

— JayCe
source
1

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
— Wernisch
source
1

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.

— Okx
source
1

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
}
— OOBalance
source
'/'peut très probablement être 47.
— Jonathan Frech
Possible 47 octets .
— Jonathan Frech
Bien merci!
— OOBalance
Je vous en prie. Je pense que vous avez oublié de mettre à jour votre en-tête pour refléter le nouveau nombre d'octets.
— Jonathan Frech
1

ForceLang, 86 78 octets

set a io.readnum()
set b io.readnum()
set d number.parse a+b+""
io.write d=a+b
— SuperJedi224
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.