Est-ce un nombre entier?

26

Un nombre est entier s'il s'agit d'un entier non négatif sans partie décimale. Donc , 0et 8et 233494.0sont tout, tout 1.1et 0.001et 233494.999ne sont pas.

Contribution

Un nombre à virgule flottante dans la base / l'encodage par défaut de votre langue.

Par exemple, la représentation entière par défaut pour le calcul lambda binaire serait des chiffres d'église . Mais la représentation entière par défaut pour Python est la base 10 décimale , pas Unary .

Sortie

Une valeur vraie si l'entrée est entière, une valeur fausse si elle ne l'est pas.

Notez que si votre langue ne prend en charge que la précision décimale jusqu'à, disons, 8 positions, elle 1.000000002peut être considérée comme entière.

L'entrée et la sortie peuvent être effectuées via n'importe quelle méthode d'E / S standard .

Cas de 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

Notation

Comme pour le code-golf , la soumission la plus courte l'emporte. Bonne chance!

code-golf  number  decision-problem  integer 
— MD XF
source
2
@StephenLeppik Ce n'est pas plus facile que le défi de la parité vanille, ou le Hello World ou la Truth Machine. (En fait, c'est plus difficile que la plupart d'entre eux.)
— MD XF
Pouvons-nous prendre l'entrée comme deux nombres, représentant une fraction?
— LyricLy
@LyricLy Non, ce serait beaucoup plus facile pour certaines langues ou inutile pour d'autres.
— MD XF
Notez que les nombres entiers sont des entiers non négatifs. Veuillez mettre à jour votre première phrase pour refléter cela. Et vous pouvez ajouter des cas de test de nombres négatifs si vous souhaitez montrer comment les nombres entiers ne sont pas négatifs et les sorties falsifiées pour les nombres négatifs sont valides.
— Thomas Ward
1
@ThomasWard, cet article de wikipedia ne semble pas entièrement d'accord avec vous: "Les textes qui excluent zéro des nombres naturels font parfois référence aux nombres naturels avec zéro comme nombres entiers, mais dans d'autres écrits, ce terme est utilisé à la place pour les entiers (y compris les entiers négatifs) ". J'ai lu le titre comme demandant des nombres entiers.
— ilkkachu

Réponses:

16

Haskell , 27 16 octets

Cette fonction vérifie si elle xest contenue dans la liste des entiers non négatifs qui ne sont pas supérieurs à x.

f x=elem x[0..x]

Essayez-le en ligne!

— flawr
source
6

Husk , 3 octets

£ΘN

Essayez-le en ligne! Le troisième cas de test arrive à expiration dans TIO, j'ai donc coupé quelques chiffres. J'ai essayé de l'exécuter localement, mais je l'ai tué après quelques minutes car il utilisait plus de 6 Go de mémoire et mon ordinateur a commencé à bégayer. Il devrait théoriquement se terminer à un moment donné ...

Explication

Cela correspond assez directement à la description du défi.

£Θ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
source
À quoi λx → floor(x) == abs(x)ressemblerait Husk?
— Lynn
@Lynn Ce serait §=⌊adonc un octet de plus.
— Zgarb
5

/// , 94 octets, entrée codée en dur

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

Essayez-le en ligne!

Entrée entre les deux lignes verticales terminales ( ||)

Supprime -00...0et .00...0convertit tous les chiffres restants en xs, puis teste si le nombre restant a toujours xs après .ou -non suivi de ..

Pourrait économiser jusqu'à 7 octets en fonction de ce qui est considéré comme véridique et falsey car cette langue n'a pas de valeurs natives vérité / falsey, est actuellement en cours de sortie trueet falsepeut changer, par exemple, Tet Fpour 87 octets si cela est autorisé.

— boboquack
source
5

Octave , 15 octets

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

Essayez-le en ligne!

Celui-ci est basé sur l'approche utilisée dans la réponse Haskell de @ flawr .

Bien qu'il porte le nombre d'octets jusqu'à 15, il est honteusement inefficace (pas d' infraction prévu), la création d' une liste de tout entier de 0à xet de voir si xest contenu.

