No ensino fundamental, as crianças aprendem sobre frações apropriadas, onde o numerador é menor que o denominador e, portanto, o valor da fração é menor que um. Posteriormente, eles são ensinados sobre frações em que o valor da fração é maior que uma e duas maneiras diferentes de expressar essas frações: frações mistas e frações impróprias.

Dada uma fração mista, determine se é equivalente à fração imprópria em que o valor inteiro e o numerador são concatenados juntos. Por exemplo, para entrada 1 3/4, a fração imprópria é 13/4.

Casos de teste

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 entrada, você pode considerar a parte inteira e a parte da fração como entradas separadas, mas não pode considerar a fração como entrada em duas partes e não pode ser considerada como valor decimal. Você pode soltar a parte inteira (não a aceitará como entrada) se não precisar usá-la.

MATL , 7 bytes

UsGXzU=

Entrada é uma sequência. A saída é 1para verdade, 0para falsey.

Experimente online!Ou verifique todos os casos de teste .

Explicação

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~$_}

Experimente online!

Recebe a entrada como uma sequência que representa a fração. Acontece que a digitação dinâmica do Perl 6 pode manipular cadeias de caracteres para frações racionais, quem sabia? Então a corda"1/10" quando forçada a um número, retorna0.1

O bloco de código anônimo simplesmente verifica se a fração mais um é igual a uma concatenada com a fração. Graças à resposta Python do xnor por me mostrar que a parte inteira não importa.

Solução antiga, 27 26 bytes

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

Experimente online!

Recebe a entrada como uma fração mista racional e retorna verdadeiro ou falso. Retorna false para o quarto caso de teste porque pode ser simplificado.

Explicação:

.nuderetorna uma 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)*$

Experimente online! Requer apenas a parte da fração, para que o conjunto de testes vinculado remova o número inteiro dos casos de teste. Explicação: A concatenação imprópria é igual ao número misto apenas se o denominador for uma potência de 10 e o numerador tiver um dígito para cada zero no denominador. Os grupos de balanceamento do .NET são usados ​​para verificar se existem dígitos suficientes. Editar: salvou 1 byte graças a @sundar.

Casca , 8 bytes

§·=r¤+r+

Experimente online!

Explicação

