Je pense que nous avons tous fait cela dans notre enfance: certains sites Web exigent un âge minimum de 18 ans. Nous soustrayons donc quelques années de l'année de naissance et voilà, nous avons 18 ans ou plus.
En outre, pour la plupart des manèges dans les parcs d’attractions, la hauteur minimale à franchir pour entrer est de 1,40 mètre (ici aux Pays-Bas au moins). Bien sûr, cela peut être triché moins facilement que l'âge, mais vous pouvez porter des chaussures à talons épais, relever vos cheveux, porter un chapeau, vous tenir debout sur vos orteils, etc.

Contribution:

Votre programme / fonction accepte un entier positif ou un nombre décimal.

Sortie:

• L'entrée est-elle un entier >= 18? Imprimez simplement l'entrée.
• L'entrée est-elle un entier 0-17? Imprimer 18.
• L'entrée est-elle décimale >= 1.4? Imprimez simplement l'entrée.
• L'entrée est-elle décimale 0.0-1.4? Imprimer 1.4.

Règles du challenge:

• Supposons que l'entrée sera toujours dans la plage de 0-122(la plus vieille femme a jamais été 122) ou 0.0-2.72(le plus grand homme a jamais été 2,72).
• Vous êtes autorisé à prendre l’entrée sous forme de chaîne, d’objet ou de tout autre élément de votre choix.
• Les entrées décimales n'auront jamais plus de trois décimales après le point décimal.
• 2ou les 2.deux ne sont pas des sorties valides pour 2.0. Vous êtes libre de sortie 2.00ou 2.000au lieu de 2.0cependant.
  Tout comme l'entrée, la sortie n'aura jamais plus de trois décimales après le point.

Règles générales:

• C'est du code-golf , donc la réponse la plus courte en octets est gagnante.
  Ne laissez pas les langues de code-golf vous décourager de poster des réponses avec des langues autres que le code de golf. Essayez de trouver une réponse aussi courte que possible à n'importe quel langage de programmation.
• Les règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés, programmes complets. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Ajoutez également une explication si nécessaire.

Cas de test:

0      ->  18
1      ->  18
2      ->  18
12     ->  18
18     ->  18
43     ->  43
115    ->  115
122    ->  122

0.0    ->  1.4
1.04   ->  1.4
1.225  ->  1.4
1.399  ->  1.4
1.4    ->  1.4
1.74   ->  1.74
2.0    ->  2.0
2.72   ->  2.72

Convexe , 9 octets

_1ÛI1.4?»

Essayez-le en ligne!

Python 2.7, 34 octets

lambda x:max(x,[18,1.4]['.'in`x`])

JavaScript (ES6), 27 31

Entrée prise comme une chaîne. Pour vérifier si la valeur d'entrée a des décimales, elle est ajoutée à elle-même: s'il n'y a pas de point décimal, le résultat est toujours un nombre valide, sinon ce n'est pas le cas. Pour reconnaître un nombre valide (y compris 0), j’utilise la division car javascript 1/nest numérique et non 0 pour n’importe quel chiffre n (éventuellement la valeur est Infinitypour n==0), sinon c’estNaN

x=>x<(y=1/(x+x)?18:1.4)?y:x

Tester

f=    
x=>x<(y=1/(x+x)?18:1.4)?y:x

;[
 ['0', '18' ],['1', '18' ],['2', '18' ],['12', '18' ],['18', '18' ],['43', '43' ],['115', '115'], ['122', '122' ]
,['0.0', '1.4'],['1.0', '1.4'],['1.04', '1.4'],['1.225', '1.4'],['1.399', '1.4'],['1.4', '1.4'],['1.74', '1.74'],['2.0', '2.0'],['2.72', '2.72']
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i)
  console.log(i,k,r,k==r?'OK':'KO')
})

Ma solution précédente (mauvaise):

En prenant l'entrée comme un nombre, vous pouvez utiliser l'opérateur restant %pour vérifier si le nombre est entier.

x=>x<(y=x%1?1.4:18)?y:x

ou

x=>Math.max(x,x%1?1.4:18)

Mais cela ne fonctionne pas comme la demande de contestation de discrimination entre, disons, 2et 2.0et c'est le même numéro. Il n'est donc pas possible d'obtenir l'entrée sous forme de nombre

05AB1E , 13 à 11 octets

Utilise le codage CP-1252 .

ÐîQ18*14T/M

Explication

Ð             # triplicate input
 î            # round up
  Q           # check for equality
   18*        # multiply 18 by this (18 if input is int, else 0)
      14T/    # push 14 / 10
          M   # take max of stack (input and 1.4 or 18)

Essayez-le en ligne

Java 8, 90 61 57 octets

i->(i+"").contains(".")?(float)i<1.4?1.4:i:(int)i<18?18:i

