Existe um comando unix que fornece o mínimo / máximo de dois números?

Eu estava procurando por um comando para limitar os números de leitura stdin.

Escrevi um pequeno script para esse fim (a crítica é bem-vinda), mas fiquei imaginando se não havia um comando padrão para esse caso de uso simples e (acho) comum.

Meu script que encontra o mínimo de dois números:

#!/bin/bash
# $1 limit

[ -z "$1" ] && { echo "Needs a limit as first argument." >&2; exit 1; }

read number

if [ "$number" -gt "$1" ]; then
        echo "$1"
else
        echo "$number"
fi

Você pode comparar apenas dois números com os seguintes dc:

dc -e "[$1]sM $2d $1<Mp"

... onde "$1"está seu valor máximo e "$2"é o número que você imprimiria se for menor que "$1". Isso também requer o GNU dc- mas você pode fazer o mesmo de maneira portável:

dc <<MAX
    [$1]sM $2d $1<Mp
MAX

Em ambos os casos acima, você pode definir a precisão para algo diferente de 0 (o padrão) como ${desired_precision}k. Para ambos, também é imperativo que você verifique se os dois valores são definitivamente números, pois dcpodem fazer system()chamadas com o !operador.

Com o pequeno script a seguir (e o próximo), você deve verificar a entrada também - grep -v \!|dcou algo assim - para lidar com entrada arbitrária de maneira robusta. Você também deve saber que dcinterpreta números negativos com um _prefixo em vez de um -prefixo - porque o último é o operador de subtração.

Além disso, com esse script, dcvocê lerá o número sequencial de \nnúmeros de linha de ew que você gostaria de fornecê-lo e imprimirá para cada um o seu $maxvalor ou a entrada, dependendo de qual é o menor dos dois:

dc -e "${max}sm
       [ z 0=? d lm<M p s0 lTx ]ST
       [ ? z 0!=T q ]S?
       [ s0 lm ]SM lTx"

Então ... cada um desses [colchetes quadrados ]extensões é uma dc seqüência de objeto que é SAVED cada um para seu respectivo array - qualquer um dos T, ?ou M. Além de algumas outras coisas que dcpodem fazer com uma string , ela também pode ser xreproduzida como uma macro. Se você acertar, um pequeno dcscript totalmente funcional será montado com bastante simplicidade.

dctrabalha em uma pilha . Todos os objetos de entrada são empilhados, cada um sobre o último - cada novo objeto de entrada pressionando o último objeto superior e todos os objetos abaixo dele na pilha por um à medida que são adicionados. A maioria das referências a um objeto são para o valor superior da pilha, ea maioria das referências pop que topo da pilha (que puxa todos os objetos abaixo-lo por um) .

Além da pilha principal, também existem (pelo menos) 256 matrizes e cada elemento da matriz vem com uma pilha própria. Eu não uso muito disso aqui. Eu apenas guardo as strings conforme mencionado para poder lcarregá-las quando desejado e xcalculá-las condicionalmente, e srasguei $maxo valor na parte superior da mmatriz.

Enfim, esse pouco dcfaz, em grande parte, o que o seu shell-script faz. Ele usa a -eopção GNU-ism - como dcgeralmente tira seus parâmetros do padrão - mas você pode fazer o mesmo como:

echo "$script" | cat - /dev/tty | dc

... se $scriptparecia com a parte acima.

Funciona como:

• lTx- Isso lapaga e faz xeco da macro armazenada no topo T (para teste, eu acho - eu geralmente escolho esses nomes arbitrariamente) .
• z 0=?- Test testa a profundidade da pilha w / ze, se a pilha estiver vazia (leia-se: contém 0 objetos) , chama a ?macro.
• ? z0!=T q- A ?macro é nomeada para o ? dccomando embutido que lê uma linha de entrada do stdin, mas também adicionei outro zteste de profundidade da pilha, para que ele possa qutilizar todo o pequeno programa se puxar uma linha em branco ou atingir o EOF. Mas se não !preencher e preencher com êxito a pilha, ela chamará Test novamente.
• d lm<M- Test então dduplicará a parte superior da pilha e comparará com $max (conforme armazenado em m) . Se mfor o menor valor, dcchama a Mmacro.
• s0 lm- Mapenas abre a parte superior da pilha e a despeja no escalar fictício 0- apenas uma maneira barata de estourar a pilha. Também se lrecupera mantes de retornar ao Test.
• p- Isso significa que, se mfor menor que o topo da pilha atual, a msubstitui (a dcópia da mesma, de qualquer maneira) e fica aqui pdefinida, caso contrário, não existe e o que quer que a entrada tenha sido pdefinida.
• s0- Depois (porque pnão abre a pilha) , despejamos o topo da pilha 0novamente e depois ...
• lTx- recursivamente load Test mais uma vez, em seguida, e xecute-lo novamente.

