Como escrever um script de shell para atribuir notas de letras a intervalos numéricos?

Question

Eu quero criar um script que solicite um número entre 0 e 100 e, em seguida, forneça a nota com base no número.

Eu gostaria disso no bash.

PS3='Please enter your choice: '
(Something here)

do
case $
    "0-59")
        echo "F"
        ;;
    "60-69")
        echo "D"
        ;;
    "70-79")
        echo "C"
        ;;
    "Quit")
        break
        ;;
    *) echo invalid option;;
esac
done

    

Answer 1

Brevidade x legibilidade: um meio-termo

Como você viu, este problema admite soluções que são moderadamente longas e um pouco repetitivas, mas altamente legíveis ( terdon's e respostas AB bash), bem como aquelas que são muito curtas mas não intuitivas e muito menos autodocumentação ( python do Tim e respostas bash e glenn jackman perl resposta ). Todas essas abordagens são valiosas.

Você também pode resolver esse problema com código no meio do continuum entre compacidade e legibilidade. Essa abordagem é quase tão legível quanto as soluções mais longas, com um comprimento mais próximo das pequenas soluções esotéricas.

#!/usr/bin/env bash

read -erp 'Enter numeric grade (q to quit): '
case $REPLY in [qQ]) exit;; esac

declare -A cutoffs
cutoffs[F]=59 cutoffs[D]=69 cutoffs[C]=79 cutoffs[B]=89 cutoffs[A]=100

for letter in F D C B A; do
    ((REPLY <= cutoffs[$letter])) && { echo $letter; exit; }
done
echo "Grade out of range."

Nesta solução bash, incluí algumas linhas em branco para melhorar a legibilidade, mas você pode removê-las se quiser ainda menos.

Linhas em branco incluídas, isto é, na verdade, apenas ligeiramente menor do que uma variante compactada, ainda bastante legível de A solução do bas da AB . Suas principais vantagens sobre esse método são:

• É mais intuitivo.
• É mais fácil alterar os limites entre as notas (ou adicionar notas adicionais).
• Aceita automaticamente entradas com espaços iniciais e finais (veja abaixo uma explicação de como (( )) funciona).

Todas essas três vantagens surgem porque esse método usa a entrada do usuário como dados numéricos em vez de examinar manualmente seus dígitos constituintes.

Como funciona

1. Entrada de leitura do usuário. Deixe-os usar as teclas de seta para se mover no texto eles entraram ( -e ) e não interpretam \ como um caractere de escape ( -r ).
   _{Este script não é uma solução rica em recursos - veja abaixo um refinamento -mas esses recursos úteis só fazem dois caracteres a mais. Eu recomendo sempre usar -r com read , a menos que você saiba que precisa deixar o usuário fornecer \ escapes.}
2. Se o usuário escreveu q ou Q , saia.
3. Crie uma associação array ( declare -A ). Preenchê-lo com o maior grau numérico associado a cada grau de letra.
4. Efetue o loop das classificações das letras do menor para o maior, verificando se o número fornecido pelo usuário é baixo o suficiente para se encaixar no intervalo numérico de cada letra.
   _{Com a avaliação aritmética de (( )) , os nomes das variáveis não precisam ser expandidos com $ . (Na maioria das outras situações, se você quiser usar o valor de uma variável no lugar de seu nome, você deve fazer isso .}
5. Se ele estiver no intervalo, imprima a nota e saia .
   _{Por brevidade, eu uso o curto-circuito e operador ( && ) em vez de um if - then .}
6. Se o loop terminar e nenhum intervalo tiver sido correspondido, suponha que o número digitado seja muito alto (acima de 100) e diga ao usuário que ele estava fora do intervalo.

Como isso se comporta, com entradas estranhas

Como as outras soluções short postadas, esse script não verifica a entrada antes de assumir que é um número. A avaliação aritmética ( (( )) ) automaticamente remove espaços em branco iniciais e finais, então isso não é problema, mas:

• A entrada que não se parece com um número é interpretada como 0.
• Com a entrada que parece um número (ou seja, se começar com um dígito), mas contém caracteres inválidos, o script emite erros.
• Entrada de vários dígitos começando com 0 é interpretada como em octal . Por exemplo, o script dirá a você que 77 é um C, enquanto 077 é um D. Embora alguns usuários possam querer isso, provavelmente não o fazem e isso pode causar confusão.
• No lado positivo, quando recebe uma expressão aritmética, esse script automaticamente simplifica e determina o grau de letra associado. Por exemplo, ele dirá que 320/4 é um B.

Uma versão expandida e totalmente apresentada

Por esses motivos, talvez você queira usar algo como esse script expandido, que verifica se a entrada é boa e inclui alguns outros aprimoramentos.

#!/usr/bin/env bash
shopt -s extglob

declare -A cutoffs
cutoffs[F]=59 cutoffs[D]=69 cutoffs[C]=79 cutoffs[B]=89 cutoffs[A]=100

while read -erp 'Enter numeric grade (q to quit): '; do
    case $REPLY in  # allow leading/trailing spaces, but not octal (e.g. "03") 
        *( )@([1-9]*([0-9])|+(0))*( )) ;;
        *( )[qQ]?([uU][iI][tT])*( )) exit;;
        *) echo "I don't understand that number."; continue;;
    esac

    for letter in F D C B A; do
        ((REPLY <= cutoffs[$letter])) && { echo $letter; continue 2; }
    done
    echo "Grade out of range."