-4 octets renvoyés à la Objectplace de String; et quelques octets supplémentaires convertissant Java 7 en 8.
-4 octets en prenant l'entrée comme Objectau lieu de String.

Explication:

Essayez ici.

i->                      // Method with Object as both parameter and return-type
  (i+"").contains(".")?  //  If the input as String contains a dot:
   (float)i<1.4?         //   If the input is a float below 1.4:
    1.4                  //    Return double 1.4
   :                     //   Else:
    i                    //    Return the input-float as is
  :(int)i<18?            //  Else if the input is an integer below 18:
   18                    //   Return integer 18
  :                      //  Else:
   i                     //   Return the input-integer as is

Pyth, 14 octets

eS,@,18h.4}\.`

Essayez-le en ligne.

PHP, 40 octets

modifié par @ user59178 Merci

<?=max(is_int(0+$i=$argv[1])?18:1.4,$i);

PHP, première version de 42 octets

<?=max(strpos($i=$argv[1],".")?1.4:18,$i);

EXCEL: 26 31 29 octets

=MAX(A1;IF(MOD(A1;1);1,4;18))

La formule peut aller n'importe où sauf A1, la cellule d'entrée.

Correction d'erreurs et remplacé par la suggestion d'Emigna.

Merci à Alexandru pour m'avoir sauvé quelques octets en utilisant des vérités

Brachylog , 14 octets

#$:18ot|:1.4ot

Essayez-le en ligne!

Explication

    #$             Input is an integer
      :18o         Sort the list [Input, 18]
          t        Take the last element
|              Or
    :1.4o          Sort the list [Input, 1.4]
         t         Take the last element

Perl, 29 à 27 octets

Comprend +2 pour -lp

Donnez votre avis sur STDIN

adult.pl <<< 1.24

adult.pl:

#!/usr/bin/perl -lp
$_>($a=/\./?1.4:18)or*_=a

Si vous ne craignez pas un saut de ligne supplémentaire si vous étiez vraiment un adulte, laisser de côté l' loption de 26 octets marche aussi

GNU sed, 40 + 1 = 41 octets

(score +1 pour l'utilisation du -rdrapeau à l'interprète)

s/^.$|^1[^9]$/18/
/^0|1\.[0-3]/s/.*/1.4/

Annoté:

#!/bin/sed -rf

# First, anything that's a single digit or is '1' followed by a
# digit other than '9' is replaced with '18'.
s/^.$|^1[^9]$/18/

# Now, any line beginning with '0' or containing '1.0' to '1.3' is
# replaced with '1.4'.
/^0|1\.[0-3]/s/.*/1.4/

Nous profitons des contraintes sur les entrées, vous n'avez donc pas à tester le début de chaîne lorsque vous voyez '1'. - Nous savons qu'il n'y a qu'un chiffre avant la virgule.

Résultat du test:

$ ./94832.sed <<END
> 0
> 1
> 2
> 12
> 18
> 43
> 122
> 
> 0.0
> 1.04
> 1.225
> 1.399
> 1.4
> 1.74
> 2.0
> 2.72
> END
18
18
18
18
18
43
122

1.4
1.4
1.4
1.4
1.4
1.74
2.0
2.72

Haskell, 50 octets

x#y=show$max x$read y 
f s|elem '.'s=1.4#s|1<2=18#s

Exemple d'utilisation: f "1.0"-> "1.6".

Le type strict de Haskell nécessite l'utilisation de chaînes en entrée et en sortie. Howevers, read, maxet showsont polymorphes et de gérer tous les types numériques.

Java, 79 70 octets

int f(int x){return x<18?18:x;}
float f(float x){return x<1.4?1.4f:x;}

Définit deux méthodes avec surcharge, qui utilisent l'opérateur conditionnel.

Appelez ça comme f(5)ou f(1.4f).

CJam, 18 14 octets

Sauvegardé 4 octets grâce à Martin Ender.

q~_`'.&1.4I?e>

Interprète en ligne

C #, 69 octets

s=>s.Contains(".")?float.Parse(s)<1.4?"1.4":s:int.Parse(s)<18?"18":s;

Essayez-le en ligne!

Programme complet avec cas de test:

using System;

namespace YesImAnAdult
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,string>f= s=>s.Contains(".")?float.Parse(s)<1.4?"1.4":s:int.Parse(s)<18?"18":s;

            Console.WriteLine(f("0"));  //18
            Console.WriteLine(f("1"));  //18
            Console.WriteLine(f("2"));  //18
            Console.WriteLine(f("12")); //18
            Console.WriteLine(f("18")); //18
            Console.WriteLine(f("43")); //43
            Console.WriteLine(f("122"));    //122

            Console.WriteLine(f("0.0"));    //1.4
            Console.WriteLine(f("1.04"));   //1.4
            Console.WriteLine(f("1.225"));  //1.4
            Console.WriteLine(f("1.399"));  //1.4
            Console.WriteLine(f("1.4"));    //1.4
            Console.WriteLine(f("1.74"));   //1.74
            Console.WriteLine(f("2.0"));    //2.0
            Console.WriteLine(f("2.72"));   //2.72
        }
    }
}

