Um número é inteiro se for um número inteiro não negativo sem parte decimal. Então 0e 8e 233494.0são inteiros, enquanto 1.1e 0.001e 233494.999não são.

Entrada

Um número de ponto flutuante na base / codificação padrão do seu idioma.

Por exemplo, a representação inteira padrão para Cálculo lambda binário seria numerais da igreja . Mas a representação inteira padrão para Python é a base 10 decimal , não Unary .

Saída

Um valor verdadeiro, se a entrada for inteira, um valor falso, se não for.

Observe que, se o seu idioma suportar apenas a precisão decimal, digamos, 8 casas, 1.000000002poderá ser considerado inteiro.

A entrada e a saída podem ser feitas por qualquer método de E / S padrão .

Casos de teste

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

Pontuação

Assim como no código-golfe , o envio mais curto vence. Boa sorte!

APL (Dyalog) , 3 bytes

⌊≡|

Experimente online!

Observe que f←foi anexado no link do TIO devido a limitações técnicas, mas normalmente não é necessário.

Haskell , 27 16 bytes

Esta função verifica se xestá contida na lista de números inteiros não negativos que não são maiores que x.

f x=elem x[0..x]

Experimente online!

Wolfram Language (Mathematica) , 17 15 14 bytes

Guardado 1 byte graças a Not a tree!

#>=0==#~Mod~1&

Experimente online!

Primeira resposta do Mathematica \ o /

Mathematica, 15 bytes

Economizou 2 bytes graças a @ user202729!

#==⌊Abs@#⌋&

Pitão, 4 bytes

qs.a

Suíte de teste

O número é igual ( q) ao piso ( s) do seu valor absoluto ( .a)?

Casca , 3 bytes

£ΘN

Experimente online! O terceiro caso de teste atinge o tempo limite no TIO, então cortei alguns dígitos. Tentei executá-lo localmente, mas o matei após alguns minutos, pois estava usando mais de 6 GB de memória e meu computador começou a gaguejar. Teoricamente, deveria terminar em algum momento ...

Explicação

Isso corresponde à descrição do desafio diretamente.

£Θ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?

Python 2 , 18 bytes

lambda n:n%1==0<=n

Experimente online!

/// , 94 bytes, entrada codificada

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

Experimente online!

Entrada entre as duas linhas verticais finais ( ||)

Tira -00...0e .00...0converte todos os dígitos restantes em xs e testa se o número restante ainda tem xs após .ou -não seguido por ..

Pode salvar até 7 bytes, dependendo do que é contado como truthy e falsey, já que esse idioma não possui valores nativos de truthy / falsey, está atualmente sendo exibido truee, falsemas pode mudar para, por exemplo, Te Fpara 87 bytes, se for permitido.

Oitava , 15 bytes

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

Experimente online!

Este é baseado na abordagem usada na resposta Haskell do @ flawr .

Enquanto ele traz a contagem de bytes para 15, é vergonhosamente ineficiente (sem querer ofender), criando uma lista de cada número inteiro de 0para xe ver se xestá contido dentro.

Oitava , 18 bytes

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

Experimente online!

Recebe a entrada como um número de precisão dupla. Retorna verdadeiro se inteiro.

Verifica se a entrada quando arredondada é igual à magnitude da entrada. Este será apenas o caso quando o número for positivo e inteiro.

Oitava , 18 bytes

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

Experimente online!

Uma solução alternativa para 18 bytes. Infelizmente, a modfunção no Octave não converte implicitamente a boolem a double; portanto, +( )é necessário em torno da comparação maior que a. Caso contrário, essa solução teria sido mais curta.

Oitava , 18 bytes

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

Experimente online!

E outro ... não consigo obter menos de 18 bytes . Tudo por ter que permitir que 0 seja verdadeiro com o >=invés de apenas >.

C ++ (gcc) , 33 bytes

int f(float x){return(uint)x==x;}

Experimente online!

Aceto , 6 bytes

rfdi±=p

r agarra a entrada
f o converte em um flutuador
dei e duplica e converte-o para um número inteiro
± pressiona o valor absoluto (b / c não pode ser negativo)
= verifica se são iguais
p imprime o resultado

Experimente online!

Pitão , 6 bytes

&gQZsI

Experimente online!

QBIC , 17 bytes

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

Explicação

?             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

Se uma das verificações falhar, isso retornará 0. Se ambas forem verdadeiras, retornará -1 x -1 = 1

Python 2 e Python 3 , 21 18 bytes

lambda n:n>=0==n%1

Experimente online! (Py2)
Experimente online! (Py3)

3 bytes salvos graças ao Sr. XCoder.

C (gcc), 27 28 27 25 bytes

^{-2 graças a PrincePolka}

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

Experimente online!

Define uma macro "função" gque aceita um parâmetro f(de qualquer tipo). Em seguida, verifica se a conversão f mod 1é zero e se fnão é negativa.

C #, Java: 43 bytes

-1 byte graças a Zacharý
-1 byte graças a TheLetalCoder

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

O C # possui uma otimização especial de 33 bytes que você não pode fazer em java:

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

Para teste

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));
        }
    }
}

Planilhas Google, 10 bytes

Função de planilha anônima que registra as entradas da célula A1e as saídas para a célula chamadora.

=A1=Int(A1

Prolog (SWI) , 24 bytes

f(X):-X>=0,round(X)=:=X.

Experimente online!

Ly , 35 47 bytes

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

Experimente online!

Ly tem suporte de flutuador, mas a única maneira de criar um flutuador atualmente é realizando divisão. Não há como usar um float como entrada, então tive que verificar manualmente a string.

Perdeu 13 bytes adicionando suporte para números negativos.

JavaScript, 14

n=>!(n<0||n%1)

Perl 5, 11 +1 (-p) bytes

$_=abs==int

O -lcomutador não é contado porque, para testes, é exibido

experimente online

Perl 6 ,  15  13 bytes

{.narrow~~UInt}

Teste-o

{.Int==$_>=0}

Teste-o

Java (OpenJDK 8) , 14 bytes

n->n%1==0&n>=0

Experimente online!

C #, 40 37 29 bytes

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

Guardado 8 bytes graças a @Dennis_E!

Resposta antiga (37 bytes)

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

Resposta antiga antiga (40 bytes):

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

JavaScript, 17 15 bytes

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

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

Obrigado a edc65 por detectar meus erros.

Sinclair ZX81 não expandido, 20 bytes

 1 INPUT A
 2 PRINT ABS A=INT A

20 bytes porque BASIC é tokenizado.

Simplesmente produzirá 1 (verdadeiro) se o número for positivo e o valor do número digitado for igual ao seu valor inteiro. As saídas 0 de qualquer uma dessas condições não são atendidas.

C, C ++: 38 37 bytes

-1 byte graças a Zacharý

-1 byte graças ao ceilingcat

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

Para teste

C: Experimente online

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;
}

JavaScript (Node.js) , 11 bytes

n=>n<0==n%1

Experimente online!

J , 7 4 bytes

Foi removida a verificação desnecessária de celing após a solução de Erik The Outgolfer

<.=|

Experimente online!

Lisp comum, 36 32 bytes

(lambda(n)(=(max n 0)(floor n)))

Experimente online!

Transposição da resposta de marmeladze .

Python simbólico , 21 bytes

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

Experimente online!

Usa uma comparação encadeada:

• _%(_==_) == (_!=_)verifica se n%1 == 0, somente verdadeiro sen não tiver parte decimal.
• (_!=_) <= _verifica se 0 <= n, somente verdadeiro se o número inteiro não for negativo.