¿Cómo escribir un guión de shell para asignar notas de letras a rangos numéricos?

19

Quiero hacer una secuencia de comandos que le solicite un número entre 0-100 y luego darle la calificación basada en el número.

Me gustaría en 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
    
pregunta Temple Pate 09.05.2015 - 11:46

9 respuestas

20

Brevedad vs. legibilidad: un punto medio

Como ha visto, este problema admite soluciones que son moderadamente largas y algo repetitivas, pero altamente legibles ( terdon's y respuestas de bash de AB ), así como aquellas que son muy cortas pero no intuitivas y Mucho menos auto-documentación (Tim python y bash respuestas y glenn jackman's respuesta perl ). Todos estos enfoques son valiosos.

También puede resolver este problema con un código en el medio del continuo entre compacidad y legibilidad. Este enfoque es casi tan legible como las soluciones más largas, con una longitud más cercana a las pequeñas soluciones 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."

En esta solución de bash, he incluido algunas líneas en blanco para mejorar la legibilidad, pero podrías eliminarlas si quisieras aún más corto.

Las líneas en blanco incluidas, esto es en realidad solo un poco más corto que una variante compacta, aún bastante legible de Solución de bash de AB . Sus principales ventajas sobre ese método son:

  • Es más intuitivo.
  • Es más fácil cambiar los límites entre las calificaciones (o agregar calificaciones adicionales).
  • Acepta automáticamente la entrada con espacios iniciales y finales (ver a continuación una explicación de cómo (( )) funciona).

Las tres ventajas surgen porque este método utiliza la entrada del usuario como datos numéricos en lugar de examinar manualmente los dígitos que lo componen.

Cómo funciona

  1. Leer la entrada del usuario. Permítales usar las teclas de flecha para moverse en el texto han ingresado ( -e ) y no interpretan \ como un carácter de escape ( -r ).

    Esta secuencia de comandos no es una solución rica en funciones - vea a continuación un refinamiento- -pero esas funciones útiles solo lo hacen dos caracteres más. Recomiendo siempre usar -r con read , a menos que sepa que debe permitir que el usuario suministre \ escapes.
  2. Si el usuario escribió q o Q , quit.
  3. Cree un sistema asociativo matriz ( declare -A ). Rellenarlo con la calificación numérica más alta asociada con cada grado de letra.
  4. Recorre la letra de mayor a menor, y comprueba si el número proporcionado por el usuario es lo suficientemente bajo como para caer en el rango numérico de cada grado de letra.
    Con (( )) de evaluación aritmética, los nombres de las variables no necesitan expandirse con $ . (En la mayoría de las demás situaciones, si desea usar el valor de una variable en lugar de su nombre, debes hacer esto .)
  5. Si está dentro del rango, imprima la calificación y exit .
    Para abreviar, utilizo el operador de cortocircuito y ( && ) en lugar de un if - then .
  6. Si el bucle finaliza y no se ha igualado ningún rango, suponga que el número ingresado es demasiado alto (más de 100) y dígale al usuario que estaba fuera de rango.

Cómo se comporta esto, con entradas raras

Al igual que las otras soluciones cortas publicadas, ese script no verifica la entrada antes de asumir que es un número. La evaluación aritmética ( (( )) ) elimina automáticamente el espacio en blanco inicial y final, por lo que eso es no hay problema, pero:

  • La entrada que no se parece a ningún número se interpreta como 0.
  • Con una entrada que se parece a un número (es decir, si comienza con un dígito) pero contiene caracteres no válidos, el script emite errores.
  • La entrada de varios dígitos que comienza con 0 es interpretada como en octal . Por ejemplo, el script le dirá 77 es una C, mientras que 077 es una D. Aunque algunos usuarios pueden querer esto, probablemente no lo haga y puede causar confusión.
  • En el lado positivo, cuando se le da una expresión aritmética, este script lo simplifica y determina automáticamente el grado de letra asociado. Por ejemplo, le dirá que 320/4 es un B.

Una versión ampliada y completamente presentada

