¿Es un número entero?

26

Un número es entero si es un entero no negativo sin parte decimal. So 0y 8y 233494.0son completos, while 1.1y 0.001y 233494.999no lo son.

Entrada

Un número de coma flotante en la base / codificación predeterminada de su idioma.

Por ejemplo, la representación entera predeterminada para el cálculo binario de Lambda serían los números de la Iglesia . Pero la representación entera predeterminada para Python es base 10 decimal , no unario .

Salida

Un valor verdadero si la entrada es completa, un valor falso si no lo es.

Tenga en cuenta que si su idioma solo admite precisión decimal, por ejemplo, 8 lugares, 1.000000002puede considerarse completo.

La entrada y salida se pueden realizar a través de cualquier método de E / S estándar .

Casos de prueba

Input        -> Output
332          -> true
33.2         -> false
128239847    -> true
0.128239847  -> false
0            -> true
0.000000000  -> true
1.111111111  -> false
-3.1415926   -> false
-3           -> false

Tanteo

Al igual que con code-golf , gana la presentación más corta. ¡Buena suerte!

code-golf  number  decision-problem  integer 
— MD XF
fuente
2
@StephenLeppik No es más fácil que el desafío de paridad de vainilla, o Hello World, o la Máquina de la Verdad. (De hecho, es más difícil que la mayoría de esos.)
— MD XF
¿Podemos tomar la entrada como dos números, que representan una fracción?
— Letra de
@LyricLy No, eso sería mucho más fácil para algunos idiomas o innecesario para otros.
— MD XF
Tenga en cuenta que los números enteros son enteros no negativos. Actualice su primera oración para reflejar esto. Y puede agregar casos de prueba de números negativos si desea mostrar cómo los números enteros no son negativos y las salidas falsas para números negativos son válidas.
— Thomas Ward,
1
@ThomasWard, ese artículo de wikipedia parece no estar totalmente de acuerdo con usted: "Los textos que excluyen el cero de los números naturales a veces se refieren a los números naturales junto con el cero como números enteros, pero en otros escritos, ese término se usa para los enteros (incluidos los enteros negativos) ". Leí el título como preguntando sobre enteros.
— ilkkachu

Respuestas:

6

Casco , 3 bytes

£ΘN

Pruébalo en línea! El tercer caso de prueba agotó el tiempo en TIO, por lo que corté un par de dígitos. Traté de ejecutarlo localmente, pero lo maté después de un par de minutos, ya que estaba usando más de 6 GB de memoria y mi computadora comenzó a tartamudear. Teóricamente debería terminar en algún momento ...

Explicación

Esto corresponde a la descripción del desafío de forma bastante directa.