Une solution assez simple. Notez que sur certains systèmes, float.Parse () peut renvoyer des résultats incorrects. Passez CultureInfo.InvariantCulture comme deuxième argument en fonction de cette réponse .

Formule IBM / Lotus Notes, 58 49 octets

@If(@Like(@Text(a);"%.%");@If(a<1.4;1.4;a);@If(a<18;18;a))

Formule de champ calculé où a est un champ numérique éditable.

MODIFIER

@If(@Like(@Text(a);"%.%");@Max(1.4;a);@Max(18;a))

Alternative inspirée par @Mego

Jelly , 16 15 13 octets

ŒṘċ”.ị1.4,18»

TryItOnline
Ou consultez tous les cas de test, également sur TryItOnline

Comment?

ŒṘċ”.ị1.4,18» - Main link: n
      1.4,18 - pair literals 1.4 and 18:   [1.4,18]
     ị       - index (1-based & modular ie:^  1, 0^)
  ċ          -     count (occurrences of)
   ”.        -         string "." (present in)
ŒṘ           -         string representation of n
           » - maximum (of this and n)

C ++, 68 octets

int A(int a){return a<18?18:a;}float A(float h){return h<1.4?1.4:h;}

Cette réponse correspond en fait à 2 fonctions portant le même nom, et le compilateur me demande lequel appeler. Elle agit donc comme une fonction sans que je doive prendre une entrée et décider de quelle entrée. Etant donné que l’entrée sur la virgule flottante a la garantie d’être de la même précision que la sortie, je peux la retourner en toute sécurité sans avoir à la tronquer non plus.

Ungolfed + tests

#include <iostream>

int A(int a)
{
   return a < 18 ? 18 : a;
}

float A(float h)
{
   return h < 1.4 ? 1.4 : h;
}

int main()
{
  std::cout << 0 << " " << A(0) << "\n";
  std::cout << 19 << " " << A(19) << "\n";
  std::cout << 1.1 << " " << A(1.1f) << "\n";
  std::cout << 2.2 << " " << A(2.2f) << "\n";
}

C #, 58 octets

x=>x is int?(int)x>17?x:18:(float)x<1.4?"1.4":$"{x:.0##}";

Aucune analyse de chaîne folle nécessaire pour C #. On s'attend à ce que l'entrée soit un intou float(malheureusement, C # ne peut pas lancer un doubleà floatsi le doubleest dans un object). Sortie sera soit intou stringdans un object.

(a failli manquer l'exigence d'au moins 1 décimale, maintenant)

Ungolfed:

/*Func<object, object> Lambda = */ x =>
    x is int // if parameter is an int
        ? (int)x > 17 // check if x is at least 18
            ? x // at least 18 so return x
            : 18 // less than 18 so return 18
        : (float)x < 1.4 // x is float, check if at least 1.4
            ? "1.4" // less than 1.4 so return 1.4
            : $"{x:.0##"} // at least 1.4 so return x and ensure at least 1 decimal place
;

Autre implémentation qui est également 58 octets.

x=>x is int?(int)x>17?x:18:$"{((float)x<1.4?1.4:x):.0##}";

En fait, 16 octets

