Uguaglianza della frazione mista

15

Nella scuola elementare, i bambini imparano a conoscere le frazioni appropriate, dove il numeratore è inferiore al denominatore e quindi il valore della frazione è inferiore a uno. Successivamente, vengono insegnate le frazioni in cui il valore della frazione è maggiore di uno e due modi diversi per esprimere queste frazioni: frazioni miste e frazioni improprie.

Data una frazione mista, determinare se è equivalente alla frazione impropria in cui il valore intero e il numeratore sono concatenati insieme. Ad esempio, per l'input 1 3/4, la frazione impropria è 13/4.

Casi 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

Per l'input, puoi prendere la parte intera e la parte della frazione come input separati, ma non puoi prendere la frazione come input in due pezzi e non puoi prenderla come valore decimale. È possibile eliminare la parte intera (non prenderla come input) se non è necessario utilizzarla.

code-golf  number  decision-problem  rational-numbers 
— Stefano
fonte
La frazione dovrebbe o può essere semplificata? Come il quarto caso di prova sarebbe falso in quanto 54/100semplifica27/50
— Jo King il
1
L'output dovrebbe essere due valori distinti e coerenti o qualsiasi valore, forse incoerente, di verità / falsità?
— Luis Mendo,
1
A proposito, correggere il quarto caso di test su 55 non cambierebbe il problema, ma 55/100può anche essere semplificato 11/20, quindi la stessa domanda sollevata da @JoKing sorge qui.
— Sundar - Ripristina Monica il
3
"non puoi prendere la frazione come input in due pezzi" - err perché? Questo è esattamente ciò che /fa: /
— Jonathan Allan il
11
Questo sembra essere equivalente a "dato un input che non ha importanza e due numeri come una stringa separata da una barra, determinare se il secondo numero equivale a 10 alla potenza della lunghezza del primo numero".
— xnor

Risposte:

8

MATL , 7 byte

UsGXzU=

L'input è una stringa. L'output è 1per la verità, 0per la falsità.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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
fonte
8

Perl 6 , 16 12 byte

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

Provalo online!

Prende l'input come stringa che rappresenta la frazione. Si scopre che la tipizzazione dinamica di Perl 6 può gestire le stringhe in frazioni razionali, chi lo sapeva? Quindi la stringa "1/10"quando viene forzata su un numero, ritorna0.1

Il blocco di codice anonimo verifica semplicemente se la frazione più una è uguale a una concatenata con la frazione. Grazie alla risposta Python di xnor per avermi mostrato che la parte intera non ha importanza.

Vecchia soluzione, 27 26 byte

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

Provalo online!

Prende input come una frazione mista razionale e restituisce vero o falso. Restituisce false per il quarto caso di test perché può essere semplificato.

Spiegazione:

.nuderestituisce un elenco di [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
fonte
7
Immagino che .nudesia chiamato per nu merator + de nominator, ma qualcuno probabilmente ha avuto grande piacere nel poterlo chiamare così.
— Οuroso
1
Stavo per andare con qualcosa che lo prendeva come una singola stringa'1 3/10' {S/\s//==.words.sum}
— Brad Gilbert b2gills
6

Retina 0.8.2 , 17 16 byte

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

Provalo online! Richiede solo la parte della frazione, quindi la suite di test collegata rimuove l'intero dai casi di test. Spiegazione: La concatenazione impropria è uguale al numero misto solo se il denominatore è una potenza di 10 e il numeratore ha una cifra per ogni zero nel denominatore. I gruppi di bilanciamento di .NET vengono utilizzati per verificare l'esistenza di cifre sufficienti. Modifica: salvato 1 byte grazie a @sundar.

— Neil
fonte
Non funziona per 1 11/10. Sembra essere un problema con l'implementazione, non con il metodo
— H.PWiz,
1
Si noti che "È possibile eliminare la parte intera (non prenderla come input) se non è necessario utilizzarla". - quindi lo spazio iniziale potrebbe non essere necessario se si modifica l'input per avere solo la frazione.
— Sundar - Ripristina Monica il
1
@ H.PWiz Non penso che dobbiamo trattare input in cui il numeratore è maggiore del denominatore (dal momento che si suppone che siano frazioni miste con solo la parte decimale non integrale espressa come frazione). Ma chiederò all'OP di confermarlo.
— Sundar - Ripristina Monica il
@sundar Dovrei cambiarlo in ^invece, quindi non aiuta.
— Neil,
La /rende inequivocabile quello che stai corrispondenza, quindi non credo che è necessario l'ancora lì (che va da normali regole regex di corrispondenza, senza Retina esperienza qui). Sembra funzionare comunque: provalo online! .
— Sundar - Ripristina Monica il
6

Buccia , 8 byte

§·=r¤+r+

Provalo online!

Spiegazione

§(·=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
— ბიმო
fonte
5

R , 78 65 byte

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

Provalo online!

-13 byte grazie sia a Giuseppe che a JayCe!

— Robert S.
fonte
1
Basta subè bene qui. Inoltre, puoi usare t=invece ditext=
— Giuseppe il
1
Cosa posso dire? Brillante! semplifica piacevolmente a 65 byte
— JayCe
@JayCe Sono contento di vedere che ero sulla pagina giusta! Grazie!
— Robert S.
Puoi provare a eseguire il porting della risposta Python 3 di xnor per probabilmente 20 byte ...
— JayCe,
— Giuseppe,
4

Stax , 5 byte

╡ÄLσ`

Esegui ed esegui il debug

Spiegazione:

+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
fonte
4

Python 3 , 26 byte

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

Provalo online!

Ad esempio, input 3/4dà 3/4+1==13/4. Invece di prendere l'intera parte della frazione, l'abbiamo semplicemente impostata 1per testare l'uguaglianza della frazione mista. Casi di test di Chas Brown.

— XNOR
fonte
4

Brachylog , 15 byte

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

Provalo online!

Prende da solo la parte frazionaria come input di stringa.

Utilizza indirettamente la stessa idea della mia risposta Julia: "il denominatore è 10 ^ {lunghezza del numeratore}" si può dire come "il denominatore è una potenza di dieci e la lunghezza del denominatore è uguale alla lunghezza del numeratore + la lunghezza di "/" (ovvero 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

Risposta precedente:

15 20 byte

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

Provalo online!

(-1 byte grazie a @Fatalize, ma sfortunatamente +6 byte da quando ho scoperto bug nel metodo precedente.)

Stessa idea della mia risposta Julia .

— Sundar - Ripristina Monica
fonte
1
Puoi accorciarlo di 1 byte sostituendo la variabile Acon la variabile di output .(e quindi rimuovere l'ultimo Aperché la variabile di output è implicitamente lì alla fine)
— Fatalizza il
@Fatalize Grazie, ho dimenticato che l'output è praticamente disponibile come variabile libera in questi problemi di decisione. Sfortunatamente ho trovato dei bug nel codice che avevo: poiché richiedeva solo qualsiasi prefisso numerico e qualsiasi suffisso numerico, stava passando cose come 61/10(usando solo 6 come numeratore / prefisso) 2/110(usando solo 10 come denominatore / suffisso). Ho provato a risolverlo, non sono sicuro che questo sia il modo migliore per farlo.
— Sundar - Ripristina Monica il
Non sono sicuro di poterti aiutare perché non capisco affatto le specifiche di questa sfida, anche dopo averlo letto 3 volte. Non so come si chiamano "frazioni miste e frazioni improprie" nel mio paese, o se viene persino insegnato nelle scuole elementari qui.
— Fatalizza il
1
@Fatalize Abbastanza giusto. Ti interessa ripristinare la chat room? Ho un sacco di domande con cui tormentarti, se sei interessato e hai tempo.
— Sundar - Ripristina Monica il
Certo, chiedi a una mod di rianimare la stanza e
— taggami
3

Julia 0.6 , 29 byte

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

Provalo online!

Basato sull'idea che l'output dovrebbe essere vero solo quando il denominatore è una potenza di dieci con tanti zeri quante sono le cifre nel numeratore. Prende input come Rationaltipo, verifica che il denominatore sia uguale a 10 elevato al numero di cifre nel numeratore.

— Sundar - Ripristina Monica
fonte
3

Pulito , 57 byte

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

Provalo online!

Questo è un po 'più corto ma si rompe per numeratori / denominatori di grandi dimensioni.

Pulito , 77 61 60 58 byte

-1 grazie al suggerimento di OM sull'altra mia risposta

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

Provalo online!

Questo utilizza il metodo di Neil , è un po 'più breve di farlo direttamente.
C'è qualche trucco con sovraccarico di conversione, dove 1<+[48\\_<-:u]converte [Int]in [Char]e poi in {#Char} (:== String), ma Intdirettamente in String.

Pulito , 91 89 byte

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

Provalo online!

Definisce una funzione $ :: String String -> Boolche estrae il numeratore e il denominatore, la stringa concatena la parte intera e il numeratore e verifica l'equivalenza.

— Οurous
fonte
3

05AB1E , 7 byte

'/¡ćg°Q

Prende solo le frazioni come input.

Provalo online o verifica tutti i casi di test .

Spiegazione:

'/¡        # 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 spiegazione più generale:

Dobbiamo convalidare due cose:

  • Il denominatore è un fattore 10 ( 1, 10, 100, 1000, ecc.)?
  • La lunghezza del numeratore + 1 equivale alla lunghezza del denominatore?
    • Questa seconda parte viene eseguita controllando se il denominatore così com'è è uguale a 10 alla potenza della lunghezza del numeratore, che consente di risparmiare 2 byte

PS: Se potremmo prendere il numeratore e denominatore come ingressi separati, soli 3 byte sarebbe stato sufficiente: g°Q.

— Kevin Cruijssen
fonte
3

JavaScript, 26 byte

Accetta input nella sintassi del curry (f(x)(y) ) dove xè il numero intero ed yè la frazione come stringa.

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

Provalo online

— ispido
fonte
3

Java 10, 107 70 67 57 byte

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

Benvenuti nel mondo senza eval...

-40 byte creando una porta della risposta Python 2 di @ChasBrown .
-10 byte grazie a @Shaggy (avrei dovuto leggere meglio la risposta di @ChasBrown e il suo uso difind ( indexOf) ..)

Provalo online.

Spiegazione:

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
fonte
1
— Shaggy,
@Shaggy Ah, Chas Brown ha anche lo stesso nella risposta di Python 2 che ho collegato .. Non so perché non l'ho già usato .. Grazie!
— Kevin Cruijssen,
2

Perl 5 -p, 23 byte

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

Provalo online!

Prende da solo la parte frazionaria come input (come consentito da OP), output 1 per true e niente per 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

La parte decimale da sola sarebbe esattamente uguale al numeratore solo quando il denominatore è la prossima potenza immediata di dieci maggiore del numeratore, che è la condizione che dobbiamo verificare.

— Sundar - Ripristina Monica
fonte
2

Noether, 17 byte

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

Provalo online!

Spiegazione

Quindi come funziona? Bene, se guardi i casi di test, gli unici veri casi sono quando il denominatore ha una potenza di dieci,10un', dove un' è la lunghezza del numeratore più uno (un'=⌊log10⁡n⌋+1, dove n è il numeratore e ⌊X⌋ rappresenta la funzione di pavimentazione).

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
— Decadimento beta
fonte
2

R , 53 byte

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

Provalo online!

Prende solo la parte frazionaria come input. Come menzionato da xnor in un commento:

Questo sembra essere equivalente a "dato un input che non ha importanza e due numeri come una stringa separata da una barra, determinare se il secondo numero equivale a 10 alla potenza della lunghezza del primo numero".

La risposta di Robert S. è meno golosa ma molto più interessante della mia.

— Jayce
fonte
1

Excel, 52 byte

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

Ignora l'ingresso Numero intero. Fondamentalmente:IS Denominator = 10^LEN(Numerator)

Per denominatori limitati a <10^9: 48 byte:

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

La massa della logica si sta dividendo /. Se l'input può essere preso separatamente, 16 byte:

=10^LEN(B1)-C1=0
— Wernisch
fonte
1

Elisir , 81 byte

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

Provalo online!

Potrebbe essere in grado di andare da qualche parte con {n,"/"<>d}=Integer.parse b, ma non so come.

— Okx
fonte
1

2DFuck , 86 byte

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

Provalo online!

Accetta input senza parte intera.

— Wastl
fonte
1

C (gcc / clang), 59 49 47 byte

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

La risposta di Python 2 di Port of Chas Brown . Provalo online qui .

Ignora la parte intera dell'input. Grazie a Jonathan Frech per aver a golf 2 byte.

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
}
— OOBalance
fonte
'/'molto probabilmente può essere 47.
— Jonathan Frech,
Possibili 47 byte .
— Jonathan Frech,
Bello grazie!
— OOBalance,
Prego. Penso che ti sia dimenticato di aggiornare l'intestazione per riflettere il nuovo conteggio dei byte.
— Jonathan Frech,
1

ForceLang, 86 78 byte

set a io.readnum()
set b io.readnum()
set d number.parse a+b+""
io.write d=a+b
— SuperJedi224
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.