Sim, claro que sou adulta!

44

Eu acho que todos nós fizemos isso quando criança: alguns sites exigem idade mínima de 18 anos, então apenas subtraímos alguns anos a partir do ano de nascimento e pronto, somos 'maiores de 18 anos'.
Além disso, para a maioria dos passeios em parques de diversões, a altura mínima para entrada é de 1,40 metros (aqui na Holanda, pelo menos). É claro que isso pode ser enganado com menos facilidade do que a idade, mas você pode usar sapatos com saltos grossos, arrumar o cabelo, usar chapéu, ficar na ponta dos pés etc.

Entrada:

Seu programa / função aceita um número inteiro positivo ou decimal.

Resultado:

  • A entrada é um número inteiro >= 18? Simplesmente imprima a entrada.
  • A entrada é um número inteiro 0-17? Imprimir 18.
  • A entrada é decimal >= 1.4? Simplesmente imprima a entrada.
  • A entrada é decimal 0.0-1.4? Imprimir 1.4.

Regras do desafio:

  • Suponha que a entrada esteja sempre na faixa de 0-122(a mulher mais velha já teve 122 anos) ou 0.0-2.72(o homem mais alto já teve 2,72).
  • Você pode receber a entrada como uma String, objeto ou qualquer outra coisa que preferir.
  • As entradas decimais nunca terão mais de três casas decimais após o ponto decimal.
  • 2ou 2.ambos não são saídas válidas para 2.0. Você é livre para produzir 2.00ou, em 2.000vez disso, 2.0no entanto.
    Assim como a entrada, a saída nunca terá mais de três casas decimais após o ponto.

Regras gerais:

  • Isso é , então a resposta mais curta em bytes vence.
    Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
  • As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados, programas completos. Sua chamada.
  • As brechas padrão são proibidas.
  • Se possível, adicione um link com um teste para o seu código.
  • Além disso, adicione uma explicação, se necessário.

Casos de teste:

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
fonte
Podemos assumir que a entrada está livre de zeros à esquerda?
Toby Speight
@TobySpeight Sim, sem zeros à esquerda.
Kevin Cruijssen
2
0.0-2.72 (tallest man ever was 2.72).- Você não é 0.0quando você nasceu ...
Johan Karlsson
1
@JohanKarlsson eu sei, pensei em adicionar um mínimo, mas decidi deixá-lo começar em 0e 0.0. :) O adicionado tallest man ever was 2.72e oldest woman ever was 122foi adicionado apenas como fatos informativos para os interessados.
Kevin Cruijssen 29/09/16
9
"[...] então adicionamos apenas alguns anos ao ano de nascimento [...]" Você não deve subtrair alguns anos do ano de nascimento?
Wythagoras #

Respostas:

45

Python 2.7, 34 bytes

lambda x:max(x,[18,1.4]['.'in`x`])
Lynn
fonte
O que isso retorna para o 2.0?
Adám 29/09/16
2
@ Adámmax(2.0,[18,1.4][True]) == max(2.0,1.4) == 2.0
Lynn
3
Não, não faz. Por que você não tenta você mesmo? :)
Lynn
5
@ Adám Eu uso repl.it ou ideone.com para Python. Veja qualquer resposta em Python que eu já tenha postado e provavelmente tem um link para um desses dois.
mbomb007
1
deixa pra lá, entendi. então, basicamente, true ou false mapeia para o índice 0 ou 1 nessa matriz e depois aplica max nos dois números.
Alexandru Pupsa
15

JavaScript (ES6), 27 31

Entrada tomada como uma sequência. Para verificar se o valor de entrada possui decimais, ele é anexado a si mesmo: se não houver ponto decimal, o resultado ainda será um número válido, caso contrário, não será. Para reconhecer um número válido (incluindo 0), eu uso a divisão, pois em javascript 1/né numérico e não 0 para qualquer número n (eventualmente o valor é Infinitypara n==0); caso contrário, éNaN

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

Teste

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

Minha solução anterior (incorreta):

Tomando a entrada como um número, você pode usar o operador restante %para verificar se o número é inteiro.

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

ou

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

Mas isso não funciona como o pedido desafio para discriminar entre, digamos, 2e 2.0e esse é o mesmo número. Portanto, não é possível obter a entrada como um número

edc65
fonte
2
O resultado para 2.0deveria ser 2.0, não 18.
Neil
de fato. 2.0%1e 1.0%1resultará em 0
aross
4
'javascript (es6) é detalhado', você só vê isso em codegolf
dwana 29/09
@Neil Pensando bem provavelmente você está certo
edc65
3
1/(x+x)- agora é imaginativo!
Neil
13