done

Esta ainda é uma solução bastante compacta.

Quais recursos isso adiciona?

Os principais pontos deste script expandido são:

• Validação de entrada. roteiro de terdon verifica entrada com if [[ ! $response =~ ^[0-9]*$ ]] ... , então eu mostrar uma outra maneira, que sacrifica um pouco brevidade, mas é mais robusto, permitindo que o usuário para inserir espaços iniciais e finais e se recusar a permitir uma expressão que possa ou não ser destinada como octal (a menos que seja zero).
• Eu usei case com expandido globbing em vez de [[ com a expressão regular =~ correspondência regular operador (como em resposta de terdon ). Eu fiz isso para mostrar que (e como) também pode ser feito dessa maneira. Os globs e regexps são duas maneiras de especificar padrões que correspondem ao texto, e o método é adequado para esse aplicativo.
• da AB script bash , tenho fechado a coisa toda em um loop exterior (exceto a criação inicial da matriz cutoffs ). Ele solicita números e fornece notas de letras correspondentes, desde que a entrada do terminal esteja disponível e o usuário não tenha solicitado a saída. A julgar pelo do ... done em torno do código na sua pergunta, parece que você quer isso.
• Para facilitar o encerramento, eu aceito qualquer variante de q ou quit que não diferencia maiúsculas de minúsculas.

Este script usa algumas construções que podem não ser familiares aos novatos; eles estão detalhados abaixo.

Explicação: Uso de continue

Quando eu quiser pular o resto do corpo do loop while externo, eu uso o comando continue . Isso traz de volta à parte superior do loop, para ler mais entradas e executar outra iteração.

Na primeira vez que faço isso, o único loop em que estou é o loop while externo, portanto, posso chamar continue sem argumento. (Estou em uma construção case , mas isso não afeta a operação de break ou continue .)

        *) echo "I don't understand that number."; continue;;

Na segunda vez, no entanto, estou em um loop for interno que está aninhado dentro do loop while externo. Se eu usasse continue sem argumento, isso seria equivalente a continue 1 e continuaria o loop for interno em vez do loop while externo.

        ((REPLY <= cutoffs[$letter])) && { echo $letter; continue 2; }

Então, nesse caso, eu uso continue 2 para fazer o bash encontrar e continuar o segundo loop em vez disso.

Explicação: case rótulos com Globs

Eu não uso case para descobrir qual o tamanho da letra bin em que um número entra (como em < um href="https://askubuntu.com/a/621471/22949"> resposta de bash do AB ). Mas eu uso case para decidir se a entrada do usuário deve ser considerada:

• um número válido, *( )@([1-9]*([0-9])|+(0))*( )
• o comando quit, *( )[qQ]?([uU][iI][tT])*( )
• qualquer outra coisa (e, portanto, entrada inválida), *

Estes são shell globs .

• Cada um é seguido por um ) que não corresponde a nenhuma abertura ( , que é a sintaxe de case para separar um padrão dos comandos executados quando é correspondido.
• A sintaxe ;; é case para indicar o final dos comandos a serem executados para uma correspondência de maiúsculas e minúsculas (e que nenhum caso subseqüente deve ser testado após executá-los).

A globalização shell ordinária fornece * para corresponder a zero ou mais caracteres, ? para corresponder exatamente a um caractere e classes / intervalos de caracteres em [ ] colchetes. Mas eu estou usando globalização estendida , que vai além disso. A globalização estendida é ativada por padrão ao usar bash interativamente, mas é desativada por padrão ao executar um script. O comando shopt -s extglob na parte superior do script o ativa.

Explicação: Globbing ampliado

*( )@([1-9]*([0-9])|+(0))*( ) , que verifica a entrada numérica , corresponde a uma sequência de:

• Zero ou mais espaços ( *( ) ). A construção *( ) corresponde a zero ou mais do padrão entre parênteses, que aqui é apenas um espaço.
  _{Na verdade, existem dois tipos de espaço em branco horizontal, espaços e tabulações, e geralmente é desejável coincidir com guias também. Mas não estou me preocupando com isso aqui, porque esse script é escrito para entrada interativa manual e o -e flag para read ativa a linha de leitura GNU. Isso é para que o usuário possa ir e voltar em seu texto com as teclas de seta para a esquerda e para a direita, mas tem o efeito colateral de geralmente impedir que as guias sejam inseridas literalmente.}
• Uma ocorrência ( @( ) ) de ( | ):
  • Um dígito diferente de zero ( [1-9] ) seguido por zero ou mais ( *( ) ) de qualquer dígito ( [0-9] ).
  • Um ou mais ( +( ) ) de 0 .
• Zero ou mais espaços ( *( ) ), novamente.

*( )[qQ]?([uU][iI][tT])*( ) , que verifica o comando quit , corresponde a uma sequência de:

• Zero ou mais espaços ( *( ) ).
• q ou Q ( [qQ] ).
• Opcionalmente - ou seja, zero ou uma ocorrência ( ?( ) ) - de:
  • u ou U ( [uU] ) seguido por i ou I ( [iI] ) seguido por t ou T ( [tT] ).
• Zero ou mais espaços ( *( ) ), novamente.

Variante: Validando entrada com uma expressão regular estendida

Se você preferir testar a entrada do usuário em relação a uma expressão regular em vez de um shell glob, talvez prefira usar essa versão, que funciona da mesma forma, mas usa [[ e =~ (como em terdon's answer ) em vez de case e extensão de globbing.

#!/usr/bin/env bash
shopt -s nocasematch

declare -A cutoffs
cutoffs[F]=59 cutoffs[D]=69 cutoffs[C]=79 cutoffs[B]=89 cutoffs[A]=100

while read -erp 'Enter numeric grade (q to quit): '; do
    # allow leading/trailing spaces, but not octal (e.g., "03")
    if [[ ! $REPLY =~ ^\ *([1-9][0-9]*|0+)\ *$ ]]; then
        [[ $REPLY =~ ^\ *q(uit)?\ *$ ]] && exit
        echo "I don't understand that number."; continue
    fi

    for letter in F D C B A; do
        ((REPLY <= cutoffs[$letter])) && { echo $letter; continue 2; }
    done
    echo "Grade out of range."
done

Possíveis vantagens dessa abordagem são:

• Neste caso particular, a sintaxe é um pouco mais simples, pelo menos no segundo padrão, onde eu verifico o comando quit. Isso ocorre porque eu consegui definir a opção nocasematch shell e, em seguida, todas as variantes de caso de q e quit foram cobertas automaticamente.

  Isso é o que o comando shopt -s nocasematch faz. O comando shopt -s extglob é omitido, já que globbing não é usado nesta versão.

• Habilidades de expressões regulares são mais comuns do que proficiência em extlags de bash.

Explicação: expressões regulares

Quanto aos padrões especificados à direita do operador =~ , veja como essas expressões regulares funcionam.

^\ *([1-9][0-9]*|0+)\ *$ , que verifica a entrada numérica , corresponde a uma sequência de:

• O começo - isto é, a margem esquerda - da linha ( ^ ).
• Zero ou mais ( * , postfix aplicado) espaços. Um espaço normalmente não precisa ser \ -escaped em uma expressão regular, mas isso é necessário com [[ para evitar um erro de sintaxe.
• Uma substring ( ( ) ) que é um ou o outro ( | ) de:
  • [1-9][0-9]* : um dígito diferente de zero ( [1-9] ) seguido por zero ou mais ( * , postfix aplicado) de qualquer dígito ( [0-9] ).
  • 0+ : um ou mais ( + , postfix aplicado) de 0 .
• Zero ou mais espaços ( \ * ), como antes.
• O final - ou seja, a borda direita - da linha ( $ ).

Ao contrário de case labels, que correspondem à expressão inteira sendo testada, =~ retorna true se qualquer parte de sua expressão à esquerda corresponder ao padrão fornecido como sua expressão à direita. É por isso que as âncoras ^ e $ , especificando o início e o fim da linha, são necessárias aqui e não correspondem sintaticamente a nada que apareça no método com case e extglobs.

Os parênteses são necessários para que ^ e $ se vinculem à disjunção de [1-9][0-9]* e 0+ . Caso contrário, seria a disjunção de ^[1-9][0-9]* e 0+$ e corresponderia qualquer entrada começando com um dígito diferente de zero ou terminando com 0 (ou ambos, que ainda poderiam incluir não dígitos em entre).

^\ *q(uit)?\ *$ , que verifica o comando quit , corresponde a uma sequência de:

• O começo da linha ( ^ ).
• Zero ou mais espaços ( \ * , veja a explicação acima).
• A letra q . Ou Q , pois shopt nocasematch está ativado.
• Opcionalmente - ou seja, zero ou uma ocorrência (postfix ? ) - da subseqüência ( ( ) ):
  • u , seguido por i , seguido por t . Ou, como shopt nocasematch está ativado, u pode ser U ; independentemente, i pode ser I ; e de forma independente, t pode ser T . (Isto é, as possibilidades são não limitadas a uit e UIT .)
• Zero ou mais espaços novamente ( \ * ).
• O final da linha ( $ ).

Answer 2

Você já tem a ideia básica. Se você quiser codificar isto em bash (que é uma escolha razoável, já que é o shell padrão no Ubuntu e na maioria dos outros Linuxes), você não pode usar case porque ele não entende os intervalos. Em vez disso, você pode usar if / else :

#!/usr/bin/env bash

read -p "Please enter your choice: " response

## If the response given did not consist entirely of digits
if [[ ! $response =~ ^[0-9]*$ ]]
then
    ## If it was Quit or quit, exit
    [[ $response =~ [Qq]uit ]] && exit
    ## If it wasn't quit or Quit but wasn't a number either,
    ## print an error message and quit.
    echo "Please enter a number between 0 and 100 or \"quit\" to exit" && exit
fi
## Process the other choices
if [ $response -le 59 ]
then
    echo "F"
elif [ $response -le 69 ]
then
    echo "D"
elif  [ $response -le 79 ]
then
    echo "C"
elif  [ $response -le 89 ]
then
    echo "B"
elif [ $response -le 100 ]
then
    echo "A"
elif [ $response -gt 100 ]
then
    echo "Please enter a number between 0 and 100"
     exit
fi

    

Answer 3

#!/bin/bash

while true
do
  read -p "Please enter your choice: " choice

  case "$choice"
   in
      [0-9]|[1-5][0-9])
          echo "F"
          ;;
      6[0-9])
          echo "D"
          ;;
      7[0-9])
          echo "C"
          ;;
      8[0-9])
          echo "B"
          ;;
      9[0-9]|100)
          echo "A"
          ;;
      [Qq])
          exit 0
          ;;
      *) echo "Only numbers between 0..100, q for quit"
          ;;
  esac
