Penso che l'abbiamo fatto tutti da bambino: alcuni siti web richiedono un'età minima di 18 anni, quindi sottraggiamo solo alcuni anni dall'anno di nascita e voilà, abbiamo '18 anni'.
Inoltre, per la maggior parte delle giostre nei parchi di divertimento l'altezza minima per entrare è di 1,40 metri (almeno qui in Olanda). Naturalmente questo può essere ingannato meno facilmente dell'età, ma potresti indossare scarpe con tacchi spessi, alzare i capelli, indossare un cappello, stare in piedi, ecc.

Ingresso:

Il tuo programma / funzione accetta un numero intero o un decimale positivo.

Produzione:

• L'input è un numero intero >= 18? Basta stampare l'input.
• L'input è un numero intero 0-17? Stampa 18.
• L'input è un decimale >= 1.4? Basta stampare l'input.
• L'input è un decimale 0.0-1.4? Stampa 1.4.

Regole della sfida:

• Supponiamo che l'input sia sempre nel range di 0-122(la donna più anziana che abbia mai avuto 122 anni) o 0.0-2.72(l'uomo più alto di sempre è stato 2,72).
• Puoi prendere l'input come stringa, oggetto o qualsiasi altra cosa tu preferisca.
• Gli input decimali non avranno mai più di tre decimali dopo il punto decimale.
• 2o 2.entrambi non sono output validi per 2.0. Sei libero di produrre 2.00o 2.000invece di 2.0comunque.
  Proprio come l'input, l'output non avrà mai più di tre cifre decimali dopo il punto.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi 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

Convesso , 9 byte

_1ÛI1.4?»

Provalo online!

Python 2.7, 34 byte

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

JavaScript (ES6), 27 31

Input preso come una stringa. Per verificare se il valore di input ha decimali, viene aggiunto a se stesso: se non esiste un punto decimale, il risultato è ancora un numero valido, altrimenti non lo è. Per riconoscere un numero valido (incluso 0), uso la divisione come in javascript 1/nè numerico e non 0 per qualsiasi numero n (eventualmente il valore è Infinityper n==0), altrimenti è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')
})

La mia soluzione prev (sbagliata):

Prendendo l'input come numero, è possibile utilizzare l'operatore residuo %per verificare se il numero è intero.

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

o

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

Ma questo non funziona come la richiesta sfida di discriminare tra, diciamo, 2e 2.0ed è per lo stesso numero. Quindi non è possibile ottenere l'input come numero

05AB1E , 13 11 byte

Utilizza la codifica CP-1252 .

ÐîQ18*14T/M

Spiegazione

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

Provalo online

Java 8, 90 61 57 byte

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

-4 byte che ritornano Objectinvece di String; e alcuni byte aggiuntivi che convertono Java 7 in 8.
-4 byte prendendo anche l'input Objectanziché String.

Spiegazione:

Provalo qui.

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 byte

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

Provalo online.

PHP, 40 byte

modificato da @ user59178 Grazie

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

PHP, 42 byte prima versione

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

EXCEL: 26 31 29 byte

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

La formula può andare ovunque tranne A1, la cella di input.

Risolti errori e sostituiti con il suggerimento di Emigna.

Grazie ad Alexandru per avermi salvato alcuni byte usando le verità

Brachylog , 14 byte

#$:18ot|:1.4ot

Provalo online!

Spiegazione

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

Include +2 per -lp

Dare input su STDIN

adult.pl <<< 1.24

adult.pl:

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

Se non ti dispiace una newline extra se fossi davvero un adulto completo, lasciare fuori l' lopzione per 26 byte funziona anche

GNU sed, 40 + 1 = 41 byte

(punteggio +1 per l'uso della -rbandiera per l'interprete)

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

commentata:

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

Sfruttiamo i vincoli sull'input, quindi non dobbiamo testare l'inizio della stringa quando vediamo '1'. - sappiamo che c'è solo una cifra prima del punto decimale.

Risultato del 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 byte

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

Esempio di utilizzo: f "1.0"-> "1.6".

Il tipo rigoroso di Haskell richiede l'uso di stringhe come input e output. Howevers, read, maxe showsono polimorfici e gestire tutti i tipi numerici.

Java, 79 70 byte

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

Definisce due metodi con sovraccarico, che utilizzano l'operatore condizionale.

Chiamalo come f(5)o f(1.4f).

CJam, 18 14 byte

Risparmiato 4 byte grazie a Martin Ender.

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

Interprete online

C #, 69 byte

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

Provalo online!

Programma completo con casi di 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
        }
    }
}

Una soluzione piuttosto semplice. Notare che su alcuni sistemi float.Parse () potrebbe restituire risultati errati. Passa CultureInfo.InvariantCulture come secondo argomento in base a questa risposta .

Linguaggio formula IBM / Lotus Notes, 58 49 byte

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

Formula di campo calcolata in cui a è un campo numerico modificabile.

MODIFICARE

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

Alternativa ispirata a @Mego

Gelatina , 16 15 13 byte

ŒṘċ”.ị1.4,18»

TryItOnline
O vedi tutti i casi di test, anche su TryItOnline

Come?

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

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

Questa risposta è in realtà 2 funzioni con lo stesso nome, e il compilatore risolve per me quale chiamare, quindi agisce come una funzione senza che io debba prendere un input e decidere quale sia. Poiché è garantito che l'input sul virgola mobile abbia la stessa precisione dell'output, posso restituirlo in modo sicuro senza doverlo troncare.

Ungolfed + test

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

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

Non è necessario l'analisi pazza delle stringhe per C #. Si prevede che l'input sia un into float(sfortunatamente C # non può lanciare un doublea floatse doubleè in un object). L'output sarà into stringin unobject .

(quasi mancato il requisito almeno 1 decimale, aggiunto ora)

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
;

Implementazione alternativa che è anche 58 byte.

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

In realtà, 16 byte

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

Provalo online!

Spiegazione:

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

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

Indovina dal "tipo di dati" se utilizzare la versione intera o float. ( floatprestituisce tper 1.0, ma non per 1.) Il parametro è un numero come intero o float, ovvero dovrebbe soddisfare numberp.

Haskell, 49 byte

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

Fondamentalmente, questo prima tenta di leggere l'input come numero intero e poi come doppio se fallisce. Quindi procede a confrontarlo con la rispettiva base di confronto.

Dyalog APL , 14 byte Resi non validi da ulteriori specifiche

⎕IO←0che è predefinito su molti sistemi. Prende la stringa come argomento.

⍎⌈18 1.4⊃⍨'.'∘∊

⍎⌈ max dell'argomento valutato e

18 1.4⊃⍨ {18,1,4} selezionato da

'.'∘∊ se l'argomento contiene un punto

C #, 95 byte

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

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

Produzione:

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 byte

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

Uso:

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

Il test è stato eseguito gawksu RHEL 6. Ho provato con tutti i casi di test, purtroppo non ce l'hoAWK sulla macchina che ha accesso a Internet, quindi non è possibile copiare e incollare.

C'è un modo più compatto per farlo in AWK?

C, 50 byte:

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

Il conteggio dei byte include la nuova riga alla fine della definizione di 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 byte

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

provalo qui

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

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

Produzione

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

Lotto, 102 byte

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

Innanzitutto determina se l'input è un numero intero controllando se l'eliminazione di tutti .i messaggi di posta elettronica ha qualche effetto sulla stringa. In tal caso, il valore viene facilmente confrontato con 18, altrimenti il ​​primo e il terzo carattere vengono combinati in un numero confrontato con 14.

PHP: 40 byte

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

psuedocode, (turnary nidificato):

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