Octave , 18 octets

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

Essayez-le en ligne!

Prend l'entrée comme un nombre à double précision. Renvoie vrai s'il est entier.

Vérifie si l'entrée une fois arrondie est égale à la grandeur de l'entrée. Ce ne sera le cas que lorsque le nombre est positif et entier.

Octave , 18 octets

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

Essayez-le en ligne!

Une solution alternative pour 18 octets. Malheureusement, la modfonction dans Octave ne convertira pas implicitement un boolen un double, donc le +( )est nécessaire autour de la comparaison supérieure à. Sinon, cette solution aurait été plus courte.

Octave , 18 octets

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

Essayez-le en ligne!

Et un autre ... Je n'arrive pas à obtenir moins de 18 octets . Tout cela parce que vous devez permettre à 0 d'être vrai avec le >=au lieu de juste >.

— Tom Carpenter
source
4

Aceto , 6 octets

rfdi±=p

r saisit l'entrée
f le convertit en flotteur
d et i le duplique et le convertit en un entier
± pousse sa valeur absolue (b / c ne peut pas être négatif)
= vérifie si elles sont égales
p imprime le résultat

Essayez-le en ligne!

— FantaC
source
4

QBIC , 17 octets

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

Explication

?             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 l'une des vérifications échoue, cela renvoie 0. Si les deux sont vraies, elle renvoie -1 x -1 = 1

— steenbergh
source
4

C (gcc), 27 28 27 25 octets

-2 merci à PrincePolka

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

Essayez-le en ligne!

Définit une macro "fonction" gqui prend un paramètre f(de tout type). Vérifie ensuite si la conversion f mod 1est nulle et si elle fn'est pas négative.

— MD XF
source
Je pense que vous devez inclure la taille de la includedirective dans votre nombre d'octets, car fmod est défini dans math.h: voir ici
— HatsuPointerKun
@HatsuPointerKun Cela fonctionne aussi sans lui
— M. Xcoder
2
Je ne pense pas que vous ayez besoin de -lm sur les distributions C basées sur Windows (fonctionne sur ma machine)
— Conor O'Brien
25, #define g (f)! Fmod (f, f> = 0)
— PrincePolka
4

C #, Java: 43 octets

-1 octet grâce à Zacharý
-1 octet grâce à TheLetalCoder

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

C # a une optimisation spéciale de 33 octets que vous ne pouvez pas faire en java: 

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

Pour tester

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