£ΘN  Implicit input: a number.
  N  The infinite list [1,2,3,4...
 Θ   Prepend 0: [0,1,2,3,4...
£    Is the input an element of this list?
— Zgarb
fuente
¿Cómo se λx → floor(x) == abs(x)vería en Husk?
— Lynn
@ Lynn Eso sería §=⌊a, así que un byte más.
— Zgarb
5

/// , 94 bytes, entrada codificada

/=/\/x://:/\/\///-0/-:.0/.:.|/|:-|/|:0=1=2=3=4=5=6=7=8=9=|x/|:||/true:x:/-:/.:/|/+:++/false/||

Pruébalo en línea!

Entrada entre las dos líneas verticales de terminación (|| )

Tiras -00...0y .00...0, convierte todos los dígitos restantes a xs, luego prueba si el número restante todavía tiene xs después .o -no seguido de. .

Podría ahorrar hasta 7 bytes dependiendo de lo que se cuenta como verdadero y falso, ya que este lenguaje no tiene valores de verdadero / verdadero, actualmente se emite truey falsepodría cambiar, por ejemplo, Ty Fpor 87 bytes si está permitido.

— boboquack
fuente
5

Octava , 15 bytes

@(x)any(x==0:x)

Pruébalo en línea!

Este se basa en el enfoque utilizado en la respuesta de Haskell de @ flawr .

Si bien reduce el recuento de bytes a 15, es vergonzosamente ineficiente (sin intención de ofender), creando una lista de cada número entero desde y 0hasta xsi xestá contenido dentro.

Octava , 18 bytes

@(x)fix(x)==abs(x)

Pruébalo en línea!

Toma la entrada como un número de doble precisión. Devuelve verdadero si está entero.

Comprueba si la entrada cuando se redondea es igual a la magnitud de la entrada. Este solo será el caso cuando el número sea positivo y completo.

Octava , 18 bytes

@(x)~mod(x,+(x>0))

Pruébalo en línea!

Una solución alternativa para 18 bytes. Lamentablemente, la modfunción en Octave no convertirá implícitamente boola a double, por lo que +( )se necesita alrededor de la comparación. De lo contrario, esta solución habría sido más corta.

Octava , 18 bytes

@(x)x>=0&~mod(x,1)

Pruébalo en línea!

Y otro ... Parece que no puedo bajar de 18 bytes . Todo por tener que permitir que 0 sea verdadero con el en >=lugar de solo >.

— Tom Carpenter
fuente
4

Aceto , 6 bytes

rfdi±=p

r toma entrada
f lo convierte en un flotador
dy lo duplicamos y lo convertimos en un número entero
± empuja su valor absoluto (b / c no puede ser negativo)
= comprueba si son iguales
p imprime el resultado

Pruébalo en línea!

— FantaC
fuente
4

QBIC , 17 bytes

?(:=int(a))*(a>0)

Explicación

?             PRINT
 (:=int(a))     if the input (: assigns the cmd line param to 'a') equals itself 
                cast to int, -1 else 0
 *              times
 (a>0)          if the input > 0, -1 else 0

Si cualquiera de las comprobaciones falla, esto devuelve 0. Si ambas son verdaderas, devuelve -1 x -1 = 1

— Steenbergh
fuente
4

C (gcc), 27 28 27 25 bytes

-2 gracias a PrincePolka

#define g(f)!fmod(f,f>=0)

Pruébalo en línea!

Define una macro "función" gque toma un parámetro f(de cualquier tipo). Luego comprueba si el lanzamiento f mod 1es cero y si fno es negativo.

— MD XF
fuente
Creo que debe incluir el tamaño de la includedirectiva en el recuento de bytes, ya que fmod se define en math.h: ver allí
— HatsuPointerKun
@HatsuPointerKun También funciona sin él
— Sr. Xcoder
2
No creo que necesites -lm en distribuciones C basadas en Windows (funciona en mi máquina)
— Conor O'Brien
25, #define g (f)! Fmod (f, f> = 0)
— PrincePolka
4

C #, Java: 43 bytes

-1 byte gracias a Zacharý
-1 byte gracias a TheLetalCoder

int w(float n){return(n==(int)n&&n>=0)?1:0;}

C # tiene una optimización especial de 33 bytes que no puede hacer en Java: 

bool w(float n){return(int)n==n;}

Para las pruebas

Código C #:

class Program {
    int w(float n){return(n==(int)n&&n>=0)?1:0;}

    static void Main(string[] args)
    {
        var p = new Program();
        float[] fTab = new float[]{
            332,33.2f,128239847,0.128239847f,0,0.0000f,1.1111111111f,-3.1415926f,-3
        };
        foreach (float f in fTab) {
            Console.WriteLine(string.Format("{0} = {1}", f, (p.w(f) != 0).ToString()));
        }
        Console.ReadKey();
    }
}

Código Java:

public class MainApp {
    int w(float n){return(n==(int)n&&n>=0)?1:0;}

    public static void main(String[]a) {
        MainApp m = new MainApp();
        float testArr[] = new float[]{
                332,33.2f,128239847,0.128239847f,0,0.0000f,1.1111111111f,-3.1415926f,-3
        };

        for (float v : testArr) {
            System.out.println(v + " = " + String.valueOf(m.w(v)!=0));
        }
    }
}
— HatsuPointerKun
fuente
Creo que puedes eliminar un espacio entre returny (.
— Zacharý
devuelve ay boolno hay necesidad del ternario.
— TheLethalCoder
@TheLethalCoder boolno existe en Java
— HatsuPointerKun
No conozco Java / C # tan bien, pero ¿puedes hacerlo return(int)n==n? ¿O eso se lanzaría n==na un int en lugar de solo n?
— Zacharý
1
Puede reducir la respuesta de Java 7 en 3 bytes invirtiendo la comprobación y cambiando el operador booleano a uno bit a bit: int w(float n){return(int)n!=n|n<0?0:1;}( 40 bytes ). Como Java 8 lambda es aún más corto: n->(int)n==n&n>=0( 17 bytes ) , y lo mismo se aplica a la respuesta de C # como lambda: n=>(int)n==n&n>=0(también 17 bytes ) .
— Kevin Cruijssen
4

Hojas de cálculo de Google, 10 bytes

Función de hoja de trabajo anónima que cuenta la entrada de la celda A1y las salidas a la celda que llama

=A1=Int(A1
— Taylor Scott
fuente
3

Ly , 35 47 bytes

ir"-"=[0u;]pr[["0"=![psp>l"."=[ppr!u;]p<2$]pp]]

Pruébalo en línea!

Ly tiene soporte flotante, pero la única forma de crear un flotante actualmente es realizando una división. No hay forma de tomar un flotador como entrada, por lo que tuve que verificar manualmente la cadena.

Perdió 13 bytes agregando soporte para números negativos.

— LyricLy
fuente
3

JavaScript, 14

n=>!(n<0||n%1)
— edc65
fuente
13 bytes:n=>!(n-(n|0))
— Ismael Miguel el
@IsmaelMiguel. No funciona para números negativos.
@ThePirateBay ¿Qué número exacto? Intenté con 5, 5.1, -5, -5.1, 0, 0.1 y -0.1.
— Ismael Miguel
@IsmaelMiguel. (n=>!(n-(n|0)))(-3)vuelve true, pero debería volver false. Ver el último caso de prueba.
Oh, tienes razón en eso: / Leí mal la pregunta: /
— Ismael Miguel
3

C #, 40 37 29 bytes

bool z(float x)=>x%1==0&x>=0;

¡Guardado 8 bytes gracias a @Dennis_E!

Respuesta anterior (37 bytes)

bool z(float x){return x%1==0&&x>=0;}

Antigua respuesta anterior (40 bytes):

bool z(float x){return (int)x==x&&x>=0;}
— yummypasta
fuente
2
30 bytes: bool z(float x)=>x%1==0&&x>=0;y puede usar un solo &para 29 bytes
— Dennis_E
@Dennis_E ¡Gracias!
— yummypasta
x=>x%1==0&x>=0es más corto y compilado aFunc<float, bool>
— TheLethalCoder
3

JavaScript, 17 15 bytes

_=>_<0?0:_==~~_


_=>_<0?0:_==(_|0)

Gracias a edc65 por atrapar mis errores.

— ericw31415
fuente
3

Sinclair ZX81 sin expandir, 20 bytes

 1 INPUT A
 2 PRINT ABS A=INT A

20 bytes porque BASIC está tokenizado.

Simplemente generará 1 (verdadero) si el número es positivo y el valor del número ingresado es igual a su valor entero. Las salidas 0 de cualquiera de esas condiciones no se cumplen.

— Shaun Bebbers
fuente
1
¿Es este un lenguaje tokenizado? Si es así, debe indicarlo en su respuesta.
— Taylor Scott
1
Lo sentimos, sí a tokenizado, es decir, INPUT es 1 byte de RAM, al igual que PRINT e incluso> = debido a una característica pretendida ~ peculiar ~ de Sinclair BASIC
— Shaun Bebbers
1
Específicamente, cada número de línea es 5 bytes + 1 newline( \r\nequivalente en el lenguaje ZX81), los espacios en blanco no cuentan como bytes, ya que esos ya están incluidos en las palabras clave, generalmente debido al sistema de entrada Sinclair 'presionar una tecla'. Al ejecutarse, tomará más bytes ya que pondrá el valor de Aen var stack; Creo que cada valor numérico siempre tiene 5 bytes de memoria.
— Shaun Bebbers
1
y ZX Spectrum también
— edc65
1
Hasta donde yo sé, el modo de tokenización es exactamente el mismo (Spectrum tiene más códigos). Y cualquier número literal es de 6 bytes: un byte de 'etiqueta numérica' seguido del valor codificado en un formato de coma flotante patentado de 5 bytes)
— edc65
3

C, C ++: 38 37 bytes

-1 byte gracias a Zacharý

-1 byte gracias a ceilingcat

int w(float n){return(int)n==n&n>=0;}

Para las pruebas

C: Pruébelo en línea

Código C:

#include <stdio.h>
int main() {
    float f[] = { 332,33.2f,128239847,0.128239847f,0,0.0000f,1.1111111111f,-3.1415926f,-3 };
    int t;
    for ( t = 0; t < 9; ++t) {
        printf("%f = %s\n", f[t], w(f[t])?"true":"false");
    }
    return 0;
}

Código C ++:

#include <iostream>
int main() {
    std::initializer_list <std::pair<float,bool>> test{
        {332.f,true}, {33.2f,false}, {128239847.f,true}, {0.128239847f,false}, {0.f,true}, {0.000000f,true}, {1.111111f,false}, {-3.1415926f,false}, {-3.f,false}
    };

    for (const auto& a : test) {
        if (w(a.first) != a.second) {
            std::cout << "Error with " << a.first << '\n';
        }
    }
    return 0;
}
— HatsuPointerKun
fuente
1
Esto solo funcionará hasta INT_MAX. (Realmente no me importa, pero algunas personas sí.)
— MD XF
¿Cambiarlo a return(int)n==n...trabajar?
— Zacharý
Puede reducir un byte utilizando unsigned int en lugar de uno firmado (ya que no necesita la >=0prueba): return(unsigned)n==n; y en C, puede omitir el tipo de retorno para otros 4 bytes.
— Toby Speight
Puede guardar 8 bytes más:w(float n){n=n==(int)n&&n>=0;}
— Johan du Toit
2

Python simbólico , 21 bytes

_=_%(_==_)==(_!=_)<=_

Pruébalo en línea!

Utiliza una comparación encadenada:

  • _%(_==_) == (_!=_)comprueba si n%1 == 0, solo verdadero si nno tiene parte decimal.
  • (_!=_) <= _comprueba si 0 <= n, solo es verdadero si el entero no es negativo.
— FlipTack
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.