Sí, por supuesto que soy un adulto!

44

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 , 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
Kevin Cruijssen
fuente
¿Podemos suponer que la entrada está libre de ceros a la izquierda?
Toby Speight
@TobySpeight Sí, no hay ceros a la izquierda.
Kevin Cruijssen
2
0.0-2.72 (tallest man ever was 2.72).- No lo eres 0.0cuando naces ...
Johan Karlsson
1
@JohanKarlsson Lo sé, pensé en agregar un mínimo, pero decidí dejarlo comenzar en 0y 0.0. :) El agregado tallest man ever was 2.72y oldest woman ever was 122acaba de agregarse como hechos informativos para los interesados.
Kevin Cruijssen
99
"[...] así que solo agregamos algunos años al año de nacimiento" [...] "¿No deberías restar algunos años del año de nacimiento?
Wythagoras

Respuestas:

45

Python 2.7, 34 bytes

lambda x:max(x,[18,1.4]['.'in`x`])
Lynn
fuente
¿Qué devuelve esto para 2.0?
Adám
2
@ Adámmax(2.0,[18,1.4][True]) == max(2.0,1.4) == 2.0
Lynn
3
No, no lo hace. ¿Por qué no lo intentas tú mismo? :)
Lynn
55
@ Adám Yo uso repl.it o ideone.com para Python. Vea cualquier respuesta de Python que haya publicado, y probablemente tenga un enlace a una de esas dos.
mbomb007
1
no importa, lo tengo. así que básicamente los mapas verdaderos o falsos a 0 o 1 índice en esa matriz y luego aplica max en los dos números.
Alexandru Pupsa el
15

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

edc65
fuente
2
Resultado para 2.0debe ser 2.0, no 18.
Neil
en efecto. 2.0%1y 1.0%1resultará en 0
aross
44
'javascript (es6) es detallado', solo se ve en codegolf
dwana
@Neil, pensándolo bien, probablemente
tengas
3
1/(x+x)- Ahora eso es imaginativo!
Neil
13

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

Emigna
fuente
2
Eres un poco lento Todavía te tomó 1,5 minutos. ; P (léase: Maldición, eso fue rápido). Es bastante sencillo, por supuesto.
Kevin Cruijssen
2
@KevinCruijssen: Sí, la implementación es bastante rápida en un idioma que no requiere muchas pulsaciones de teclas: P
Emigna
@EriktheGolfer: ¿Mejor? Si no, no dudes en editarlo. He estado experimentando con algunas formas diferentes de formateo y no he decidido una estrictamente mejor. Sugerencias bienvenidas.
Emigna
@Emigna Acabo de agregar dos espacios cruciales que faltan.
Erik the Outgolfer
2
@FrancescoCasula: Encontré una solución más corta que funciona en TIO :)
Emigna
8

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
Kevin Cruijssen
fuente
¿Es necesario poner corchetes alrededor del operador if / else?
Roman Gräf
1
@ RomanGräf Sí; el ternario tiene menor prioridad que +, lo que significa que si elimina los paréntesis, se convertiría en(""+i.contains(...)) ?
Nic Hartley
7

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);
Jörg Hülsermann
fuente
is_int($i=$argv[1]+0)es 2 bytes más corto que strpos($i=$argv[1],".")y puede servir para el mismo propósito si intercambia el 1.4y el18
user59178
@ user59178 que podría usar is_numericen una cadena pero nois_int
Jörg Hülsermann
por eso está el +0, para convertirlo a un tipo numérico.
user59178
1
Funciona correctamente para mí (probé php 5.5 y 7.0 en Windows). Tenga en cuenta que tiene condiciones verdaderas / falsas opuestas a la strpos($i=$argv[1],".")versión, ¿se acordó de intercambiar las salidas del ternario?
user59178
1
En realidad, en una lectura más cercana, debe ser en <?=max(is_int(0+$i=$argv[1])?18:1.4,$i);lugar de <?=max(is_int($i=$argv[1]+0)?18:1.4,$i);evitar la salida de 2 cuando se le da 2.0.
user59178
6

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


fuente
1
Además, ¿no es mejor definir un nombre npara la celda de entrada? Puede estar en cualquier parte del documento y también es 2 bytes más corto.
Emigna
@Emigna podría , pero en ese momento me siento un poco engañoso . 1 byte por nombre no es nada para buscar, y si mantengo este formato, la gente puede copiar y pegar con facilidad.
No veo cómo eso es diferente de usar una variable de entrada de 1 letra en una lambda en python, por ejemplo. Pero es tu
decisión
¡Hola! ¿Cómo se calculan los bytes? ¿Guardar el archivo con la fórmula con el nombre predeterminado o de alguna otra manera?
Vityata
1
Puede eliminar el '= 0' y cambiar los resultados: 1.4 primero, 18 segundos Además, como tiene coma como separador decimal, esto podría no funcionar para la mayoría de las personas.
Alexandru Pupsa el
5

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
Fatalizar
fuente
5

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

Ton Hospel
fuente
5

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
Toby Speight
fuente
5

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.