Assim, você pode executar esse pequeno trecho e digitar números de forma interativa no seu terminal e dcimprimir de volta o número digitado ou o valor $maxse o número digitado for maior. Também aceitaria qualquer arquivo (como um pipe) como entrada padrão. Ele continuará o loop de leitura / comparação / impressão até encontrar uma linha em branco ou EOF.

Algumas observações sobre isso - eu escrevi isso apenas para emular o comportamento da função shell, portanto, ele apenas lida com um número por linha. dcNo entanto, você pode lidar com tantos números separados por espaço por linha quanto gostaria de jogar nela. No entanto , devido à sua pilha, o último número de uma linha acaba sendo o primeiro em que opera, e, como está escrito, dcimprimiria sua saída ao contrário se você imprimisse / digitasse mais de um número por linha nela. lidar com isso é armazenar uma linha em uma matriz e depois trabalhá-la.

Como isso:

dc -e "${max}sm
    [ d lm<M la 1+ d sa :a z0!=A ]SA
    [ la d ;ap s0 1- d sa 0!=P ]SP 
    [ ? z 0=q lAx lPx l?x ]S?
    [q]Sq [ s0 lm ]SM 0sa l?x"

Mas ... não sei se quero explicar isso com tanta profundidade. Basta dizer que, ao dcler cada valor da pilha, ele armazena seu valor ou $maxseu valor em uma matriz indexada e, uma vez que detecta a pilha novamente vazia, ele imprime cada objeto indexado antes de tentar ler outro linha de entrada.

E assim, enquanto o primeiro script faz ...

10 15 20 25 30    ##my input line
20
20
20
15
10                ##see what I mean?

O segundo faz:

10 15 20 25 30    ##my input line
10                ##that's better
15
20
20                ##$max is 20 for both examples
20

Você pode manipular carros alegóricos de precisão arbitrária se primeiro configurá-lo com o kcomando E você pode alterar os radios nput iou output independentemente - o que às vezes pode ser útil por razões que você não pode esperar. Por exemplo:

echo 100000o 10p|dc
 00010

... que define o primeiro dcraio de saída para 100000 e depois imprime 10.

Se você sabe que está lidando com dois números inteiros ae b, essas expansões aritméticas simples do shell usando o operador ternário são suficientes para fornecer o máximo numérico:

$(( a > b ? a : b ))

e min numérico:

$(( a < b ? a : b ))

Por exemplo

$ a=10
$ b=20
$ max=$(( a > b ? a : b ))
$ min=$(( a < b ? a : b ))
$ echo $max
20
$ echo $min
10
$ a=30
$ max=$(( a > b ? a : b ))
$ min=$(( a < b ? a : b ))
$ echo $max
30
$ echo $min
20
$ 

Aqui está um script de shell demonstrando isso:

#!/usr/bin/env bash
[ -z "$1" ] && { echo "Needs a limit as first argument." >&2; exit 1; }
read number
echo Min: $(( $number  < $1 ? $number : $1 ))
echo Max: $(( $number  > $1 ? $number : $1 ))

sorte headpode fazer isso:

numbers=(1 4 3 5 7 1 10 21 8)
printf "%d\n" "${numbers[@]}" | sort -rn | head -1       # => 21

Você pode definir uma biblioteca de funções matemáticas predefinidas bce usá-las na linha de comando.

Por exemplo, inclua o seguinte em um arquivo de texto como ~/MyExtensions.bc:

define max(a,b){
  if(a>b)
  { 
   return(a)
  }else{
   return(b)
  }
}

Agora você pode ligar bcpor:

> echo 'max(60,54)' | bc ~/MyExtensions.bc
60

Para sua informação, existem funções gratuitas da biblioteca matemática , disponíveis on-line.

Usando esse arquivo, você pode calcular facilmente funções mais complicadas, como GCD:

> echo 'gcd (60,54)' | bc ~/extensions.bc -l
6

Tempo demais para um comentário:

Embora você possa fazer essas coisas, por exemplo, com os combos sort | headou sort | tail, parece um pouco abaixo do ideal em termos de manipulação de recursos e erros. No que diz respeito à execução, o combo significa gerar 2 processos apenas para verificar duas linhas. Isso parece ser um exagero.

O problema mais sério é que, na maioria dos casos, você precisa saber que a entrada é sensata, ou seja, contém apenas números. A solução da @ glennjackmann resolve isso de maneira inteligente, pois printf %ddeve vomitar não-inteiros. Também não funcionará com flutuadores (a menos que você altere o especificador de formato para %f, onde você terá problemas de arredondamento).

test $1 -gt $2 indicará se a comparação falhou ou não (o status de saída 2 significa que houve um erro durante o teste. Como esse geralmente é um shell embutido, não há processo adicional) - estamos falando da ordem de centenas execução vezes mais rápida, embora só funcione com números inteiros.