;:.7τ9τ($'.íuIkM

Essayez-le en ligne!

Explication:

;:.7τ9τ($'.íuIkM
;                 dupe input
 :.7τ             1.4 (.7*2) - note that :1.4 is the same length, but an additional delimiter would be needed to separate it from the following 1
     9τ           18 (9*2)
       ($'.íu     1-based index of "." in string representation of input, 0 if not found
             I    1.4 if input contains a "." else 18
              kM  maximum of remaining values on stack 

Emacs Lisp, 37 octets

(lambda(x)(max(if(floatp x)1.4 18)x))

Devine à partir du "type de données" si la version entière ou float doit être utilisée. ( floatprenvoie tpour 1.0, mais pas pour 1.) Le paramètre est un nombre entier ou flottant, c’est-à-dire qu’il doit satisfaire numberp.

Haskell, 49 octets

x#y=show.max x.fst<$>reads y;f s=head$18#s++1.4#s

Fondamentalement, ceci tente d’abord de lire l’entrée comme un entier, puis comme un double si cela échoue. Puis procède à la comparer à la ligne de base de comparaison respective.

Dyalog APL , 14 octets Rendu invalide par d'autres spécifications

⎕IO←0ce qui est le défaut sur beaucoup de systèmes. Prend la chaîne comme argument.

⍎⌈18 1.4⊃⍨'.'∘∊

⍎⌈ max de l'argument évalué et

18 1.4⊃⍨ {18,1.4} sélectionné par

'.'∘∊ si l'argument contient un point

C #, 95 octets

Golfé:

string y(string p){int a;return int.TryParse(p,out a)?a>17?p:"18":double.Parse(p)<1.4?"1.4":p;}

Ungolfed:

class YesOfCourseImAnAdult
  {
    public string y(string p)
    {
      int a;
      return int.TryParse(p, out a) ? a > 17 ? p : "18"
       : double.Parse(p) < 1.4 ? "1.4" : p;
    }
  }

Cas de test:

var codeGolf = new YesOfCourseImAnAdult();
Console.WriteLine(codeGolf.y("0"));
Console.WriteLine(codeGolf.y("1"));
Console.WriteLine(codeGolf.y("2"));
Console.WriteLine(codeGolf.y("12"));
Console.WriteLine(codeGolf.y("18"));
Console.WriteLine(codeGolf.y("43"));
Console.WriteLine(codeGolf.y("122"));

Console.WriteLine(codeGolf.y("0.0"));
Console.WriteLine(codeGolf.y("1.04"));
Console.WriteLine(codeGolf.y("1.225"));
Console.WriteLine(codeGolf.y("1.399"));
Console.WriteLine(codeGolf.y("1.4"));
Console.WriteLine(codeGolf.y("1.74"));
Console.WriteLine(codeGolf.y("2.0"));
Console.WriteLine(codeGolf.y("2.72"));

Sortie:

18
18
18
18
18
43
122

1.4
1.4
1.4
1.4
1.4
1.74
2.0
2.72

AWK - 29 octets

($0<c=$0~/\./?1.4:18){$0=c}1

Usage:

awk '{c=$0~/\./?1.4:18}($0<c){$0=c}1' <<< number

Les tests ont été effectués avec gawkRHEL 6. J'ai essayé tous les scénarios de test. Malheureusement, AWKla machine ne dispose pas d'un accès à Internet et le copier-coller n'est donc pas possible.

Y at-il un moyen plus compact de faire cela dans AWK?

C, 50 octets:

#define A(x)(x/2+(x+1)/2-x?x<1.4?1.4:x:x<18?18:x)

Le nombre d'octets inclut la nouvelle ligne à la fin de la définition de la macro.

Test :

#define A(x)(x/2+(x+1)/2-x?x<1.4?1.4:x:x<18?18:x)
#include <assert.h>
int main() {
  assert(A(0) == 18);
  assert(A(1) == 18);
  assert(A(2) == 18);
  assert(A(12) == 18);
  assert(A(18) == 18);
  assert(A(43) == 43);
  assert(A(115) == 115);
  assert(A(122) == 122);
  assert(A(0.0) == 1.4);
  assert(A(1.04) == 1.4);
  assert(A(1.225) == 1.4);
  assert(A(1.399) == 1.4);
  assert(A(1.4) == 1.4);
  assert(A(1.74) == 1.74);
  assert(A(2.0) == 2.0);
  assert(A(2.72) == 2.72);
}

C #, 71 octets

object A(object i){return i is int?(int)i>18?i:18:(double)i>1.4?i:1.4;}

l'essayer ici

C, 119 111 105 100

m;f(char*s){float atof(),l=atof(s);for(m=s;*s&&*s++!=46;);puts(*s?l<1.4?"1.4":m:atoi(m)>18?m:"18");}

Testé avec

main(c,v)char**v;{
    f("0");
    f("1");
    f("2");
    f("12");
    f("18");
    f("44");
    f("115");
    f("122");
    f("0.0");
    f("1.04");
    f("1.225");
    f("1.339");
    f("1.4");
    f("1.74");
    f("2.0");
    f("2.72");
}

Sortie

18
18
18
12
18
44
115
122
1.4
1.4
1.4
1.4
1.4
1.74
2.0
2.72

Lot, 102 octets

@set/ps=
@if %s:.=%==%s% (if %s% lss 18 set s=18)else if %s:~0,1%%s:~2,1% lss 14 set s=1.4
@echo %s%

Détermine d’abord si l’entrée est un entier en vérifiant si la suppression de tous les .s a un effet sur la chaîne. Si c'est le cas, la valeur est facilement comparée à 18, sinon les premier et troisième caractères sont combinés en un nombre comparé à 14.

PHP: 40 octets

$i=is_int($i)?$i>17?$i:18:$i>1.4?$i:1.4;

psuedocode, (retournement imbriqué):

if (i is an integer) then 
  if (i is bigger than 17) then i=18 else i=i  
otherwise (its a decimal)   
  if (i is bigger than 1.4) then i=i else i=1.4 
end if