Yes, of course I'm an adult!

Question

I think we've all done this as a kid: some websites require a minimum age of 18, so we just subtract a few years from the year of birth and voilà, we 'are' 18+.
In addition, for most rides at amusement parks the minimum height to enter is 1.40 meters (here in The Netherlands it as at least). Of course this can be cheated less easily than age, but you could wear shoes with thick heels, put your hair up, wear a hat, stand on your toes, etc.

Input:

Your program/function accepts a positive integer or decimal.

Output:

• Is the input an integer >= 18? Simply print the input.
• Is the input an integer 0-17? Print 18.
• Is the input a decimal >= 1.4? Simply print the input.
• Is the input a decimal 0.0-1.4? Print 1.4.

Challenge rules:

• Assume the input will always be in the range of 0-122 (oldest woman ever was 122) or 0.0-2.72 (tallest man ever was 2.72).
• You are allowed to take the input as a String, object, or anything else you prefer.
• The decimal inputs will never have more than three decimal places after the decimal point.
• 2 or 2. both aren't valid outputs for 2.0. You are free to output 2.00 or 2.000 instead of 2.0 however.
  Just like the input the output will never have more than three decimal places after the point.

General rules:

• This is code-golf, so shortest answer in bytes wins.
  Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
• Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters, full programs. Your call.
• Default Loopholes are forbidden.
• If possible, please add a link with a test for your code.
• Also, please add an explanation if necessary.

Test cases:

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

Answer 1

Convex, 9 bytes

_1ÛI1.4?»

Try it online!

Answer 2

Python 2.7, 34 bytes

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

Answer 3

JavaScript (ES6), 27 31

Input taken as a string. To check if the input value has decimals, it's appended to itself: if there is no decimal point the result is still a valid number, else it's not. To recognize a valid number (including 0), I use division as in javascript 1/n is numeric and not 0 for any numeric n (eventually the value is Infinity for n==0), else it's NaN

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

Test

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

My prev (wrong) solution:

Taking input as a number, you can use remainder operator % to check if the number is integer.

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

or

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

But this does not work as the challenge request to discriminate between, say, 2 and 2.0 and that's the same number. So it's not possibile to get the input as a number

Answer 4

05AB1E, 13 11 bytes

Uses CP-1252 encoding.

ÐîQ18*14T/M

Explanation

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

Try it online

Answer 5

Java 8, 90 61 57 bytes

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

-4 bytes returning Object instead of String; and some additional bytes converting Java 7 to 8.
-4 byte taking the input as Object instead of String as well.

Explanation:

Try it here.

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

Answer 6

PHP, 40 Bytes

modified by @user59178 Thank You

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

PHP, 42 Bytes first Version

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

Answer 7

Pyth, 14 bytes

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

Try it online.

Answer 8

EXCEL: 26 31 29 Bytes

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

Formula can go anywhere except A1, the input cell.

Fixed errors, and replaced with Emigna's suggestion.

Thanks to Alexandru for saving me some bytes using truths

Answer 9

Brachylog, 14 bytes

#$:18ot|:1.4ot

Try it online!

Explanation

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

Answer 10

Perl, 29 27 bytes

Includes +2 for -lp

Give input on STDIN

adult.pl <<< 1.24

adult.pl:

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

If you don't mind an extra newline if you really were a full adult then leaving out the l option for 26 bytes works too

Answer 11

GNU sed, 40 + 1 = 41 bytes

(score +1 for use of -r flag to interpreter)

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

Annotated:

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

We take advantage of the constraints on input, so don't have to test the start of string when we see '1.' - we know there's only one digit before the decimal point.

Test result:

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

Answer 12

Haskell, 50 bytes

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

Usage example: f "1.0" -> "1.6".

Haskell's strict type requires usage of strings as input and output. Howevers, read, max and show are polymorphic and handle all numeric types.

Answer 13

Java, 79 70 bytes

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

Defines two methods with overloading, which use the conditional operator.

Call it like f(5) or f(1.4f).

Answer 14

CJam, 18 14 bytes

Saved 4 bytes thanks to Martin Ender.

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

Online interpreter

Answer 15

IBM/Lotus Notes Formula Language, 58 49 bytes

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

Computed field formula where a is an editable numeric field.

EDIT

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

Alternative inspired by @Mego

Answer 16

Jelly, 16 15 13 bytes

ŒṘċ”.ị1.4,18»

TryItOnline
Or see all test cases, also at TryItOnline

How?

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

Answer 17

Actually, 16 bytes

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

Try it online!

Explanation:

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

Answer 18

C++, 68 bytes

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