done

e uma versão mais compacta (Thx @EliahKagan ):

#!/usr/bin/env bash

while read -erp 'Enter numeric grade (q to quit): '; do
    case $REPLY in
        [0-9]|[1-5][0-9])   echo F ;;
        6[0-9])             echo D ;;
        7[0-9])             echo C ;;
        8[0-9])             echo B ;;
        9[0-9]|100)         echo A ;;

        [Qq])               exit ;;
        *)                  echo 'Only numbers between 0..100, q for quit' ;;
    esac
done

    

Answer 4

Todas as instalações do Ubuntu têm Python, então aqui está um script python de um liner. Se você precisa estar no bash, eu também escrevi o equivalente como um script de shell .

print (chr(75-max(5,int('0'+raw_input('Enter the number: ')[:-1]))))

Para executar, salve-o em um arquivo (por exemplo, grade.py ) e, em seguida, execute-o no terminal com este:

python grade.py

Isso é o que você verá:

Enter the number: 65
E

Como isso funciona?

1. Receber entrada - 65 .
2. Adicione um 0 ao início - 065 .
3. Remova o último caractere - 06 .
4. 75 subtraia esse número - 70 .
5. Converta para uma letra (A é 65, B é 66) - E .
6. Imprima - E .

Answer 5

Após fazê-lo no Python 2 , decidi fazê-lo no bash.