Code 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
source
Je pense que vous pouvez supprimer un espace entre returnet (.
— Zacharý
retourner un boolet il n'y a pas besoin de ternaire.
— TheLethalCoder
@TheLethalCoder booln'existe pas en Java
— HatsuPointerKun
Je ne connais pas bien Java / C #, mais pouvez-vous le faire return(int)n==n? Ou cela serait-il jeté n==ndans un int plutôt que juste n?
— Zacharý
1
Vous pouvez réduire la réponse Java 7 de 3 octets en inversant la vérification et en changeant l'opérateur booléen au niveau du bit: int w(float n){return(int)n!=n|n<0?0:1;}( 40 octets ). En tant que lambda Java 8, il est encore plus court: n->(int)n==n&n>=0( 17 octets ) , et la même chose s'applique à la réponse C # en tant que lambda: n=>(int)n==n&n>=0(également 17 octets ) .
— Kevin Cruijssen
4

Google Sheets, 10 octets

Fonction de feuille de calcul anonyme qui conte les entrées de la cellule A1et les sorties vers la cellule appelante.

=A1=Int(A1
— Taylor Scott
source
3

Ly , 35 47 octets

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

Essayez-le en ligne!

Ly prend en charge les flottants, mais la seule façon de créer un flottant est actuellement d'effectuer la division. Il n'y a aucun moyen de prendre un flottant en entrée, j'ai donc dû vérifier manuellement la chaîne à la place.

Perte de 13 octets ajoutant la prise en charge des nombres négatifs.

— LyricLy
source
3

JavaScript, 14

n=>!(n<0||n%1)
— edc65
source
13 octets:n=>!(n-(n|0))
— Ismael Miguel
@IsmaelMiguel. Cela ne fonctionne pas pour les nombres négatifs.
@ThePirateBay Quel nombre exact? J'ai essayé avec 5, 5.1, -5, -5.1, 0, 0.1 et -0.1.
— Ismael Miguel
@IsmaelMiguel. (n=>!(n-(n|0)))(-3)renvoie true, mais devrait revenir false. Voir le dernier cas de test.
Oh, vous avez raison à ce sujet: / J'ai mal lu la question: /
— Ismael Miguel
3

C #, 40 37 29 octets

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

8 octets enregistrés grâce à @Dennis_E!

Ancienne réponse (37 octets)

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

Ancienne ancienne réponse (40 octets):

bool z(float x){return (int)x==x&&x>=0;}
— yummypasta
source
2
30 octets: bool z(float x)=>x%1==0&&x>=0;et vous pouvez utiliser un seul &pour 29 octets
— Dennis_E
@Dennis_E Merci!
— yummypasta
x=>x%1==0&x>=0est plus court et compile pourFunc<float, bool>
— TheLethalCoder
3

JavaScript, 17 15 octets

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


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

Merci à edc65 d'avoir rattrapé mes erreurs.

— ericw31415
source
3

Sinclair ZX81 non étendu, 20 octets

 1 INPUT A
 2 PRINT ABS A=INT A

20 octets car BASIC est tokenisé.

Il affichera simplement 1 (vrai) si le nombre est positif et la valeur du nombre entré est égale à sa valeur entière. Les sorties 0 de ces conditions ne sont pas remplies.

— Shaun Bebbers
source
1
Est-ce une langue symbolisée? Si c'est le cas, vous devez l'indiquer dans votre réponse.
— Taylor Scott
1
Désolé, oui, il est tokenisé, c.-à-d., INPUT est de 1 octet de RAM, tout comme PRINT et même> = en raison d'une fonctionnalité ~ quirk ~ prévue pour Sinclair BASIC
— Shaun Bebbers
1
Plus précisément, chaque numéro de ligne est de 5 octets + 1 newline( \r\néquivalent en langage ZX81), les espaces blancs ne comptent pas comme des octets car ceux-ci sont déjà inclus dans les mots clés, généralement en raison du système d'entrée Sinclair `` une touche ''. En cours d'exécution, cela prendra plus d'octets car il mettra la valeur de Asur var stack; Je pense que chaque valeur numérique est toujours 5 octets de mémoire.
— Shaun Bebbers
1
et ZX Spectrum aussi
— edc65
1
Pour autant que je sache, le mode de tokenisation est exactement le même (Spectrum a plus de codes). Et tout nombre littéral est de 6 octets: un octet de «balise numérique» suivi de la valeur codée dans un format à virgule flottante propriétaire de 5 octets)
— edc65
3

C, C ++: 38 37 octets

-1 octet grâce à Zacharý

-1 octet grâce au plafond

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

Pour tester

C: Essayez-le en ligne

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

Code 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
source
1
Cela ne fonctionnera que jusqu'à INT_MAX. (Je m'en fous vraiment mais certaines personnes le font.)
— MD XF
Le changerait-il pour return(int)n==n...fonctionner?
— Zacharý
Vous pouvez raser un octet en utilisant un entier non signé au lieu d'un entier signé (car vous n'avez alors pas besoin du >=0test): return(unsigned)n==n; Et en C, vous pouvez omettre le type de retour pour 4 autres octets.
— Toby Speight
Vous pouvez économiser 8 octets supplémentaires:w(float n){n=n==(int)n&&n>=0;}
— Johan du Toit
2

Python symbolique , 21 octets

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

Essayez-le en ligne!

Utilise une comparaison chaînée:

  • _%(_==_) == (_!=_)vérifie si n%1 == 0, seulement vrai si nn'a pas de partie décimale.
  • (_!=_) <= _vérifie si 0 <= n, vrai uniquement si l'entier n'est pas négatif.
— FlipTack
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.