This answer is actually 2 functions with the same name, and the compiler works out for me which to call, so it acts as one function without me having to take in one input and decide which it is. Since input on the floating point is guaranteed to be of the same precision as the output, I can return it safely without having to truncate it either.

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

Answer 19

C#, 58 bytes

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

No crazy string parsing needed for C#. Input is expected to be an int or float (unfortunately C# can't cast a double to float if the double is in an object). Output will be either int or string in an object.

(almost missed the at least 1 decimal requirement, added that now)

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
;

Alternate implementation which is also 58 bytes.

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

Answer 20

Emacs Lisp, 37 bytes

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

Guesses from the "datatype" whether the integer or float version should be used. (floatp returns t for 1.0, but not for 1.) The parameter is a number as integer or float, i.e. it should satisfy numberp.

Answer 21

Haskell, 49 bytes

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

Basically, this first attempts to read the input as an integer and then as a double if that fails. Then proceeds to compare it to the respective comparison baseline.

Answer 22

C#, 69 bytes

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

Try it online!

Full program with test cases:

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

A pretty straightforward solution. Note that on some systems float.Parse() might return incorrect results. Pass CultureInfo.InvariantCulture as the second argument according to this answer.

Answer 23

Dyalog APL, 14 bytes Rendered invalid by further specifications

⎕IO←0 which is default on many systems. Takes string as argument.

⍎⌈18 1.4⊃⍨'.'∘∊

⍎⌈ max of the evaluated argument and

18 1.4⊃⍨ {18,1.4} selected by

'.'∘∊ whether the argument contains a period

Answer 24

AWK - 29 bytes

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

Usage:

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

Testing was performed with gawk on RHEL 6. I tried with all the test cases, unfortunately I don't have AWK on the machine that has internet access, so copy-paste is not possible.

Is there a more compact way to do this in AWK?

Answer 25

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

Tested with

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

Output

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

Answer 26

C, 50 bytes:

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

The byte count includes the newline at the end of the macro definition.

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

Answer 27

C#, 71 bytes

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

try it here

Answer 28

Brachylog v2, 11 bytes

ℤ;18⌉|;1.4⌉

Try it online!

Essentially Fatalize's answer, just a bit shorter because it's a newer version of the language with a non-ASCII codepage.

               The output is
    ⌉          the largest of
  18           eighteen
 ;             and
               the input
ℤ              which is an integer,
     |         or
               the output is
          ⌉    the largest of
       1.4     1.4
      ;        and
               the input.

Answer 29

C#, 95 Bytes

Golfed:

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

Test cases:

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

Output:

18
18
18
18
18
43
122

1.4
1.4
1.4
1.4
1.4
1.74
2.0
2.72

Answer 30

Python 2, 49 bytes

lambda a:(a,1.4)[a<1.4]if"."in`a`else(a,18)[a<18]

Answer 31

Batch, 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%

First determines whether the input is an integer by checking whether deleting all .s has any effect on the string. If it is then the value is readily compared against 18, otherwise the first and third characters are combined into a number which is compared against 14.

Answer 32

PHP, 36 35 34 bytes

echo max($a=$argn,$a[1]&p?1.4:18);

Checks whether the character in the second position is a digit (binary and with p). If so, use 18 as the minimum, otherwise 1.4. Then take the bigger of the 2 numbers.

Run like this:

echo 11 | php -nR 'echo max($a=$argn,$a[1]&p?1.4:18);';echo

Explanation

Here's a table of the possible results of the &"p" operation:

input  binary      &   "p"         result      chr   Truthy/falsy
"."    0010 1110   &   0111 0000   0010 0000   " "   TRUTHY
"0"    0011 0000   &   0111 0000   0011 0000   "0"   FALSY
"1"    0011 0001   &   0111 0000   0011 0000   "0"   FALSY
"2"    0011 0010   &   0111 0000   0011 0000   "0"   FALSY
"3"    0011 0011   &   0111 0000   0011 0000   "0"   FALSY
"4"    0011 0100   &   0111 0000   0011 0000   "0"   FALSY
"5"    0011 0101   &   0111 0000   0011 0000   "0"   FALSY
"6"    0011 0110   &   0111 0000   0011 0000   "0"   FALSY
"7"    0011 0111   &   0111 0000   0011 0000   "0"   FALSY
"8"    0011 1000   &   0111 0000   0011 0000   "0"   FALSY
"9"    0011 1001   &   0111 0000   0011 0000   "0"   FALSY
null   0000 0000   &   0111 0000   0000 0000   0     FALSY

When the input is 1 digit, then taking the second digit will result in null. null&"string" will also conveniently evaluate to false. So only when the second char is a . will the expression evaluate to true and 1.4 will be used as the minimum instead of 18.

Tweaks

• Saved a byte by using $argn

