En la escuela primaria, los niños aprenden acerca de las fracciones adecuadas, donde el numerador es menor que el denominador y, por lo tanto, el valor de la fracción es menor que uno. Más tarde, se les enseña sobre fracciones donde el valor de la fracción es mayor que uno, y dos formas diferentes de expresar estas fracciones: fracciones mixtas y fracciones impropias.

Dada una fracción mixta, determine si es equivalente a la fracción impropia donde el valor entero y el numerador se concatenan juntos. Por ejemplo, para la entrada 1 3/4, la fracción impropia es 13/4.

Casos de prueba

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

Para la entrada, puede tomar la parte entera y la parte de la fracción como entradas separadas, pero no puede tomar la fracción como entrada en dos partes, y no puede tomarla como un valor decimal. Puede soltar la parte entera (no tomarla como entrada) si no necesita usarla.

MATL , 7 bytes

UsGXzU=

La entrada es una cadena. La salida es 1para la verdad, 0para falsey.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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 bytes

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

Pruébalo en línea!

Toma la entrada como una cadena que representa la fracción. Resulta que la escritura dinámica de Perl 6 puede manejar cadenas a fracciones racionales, ¿quién sabe? Entonces, la cadena "1/10"cuando se coacciona a un número, devuelve0.1

El bloque de código anónimo simplemente verifica si la fracción más uno es igual a uno concatenado con la fracción. Gracias a la respuesta de Python de xnor por mostrarme que la parte entera no importa.

Solución anterior, 27 26 bytes

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

Pruébalo en línea!

Toma la entrada como una fracción mixta racional y devuelve verdadero o falso. Devuelve falso para el cuarto caso de prueba porque puede simplificarse.

Explicación:

.nudedevuelve una lista 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 bytes

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

Pruébalo en línea! Requiere solo la parte de fracción, por lo que el conjunto de pruebas vinculado elimina el número entero de los casos de prueba. Explicación: La concatenación incorrecta es igual al número mixto solo si el denominador es una potencia de 10 y el numerador tiene un dígito por cada cero en el denominador. Los grupos de equilibrio de .NET se utilizan para verificar que existan suficientes dígitos. Editar: Guardado 1 byte gracias a @sundar.

Casco , 8 bytes

§·=r¤+r+

Pruébalo en línea!

Explicación

