Myślę, że wszyscy to zrobiliśmy jako dziecko: niektóre strony internetowe wymagają minimalnego wieku 18 lat, więc odejmujemy tylko kilka lat od roku urodzenia i voilà, mamy „18 lat”.
Ponadto w przypadku większości przejażdżek w wesołych miasteczkach minimalna wysokość, na którą można wjechać, wynosi 1,40 metra (przynajmniej w Holandii). Oczywiście można to łatwiej oszukiwać niż wiek, ale możesz nosić buty z grubymi obcasami, podnosić włosy, nosić kapelusz, stać na palcach itp.

Wejście:

Twój program / funkcja akceptuje dodatnią liczbę całkowitą lub dziesiętną.

Wynik:

• Czy wejście jest liczbą całkowitą >= 18? Po prostu wydrukuj dane wejściowe.
• Czy wejście jest liczbą całkowitą 0-17? Drukuj 18.
• Czy dane wejściowe są dziesiętne >= 1.4? Po prostu wydrukuj dane wejściowe.
• Czy dane wejściowe są dziesiętne 0.0-1.4? Drukuj 1.4.

Zasady konkursu:

• Załóżmy, że dane wejściowe będą zawsze w zakresie 0-122(najstarsza kobieta kiedykolwiek miała 122 lata) lub 0.0-2.72(najwyższy mężczyzna kiedykolwiek 2,72).
• Możesz wziąć dane wejściowe jako ciąg znaków, obiekt lub cokolwiek innego, co wolisz.
• Wprowadzanie miejsc dziesiętnych nigdy nie będzie miało więcej niż trzy miejsca po przecinku po przecinku.
• 2lub 2.oba nie są prawidłowymi danymi wyjściowymi dla 2.0. Możesz jednak generować dane wyjściowe 2.00lub 2.000zamiast nich 2.0.
  Podobnie jak wejście, wyjście nigdy nie będzie miało więcej niż trzy miejsca po przecinku za kropką.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi odnoszą się standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

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

Wypukły , 9 bajtów

_1ÛI1.4?»

Wypróbuj online!

Python 2.7, 34 bajty

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

JavaScript (ES6), 27 31

Dane wejściowe są traktowane jako ciąg. Aby sprawdzić, czy wartość wejściowa ma miejsca po przecinku, jest dołączana do siebie: jeśli nie ma przecinka dziesiętnego, wynik jest nadal poprawną liczbą, w przeciwnym razie nie. Aby rozpoznać prawidłowy numer (łącznie 0), używam podział jak w javascript 1/njest numeryczny, a nie 0 dla dowolnego numeryczne n (ostatecznie wartość jest Infinityza n==0), w przeciwnym wypadku jest toNaN

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

Moje poprzednie (złe) rozwiązanie:

Biorąc dane wejściowe jako liczbę, możesz użyć operatora reszty, %aby sprawdzić, czy liczba jest liczbą całkowitą.

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

lub

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

Ale to nie działa jako żądanie wyzwania, aby rozróżnić, powiedzmy, 2i 2.0to ta sama liczba. Dlatego nie jest możliwe uzyskanie danych wejściowych jako liczby

05AB1E , 13 11 bajtów

Wykorzystuje kodowanie CP-1252 .

ÐîQ18*14T/M

Wyjaśnienie

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

Wypróbuj online

Java 8, 90 61 57 bajtów

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

-4 bajty zwracane Objectzamiast String; i niektóre dodatkowe bajty konwertujące Java 7 na 8.
-4 bajty przyjmując dane wejściowe jako Objectzamiast String.

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów

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

Wypróbuj online.

PHP, 40 bajtów

zmodyfikowany przez @ user59178 Dziękujemy

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

PHP, 42 bajty pierwsza wersja

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

EXCEL: 26 31 29 bajtów

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

Formuła może iść wszędzie, z wyjątkiem komórki wejściowej A1.

Naprawiono błędy i zastąpiono sugestią Emigny.

Dzięki Alexandru za uratowanie mi niektórych bajtów przy użyciu prawdy

Brachylog , 14 bajtów

#$:18ot|:1.4ot

Wypróbuj online!

Wyjaśnienie

    #$             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 bajtów

Obejmuje +2 za -lp

Podaj dane na STDIN

adult.pl <<< 1.24

adult.pl:

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

Jeśli nie przeszkadza ci dodatkowa linia, jeśli naprawdę jesteś pełnoletnią osobą, opuszczenie lopcji 26 bajtów również działa

GNU sed, 40 + 1 = 41 bajtów

( -rzdobądź +1 za użycie flagi do tłumacza)

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

Adnotacja:

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

Korzystamy z ograniczeń na wejściu, więc nie musimy testować początku łańcucha, gdy widzimy „1”. - wiemy, że przed kropką dziesiętną jest tylko jedna cyfra.