Answer 33

PHP: 40 bytes

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

psuedocode, (nested turnary) :

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 

Answer 34

Powershell : 58 Bytes

Bit longer than i'd expected, so many brackets required to have it run correctly.

.({({1.4},$i)[$i-gt1.4]},{({18},$i)[$i-gt18]})[$i-is[int]]

Input as $i

. #Execute the code.. required.
( #First block
    { #Value if-false of first block
        (
        {1.4} #Return Val
        , #Or
        $i #Return Input
        )[$i-gt1.4] #If input is greater than Val
    },{ #Next Block
    ({18},$i)[$i-gt18]} #Same with different val
)[$i-is[int]] #Decides based on if val is default int

Test Cases:

@(0,1,2,12,18,43,115,122,0.0,1.04,1.225,1.399,1.4,1.74,2.0,2.72) | % {
$i = $_
Write-Host $i`t`t -NoNewline
.({({1.4},$i)[$i-gt1.4]},{({18},$i)[$i-gt18]})[$i-is[int]]
}

returns :

0       18
1       18
2       18
12      18
18      18
43      43
115     115
122     122
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      (this is a value of type 'double' - the default formatting of powershell doesn't add decimals, but the returned value is of the correct type)
2.72    2.72

Proof of 2 == 2.0

$i = 2.0
$q = .({({1.4},$i)[$i-gt1.4]},{({18},$i)[$i-gt18]})[$i-is[int]]
$q.GetType().Name
Double

Answer 35

Java, 95 bytes

void p(double d){if(d%1>0)System.out.print(d<1.4?1.4:d);else System.out.print(d<18?18:(int)d);}

5 worse than Kevin's answer, but it has the print statement inside the function so maybe I get some pity points for that.

If this is allowed in Java, you could also use

d->{if(d%1>0)System.out.print(d<1.4?1.4:d);else System.out.print(d<18?18:d);};

Which could be used like

Consumer<Double> func = d->{if(d%1>0)System.out.print(d<1.4?1.4:d);else System.out.print(d<18?18:d);};

Answer 36

Cheddar, 23 21 bytes

n->[n,n%1?1.4:18].max

Nothing super-new but I'll post it as it's pretty short.

Answer 37

Ruby - 34 bytes

Very straight-forward. Could possibly save 2 bytes by transforming that ternary.

->(x){x%1>0?x<1.4?1.4:x:x<18?18:x}

Answer 38

Scala, 44 bytes

def?(x:Int)=18 max x
def?(x:Float)=1.4 max x

Defines two methods using overloading.

Answer 39

Ruby, 31 bytes

->x{[x.to_s=~/\./?1.4:18,x].max}

Try it online!

Answer 40

C and C++ : 47 bytes

#define a(b)(sizeof b>4?b>=1.4?b:1.4:b<18?18:b)

Please let me know if this is considered a default loophole. The macro assumes that an integer literal is four bytes and a double floating point literal is greater than that.

Test using GCC 6.3.1 (C++) :

#include <iostream>

#define a(b)(sizeof b>4?b>=1.4?b:1.4:b<18?18:b)

void print_a (const auto &t) {
  std::cout << a(t) << '\n';
}

template <class T, class...P>
void print_a (const T &t, const P&...p) {
  print_a (t);
  print_a (p...);
}

int main () {

  print_a (0, 1, 2, 12, 18, 43, 115, 122, 0.0, 1.04,
   1.225, 1.399, 1.4, 1.74, 2.0, 2.72);

  return 0;
}

Answer 41

C++ (gcc), 49 bytes

-DK(T,u)T=f(T&x){x<u?x=u:x;}

K(int,18)K(float,1.4)

Try it online!

C++ (gcc), 56 bytes

-DK(T,u)T=f(T(x)){return+x<u?u:x;}

K(int,18)K(double,1.4)

Try it online!

Answer 42

Ruby, 30 bytes

->x{[x.integer??18:1.4,x].max}

I'm very surprised that an 8-character method call seems to be the shortest way to switch modes (at least if we want to treat 1.0 as a decimal).

Answer 43

dc, 34 bytes

[1.4]s1[18]s8[d18>8]s*dX0=*d1.4>1p

Try it online! Note: test cases as defined in the footer do include 0.0, but dc prints 0.0 as 0, so that test case looks like the input is wrong. Also the footer just defines the main chunk as a macro and adds some printing to tidy up the test cases a bit.

Aside from the case of 0.0 as mentioned above, dc prints trailing zeroes in decimals, so we don't really have to do anything special beyond testing for a decimal point and our two less-than tests.

Because conditionals must run macros stored in registers, some bytes are spent just storing our min values - 1.4 in macro/register 1, and 18 in macro/register 8. Macro * just checks whether or not our value is less than 18, and if so runs the aforementioned macro 8 to put 18 on the stack. The main bit is dX0=*d1.4>1. This uses the X command to see how many digits are to the right of the decimal point. If it's 0, we run the aforementioned macro * to either leave the number be, or place 18 on the stack. Fortunately, since 18 is greater than 1.4, we don't really have to worry about finagling else statements or anything (if we needed the integer 1 to pass through unharmed, things would be different). So from here we just test if we're less than 1.4; if so we run macro 1 to put 1.4 on the stack, and finally we print with p.

Answer 44

Lua, 71 bytes

function Z(a,b)print(a+0<b and b or a)end R=io.read Z(R(),18)Z(R(),1.4)

Tested in Lua 5.1.5. TIO throws an error at a+0

Ungolfed

function print_min(input,min_value)
    print(input+0<min_value and min_value or input)
end

R=io.read
print_min(R(),18)
print_min(R(),1.4)

Explanation

a+0 is the shortest way to convert a string to a number. The syntax a+0<b and b or a is a replacement for Lua's lack of a ternary operator; equivalent to a+0<b?b:a.

Answer 45

C# (Visual C# Compiler), 69 67 bytes

s=>int.TryParse(s,out int n)?n<18?"18":s:float.Parse(s)<1.4?"1.4":s

Try it online!

Edit: Saved 2 bytes thanks to Kevin Cruijssen:

1. Changed double to float
2. Removed trailing semi-colon

Answer 46

Pyke, 15 bytes

,16.6*1.4+Qb]Se