§(·=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 bytes

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

Pruébalo en línea!

R , 78 65 bytes

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

Pruébalo en línea!

-13 bytes gracias a Giuseppe y JayCe!

Stax , 5 bytes

╡ÄLσ`

Ejecutar y depurarlo

Explicación:

+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 bytes

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

Pruébalo en línea!

Por ejemplo, la entrada 3/4da 3/4+1==13/4. En lugar de tomar toda la parte de la fracción, solo la configuramos 1para probar la igualdad de fracción mixta. Casos de prueba de Chas Brown.

Brachylog , 15 bytes

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

Pruébalo en línea!

Toma la parte fraccional sola como una entrada de cadena.

Indirectamente usa la misma idea que mi respuesta de Julia: "el denominador es 10 ^ {longitud del numerador}" se puede decir que "el denominador es una potencia de diez, y la longitud del denominador es igual a la longitud del numerador + la longitud de "/" (es decir, 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

Respuesta anterior:

15 20 bytes

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

Pruébalo en línea!

(-1 byte gracias a @Fatalize, pero desafortunadamente +6 bytes desde que descubrí errores en el método anterior).

La misma idea que mi respuesta de Julia .

Julia 0.6 , 29 bytes

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

Pruébalo en línea!

Basado en la idea de que la salida debería ser verdadera solo cuando el denominador es una potencia de diez con tantos ceros como dígitos hay en el numerador. Toma la entrada como un Rationaltipo, verifica que el denominador sea igual a 10 elevado al número de dígitos en el numerador.

Limpio , 57 bytes

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

Pruébalo en línea!

Este es un poco más corto pero se rompe para numeradores / denominadores grandes.

Limpio , 77 61 60 58 bytes

-1 gracias al consejo de OMᗺ sobre mi otra respuesta

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

Pruébalo en línea!

Esto usa el método de Neil , es un poco más corto que hacerlo directamente.
Hay algunos trucos con la sobrecarga de conversión, donde se 1<+[48\\_<-:u]convierte [Int]a [Char]y luego a {#Char} (:== String), pero Intdirectamente aString .

Limpio , 91 89 bytes

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

Pruébalo en línea!

Define una función $ :: String String -> Boolque extrae el numerador y el denominador, concatena la cadena con la parte entera y el numerador, y verifica la equivalencia.

05AB1E , 7 bytes

'/¡ćg°Q

Solo toma las fracciones como entrada.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

'/¡        # 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)

O una explicación más general:

Tenemos que validar dos cosas:

• ¿Es el denominador un factor 10 ( 1, 10, 100, 1000, etc.)?
• ¿La longitud del numerador + 1 es igual a la longitud del denominador?
  • Esta segunda parte se realiza comprobando si el denominador tal como es es igual a 10 a la potencia de la longitud del numerador, lo que ahorra 2 bytes

PD: Si pudiéramos tomar el numerador y el denominador como entradas separadas, a sólo 3 bytes habría sido suficiente: g°Q.

JavaScript, 26 bytes

Toma entrada en la sintaxis de curry ( f(x)(y)) donde xes el entero y yes la fracción como una cadena.

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

Pruébalo en línea

Java 10, 107 70 67 57 bytes

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

Bienvenido al mundo sin eval..

-40 bytes creando un puerto de la respuesta Python 2 de @ChasBrown .
-10 bytes gracias a @Shaggy (debería haber leído mejor la respuesta de @ChasBrown y su uso defind ( indexOf) ..)

Pruébalo en línea.

Explicación:

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 bytes

-7 gracias a OMᗺ

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

Pruébalo en línea!

Un puerto de mi respuesta limpia usando el método de Neil.

Perl 5 -p, 23 bytes

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

Pruébalo en línea!

Toma la parte fraccional sola como entrada (según lo permitido por OP), salidas 1 para verdadero y nada para falso.

$_=       # 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 parte decimal tomada por sí misma sería exactamente igual al numerador solo cuando el denominador es la siguiente potencia inmediata de diez mayor que el numerador, que es la condición que debemos verificar.

Noether, 17 bytes

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

Pruébalo en línea!

Explicación

Entonces, ¿cómo funciona esto? Bueno, si observa los casos de prueba, los únicos casos verdaderos son cuando el denominador es una potencia de diez,$10^a$, dónde $a$ es la longitud del numerador más uno ($a = \lfloor \log_{10} n \rfloor + 1$, dónde $n$ es el numerador y $\lfloor x \rfloor$ representa la función del piso).

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 bytes

La primera entrada es la fracción, la segunda es el número entero.

Acabo de comenzar en TeaScript, por lo que podría jugar mucho golf

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

Pruébalo en línea!

R , 53 bytes

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

Pruébalo en línea!

Toma solo la parte fraccionaria como entrada. Como mencionó xnor en un comentario:

Esto parece ser equivalente a "dada una entrada que no importa y dos números como una cadena separados por una barra inclinada, determine si el segundo número es igual a 10 a la potencia de la longitud del primer número".

La respuesta de Robert S. es menos golfosa pero mucho más interesante que la mía.

C (gcc) , 67 56 55 bytes

• Once bytes guardados gracias a OOBalance .
• Guardado un byte gracias a ceilingcat .

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

Pruébalo en línea!

Excel, 52 bytes

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

Ignora la entrada entera. Básicamente:IS Denominator = 10^LEN(Numerator)

Para denominadores limitados a <10^9: 48 bytes:

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

La mayor parte de la lógica se está dividiendo /. Si la entrada se puede tomar por separado, 16 bytes:

=10^LEN(B1)-C1=0

Elixir , 81 bytes

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

Pruébalo en línea!

Podría llegar a algún lado {n,"/"<>d}=Integer.parse b, pero no estoy seguro de cómo.

2DFuck , 86 bytes

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

Pruébalo en línea!

Toma entrada sin parte entera.

C (gcc / clang), 59 49 47 bytes

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

Puerto de Chas Brown 's Python 2 respuesta . Pruébelo en línea aquí .

Ignora la parte entera de la entrada. Gracias a Jonathan Frech por jugar al golf 2 bytes.

Sin 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 bytes

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