È un numero intero?

26

Un numero è intero se è un numero intero non negativo senza parte decimale. Così 0e 8e 233494.0sono interi, mentre 1.1e 0.001e 233494.999non lo sono.

Ingresso

Un numero in virgola mobile nella base / codifica predefinita della tua lingua.

Ad esempio, la rappresentazione intera predefinita per Calcolo Lambda binario sarebbe costituita da numeri di Church . Ma la rappresentazione intera predefinita per Python è decimale in base 10 , non unaria .

Produzione

Un valore vero se l'input è intero, un valore falso se non lo è.

Nota che se la tua lingua supporta solo la precisione decimale per, diciamo, 8 posizioni, 1.000000002può essere considerata intera.

L'input e l'output possono essere eseguiti tramite qualsiasi metodo I / O standard .

Casi test

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

punteggio

Come per il code-golf , vince l'invio più breve. In bocca al lupo!

code-golf  number  decision-problem  integer 
— MD XF
fonte
2
@StephenLeppik Non è più facile della sfida della parità alla vaniglia, o di Hello World o della Truth Machine. (In effetti, è più difficile della maggior parte di quelli.)
— MD XF
Possiamo prendere input come due numeri, che rappresentano una frazione?
— Lirico, il
@LyricLy No, sarebbe molto più semplice per alcune lingue o non necessario per altre.
— MD XF,
Si noti che i numeri interi sono numeri interi non negativi. Aggiorna la tua prima frase per riflettere questo. E puoi aggiungere casi di test con numeri negativi se desideri mostrare come i numeri interi non sono negativi e gli output falsi per i numeri negativi sono validi.
— Thomas Ward,
1
@ThomasWard, l'articolo di Wikipedia sembra non essere pienamente d'accordo con te: "I testi che escludono zero dai numeri naturali a volte si riferiscono ai numeri naturali insieme a zero come i numeri interi, ma in altri scritti, quel termine viene utilizzato invece per gli interi (compresi numeri interi negativi) ". Ho letto il titolo come chiedendo numeri interi.
— ilkkachu,

Risposte:

16

Haskell , 27 16 byte

Questa funzione controlla se xè contenuta nell'elenco di numeri interi non negativi che non sono maggiori di x.

f x=elem x[0..x]

Provalo online!

— flawr
fonte
6

Buccia , 3 byte

£ΘN

Provalo online! Il terzo caso di test scade in TIO, quindi ho tagliato un paio di cifre. Ho provato a eseguirlo localmente, ma l'ho ucciso dopo un paio di minuti poiché utilizzava oltre 6 GB di memoria e il mio computer ha iniziato a balbettare. Dovrebbe teoricamente finire ad un certo punto ...

Spiegazione

Ciò corrisponde direttamente alla descrizione della sfida.

£Θ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
fonte
Che λx → floor(x) == abs(x)aspetto avrebbe in Husk?
— Lynn,
@Lynn Sarebbe §=⌊a, quindi un byte in più.
— Zgarb,
5

/// , 94 byte, input codificato

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

Provalo online!

Input tra le due linee verticali di terminazione ( ||)

Spoglia -00...0e .00...0, converte tutte le cifre rimanenti in xs, quindi verifica se il numero rimanente ha ancora xs dopo .o -no seguito da ..

Potrebbe salvare fino a 7 byte a seconda di ciò che viene considerato come verità e falsità poiché questa lingua non ha valori di verità / falsità nativi, attualmente è in uscita truee falsepotrebbe cambiare, ad esempio, Te Fper 87 byte se consentito.

— boboquack
fonte
5

Ottava , 15 byte

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

Provalo online!

Questo si basa sull'approccio utilizzato nella risposta Haskell di @ flawr .

Mentre porta il conteggio dei byte fino a 15, è vergognosamente inefficiente (senza offesa), creando una lista di ogni intero da 0a xe vedere se xè contenuto all'interno.

Ottava , 18 byte

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

Provalo online!

Accetta input come numero di precisione doppio. Restituisce vero se intero.

Verifica se l'ingresso arrotondato è uguale all'entità dell'ingresso. Questo avverrà solo quando il numero sarà positivo e intero.

Ottava , 18 byte

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

Provalo online!

Una soluzione alternativa per 18 byte. Purtroppo la modfunzione in Octave non converte implicitamente a boolin a double, quindi +( )è necessaria intorno al maggiore del confronto. Altrimenti questa soluzione sarebbe stata più breve.

Ottava , 18 byte

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

Provalo online!

E un altro ... Non riesco a ottenere meno di 18 byte . Tutto a causa della necessità di consentire che 0 sia vero con >=invece di giusto >.

— Tom Carpenter
fonte
4

Aceto , 6 byte

rfdi±=p

r prende input
f lo converte in float
d e i lo duplica e lo converte in un numero intero
± ne spinge il valore assoluto (b / c non può essere negativo)
= controlla se sono uguali
p stampa il risultato

Provalo online!

— FantaC
fonte
4

QBIC , 17 byte

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

Spiegazione

?             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 uno dei controlli fallisce, questo restituisce 0. Se entrambi sono veri, restituisce -1 x -1 = 1

— steenbergh
fonte
4

C (gcc), 27 28 27 25 byte

-2 grazie a PrincePolka

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

Provalo online!

Definisce una "funzione" macro gche accetta un parametro f(di qualsiasi tipo). Quindi controlla se il casting f mod 1è zero e se fnon è negativo.

— MD XF
fonte
Penso che sia necessario includere la dimensione della includedirettiva nel conteggio dei byte, dal momento che fmod è definito in math.h: vedi lì
— HatsuPointerKun
@HatsuPointerKun Funziona anche senza di essa
— Mr. Xcoder il
2
Non credo che tu abbia bisogno di -lm su distribuzioni C basate su Windows (funziona sulla mia macchina)
— Conor O'Brien,
25, #define g (f)! Fmod (f, f> = 0)
— PrincePolka
4

