Creo que todos hemos hecho esto cuando éramos niños: algunos sitios web requieren una edad mínima de 18 años, por lo que solo restamos unos años del año de nacimiento y voilà, somos "mayores de 18 años".
Además, para la mayoría de las atracciones en los parques de atracciones, la altura mínima para ingresar es de 1.40 metros (aquí en los Países Bajos, como mínimo). Por supuesto, esto puede ser engañado con menos facilidad que la edad, pero podría usar zapatos con tacones gruesos, peinarse, usar un sombrero, ponerse de puntillas, etc.

Entrada:

Su programa / función acepta un entero positivo o decimal.

Salida:

• ¿Es la entrada un número entero >= 18? Simplemente imprima la entrada.
• ¿Es la entrada un número entero 0-17? Imprimir 18.
• ¿La entrada es un decimal >= 1.4? Simplemente imprima la entrada.
• ¿La entrada es un decimal 0.0-1.4? Imprimir 1.4.

Reglas de desafío:

• Suponga que la entrada siempre estará en el rango de 0-122(la mujer más vieja fue 122) o 0.0-2.72(el hombre más alto fue 2.72).
• Se le permite tomar la entrada como una cadena, objeto o cualquier otra cosa que prefiera.
• Las entradas decimales nunca tendrán más de tres lugares decimales después del punto decimal.
• 2o 2.ambos no son salidas válidas para 2.0. Usted es libre de salida 2.00o en su 2.000lugar, 2.0sin embargo.
  Al igual que la entrada, la salida nunca tendrá más de tres decimales después del punto.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

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

Convexo , 9 bytes

_1ÛI1.4?»

Pruébalo en línea!

Python 2.7, 34 bytes

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

JavaScript (ES6), 27 31

Entrada tomada como una cadena. Para verificar si el valor de entrada tiene decimales, se agrega a sí mismo: si no hay un punto decimal, el resultado sigue siendo un número válido, de lo contrario no lo es. Para reconocer un número válido (incluido 0), utilizo la división ya que en javascript 1/nes numérico y no 0 para ningún numérico n (eventualmente el valor es Infinitypara n==0), de lo contrario esNaN

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

Prueba

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

Mi solución anterior (incorrecta):

Tomando la entrada como un número, puede usar el operador restante %para verificar si el número es entero.

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

o

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

Pero esto no funciona como la solicitud desafío para discriminar entre, por ejemplo, 2y 2.0, y que es el mismo número. Por lo tanto, no es posible obtener la entrada como un número

05AB1E , 13 11 bytes

Utiliza la codificación CP-1252 .

ÐîQ18*14T/M

Explicación

Ð             # 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)

Pruébalo en línea

Java 8, 90 61 57 bytes

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

-4 bytes regresan en Objectlugar de String; y algunos bytes adicionales que convierten Java 7 a 8.
-4 bytes tomando la entrada como en Objectlugar de Stringtambién.

Explicación:

Pruébalo aquí

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 bytes

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

Pruébalo en línea.

PHP, 40 bytes

modificado por @ user59178 Gracias

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

PHP, 42 Bytes primera versión

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

EXCEL: 26 31 29 Bytes

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

La fórmula puede ir a cualquier parte excepto A1, la celda de entrada.

Se corrigieron los errores y se reemplazaron con la sugerencia de Emigna.

Gracias a Alexandru por salvarme algunos bytes usando verdades

Brachylog , 14 bytes

#$:18ot|:1.4ot

Pruébalo en línea!

Explicación

    #$             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 bytes

Incluye +2 para -lp

Dar entrada sobre STDIN

adult.pl <<< 1.24

adult.pl:

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

Si no le importa una nueva línea adicional si realmente fuera un adulto completo, dejar de lado la lopción de 26 bytes también funciona

GNU sed, 40 + 1 = 41 bytes

(puntuación +1 por uso de -rbandera para intérprete)

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

Anotado:

#!/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/

Aprovechamos las restricciones en la entrada, por lo que no tenemos que probar el inicio de la cadena cuando vemos '1'. - sabemos que solo hay un dígito antes del punto decimal.