Wynik testu:

$ ./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 bajtów

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

Przykład użycia: f "1.0"-> "1.6".

Typ ścisły Haskella wymaga użycia ciągów jako danych wejściowych i wyjściowych. Howevers, read, maxi showsą polimorficzne i obsługiwać wszystkie typy numeryczne.

Java, 79 70 bajtów

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

Definiuje dwie metody z przeciążeniem, które wykorzystują operator warunkowy.

Nazwij to jak f(5)lub f(1.4f).

CJam, 18 14 bajtów

Zaoszczędzono 4 bajty dzięki Martinowi Enderowi.

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

Tłumacz online

C #, 69 bajtów

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

Wypróbuj online!

Pełny program z przypadkami testowymi:

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

Całkiem proste rozwiązanie. Zauważ, że w niektórych systemach float.Parse () może zwracać niepoprawne wyniki. Przekaż CultureInfo.InvariantCulture jako drugi argument zgodnie z tą odpowiedzią .

Język formuły IBM / Lotus Notes, 58 49 bajtów

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

Obliczona formuła pola, gdzie a jest edytowalnym polem numerycznym.

EDYTOWAĆ

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

Alternatywa inspirowana @Mego

Galaretka , 16 15 13 bajtów

ŒṘċ”.ị1.4,18»

TryItOnline
Lub zobacz wszystkie przypadki testowe, także w TryItOnline

W jaki sposób?

ŒṘċ”.ị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 bajtów

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

Ta odpowiedź to tak naprawdę 2 funkcje o tej samej nazwie, a kompilator opracowuje dla mnie, którą wywołać, więc działa jak jedna funkcja, bez konieczności przyjmowania jednego wejścia i decydowania, która to jest. Ponieważ wejście zmiennoprzecinkowe ma taką samą precyzję jak wyjście, mogę je bezpiecznie zwrócić bez konieczności obcinania.

Niegolfowane + testy

#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 bajtów

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

Żadne szalone parsowanie ciągów nie jest potrzebne dla C #. Oczekuje się, że dane wejściowe to intlub float(niestety C # nie może rzucić doublena, floatjeśli doublejest w object). Wyjście będzie albo intczy stringw sposób object.

(prawie przegapiłem przynajmniej 1 wymóg dziesiętny, dodałem to teraz)

Nie golfowany:

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

Alternatywna implementacja, która ma również 58 bajtów.

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

Właściwie 16 bajtów

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

Wypróbuj online!

Wyjaśnienie:

;:.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 bajtów

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

Odgadnięcia na podstawie „typu danych”, czy należy stosować liczbę całkowitą czy zmiennoprzecinkową. ( floatpzwraca tza 1.0, ale nie za 1.) Parametr jest liczbą całkowitą lub zmiennoprzecinkową, tzn. powinien spełniać numberp.

Haskell, 49 bajtów

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

Zasadniczo to najpierw próbuje odczytać dane wejściowe jako liczbę całkowitą, a następnie jako wartość podwójną, jeśli to się nie powiedzie. Następnie przechodzi do porównania z odpowiednią linią bazową porównania.

Dyalog APL , 14 bajtów Niepoprawne z powodu dalszych specyfikacji

⎕IO←0co jest domyślne w wielu systemach. Bierze ciąg jako argument.

⍎⌈18 1.4⊃⍨'.'∘∊

⍎⌈ max ocenianego argumentu i

18 1.4⊃⍨ {18,1.4} wybrany przez

'.'∘∊ czy argument zawiera kropkę

C #, 95 bajtów

Gra w golfa:

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

Nie golfowany:

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

Przypadki testowe:

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

Wynik:

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 bajtów

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

Stosowanie:

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

Testowanie przeprowadzono gawkna RHEL 6. Próbowałem ze wszystkimi przypadkami testowymi, niestety nie mam go AWKna komputerze, który ma dostęp do Internetu, więc kopiowanie-wklejanie nie jest możliwe.

Czy jest na to bardziej zwarty sposób AWK?

C, 50 bajtów:

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

Liczba bajtów obejmuje znak nowej linii na końcu definicji makra.

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 bajtów

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

spróbuj tutaj

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

Testowane z

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

Wynik

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

Partia, 102 bajty

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

Najpierw określa, czy wejście jest liczbą całkowitą, sprawdzając, czy usunięcie wszystkich .s ma jakikolwiek wpływ na ciąg. Jeśli tak, to wartość jest łatwo porównywana z 18, w przeciwnym razie pierwszy i trzeci znak są łączone w liczbę, która jest porównywana z 14.

PHP: 40 bajtów

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

psuedocode, (zagnieżdżony obrotowy):

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