C #, Java: 43 byte

-1 byte grazie a Zacharý
-1 byte grazie a TheLetalCoder

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

C # ha una speciale ottimizzazione di 33 byte che non puoi fare in java: 

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

Per i test

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

Codice 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
fonte
Penso che puoi rimuovere uno spazio tra returne (.
— Zacharý,
ritorna a boole non c'è bisogno del ternario.
— TheLethalCoder
@TheLethalCoder boolnon esiste in Java
— HatsuPointerKun
Non conosco Java / C # così bene, ma puoi farcela return(int)n==n? O sarebbe cast n==ndi un int piuttosto che solo n?
— Zacharý,
1
È possibile ridurre la risposta Java 7 di 3 byte invertendo il controllo e cambiando l'operatore booleano in bit a bit: int w(float n){return(int)n!=n|n<0?0:1;}( 40 byte ). Come Java 8 lambda è ancora più breve: n->(int)n==n&n>=0( 17 byte ) , e lo stesso vale per la risposta C # come lambda: n=>(int)n==n&n>=0(anche 17 byte ) .
— Kevin Cruijssen,
4

Fogli Google, 10 byte

Funzione del foglio di lavoro anonima che comunica input dalla cella A1e output alla cella chiamante.

=A1=Int(A1
— Taylor Scott
fonte
3

Ly , 35 47 byte

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

Provalo online!

Ly ha il supporto float, ma attualmente l'unico modo per creare un float è eseguire la divisione. Non c'è modo di prendere un float come input, quindi ho dovuto controllare manualmente la stringa.

Persi 13 byte aggiungendo il supporto per i numeri negativi.

— LyricLy
fonte
3

JavaScript, 14

n=>!(n<0||n%1)
— edc65
fonte
13 byte:n=>!(n-(n|0))
— Ismael Miguel,
@IsmaelMiguel. Non funziona con numeri negativi.
@ThePirateBay Quale numero esatto? Ho provato con 5, 5.1, -5, -5.1, 0, 0.1 e -0.1.
— Ismael Miguel,
@IsmaelMiguel. (n=>!(n-(n|0)))(-3)ritorna true, ma dovrebbe tornare false. Vedi l'ultimo caso di test.
Oh, hai ragione su questo: / Ho letto male la domanda: /
— Ismael Miguel il
3

C #, 40 37 29 byte

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

8 byte salvati grazie a @Dennis_E!

Vecchia risposta (37 byte)

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

Vecchia vecchia risposta (40 byte):

bool z(float x){return (int)x==x&&x>=0;}
— yummypasta
fonte
2
30 byte: bool z(float x)=>x%1==0&&x>=0;e puoi usare un singolo &per 29 byte
— Dennis_E
@Dennis_E Grazie!
— yummypasta,
x=>x%1==0&x>=0è più breve e compilare inFunc<float, bool>
— TheLethalCoder
3

JavaScript, 17 15 byte

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


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

Grazie a edc65 per aver colto i miei errori.

— ericw31415
fonte
3

Sinclair ZX81 non espanso, 20 byte

 1 INPUT A
 2 PRINT ABS A=INT A

20 byte perché BASIC è tokenizzato.

Emetterà semplicemente 1 (vero) se il numero è positivo e il valore del numero inserito è uguale al suo valore intero. Le uscite 0 di una di queste condizioni non sono soddisfatte.

— Shaun Bebbers
fonte
1
È una lingua tokenizzata? Se lo è, dovresti indicarlo nella tua risposta.
— Taylor Scott,
1
Ci dispiace, sì, tokenizzato, cioè INPUT è 1 byte di RAM, così come STAMPA e persino> = a causa di una caratteristica voluta da ~ quirk ~ di Sinclair BASIC
— Shaun Bebbers,
1
In particolare, ogni numero di riga è 5 byte + 1 newline( \r\nequivalente in ZX81 parla), gli spazi bianchi non contano come byte poiché quelli sono già inclusi nelle parole chiave di solito a causa del sistema di immissione Sinclair 'one-key-press'. Durante l'esecuzione, richiederà più byte in quanto inserirà il valore di Ain var stack; Penso che ogni valore numerico sia sempre 5 byte di memoria.
— Shaun Bebbers,
1
e anche ZX Spectrum
— edc65
1
Per quanto ne so la modalità di tokenizzazione è esattamente la stessa (lo spettro ha più codici). E qualsiasi numero letterale è di 6 byte: un byte 'tag numerico' seguito dal valore codificato in un formato proprietario in virgola mobile a 5 byte)
— edc65
3

C, C ++: 38 37 byte

-1 byte grazie a Zacharý

-1 byte grazie a ceilingcat

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

Per i test

C: Provalo online

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

Codice 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
fonte
1
Questo funzionerà solo fino a INT_MAX. (Non mi interessa davvero, ma alcune persone lo fanno.)
— MD XF
Lo cambierebbe per return(int)n==n...funzionare?
— Zacharý,
Puoi radere un byte usando int senza segno anziché uno con segno (poiché non hai bisogno del >=0test): return(unsigned)n==n; E in C, puoi omettere il tipo restituito per altri 4 byte.
— Toby Speight,
Puoi salvare altri 8 byte:w(float n){n=n==(int)n&&n>=0;}
— Johan du Toit il
2

Python simbolico , 21 byte

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

Provalo online!

Utilizza un confronto concatenato:

  • _%(_==_) == (_!=_)controlla se n%1 == 0, solo vero se nnon ha una parte decimale.
  • (_!=_) <= _controlla se 0 <= n, vero solo se il numero intero non è negativo.
— FlipTack
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.