Try it here!

Takes input in quotes. is_numeric returns 1 if the input doesn't contain a ., otherwise it returns 0

,16.6*          - 16.6*is_numeric(input)
      1.4+      - ^ + 1.4
          Qb]   - [^, float(input)] 
             Se - sorted(^)[-1]

Answer 47

Racket 76 bytes

(λ(n)(cond[(integer? n)(if(>= n 18)n 18)][(number? n)(if(>= n 1.4)n 1.4)]))

Ungolfed version:

(define f
  (λ(n)
    (cond
      [(integer? n) (if(>= n 18) n 18)]
      [(number? n) (if(>= n 1.4) n 1.4)]
      )))

Testing:

(f 1.3)
(f 15)
(f 19)
(f 1.5)

Output:

1.4
18
19
1.5

Answer 48

TI-Basic, 31 bytes

Prompt O,Str1
Disp max(18,O
Str1
If 1.4>expr(Ans
"1.4
Ans

Pretty self-explanatory. Only thing I would note is that in TI-Basic, whatever the last line evaluates to is implicitly displayed. If nothing is evaluated on the last line it will print Done.

Answer 49

GameMaker Language, 74 bytes

a=argument1;if real(a)<1.4a="1.4"show_message(string(max(argument0,18))+a)

Answer 50

SQL, 105 bytes

IF @v like'%.%'select MAX(p)from(values(@v),(1.400))as X(p)ELSE select MAX(p)from(values(@v),(18))as X(p)

tested on MS SQL Server 2008 R2

usage:

DECLARE @v as varchar(255) = '1.405'
IF @v like'%.%'select MAX(p)from(values(@v),(1.400))as X(p)ELSE select MAX(p)from(values(@v),(18))as X(p)

Answer 51

k, 20 bytes

Returns the maximum of the input, x, and 18 if x is integral or 1.4 otherwise.

{x|$[-7h=@x;18;1.4]}

Answer 52

Julia, 35 bytes

f(x)=max(x,1.4)
f(x::Int)=max(x,18)

Using multiple dispatch.

Answer 53

Logy, 74 bytes (non-competing)

m[X,Y]->X>Y&X|Y;f[X]->include["@stdlib.logy"]~X==ceil[X]&m[X,18]|m[X,1.4];

Wow... Outgolfed by Java

max[X, Y] -> X > Y & X | Y;
f[X] -> include["@stdlib.logy"]
      ~ X == ceil[X] & max[X, 18] | max[X, 1.4];

Answer 54

C++14, 52 bytes

As unnamed lambda:

[](auto t){auto l=sizeof t-4?1.4:18;return t<l?l:t;}

Assumes sizeof int==4 and sizeof double!=4 which is true on most systems. Only side effect: the returned value is always a double.

Usage:

//assign to variable
auto f=[](auto t){auto l=sizeof t-4?1.4:18;return t<l?l:t;};
f(10)
f(2.0)

//use directly
[](auto t){auto l=sizeof t-4?1.4:18;return t<l?l:t;}(10);
[](auto t){auto l=sizeof t-4?1.4:18;return t<l?l:t;}(2.0);