05AB1E , 13 11 bytes

Usa a codificação CP-1252 .

ÐîQ18*14T/M

Explicação

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

Experimente online

Emigna
fonte
2
Você é meio lento. Ainda demorou 1,5 minutos. ; P (leia-se: Droga, isso foi rápido.) É bem claro, é claro.
Kevin Cruijssen 29/09/16
2
@KevinCruijssen: Sim, a implementação é bastante rápida em um idioma que não exige muitas teclas pressionadas: P
Emigna
@EriktheGolfer: Melhor? Se não estiver à vontade para editá-lo. Tenho experimentado algumas maneiras diferentes de formatação e ainda não decidi qual é a melhor. Sugestões são bem-vindas.
Emigna 29/09/16
@ Emigna Acabei de adicionar dois espaços cruciais ausentes.
Erik the Outgolfer
2
@FrancescoCasula: Eu encontrei uma solução mais curta que funciona em 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 retornando em Objectvez de String; e alguns bytes adicionais convertendo Java 7 para 8.
-4 bytes, aceitando a entrada em Objectvez de Stringtambém.

Explicação:

Experimente aqui.

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
fonte
É necessário colocar colchetes ao redor do operador if / else?
Roman Gräf
1
@ RomanGräf Sim; o ternário tem precedência inferior +, o que significa que se você removeu os parênteses, ele se transformaria em(""+i.contains(...)) ?
Nic Hartley
7

Pitão, 14 bytes

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

Experimente online.

PurkkaKoodari
fonte
7

PHP, 40 bytes

modificado por @ user59178 Obrigado

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

PHP, primeira versão de 42 bytes

<?=max(strpos($i=$argv[1],".")?1.4:18,$i);
Jörg Hülsermann
fonte
is_int($i=$argv[1]+0)é 2 bytes mais curto que strpos($i=$argv[1],".")e pode servir ao mesmo propósito se você trocar o 1.4e o18
user59178 29/16
@ user59178 eu poderia usar is_numericem uma corda, mas nãois_int
Jörg Hülsermann
é por isso que existe o +0, para convertê-lo em um tipo numérico.
user59178
1
Funciona corretamente para mim (tentei o php 5.5 e 7.0 no windows). Observe que ele tem condições opostas verdadeiras / falsas para a strpos($i=$argv[1],".")versão, lembrou-se de trocar as saídas do ternário?
user59178
1
Na verdade, em uma leitura mais atenta, ele precisa ser, em <?=max(is_int(0+$i=$argv[1])?18:1.4,$i);vez de <?=max(is_int($i=$argv[1]+0)?18:1.4,$i);evitar a saída 2, quando fornecido 2.0.
user59178
6

EXCEL: 26 31 29 bytes

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

A fórmula pode ir a qualquer lugar, exceto A1, a célula de entrada.

Corrigidos erros e substituídos pela sugestão de Emigna.

Agradeço a Alexandru por me salvar alguns bytes usando verdades


fonte
1
Além disso, não é melhor definir um nome npara a célula de entrada? Pode estar em qualquer lugar do documento e também é 2 bytes mais curto.
Emigna
@ Emigna eu pude , mas nesse momento fica um pouco trapaceiro. 1 byte por nome não é nada para esconder, e se eu mantiver esse formato, as pessoas poderão copiar e colar com facilidade.
Não vejo como isso é diferente do que usar uma variável de entrada de uma letra em um lambda em python, por exemplo. Mas é a sua chamada :)
Emigna
Oi! Como você calcula os bytes? Salve o arquivo com a fórmula com o nome padrão ou de alguma forma?
Vityata 30/09/16
1
Você pode remover o '= 0' e alternar os resultados: 1,4 primeiro, 18 segundo Além disso, como você tem coma como separador decimal, isso pode não funcionar para a maioria das pessoas.
Alexandru Pupsa
5

Braquilog , 14 bytes

#$:18ot|:1.4ot

Experimente online!

Explicação

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

Perl, 29 27 bytes

Inclui +2 para -lp

Dê entrada no STDIN

adult.pl <<< 1.24

adult.pl:

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

Se você não se importa com uma nova linha extra, se realmente era um adulto completo, deixar de fora a lopção por 26 bytes também funciona.

Ton Hospel
fonte
5

GNU sed, 40 + 1 = 41 bytes