nimi
fuente
Pensé que sería inteligente y lo haría sin los guardias, pero eso terminó haciéndolo un poco más largo :( Mi versión:(#)x=map(show.max x.fst).reads;f s=head$18#s++1.4#s
Cubic
@Cubic: Buen uso de reads. Con una ligera modificación es un byte más corto que el mío. Por favor publíquelo como una respuesta separada. x#y=show.max x.fst<$>reads y;f s=head$18#s++1.4#s.
nimi
¡Una idea realmente genial para salvar a los padres con infix fmap!
Cubic
5

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

corvus_192
fuente
1
Hola. x<18?18:xy x<1.4f?1.4f:xson más cortos que el Math.max. Creo que puede encontrar consejos para jugar golf en Java interesantes para leer. :)
Kevin Cruijssen
Sí, por supuesto que lo son. ¿Cómo podría yo les olvidó ...
corvus_192
¡Me encanta esto! ¡Por qué codificar la lógica usted mismo cuando puede descargar eso al compilador!
corsiKa
4

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 .

adrianmp
fuente
Dadas las limitaciones Creo que puede salirse con la sustitución s.Contains(".")cons[1]=='.'
JustinM - Restablecer Monica
Hmm nvm, olvidé el caso de prueba 0. tan cerca también :(
JustinM - Restablecer Monica
1
@Phaeze: Sí, fallaría en cualquier entrada de 1 dígito con una excepción IndexOutOfRangeException. De lo contrario puede afeitarse un byte con s[1]==46, o un enfoque aún más agresiva (suponiendo que sólo tiene dígitos y un carácter en el índice 1 '') (tiene un código ASCII de 46 ''.): s[1]<47.
adrianmp
1
Oo me gusta eso, intentare recordarlo. Gracias por convertir mi idiotez en una oportunidad de aprendizaje :)
JustinM - Restablece a Monica el
4

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

ElPedro
fuente
4

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)
Jonathan Allan
fuente
2
Esto regresa 18para 2.0, tristemente :(
Lynn
Ah, la complejidad de Jelly es superior.
Erik the Outgolfer
@ Lynn gracias, arreglado a un costo enorme; Tal vez hay un camino más corto que este.
Jonathan Allan
4

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";
}
Cody
fuente
El usuario Szali Szali sugirió guardar dos bytes convirtiendo el floats en autos. Rechacé la edición de acuerdo con la política, pero siéntase libre de editarla usted mismo si ha confirmado que funciona.
Martin Ender
¡Toda esa duplicación de texto! Puede guardar varios caracteres generando las dos definiciones mediante macro.
Gracias @MartinEnder. Su edición no se compila en todos los compiladores de C ++ e introduce todo tipo de casos extraños con otros tipos que de repente se pueden pasar, por lo que voy a aceptar mis 2 bytes para mantener mi respuesta un poco más portátil.
Cody
@Cody Es su decisión, pero en lo que respecta a PPCG, los idiomas están definidos por sus implementaciones, por lo que las respuestas no necesitan ser portátiles o particularmente seguras. Siempre que haya un compilador donde el programa funcione (y las entradas requeridas funcionen, independientemente de si las inválidas también funcionarían), está completamente bien.
Martin Ender
4

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##}";
Leche
fuente
4

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 
Mego
fuente
Nunca he programado en realidad antes, pero ¿por qué usar en lugar de solo 18? Sé que es el mismo conteo de bytes, por lo que realmente no importa, pero 18parece más legible. ¿O hay alguna razón por la que no funcionará en el lenguaje de programación / implementación actual?
Kevin Cruijssen
3
@KevinCruijssen 18empuja ay 1an 8. Para empujar un literal 18, usaría :18, que es más largo que .
Mego
Ah, por supuesto, lenguajes basados ​​en pila. ¡Gracias por la explicación! +1
Kevin Cruijssen
4

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.

Lord Yuuma
fuente
4

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.

Cúbico
fuente
3

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

Adán
fuente
3

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
Pete Arden
fuente
1
Hola, bienvenido a PPCG! Su enfoque actual se puede acortar un poco de la siguiente manera: string y(string p){int a;return int.TryParse(p,out a)?a<1?"18":p:double.Parse(p)<1.4?"1.4":p;}(se eliminó el paréntesis; >=1.4al <1.4cambiar el "1.4"y p; se cambió decimalpara doubleque Mdesaparezca. Además, alguien más acaba de publicar un enfoque diferente en C # que es un poco más corto. Puede encontrar Consejos para jugar al golf en C # interesante para leer. ¡Nuevamente, bienvenido! :)
Kevin Cruijssen
Hola, gracias por los útiles comentarios. ¡Me olvidé por completo de esos corchetes adicionales que tenía para evitar perder el rastro del operador ternario-ternario! He guardado 5 bytes ahora en general.
Pete Arden
Puede guardar un byte utilizando en float.Parselugar de double.Parse. Y también, si mueve la declaración de a a los argumentos del método con un valor predeterminado, puede descartar su declaración de retorno utilizando el miembro con cuerpo de expresión. por ejemplo:string f(string s,int a=0)=>int.TryParse(s,out a)?a>17?s:"18":float.Parse(s)<1.4?"1.4":s;
JustinM - Reinstale a Monica el
3

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?

Robert Benson
fuente
3

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);
}
ecatmur
fuente
3

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í

pez espada
fuente
3

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
cleblanc
fuente
Esto no es válido ... Una entrada de 12 debería generar 18
Beta Decay
@BetaDecay tienes razón. Necesito agregar un carácter adicional. Gracias por señalar eso.
cleblanc
2

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.

Neil
fuente
2

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 
rb101
fuente
1
Bienvenido a PPCG! Tenga en cuenta que la entrada (por defecto) tiene que ser a través de STDIN, argumentos de función o argumentos completos del programa.
Aross