§(·=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('/')`

Experimente online!

R , 78 bytes 65

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

Experimente online!

-13 bytes graças a Giuseppe e JayCe!

Stax , 5 bytes

╡ÄLσ`

Execute e depure

Explicação:

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

Experimente online!

Por exemplo, entrada 3/4dá 3/4+1==13/4. Em vez de pegar a parte inteira da fração, apenas a configuramos 1para testar a igualdade da fração mista. Casos de teste de Chas Brown.

Braquilog , 15 bytes

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

Experimente online!

Toma a parte fracionária sozinha como uma entrada de sequência.

Indiretamente, usa a mesma ideia da minha resposta Julia - "o denominador é 10 ^ {comprimento do numerador}" pode ser dito como "o denominador é uma potência de dez e o comprimento do denominador é igual ao comprimento do numerador + o comprimento de "/" (ou seja, 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

Resposta mais antiga:

15 20 bytes

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

Experimente online!

(-1 byte graças a @Fatalize, mas infelizmente +6 bytes desde que descobri bugs no método mais antigo.)

Mesma ideia que a minha resposta de Julia .

Julia 0.6 , 29 bytes

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

Experimente online!

Com base na idéia de que a saída deve ser verdadeira somente quando o denominador for uma potência de dez com o número de zeros que houver dígitos no numerador. Pega a entrada como um Rationaltipo, verifica se o denominador é igual a 10 aumentado para o número de dígitos no numerador.

Limpo , 57 bytes

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

Experimente online!

Este é um pouco mais curto, mas quebra para numeradores / denominadores grandes.

Limpo , 77 61 60 58 bytes

-1 graças à dica de OMᗺ na minha outra resposta

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

Experimente online!

Isso usa o método de Neil , é um pouco menor do que fazê-lo diretamente.
Existem alguns truques com sobrecarga de conversão, onde 1<+[48\\_<-:u]converte [Int]para [Char]e depois para {#Char} (:== String), mas Intdiretamente para String.

Limpo , 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

Experimente online!

Define uma função $ :: String String -> Boolque extrai o numerador e o denominador, concatena a parte inteira e o numerador e verifica a equivalência.

05AB1E , 7 bytes

'/¡ćg°Q

Leva apenas as frações como entrada.

Experimente online ou verifique todos os casos de teste .

Explicação:

'/¡        # 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 uma explicação mais geral:

Temos que validar duas coisas:

• O denominador é um fator 10 ( 1, 10, 100, 1000, etc.)?
• O comprimento do numerador + 1 é igual ao comprimento do denominador?
  • Esta segunda parte é feita verificando se o denominador como está é igual a 10 à potência do comprimento do numerador, que economiza 2 bytes

PS: Se pudéssemos tomar o numerador eo denominador como entradas separadas, apenas 3 bytes teria sido suficiente: g°Q.

JavaScript, 26 bytes

Recebe entrada na sintaxe de curry ( f(x)(y)), onde xé o número inteiro e yé a fração como uma sequência.

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

Experimente online

Java 10, 107 70 67 57 bytes

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

Bem-vindo ao mundo sem eval ..

-40 bytes, criando uma porta da resposta Python 2 do @ChasBrown .
-10 bytes graças a @Shaggy (eu deveria ter lido melhor a resposta de @ChasBrown e seu uso de find( indexOf) ..)

Experimente online.

Explicação:

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 graças a OMᗺ

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

Experimente online!

Uma porta da minha resposta limpa usando o método de Neil.

Perl 5- p, 23 bytes

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

Experimente online!

Pega a parte fracionária sozinha como entrada (conforme permitido pelo OP), produz 1 para true e nada para false.

$_=       # 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

A parte decimal tomada por si só seria exatamente igual ao numerador apenas quando o denominador for a próxima potência imediata de dez maior que o numerador, que é a condição que precisamos verificar.

Noether, 17 bytes

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

Experimente online!

Explicação

Então, como isso funciona? Bem, se você olhar para os casos de teste, os únicos casos verdadeiros são quando o denominador é uma potência de dez,$10^a$, Onde $a$ é o comprimento do numerador mais um ($a = \lfloor \log_{10} n \rfloor + 1$, Onde $n$ é o numerador e $\lfloor x \rfloor$ representa a função do 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

A primeira entrada é a fração, a segunda é o número inteiro.

Eu apenas comecei no TeaScript, então ele pode ser muito jogado

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

Experimente online!

R , 53 bytes

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

Experimente online!

Toma apenas a parte fracionária como entrada. Como mencionado por xnor em um comentário:

Isso parece ser equivalente a "dada uma entrada que não importa e dois números como uma sequência separada por uma barra, determine se o segundo número é igual a 10 à potência do comprimento do primeiro número".

A resposta de Robert S. é menos golfe, mas muito mais interessante que a minha.

C (gcc) , 67 56 55 bytes

• Onze bytes salvos graças ao OOBalance .
• Guardou um byte graças ao ceilingcat .

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

Experimente online!

Excel, 52 bytes

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

Ignora a entrada Inteiro. Basicamente:IS Denominator = 10^LEN(Numerator)

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

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

O volume da lógica está se dividindo /. Se a entrada puder ser obtida separadamente, 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

Experimente online!

Pode ser capaz de chegar a algum lugar {n,"/"<>d}=Integer.parse b, mas não sei como.

2DFuck , 86 bytes

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

Experimente online!

Recebe entrada sem parte inteira.

C (gcc / clang), 59 49 47 bytes

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

Resposta do Python 2 do porto de Chas Brown . Experimente online aqui .

Ignora a parte inteira da entrada. Agradecimentos a Jonathan Frech por jogar 2 bytes.

Ungolfed:

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