Por estos motivos, es posible que desee utilizar algo como este script expandido, que comprueba que la entrada sea buena e incluye algunas otras mejoras.

#!/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 sigue siendo una solución bastante compacta.

¿Qué características agrega esto?

Los puntos clave de este script expandido son:

  • Validación de entrada. la secuencia de comandos de terdon comprueba la entrada con if [[ ! $response =~ ^[0-9]*$ ]] ... , por lo que se muestra de otra manera, lo que sacrifica cierta brevedad pero es más robusto, lo que permite usuario para ingresar a los espacios iniciales y finales y rehusarse a permitir una expresión que podría o no ser considerada como octal (a menos que sea cero).
  • He usado case con globbing ampliado en lugar de [[ con el =~ coincidencia de expresión regular operador (como en la respuesta de terdon ). Lo hice para mostrar eso (y cómo) también se puede hacer de esa manera. Globs y expresiones regulares son dos formas de especificar patrones que coinciden con el texto, y cualquiera de los métodos está bien para esta aplicación.
  • Al igual que script bash de AB , lo he incluido todo en un bucle externo (excepto la creación inicial) de la matriz cutoffs ). Solicita números y proporciona los grados de letra correspondientes siempre que la entrada de terminal esté disponible y el usuario no le haya indicado que abandone. A juzgar por el do ... done del código en su pregunta, parece que quiere eso.
  • Para facilitar el abandono, acepto cualquier variante insensible a mayúsculas y minúsculas de q o quit .

Este script usa algunas construcciones que pueden ser desconocidas para los principiantes; se detallan a continuación.

Explicación: uso de continue

Cuando quiero omitir el resto del cuerpo del bucle exterior while , uso el comando continue . Esto lo devuelve al principio del ciclo, para leer más entradas y ejecutar otra iteración.

La primera vez que hago esto, el único bucle en el que estoy es el bucle exterior while , así que puedo llamar continue sin argumento. (Estoy en una construcción case , pero eso no afecta la operación de break o continue .)

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

La segunda vez, sin embargo, estoy en un bucle for interno que está anidado dentro del bucle while externo. Si utilicé continue sin argumento, esto sería equivalente a continue 1 y continuaría el ciclo interior for en lugar del ciclo while externo.

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

Entonces, en ese caso, uso continue 2 para hacer que bash encuentre y continúe el segundo bucle en su lugar.

Explicación: case Etiquetas con Globs

No uso case para averiguar en qué grado de letra bin cae un número (como en < a href="https://askubuntu.com/a/621471/22949"> Respuesta bash de AB ). Pero uso case para decidir si se debe considerar la entrada del usuario:

  • un número válido, *( )@([1-9]*([0-9])|+(0))*( )
  • el comando de abandono, *( )[qQ]?([uU][iI][tT])*( )
  • cualquier otra cosa (y por lo tanto entrada no válida), *

Estos son componentes del shell .

  • A cada uno le sigue un ) que no coincide con ningún% de apertura ( , que es la sintaxis de case para separar un patrón de los comandos que se ejecutan cuando se combina.
  • ;; es la sintaxis de case para indicar el final de los comandos que se ejecutarán para una coincidencia de caso particular (y que no se deben probar casos posteriores después de ejecutarlos).

El globbing de shell ordinario proporciona * para que coincida con cero o más caracteres, ? para que coincida exactamente con un carácter, y clases de caracteres / rangos en [ ] corchetes. Pero estoy usando globbing extendido , que va más allá de eso. El globbing extendido está habilitado de forma predeterminada cuando se utiliza bash de forma interactiva, pero está deshabilitado de forma predeterminada cuando se ejecuta un script. El comando shopt -s extglob en la parte superior de la secuencia de comandos lo activa.

Explicación: Globos extendidos

*( )@([1-9]*([0-9])|+(0))*( ) , que busca entradas numéricas , coincide con una secuencia de:

  • Cero o más espacios ( *( ) ). El constructo *( ) coincide con cero o más del patrón entre paréntesis, que aquí es solo un espacio.
    En realidad, hay dos tipos de espacios en blanco horizontales, espacios y pestañas, y con frecuencia es deseable también coincide con las pestañas. Pero no estoy preocupado por eso aquí, porque este script está escrito para entrada manual, interactiva, y el indicador -e para read habilita la línea de lectura GNU. Esto es para que el usuario pueda avanzar y retroceder en el texto con las teclas de flecha izquierda y derecha, pero tiene el efecto secundario de evitar que las pestañas se ingresen literalmente.
  • Una ocurrencia ( @( ) ) de cualquiera ( | ):
    • Un dígito distinto de cero ( [1-9] ) seguido de cero o más ( *( ) ) de cualquier dígito ( [0-9] ).
    • Uno o más ( +( ) ) de 0 .
  • Cero o más espacios ( *( ) ), nuevamente.

*( )[qQ]?([uU][iI][tT])*( ) , que busca el comando de abandono , coincide con una secuencia de:

  • Cero o más espacios ( *( ) ).
  • q o Q ( [qQ] ).
  • Opcionalmente, es decir, cero o una ocurrencia ( ?( ) ) - de:
    • u o U ( [uU] ) seguido de i o I ( [iI] ) seguido de t o T ( [tT] ).
  • Cero o más espacios ( *( ) ), nuevamente.

Variante: validación de entrada con una expresión regular extendida

Si prefiere probar la entrada del usuario contra una expresión regular en lugar de un comodín, quizás prefiera usar esta versión, que funciona igual pero usa [[ y =~ (como en respuesta deterdon ) en lugar de case y globbing extendido.

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

Las posibles ventajas de este enfoque son las siguientes:

  • En este caso particular, la sintaxis es un poco más simple, al menos en el segundo patrón, donde compruebo el comando quit. Esto se debe a que pude establecer la opción nocasematch shell, y luego todas las variantes de casos de q y quit se cubrieron automáticamente.

    Eso es lo que hace el comando shopt -s nocasematch . El comando shopt -s extglob se omite porque no se usa globbing en esta versión.

  • Las habilidades de expresión regular son más comunes que el dominio de los extglobs de bash.

Explicación: expresiones regulares

En cuanto a los patrones especificados a la derecha del operador =~ , así es cómo funcionan esas expresiones regulares.

^\ *([1-9][0-9]*|0+)\ *$ , que busca entradas numéricas , coincide con una secuencia de:

  • El comienzo, es decir, el borde izquierdo de la línea ( ^ ).
  • Cero o más espacios ( * , postfix aplicado). Un espacio normalmente no necesita ser \ -escaped en una expresión regular, pero esto es necesario con [[ para evitar un error de sintaxis.
  • Una subcadena ( ( ) ) que es una o la otra ( | ) de:
    • [1-9][0-9]* : un dígito distinto de cero ( [1-9] ) seguido de cero o más ( * , postfijo aplicado) de cualquier dígito ( [0-9] ).
    • 0+ : uno o más ( + , postfijo aplicado) de 0 .
  • Cero o más espacios ( \ * ), como antes.
  • El final, es decir, el borde derecho de la línea ( $ ).

A diferencia de las etiquetas case , que coinciden con toda la expresión que se prueba, =~ devuelve verdadero si alguna parte de su expresión de la izquierda coincide con el patrón dado como su expresión de la mano derecha. Esta es la razón por la cual los anclajes ^ y $ , que especifican el comienzo y el final de la línea, son necesarios aquí, y no corresponden sintácticamente a nada que aparezca en el método con case y extglobs.

Los paréntesis son necesarios para hacer que ^ y $ se unan a la disyunción de [1-9][0-9]* y 0+ . De lo contrario, sería la disyunción de ^[1-9][0-9]* y 0+$ , y coincidiría con cualquier entrada que comenzara con un dígito distinto de cero o que terminara con un 0 (o ambos, que aún podría incluir no dígitos en entre).

^\ *q(uit)?\ *$ , que busca el comando de abandono , coincide con una secuencia de:

  • El comienzo de la línea ( ^ ).
  • Cero o más espacios ( \ * , consulte la explicación anterior).
  • La letra q . O Q , ya que shopt nocasematch está habilitado.
  • Opcionalmente, es decir, cero o una ocurrencia (posfijo ? ) - de la subcadena ( ( ) ):
    • u , seguido de i , seguido de t . O bien, dado que shopt nocasematch está habilitado u puede ser U ; independientemente, i puede ser I ; e independientemente, t puede ser T . (Es decir, las posibilidades son no limitadas a uit y UIT .)
  • Cero o más espacios de nuevo ( \ * ).
  • El final de la línea ( $ ).
respondido por el Eliah Kagan 09.05.2015 - 18:31
23

Ya tienes la idea básica. Si desea codificar esto en bash (que es una opción razonable ya que es el shell predeterminado en Ubuntu y la mayoría de las otras Linux), no puede usar case porque no comprende los rangos. En cambio, podrías 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
    
respondido por el terdon 09.05.2015 - 12:04
12
#!/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

y una versión más 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
    
respondido por el A.B. 09.05.2015 - 11:58
9

Todas las instalaciones de Ubuntu tienen Python, por lo que aquí hay un script de python . Si necesita que esté en bash, también he escrito el equivalente como script de shell .

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

Para ejecutar, guárdelo en un archivo (por ejemplo, grade.py ) y luego ejecútelo en la terminal con esto:

python grade.py

Esto es lo que verá:

Enter the number: 65
E

¿Cómo funciona esto?

  1. Tomar entrada - 65 .
  2. Agregue un 0 al comienzo - 065 .
  3. Eliminar la última char - 06 .
  4. 75 resta ese número - 70 .
  5. Convertir a una letra (A es 65, B es 66) - E .
  6. Imprimirlo - E .
respondido por el Tim 09.05.2015 - 12:56
6

Después de hacerlo en Python 2 , decidí hacerlo en 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 ejecutar, guárdelo en un archivo (por ejemplo, grade.sh), hágalo ejecutable con chmod +x grade.sh y luego ejecútelo con ./grade.sh .

Esto es lo que verá:

Enter the number: 65
E

¿Cómo funciona esto?

  1. Tomar entrada - 65 .
  2. Agregue un 0 al comienzo - 065 (y el 10# lo mantiene en la base 10).
  3. Eliminar la última char - 06 .
  4. 75 resta ese número - 70 .
  5. Convertir a una letra (A es 65, B es 66) - E .
  6. Imprimirlo - E .
respondido por el Tim 09.05.2015 - 13:33
6

Aquí está mi semi -resoteric bash solution, que llena una matriz con 101 entradas y luego verifica la entrada del usuario en contra de ellas. Incluso para el uso en el mundo real eso es razonable: si necesitaras un rendimiento excelente, no estarías utilizando bash, y un centenar (más o menos) de tareas aún es rápido. Pero dejaría de ser razonable si se extendiera a un rango mucho mayor (como un millón).

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

Ventajas:

  • No es realmente tan esotérico. A pesar de que es más largo que las soluciones más cortas, y no tan auto-documentadas como las soluciones más largas ... es razonablemente auto-documentado , mientras aún decididamente en el lado más pequeño.
  • Permite una modificación fácil para cambiar los rangos de grados o agregar / eliminar grados.
  • Funciona en un bucle y se cierra en q , quit o cualquier cosa que comience por q / Q .
  • Enumera primero las calificaciones más altas para ayudarlo a pensar de manera positiva. :)
  • Hmm, esto hace el trabajo, sigue teniendo sentido incluso después de verlo, y tiene las características esenciales. ¡Podrías usar esto realmente!

Desventajas:

  • Te da una F cuando pones una entrada no numérica ... pero eso no es tan malo, ¿o sí? Si le da un número que no es el número donde se necesita un número, tal vez se merece un F!
  • La entrada ambigua, posiblemente octal, se trata como octal (ya que g es una matriz indexada unidimensional ). Como dice el viejo refrán, "¡No es un error, es una característica!" Bueno, tal vez.
  • La entrada que está fuera del rango o no es un número hace que se imprima una línea vacía. Sin embargo, no hay nada realmente malo en eso: te dice qué grado de letra corresponde a tu entrada, y para la entrada incorrecta no hay ninguna.
  • Ponga un número negativo, y ... bueno, llámelo un huevo de Pascua .
  • Aún es significativamente más largo que la solución de Tim para Python . Sí, realmente no puedo girar eso para parecer una ventaja.

Un poco genial, ¿eh? (Bueno, eso creo).

Cómo funciona

  1. La función p p opta por una matriz indexada numéricamente g de g rades, en índices que van desde su primer argumento hasta el segundo, con el valor (de la letra) dado en su tercer argumento.
  2. Se solicita p para cada grado de letra, para definir su rango numérico.
  3. Siga leyendo la entrada del usuario mientras esté disponible y no comience con q (o Q ), verifique la matriz g para la cual la calificación de la letra corresponde al número ingresado e imprima esa letra.
respondido por el Eliah Kagan 11.05.2015 - 05:13
5

Y aquí está mi versión de 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"
    }
}' -

o como un trazador de líneas:

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"}}' -
    
respondido por el A.B. 09.05.2015 - 19:13
4

Aquí hay otra respuesta "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
'

Explicación

  • perl -E : -E , como -e , permite pasar una secuencia de comandos como un argumento de línea de comando. Esta es una forma de ejecutar perl one-liners. A diferencia de -e , -E también habilita todas las características opcionales (como say , que es básicamente un print con una línea nueva posterior).
  • print "number: "; : solicita al usuario que ingrese un número.
  • $n = <>; : guarde ese número como $n .

El próximo bit debe ser desglosado un poco. qw/string/ evalúa a una lista hecha rompiendo string en espacios en blanco. Entonces, qw/A A B C D E F F F F F/ es en realidad esta lista:

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

Por lo tanto, say qw/A A B C D E F F F F F/[11-($n+1)/10] es equivalente a

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

Ahora, Perl permite usar índices negativos para recuperar elementos contando desde el final de la matriz. Por ejemplo, $arrray[-1] imprimirá el último elemento de la matriz. Además, los índices de matriz de coma flotante (por ejemplo, 10.7) se truncan automáticamente al siguiente entero inferior (10.7, o 10.3 o lo que sea que todos se conviertan en 10).

El resultado de todo esto es que el índice 11-($n+1)/10 siempre evalúa el elemento apropiado (grado) de la matriz.

    
respondido por el glenn jackman 09.05.2015 - 14:03
1

Aunque pediste una solución bash, creo que en Python, esto se puede hacer de una manera elegante y breve. Cubre tanto los errores de manejo en caso de ingreso incorrecto como la "conversión" de un número entre 0 y 100 en letras de A a F (o cualquier otra):

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

Explicación

  1. Primero necesitamos obtener el número del usuario:

    n = int(input("number: "))
    
  2. Probamos que este número sea válido para una serie de condiciones:

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

    Para cada una de estas pruebas, el resultado será False o True . Por lo tanto (comprimiendo el código un poco):

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

    producirá una cifra de 0 a 5

  3. Posteriormente, podemos usar esta figura como un índice para una cadena, para producir un carácter como salida, por ejemplo,

    "ABCDEF"[3] 
    

    mostrará "D" (desde el primer carácter="A")

  4. El 101 adicional de la lista es para generar un error (Index-) en caso de que el número exceda 100 , ya que "ABCDEF"[6] no existe. Lo mismo aplica para n = n if n>=0 else "" , que creará un error (de valor) si se ingresa un número por debajo de 0
    En esos casos, así como si la entrada no es una figura, el resultado será:

    invalid input
    

Las pruebas:

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
    
respondido por el Jacob Vlijm 07.07.2015 - 13:05

Lea otras preguntas en las etiquetas