Resultado de la prueba:

$ ./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 bytes

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

Ejemplo de uso: f "1.0"-> "1.6".

El tipo estricto de Haskell requiere el uso de cadenas como entrada y salida. Howevers, read, maxy showson polimórficos y manejar todos los tipos numéricos.

Java, 79 70 bytes

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

Define dos métodos con sobrecarga, que utilizan el operador condicional.

Llámalo como f(5)o f(1.4f).

CJam, 18 14 bytes

Guardado 4 bytes gracias a Martin Ender.

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

Intérprete en línea

C #, 69 bytes

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

Pruébalo en línea!

Programa completo con casos de prueba:

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

Una solución bastante sencilla. Tenga en cuenta que en algunos sistemas float.Parse () puede devolver resultados incorrectos. Pase CultureInfo.InvariantCulture como segundo argumento según esta respuesta .

Lenguaje de fórmulas IBM / Lotus Notes, 58 49 bytes

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

Fórmula de campo calculado donde a es un campo numérico editable.

EDITAR

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

Alternativa inspirada en @Mego

Jalea , 16 15 13 bytes

ŒṘċ”.ị1.4,18»

TryItOnline
O vea todos los casos de prueba, también en TryItOnline

¿Cómo?

ŒṘċ”.ị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 bytes

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

Esta respuesta es en realidad 2 funciones con el mismo nombre, y el compilador determina a qué llamar, por lo que actúa como una función sin que tenga que tomar una entrada y decidir cuál es. Dado que se garantiza que la entrada en el punto flotante sea de la misma precisión que la salida, puedo devolverla de forma segura sin tener que truncarla tampoco.

Sin golf + pruebas

#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 bytes

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

No se necesita un análisis de cadenas loco para C #. Se espera que la entrada sea un into float(desafortunadamente C # no puede emitir un doubleto floatsi doubleestá en un object). La salida será into stringen un object.

(Casi no cumplí el requisito de al menos 1 decimal, lo agregué ahora)

Sin golf:

/*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
;

Implementación alternativa que también es de 58 bytes.

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

En realidad, 16 bytes

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

Pruébalo en línea!

Explicación:

;:.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 bytes

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

Adivina del "tipo de datos" si se debe usar la versión entera o flotante. ( floatpdevuelve tpara 1.0, pero no para 1.) El parámetro es un número como entero o flotante, es decir, debe satisfacer numberp.

Haskell, 49 bytes

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

Básicamente, esto primero intenta leer la entrada como un número entero y luego como un doble si eso falla. Luego procede a compararlo con la línea base de comparación respectiva.

Dyalog APL , 14 bytes Renuncia inválida por otras especificaciones

⎕IO←0que es el predeterminado en muchos sistemas. Toma una cuerda como argumento.

⍎⌈18 1.4⊃⍨'.'∘∊

⍎⌈ max del argumento evaluado y

18 1.4⊃⍨ {18,1.4} seleccionado por

'.'∘∊ si el argumento contiene un punto

C #, 95 bytes

Golfizado:

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

Sin golf:

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

Casos de prueba:

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

Salida:

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 bytes

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

Uso:

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

La prueba se realizó con gawkRHEL 6. Intenté con todos los casos de prueba, desafortunadamente no tengo AWKen la máquina que tenga acceso a Internet, por lo que no es posible copiar y pegar.

¿Hay una forma más compacta de hacer esto AWK?

C, 50 bytes:

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

El recuento de bytes incluye la nueva línea al final de la definición de macro.

Prueba :

#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 bytes

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

pruébalo aquí

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

Probado con

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

Salida

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

Lote, 102 bytes

@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%

Primero determina si la entrada es un entero comprobando si eliminar todos los .s tiene algún efecto en la cadena. Si es así, el valor se compara fácilmente con 18, de lo contrario, el primer y el tercer carácter se combinan en un número que se compara con 14.

PHP: 40 bytes

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

psuedocode, (giro anidado):

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