(marcar +1 pelo uso da -rbandeira para o 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/

Aproveitamos as restrições de entrada, portanto, não precisamos testar o início da string quando virmos '1'. - sabemos que há apenas um dígito antes do ponto decimal.

Resultado do teste:

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

Haskell, 50 bytes

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

Exemplo de uso: f "1.0"-> "1.6".

O tipo estrito de Haskell requer o uso de strings como entrada e saída. Howevers, read, maxe showsão polimórficos e lidar com todos os tipos numéricos.

nimi
fonte
Eu pensei que seria inteligente e faria isso sem os guardas, mas isso acabou tornando-o um pouco mais longo :( Minha versão:(#)x=map(show.max x.fst).reads;f s=head$18#s++1.4#s
Cubic
@ Cubic: Bom uso de reads. Com uma pequena modificação, é um byte menor que o meu. Poste-o como uma resposta separada. x#y=show.max x.fst<$>reads y;f s=head$18#s++1.4#s.
nimi
Idéia muito legal salvar os parênteses com o 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 dois métodos com sobrecarga, que usam o operador condicional.

Chame como f(5)ou f(1.4f).

corvus_192
fonte
1
Oi. x<18?18:xe x<1.4f?1.4f:xsão mais curtos que o Math.max. Eu acho que você pode encontrar dicas de golfe em Java interessantes para ler. :)
Kevin Cruijssen
Sim, claro que são. Como poderia eu esqueci-los ...
corvus_192
Eu amo isto! Por que codificar a lógica quando você pode descarregar isso para o compilador!
corsiKa
4

CJam, 18 14 bytes

Economizou 4 bytes graças a Martin Ender.

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

Intérprete online

Neorej
fonte
4

C #, 69 bytes

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

Experimente online!

Programa completo com casos de teste:

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

Uma solução bastante direta. Observe que em alguns sistemas float.Parse () pode retornar resultados incorretos. Passe CultureInfo.InvariantCulture como o segundo argumento de acordo com esta resposta .

adrianmp
fonte
Dadas as restrições, acho que você pode se safar de substituir s.Contains(".")por #s[1]=='.'
JustinM - Reinstate Monica
Hummm, esqueci o caso de teste 0. tão perto também :(
JustinM - Reinstate Monica
1
@ Faeze: Sim, falharia em qualquer entrada de 1 dígito com uma IndexOutOfRangeException. Caso contrário, você pode raspar um byte fora com s[1]==46, ou uma abordagem ainda mais agressiva (presumindo que você só tem dígitos e um personagem no índice 1 '') (tem um código ASCII de 46 ''): s[1]<47.
adrianmp
1
Oo eu gosto disso, tentarei lembrar. Obrigado por transformar minha idiotice em um oppurtunity aprendendo :)
JustinM - Reintegrar Monica
4

IBM / Lotus Notes Formula Language, 58 49 bytes

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

Fórmula de campo computado em que a é um campo numérico editável.

EDITAR

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

Alternativa inspirada em @Mego

ElPedro
fonte
4

Gelatina , 16 15 13 bytes

ŒṘċ”.ị1.4,18»

TryItOnline
Ou veja todos os casos de teste, também em TryItOnline

Quão?

ŒṘċ”.ị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
fonte
2
Isso retorna 18para 2.0, infelizmente :(
Lynn
Ah, a complexidade do Jelly é superior.
Erik the Outgolfer
@ Lynn obrigado, fixado a um preço imenso; talvez exista uma maneira mais curta do que isso.
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 resposta é na verdade 2 funções com o mesmo nome, e o compilador trabalha para mim o que chamar; portanto, ele atua como uma função sem que eu precise receber uma entrada e decidir qual é. Como a entrada no ponto flutuante é garantida com a mesma precisão que a saída, eu posso devolvê-la com segurança sem precisar truncá-la.

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";
}
Cody
fonte
O usuário Szali Szali sugeriu salvar dois bytes, transformando floats em autos. Rejeitei a edição de acordo com a política, mas sinta-se à vontade para editá-la, se você confirmou que funciona.
Martin Ender
Toda essa duplicação de texto! Você pode salvar vários caracteres, gerando as duas definições via macro.
Obrigado @MartinEnder. A edição deles não é compilada em todos os compiladores C ++ e apresenta todos os tipos de casos estranhos, com outros tipos sendo repentinamente passados, então vou aceitar meus 2 bytes para manter minha resposta um pouco mais portátil.
Cody
@Cody É sua decisão, mas no que diz respeito ao PPCG, as linguagens são definidas por suas implementações, para que as respostas não precisem ser portáveis ​​ou particularmente seguras. Desde que exista um compilador no qual o programa funcione (e as entradas necessárias funcionem, independentemente de as inválidas funcionarem também), tudo bem.
Martin Ender
4

C #, 58 bytes

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

Não é necessária análise de string maluca para C #. A entrada deve ser um intou float(infelizmente, o C # não pode converter um doublepara floatse doubleestiver em um object). A saída será intou stringem um object.

(quase perdeu o requisito de pelo menos 1 decimal, acrescentou isso agora)

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
;

Implementação alternativa, que também tem 58 bytes.

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

Na verdade, 16 bytes

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

Experimente online!

Explicação:

;:.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
fonte
Eu nunca tinha programado na verdade antes, mas por que usar em vez de apenas 18? Eu sei que é a mesma contagem de bytes, por isso realmente não importa, mas 18parece mais legível. Ou existe um motivo para não funcionar na atual linguagem de implementação / programação?
Kevin Cruijssen
3
@KevinCruijssen 18empurra um 1e um 8. Para enviar um literal 18, você usaria :18, que é maior que .
Mego
Ah, é claro, linguagens baseadas em pilha. Obrigada pelo esclarecimento! +1
Kevin Cruijssen
4

Emacs Lisp, 37 bytes

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

Supõe, a partir do "tipo de dados", se a versão inteira ou flutuante deve ser usada. ( floatpretorna tpara 1.0, mas não para 1.) O parâmetro é um número como número inteiro ou flutuante, ou seja, deve satisfazer numberp.

Lord Yuuma
fonte
4

Haskell, 49 bytes

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

Basicamente, isso primeiro tenta ler a entrada como um número inteiro e, em seguida, como um duplo, se isso falhar. Em seguida, prossiga para compará-lo à respectiva linha de base de comparação.

Cúbico
fonte
3

Dyalog APL , 14 bytes inválido por outras especificações

⎕IO←0que é padrão em muitos sistemas. Aceita string como argumento.

⍎⌈18 1.4⊃⍨'.'∘∊

⍎⌈ max do argumento avaliado e

18 1.4⊃⍨ {18,1.4} selecionado por

'.'∘∊ se o argumento contém um período

Adão
fonte
3

C #, 95 bytes

Golfe:

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

Casos de teste:

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

Resultado:

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
fonte
1
Olá, seja bem-vindo ao PPCG! Sua abordagem atual pode ser encurtado um pouco como este: string y(string p){int a;return int.TryParse(p,out a)?a<1?"18":p:double.Parse(p)<1.4?"1.4":p;}(parêntese removido; >=1.4a <1.4, trocando o "1.4"e p; mudou decimalde doublemodo que o Mé gone Além disso, alguém acabou de enviar. Uma abordagem diferente em C # que é ligeiramente mais curto Você pode achar. Dicas para o golfe em C # interessante para ler através de uma vez, bem-vindo :).!
Kevin Cruijssen
Olá, obrigado pelos comentários úteis! Eu esqueci completamente os colchetes extras que eu tinha para me impedir de perder a noção do operador Ternary-Ternary! Eu salvei 5 bytes agora no geral.
Pete Arden
Você pode salvar um byte usando em float.Parsevez de double.Parse. E também, se você mover a declaração de a para os argumentos do método com um valor padrão, poderá descartar sua declaração de retorno usando o membro incorporado da expressão. por exemplo: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 - Restabelece Monica
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

Os testes foram realizados gawkno RHEL 6. Tentei com todos os casos de teste, infelizmente não tenho AWKna máquina que possui acesso à Internet, portanto, copiar e colar não é possível.

Existe uma maneira mais compacta de fazer isso AWK?

Robert Benson
fonte
3

C, 50 bytes:

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

A contagem de bytes inclui a nova linha no final da definição da macro.

Teste :

#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
fonte
3

C #, 71 bytes

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

tente aqui

agarrar o peixe
fonte
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");}

Testado com

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

Resultado

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
fonte
Isso é inválido ... Uma entrada de 12 deve gerar 18
Decay Beta
@BetaDecay você está certo. Preciso adicionar um caractere & adicional. Obrigado por apontar isso.
Cleblanc 3/10
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%

Primeiro determina se a entrada é um número inteiro, verificando se a exclusão de todos os .s tem algum efeito na sequência. Se for, o valor será facilmente comparado com 18, caso contrário, o primeiro e o terceiro caracteres serão combinados em um número que será comparado com 14.

Neil
fonte
2

PHP: 40 bytes

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

psuedocode (turnary aninhado):

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
fonte
1
Bem-vindo ao PPCG! Observe que a entrada (por padrão) deve ser via STDIN, argumentos de função ou argumentos completos do programa.
aross 30/09/16