Ich denke, wir haben das alle als Kind gemacht: Einige Websites erfordern ein Mindestalter von 18 Jahren, also ziehen wir nur ein paar Jahre vom Geburtsjahr ab und voilà, wir sind 18+.
Darüber hinaus beträgt die Mindesteinstiegshöhe für die meisten Fahrten in Vergnügungsparks 1,40 m (hier in den Niederlanden mindestens 1,40 m). Natürlich kann dies weniger leicht betrogen werden als das Alter, aber Sie könnten Schuhe mit dicken Absätzen tragen, Ihre Haare hochlegen, einen Hut tragen, auf Ihren Zehen stehen usw.

Eingang:

Ihr Programm / Ihre Funktion akzeptiert eine positive Ganzzahl oder eine Dezimalzahl.

Ausgabe:

• Ist die Eingabe eine Ganzzahl >= 18? Einfach die Eingabe ausdrucken.
• Ist die Eingabe eine Ganzzahl 0-17? Drucken 18.
• Ist die Eingabe eine Dezimalzahl >= 1.4? Einfach die Eingabe ausdrucken.
• Ist die Eingabe eine Dezimalzahl 0.0-1.4? Drucken 1.4.

Herausforderungsregeln:

• Angenommen, die Eingabe liegt immer im Bereich von 0-122(älteste Frau war 122 Jahre alt) oder 0.0-2.72(größter Mann war 2,72 Jahre alt).
• Sie können die Eingabe als Zeichenfolge, Objekt oder eine andere von Ihnen bevorzugte Methode verwenden.
• Die Dezimaleingaben haben niemals mehr als drei Dezimalstellen nach dem Komma.
• 2oder 2.beide sind keine gültigen Ausgaben für 2.0. Sie sind frei , die Ausgabe 2.00oder 2.000statt 2.0jedoch.
  Genau wie die Eingabe wird die Ausgabe niemals mehr als drei Dezimalstellen nach dem Punkt haben.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methode mit den richtigen Parametern und vollständige Programme verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

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

Konvex , 9 Bytes

_1ÛI1.4?»

Probieren Sie es online!

Python 2.7, 34 Bytes

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

JavaScript (ES6), 27 31

Eingabe als Zeichenfolge Um zu überprüfen, ob der Eingabewert Dezimalstellen enthält, wird er an sich selbst angehängt: Wenn kein Dezimalpunkt vorhanden ist, ist das Ergebnis immer noch eine gültige Zahl, ansonsten nicht. Um eine gültige Zahl (einschließlich 0) zu erkennen, verwende ich Division, da Javascript 1/nnumerisch ist und nicht 0 für eine Zahl ( n schließlich ist der Wert Infinityfür n==0), sonst ist esNaN

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

Prüfung

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

Meine vorige (falsche) Lösung:

Wenn Sie die Eingabe als Zahl verwenden, können Sie den Restoperator verwenden %, um zu überprüfen, ob die Zahl eine Ganzzahl ist.

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

oder

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

Dies funktioniert jedoch nicht als Aufforderung, zwischen beispielsweise 2und zu unterscheiden, 2.0und das ist die gleiche Zahl. Es ist also nicht möglich, die Eingabe als Zahl zu erhalten

05AB1E , 13 11 Bytes

Verwendet die CP-1252- Codierung.

ÐîQ18*14T/M

Erläuterung

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

Probieren Sie es online aus

Java 8, 90 61 57 Bytes

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

-4 Bytes werden zurückgegeben Objectanstatt String; und einige zusätzliche Bytes Umwandeln Java 7 bis 8.
-4 - Byte unter den Eingang als Objectanstelle von Stringals auch.

Erläuterung:

Probieren Sie es hier aus.

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}\.`

Probieren Sie es online aus.

PHP, 40 Bytes

Geändert von @ user59178 Vielen Dank

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

PHP, 42 Bytes erste Version

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

EXCEL: 26 31 29 Bytes

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

Die Formel kann an eine beliebige Stelle außer A1, der Eingabezelle, verschoben werden.

Fehler behoben und durch den Vorschlag von Emigna ersetzt.

Vielen Dank an Alexandru, der mir ein paar Bytes mit Wahrheiten erspart hat

Brachylog , 14 Bytes

#$:18ot|:1.4ot

Probieren Sie es online!

Erläuterung

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

Beinhaltet +2 für -lp

Geben Sie eine Eingabe für STDIN ein

adult.pl <<< 1.24

adult.pl:

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

Wenn Ihnen ein zusätzlicher Zeilenumbruch nichts ausmacht, wenn Sie wirklich volljährig sind, können Sie auch die lOption für 26 Byte weglassen

GNU sed, 40 + 1 = 41 Bytes

(Punktzahl +1 für die Verwendung der -rFlagge als Dolmetscher)

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

Kommentiert:

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

Wir machen uns die Eingabebeschränkungen zunutze und müssen den Anfang der Zeichenfolge nicht testen, wenn "1" angezeigt wird. - Wir wissen, dass es nur eine Ziffer vor dem Komma gibt.

Testergebnis:

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

Anwendungsbeispiel: f "1.0"-> "1.6".

Haskells strenger Typ erfordert die Verwendung von Strings als Eingabe und Ausgabe. Howevers, read, maxund showsind polymorph und behandeln alle numerischen Typen.

Java, 79-70 Bytes

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

Definiert zwei Methoden mit Überladung, die den bedingten Operator verwenden.

Nennen Sie es wie f(5)oder f(1.4f).

CJam, 18 14 Bytes

4 Bytes gespart dank Martin Ender.

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

Online-Dolmetscher

C #, 69 Bytes

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

Probieren Sie es online!

Volles Programm mit Testfällen:

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

Eine ziemlich einfache Lösung. Beachten Sie, dass float.Parse () auf einigen Systemen möglicherweise falsche Ergebnisse zurückgibt. Pass CultureInfo.InvariantCulture als zweites Argument nach dieser Antwort .

IBM / Lotus Notes Formula Language, 58 49 Byte

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

Berechnete Feldformel wobei a ein bearbeitbares numerisches Feld ist.

BEARBEITEN

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

Alternative inspiriert von @Mego

Jelly , 16 15 13 Bytes

ŒṘċ”.ị1.4,18»

TryItOnline
Oder sehen Sie alle Testfälle, auch bei TryItOnline

Wie?

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

Diese Antwort besteht eigentlich aus 2 Funktionen mit demselben Namen, und der Compiler ermittelt, welche Funktion ich aufrufen soll, sodass er als eine Funktion fungiert, ohne dass ich eine Eingabe vornehmen und entscheiden muss, um welche es sich handelt. Da die Eingabe auf dem Gleitkomma garantiert die gleiche Genauigkeit wie die Ausgabe hat, kann ich sie sicher zurückgeben, ohne sie abschneiden zu müssen.

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 Bytes

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

Für C # ist kein verrücktes String-Parsen erforderlich. Es wird erwartet, dass die Eingabe ein intoder ist float(leider kann C # kein in umwandeln double, floatwenn das doublein ein ist object). Die Ausgabe wird entweder intoder stringin ein object.

(Mindestens 1 Dezimalstelle wurde fast verfehlt, jetzt hinzugefügt)

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
;

Alternative Implementierung, die ebenfalls 58 Byte umfasst.

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

Eigentlich 16 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Vermutungen aus dem "Datentyp", ob die Integer- oder Float-Version verwendet werden soll. ( floatpgibt tfür 1.0, aber nicht für zurück 1.) Der Parameter ist eine Zahl als Ganzzahl oder Fließkomma, dh er sollte erfüllen numberp.

Haskell, 49 Bytes

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

Grundsätzlich wird zuerst versucht, die Eingabe als Ganzzahl und dann als Double zu lesen, wenn dies fehlschlägt. Dann wird mit dem Vergleich mit der jeweiligen Vergleichsgrundlinie fortgefahren.

Dyalog APL , 14 Byte Durch weitere Angaben ungültig gemacht

⎕IO←0Das ist auf vielen Systemen Standard. Nimmt string als Argument.

⍎⌈18 1.4⊃⍨'.'∘∊

⍎⌈ max des bewerteten Arguments und

18 1.4⊃⍨ {18,1.4} ausgewählt von

'.'∘∊ ob das Argument einen Punkt enthält

95 Bytes

Golf gespielt:

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

Testfälle:

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

Ausgabe:

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

Verwendungszweck:

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

Das Testen wurde mit gawkRHEL 6 durchgeführt. Ich habe es mit allen Testfällen versucht, leider habe ich AWKauf dem Computer keinen Internetzugang, daher ist Kopieren und Einfügen nicht möglich.

Gibt es eine kompaktere Möglichkeit, dies zu tun AWK?

C, 50 Bytes:

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

Die Byteanzahl schließt die neue Zeile am Ende der Makrodefinition ein.

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 Bytes

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

versuche es hier

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

Getestet mit

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

Ausgabe

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

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%

Bestimmt zunächst, ob es sich bei der Eingabe um eine Ganzzahl handelt, indem überprüft wird, ob das Löschen aller .s Auswirkungen auf die Zeichenfolge hat. Wenn dies der Fall ist, wird der Wert leicht mit 18 verglichen, andernfalls werden das erste und dritte Zeichen zu einer Zahl kombiniert, die mit 14 verglichen wird.

PHP: 40 Bytes

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

psuedocode (verschachtelter 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