#! /bin/bash

read -p "Enter the number: " i
i=0$i
x=$((10#${i::-1}))
printf "\x$(printf %x $((11-($x>5?$x:5)+64)))\n"

Para executar, salve-o em um arquivo (por exemplo, grade.sh), torne-o executável com chmod +x grade.sh e, em seguida, execute com ./grade.sh .

Isso é o que você verá:

Enter the number: 65
E

Como isso funciona?

1. Receber entrada - 65 .
2. Adicione um 0 ao início - 065 (e o 10# mantém a base 10).
3. Remova o último caractere - 06 .
4. 75 subtraia esse número - 70 .
5. Converta para uma letra (A é 65, B é 66) - E .
6. Imprima - E .

Answer 6

Aqui está minha solução bash semi -esotérica, que preenche uma matriz com 101 entradas e, em seguida, verifica a entrada do usuário contra elas. Mesmo para o uso no mundo real, isso é razoável - se você precisasse de um excelente desempenho, você não usaria o bash, e uma centena (ou mais) de tarefas ainda é rápida. Mas deixaria de ser razoável, se estendido a um alcance muito maior (como um milhão).

#!/usr/bin/env bash
p(){ for i in 'seq  '; do g[$i]=; done; }
p A 90 100; p B 80 89; p C 70 79; p D 60 69; p F 0 59
while read -r n && [[ ! $n =~ ^[qQ] ]]; do echo ${g[$n]}; done

Vantagens:

• Não é tão esotérico. Embora seja mais longo que as soluções mais curtas, e não tão auto-documentado quanto as soluções mais longas ... é razoavelmente auto-documentável , enquanto ainda decididamente no lado minúsculo.
• Permite uma modificação fácil para alterar os intervalos de notas ou adicionar / remover notas.
• Ele opera em um loop e sai em q , quit ou qualquer coisa que comece com q / Q .
• Relaciona as notas mais altas primeiro, para ajudá-lo a pensar positivo. :)
• Hmm, isso faz o trabalho, continua fazendo sentido mesmo depois de você olhar para ele, e tem os recursos essenciais. Você pode realmente usar isso!

Desvantagens:

• Ele te dá um F quando você insere uma entrada não numérica ... mas isso não é tão ruim assim, é? Se você der um non-number onde um número é necessário, talvez você mereça um F!
• A entrada octal, possivelmente octal, é tratada como octal (pois g é um array indexado unidimensional ). Como diz o velho ditado: "Não é um bug, é uma característica!" Bem, talvez.
• Entrada fora do intervalo ou não um número faz com que uma linha vazia seja impressa. Não há nada realmente errado com isso: ele diz a você qual letra corresponde à sua entrada e, para uma entrada errada, não existe uma.
• Coloque um número negativo e ... bem, chame-o de ovo de páscoa .
• Ainda significativamente maior que a solução python de Tim . Sim, eu não posso realmente girar isso para parecer uma vantagem.

Meio legal, né? (Bem, eu acho que sim.)

Como funciona

1. A função p p opõe uma matriz numericamente indexada g de g rades, em índices que vão desde o primeiro argumento até o segundo, com o valor (carta) dado em seu terceiro argumento.
2. p é chamado para cada grau de letra, para definir seu intervalo numérico.
3. Continue lendo a entrada do usuário contanto que ela esteja disponível e não comece com q (ou Q ), verificando a matriz g para a qual a nota corresponde ao número digitado e imprimindo essa letra. / li>

Answer 7

E aqui está a minha versão do awk:

awk '{
  if($_ <= 100 && $_ >= 0) {
      sub(/^([0-9]|[1-5][0-9])$/, "F", $_);
      sub(/^(6[0-9])$/, "D", $_);
      sub(/^(7[0-9])$/, "C", $_);
      sub(/^(8[0-9])$/, "B", $_);
      sub(/^(9[0-9]|100)$/, "A", $_);
      print
    }
    else {
      print "Only numbers between 0..100"
    }
}' -

ou como one-liner:

awk '{if($_ <= 100 && $_ >= 0) { sub(/^([0-9]|[1-5][0-9])$/, "F", $_); sub(/^(6[0-9])$/, "D", $_); sub(/^(7[0-9])$/, "C", $_); sub(/^(8[0-9])$/, "B", $_);sub(/^(9[0-9]|100)$/, "A", $_);   print} else { print "Only numbers between 0..100"}}' -

    

Answer 8

Aqui está outra resposta "esotérica"

perl -E '
    print "number: "; 
    $n = <>; 
    say qw/A A B C D E F F F F F/[11-($n+1)/10]
       if $n=~/^\s*\d/ and 0<=$n and $n<=100
'

Explicação

• perl -E : o -E , como -e , permite passar um script como um argumento de linha de comando. Esta é uma maneira de rodar perl one-liners. Ao contrário de -e , -E também ativa todos os recursos opcionais (como say , que é basicamente print com uma nova linha final).
• print "number: "; : solicita ao usuário que digite um número.
• $n = <>; : salve esse número como $n .

O próximo bit precisa ser quebrado um pouco. qw/string/ avalia uma lista feita quebrando string no espaço em branco. Então, qw/A A B C D E F F F F F/ é na verdade essa lista:

0 : A
1 : A
2 : B
3 : C
4 : D
5 : E
6 : F
7 : F
8 : F
9 : F
10 : F

Portanto, say qw/A A B C D E F F F F F/[11-($n+1)/10] é equivalente a

my @F=("A","A","B","C","D","E","F","F","F","F","F");
print "$F[11-($n+1)/10]\n"

Agora, o Perl permite o uso de índices negativos para recuperar elementos contando a partir do final da matriz. Por exemplo, $arrray[-1] imprimirá o último elemento da matriz. Além disso, os índices de array de ponto flutuante (por exemplo, 10.7) são automaticamente truncados para o próximo inteiro inferior (10.7 ou 10.3, ou seja o que for, todos se tornam 10).

O resultado de tudo isso é que o índice 11-($n+1)/10 sempre avalia o elemento apropriado (nota) da matriz.

    

Answer 9

Embora você tenha pedido uma solução bash, acho que em python, isso pode ser feito de maneira elegante e rápida. Cobrindo erros de manipulação em caso de entrada incorreta e a "conversão" de um número entre 0 e 100 em letras de A a F (ou qualquer outra):

#!/usr/bin/env python3
try:
    n = int(input("number: ")); n = n if n>0 else ""
    print("FEDCBA"[[n>=f for f in [50,60,70,80,90,101]].count(True)])
except:
    print("invalid input")

Explicação

1. Primeiro, precisamos obter o número do usuário:

   n = int(input("number: "))
   

2. Testamos esse número como válido para várias condições:

   n>=50, n>=60, n>=70, n>=80, n>=90
   

   Para cada um desses testes, o resultado será False ou True . Portanto (compactando o código um pouco):

   [n>=f for f in [50,60,70,80,90]].count(True)]
   

   produzirá uma figura de 0 a 5

3. Posteriormente, podemos usar essa figura como um índice para uma string, para produzir um caractere como saída, por exemplo

   "ABCDEF"[3] 
   

   produzirá "D" (desde o primeiro caractere="A")

4. O 101 adicional à lista é para gerar um erro (Índice-) caso o número exceda 100 , pois "ABCDEF"[6] não existe. O mesmo vale para n = n if n>=0 else "" , o que criará um erro (Valor-) se um número abaixo de 0 for inserido. Nesses casos, assim como se a entrada não for uma figura, o resultado será:

   invalid input
   

Os testes:

number: 10
F

number: 50
E

number: 60
D

number: 70
C

number: 80
B

number: 90
A

number: 110
invalid input

number: -10
invalid input

number: Monkey
invalid input