Se você precisar comparar alguns números de ponto flutuante, uma opção interessante pode ser bc:

define x(a, b) {
    if (a > b) {
       return (a);
    }
    return (b);
 }

seria o equivalente a test $1 -gt $2, e usando no shell:

max () { printf '
    define x(a, b) {
        if (a > b) {
           return (a);
        }
        return (b);
     }
     x(%s, %s)
    ' $1 $2 | bc -l
}

ainda é quase 2,5 vezes mais rápido que printf | sort | head(para dois números).

Se você pode confiar nas extensões GNU bc, também pode usar a read()função para ler os números diretamente na bcassinatura.

Para obter o maior valor de $ a e $ b, use o seguinte:

[ "$a" -gt "$b" ] && $a || $b

Mas você precisa de algo em torno disso, provavelmente não pretende executar o número; portanto, para exibir o maior valor dos dois, use "eco"

[ "$a" -gt "$b" ] && echo $a || echo $b

O item acima se encaixa perfeitamente em uma função shell, por exemplo

max() {
   [ "$1" -gt "$2" ] && echo $1 || echo $2
}

Para atribuir o maior dos dois à variável, use esta versão modificada:

[ "$a" -gt "$b" ] && biggest=$a || biggest=$b

ou use a função definida:

biggest=$( max $a $b )

A variação da função também oferece a oportunidade de adicionar uma verificação de erro de entrada ordenadamente.

Para retornar o máximo de dois números decimais / ponto flutuante, você pode usar awk

decimalmax() { 
   echo $1 $2 | awk '{if ($1 > $2) {print $1} else {print $2}}'; 
}

EDIT: Usando esta técnica, você pode criar uma função de "limite" que opera de maneira inversa, conforme sua edição / nota. Esta função retornará o menor dos dois, por exemplo:

limit() {
   [ "$1" -gt "$2" ] && echo $2 || echo $1
}

Eu gosto de colocar funções utilitárias em um arquivo separado, chamá-lo myprogram.funcse usá-lo em um script da seguinte maneira:

#!/bin/bash

# Initialization. Read in the utility functions
. ./myprogram.funcs

# Do stuff here
#
[ -z "$1" ] && { echo "Needs a limit as first argument." >&2; exit 1; }

read number
echo $( limit $1 $number )

FWIW, isso ainda faz o que você fez, e sua versão, embora seja mais detalhada, é igualmente eficiente.

A forma mais compacta não é realmente melhor, mas evita a confusão de seus scripts. Se você tem muitas construções simples de se-então-outro-fi, o script se expande rapidamente.

Se você deseja reutilizar a verificação de números maiores / menores várias vezes em um único script, coloque-a em uma função. O formato da função facilita a depuração e a reutilização e permite substituir facilmente essa parte do script, por exemplo, por um comando awk para poder manipular números decimais não inteiros.

Se for um caso de uso único, basta codificá-lo em linha.

Você pode definir uma função como

maxnum(){
    if [ $2 -gt $1 ]
    then
        echo $2
    else
        echo $1
    fi
}

Chame como maxnum 54 42e ecoa 54. Você pode adicionar informações de validação dentro da função (como dois argumentos ou números como argumentos), se desejar.

Em um script de shell, existe uma maneira de usar qualquer método estático público Java (e, por exemplo, Math.min () ). Do bash no Linux:

. jsbInit
jsbStart 
A=2 
B=3 
C=$(jsb Math.min "$A" "$B")
echo "$C"

Isso requer o Java Shell Bridge https://sourceforge.net/projects/jsbridge/

Muito rápido, porque as chamadas de método são canalizadas internamente ; nenhum processo é necessário.

A maioria das pessoas simplesmente faz sort -n input | head -n1(ou segue), é bom o suficiente para a maioria das situações de script. No entanto, isso é um pouco desajeitado se você tiver números em uma linha em vez de em uma coluna - precisará imprimi-lo em um formato adequado ( tr ' ' '\n'ou algo semelhante).

Os shells não são exatamente ideais para processamento numérico, mas você pode facilmente inserir outros programas que são melhores nele. Dependendo da sua preferência, você liga no máximo dc(um pouco ofuscado, mas se você sabe o que está fazendo, tudo bem - veja a resposta do mikeserv), ou awk 'NR==1{max=$1} {if($1>max){max=$1}} END { print max }'. Ou possivelmente perlou pythonse você preferir. Uma solução (se você estiver disposto a instalar e usar software menos conhecido) seria ised(especialmente se seus dados estiverem em uma única linha: você só precisa fazê-lo ised --l input.dat 'max$1').

Como você está pedindo dois números, tudo isso é um exagero. Isso deve ser suficiente:

python -c "print(max($j,$k))"