Hay 97 caracteres ASCII que las personas encuentran regularmente. Se dividen en cuatro categorías:

1. Cartas (52 en total)

   ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
   

2. Números o dígitos (10 en total)

   0123456789
   

3. Símbolos y puntuación (32 en total)

   !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
   

4. Espacio en blanco (3 en total)

   Espacio , tabulación \ty nueva línea \n. (Trataremos las variantes de nueva línea \r\ncomo un solo personaje).

Para mayor concisión, llamaremos a estas categorías L, N, S y W, respectivamente.

Elija cualquiera de las 24 permutaciones de las letras LNSWque desee y repítalas indefinidamente para formar una plantilla de programación para usted.

Por ejemplo, puede elegir la permutación NLWS, por lo que su plantilla de programación sería:

NLWSNLWSNLWSNLWSNLWS...

Necesita escribir un programa o función basado en esta plantilla, donde:

1. Cada Lse reemplaza con cualquier letra ( ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz).

2. Cada Nse reemplaza con cualquier número ( 0123456789).

3. Cada Sse reemplaza con cualquier símbolo ( !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~).

4. Cada Wse reemplaza con cualquier carácter de espacio en blanco ( \t\n).

Básicamente, su código debe seguir el patrón

<letter><number><symbol><whitespace><letter><number><symbol><whitespace>...

como sugiere el título de la pregunta, excepto que puede elegir un orden diferente de las cuatro categorías de caracteres, si lo desea.

Tenga en cuenta que:

• Los reemplazos para una categoría pueden ser caracteres diferentes. Por ejemplo, se 9a ^8B\t~7c\n]ajusta válidamente a la plantilla NLWSNLWSNLWS( \ty \nserían sus caracteres literales).

• No hay restricciones de longitud de código. por ejemplo, 1A +2B -and 1A +2By 1A y 1todos se ajustan a la plantilla NLWSNLWSNLWS....

Lo que debe hacer su código conformado por plantilla es tomar un carácter ASCII no extendido y generar un número del 0 al 4 en función de la categoría de la que es miembro en la categorización anterior. Es decir, salida 1si la entrada es una letra, 2si es un número, 3si es un símbolo y 4si es un espacio en blanco. Salida 0si la entrada no es ninguno de estos (un carácter de control ).

Para la entrada, también puede tomar un número del 0 al 127 inclusive que represente el código del carácter ASCII de entrada.

Los pares de entrada (como código char) y salida que debe tener su código son exactamente los siguientes:

in out
0 0
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 4
10 4
11 0 or 4
12 0 or 4
13 0 or 4
14 0
15 0
16 0
17 0
18 0
19 0
20 0
21 0
22 0
23 0
24 0
25 0
26 0
27 0
28 0
29 0
30 0
31 0
32 4
33 3
34 3
35 3
36 3
37 3
38 3
39 3
40 3
41 3
42 3
43 3
44 3
45 3
46 3
47 3
48 2
49 2
50 2
51 2
52 2
53 2
54 2
55 2
56 2
57 2
58 3
59 3
60 3
61 3
62 3
63 3
64 3
65 1
66 1
67 1
68 1
69 1
70 1
71 1
72 1
73 1
74 1
75 1
76 1
77 1
78 1
79 1
80 1
81 1
82 1
83 1
84 1
85 1
86 1
87 1
88 1
89 1
90 1
91 3
92 3
93 3
94 3
95 3
96 3
97 1
98 1
99 1
100 1
101 1
102 1
103 1
104 1
105 1
106 1
107 1
108 1
109 1
110 1
111 1
112 1
113 1
114 1
115 1
116 1
117 1
118 1
119 1
120 1
121 1
122 1
123 3
124 3
125 3
126 3
127 0

Las entradas 11, 12 y 13 corresponden a caracteres que a veces se consideran espacios en blanco, por lo tanto, sus salidas pueden ser 0o 4como desee.

El código más corto en bytes gana.

Haskell 300 bytes

Este código no debe tener una nueva línea final. La función m1toma la entrada como a Chary devuelve la respuesta como a Char.

f1 (l1 :n1 :p1 :y1 :l2 :n2 :p2 :y2 :r3 )x1 |y1 >p1 =b1 (x1 )y2 (f1 (r3 )x1 )y1 (n1 )n2 |p2 <p1 =b1 (x1 )y1 (n1 )p2 (f1 (p2 :y2 :r3 )x1 )l2 |p2 >p1 =b1 (x1 )p1 (l2 )l1 (n2 )n1
;b1 (x1 )s1 (r1 )b1 (r2 )r3 |x1 <s1 =r1 |x1 >b1 =r2 |s1 <b1 =r3
;m1 =f1 "d0 \t4 \r0 ~d3 {d1 `d3 [d1 @d3 :d2 /d3 !d4 \n0 ?d0 "

No pude resistir un desafío que alguien afirmó que era imposible para los idiomas "convencionales".

Puede cuestionar si Haskell cuenta, pero la mayoría de las palabras clave y los identificadores son caracteres múltiples y no se pueden usar. Sin embargo, las definiciones de funciones de nivel superior, las listas, los literales de cadena, las comparaciones estrictas, la coincidencia de patrones y la ramificación con guardias funcionan, siempre que las letras aparezcan justo antes de los dígitos, y si los símbolos también aparecen antes de las letras, tenemos caracteres de escape como \ty \r. Desafortunadamente, las permutaciones que funcionan para la programación general no permiten literales numéricos, por lo que no pude obtener números de ninguna manera útil.

Cómo funciona:

• Los intervalos de las clases de caracteres están codificados en la cadena en la última línea, con caracteres de límite en la mayoría de los lugares de símbolos y los resultados en la mayoría de los lugares de dígitos, aunque algunos en los extremos son de relleno.
• La función principal es m1.
• x1 es el personaje que se analiza.
• La f1función divide la cadena con la coincidencia de patrones de lista y tiene tres ramas: para cuando los límites son símbolos más grandes que el espacio, para cuando los límites se escapan, los caracteres de control son más pequeños que el espacio y para manejar la comparación final con el espacio en sí. Los nombres de las piezas de la lista son mnemotécnicos para la primera rama: letra, número, espacio, símbolo, resto.
• La b1función maneja la ramificación de dos caracteres de límite s1 < b1a la vez.

Pruébalo en línea

Retina , 113 bytes

Letra, Número, Espacio, Símbolo, Repetir

T1 `a0 @a0 `b1	:D0
+T1 `d9 `a2
+T1 `a9	\n9 `a4
+T1 `l9 @L9 `a1
+T1 `d9 @p9 `d3
\b4
$n3
\b3
$n2
\b2
$n1
\b1
$n0
\n

Pruébalo en línea!

¡Pruébalo en sí mismo!

La retina parece una buena herramienta para este trabajo: podemos usar todo tipo de caracteres de manera flexible en la configuración del escenario, y tenemos algunas clases de caracteres predefinidas que pueden ser útiles.

Creo que este problema podría resolverse con etapas de reemplazo o etapas de transliteración; Elegí las transliteraciones porque son más flexibles y tienen las clases de caracteres más útiles. Con respecto al patrón de la fuente, me vi obligado a poner símbolos justo antes de las letras para usarlas \nen las nuevas líneas (en realidad, tuve una solución más corta usando el ¶ más práctico para las nuevas líneas, pero los caracteres no ascii están prohibidos).

Explicación

Las primeras etapas son transliteraciones. Usamos +y 1como opciones para mantener el patrón, pero no afectarán el resultado de la etapa. La sintaxis es T`from`toasignar cada carácter de fromal personaje en la misma posición en to. Si toes más corto que from, su carácter final se repite tanto como sea necesario. Si fromtiene caracteres repetidos, solo se considera la primera aparición de cada uno. Algunas letras corresponden a clases de caracteres, por ejemplo, des equivalente a 0123456789.

T1 `a0 @a0 `b   :D0

Con esto, asignamos algunos caracteres a otros caracteres de la misma clase para "hacer algo de espacio" para las siguientes transliteraciones. ( a-> b, 0-> 1, space-> tab, @-> ;). La final :D0es solo una carita: D0

+T1 `d9 `a2

Comenzamos con dígitos, des la clase de caracteres 0-9, aquí estamos transformando 0-> a, 1-9-> 2, space-> 2: las transliteraciones para 0y spaceson incorrectas, pero esos caracteres han sido eliminados por la transliteración previa.

+T1 `a9 \n9 `a4

Los espacios en blanco, transformar a-> a, ( 9, tab, \n, space) -> 4. 9ya se eliminó en la etapa anterior.

+T1 `l9 @L9 `a1

Letras, aquí usamos dos clases de caracteres diferentes (por falta de una más completa): lpara letras minúsculas y Lpara letras mayúsculas. Todos se asignan 1, junto con algunos otros personajes que se han tratado en las etapas anteriores.

+T1 `d9 @p9 `d3

Símbolos Como todas las demás clases se han convertido en un dígito, aquí asignamos todos los dígitos a sí mismos con d-> d, y luego todos los caracteres imprimibles 3con p-> 3. Los dígitos también se encuentran entre los caracteres imprimibles, pero gana la primera transliteración.

Ahora necesitamos asignar 0caracteres de control, pero no he encontrado una forma válida de abordar explícitamente esa clase. En su lugar, convertiremos cada dígito a unario: los caracteres de control no son dígitos y, por lo tanto, se consideran como la cadena vacía, que es igual 0a unario. Desafortunadamente, el comando de conversión unaria en retina es $*, que son dos símbolos cerca uno del otro, por lo que en su lugar convertiremos "manualmente" usando sustituciones.

\b4
$n3
\b3
$n2
\b2
$n1
\b1
$n0

Nuestro dígito unario es $n, que es un patrón de reemplazo para las nuevas líneas. \bcoincide con un "límite", donde una palabra alfanumérica comienza o termina: en nuestro caso, siempre coincidirá antes de cualquier número. Básicamente, estamos reemplazando cada número ncon una nueva línea más n-1.

\n

Al final, contamos el número de nuevas líneas y obtenemos el resultado deseado.

Cardenal 2240 2224 bytes

Plantilla utilizada LSNW

a%1
a:1 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a+1 a+1 a+1 a+1 a.1 x.1 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a.0 a>0 a+1 a+1 a+1 a+1 a.1 x>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a+1 a+1 a+1 a.0 x>1 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a+1 a+1 a.0 x>1 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a>0 a+1 a+1 a+1 a.0 x>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a+1 a.0 x>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a+1 a+1 a+1 a.0 x>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a>1 a+1 a.0 x>1 a>1 a>1 a>1 a>1 a>1 a>1 a+1 a+1 a+1 a.0
a>1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a>1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^1 a>1 a-1 J^1 a-1 J^1 a-1 J^1 a-1 J^0 a.0

El código tiene una nueva línea final.

Cómo funciona:

Este código tiene muchos caracteres que no se usan.
% libera un puntero en todas las direcciones. 3 de ellos simplemente llegan al final de una línea y mueren.
El último puntero toma una entrada en:
Esta entrada se compara con cada valor de 0 a 127.

Impresiones:
0 para 0-8
4 para 9-12
0 para 13-31
4 para 32
3 para 33-47
2 para 48-57
3 para 58-64
1 para 65-90
3 para 91-96
1 para 97-122
3 para 123-126
0 para 127

Operaciones utilizadas:
J = Saltar la siguiente operación si no es cero
^ = Cambiar la dirección hacia arriba
> = Cambiar la dirección hacia la izquierda
- = Disminuir
+ = Incrementar
: = Tomar la entrada
% = Crear punteros al inicio del programa
x = Eliminar el puntero
0 = Establecer activo valor del puntero a 0

Pruébalo en línea

Perl 5 , 293 bytes

Código de 291 bytes + 2 para -0p.

Me han informado que los indicadores de la línea de comandos son gratuitos, pero los he agregado aquí para mayor visibilidad, ya que el enlace TIO no incluye -0, para facilitar las pruebas.

y 0-a 1"a 1#a 1$a 1%a 1&a 1'a 1(a 1)a 1*a 1+a 1,a 1.a 1/a 1_a 1{a 1|a 1}a 1~a 0!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 1!a 0;s 0\s
0\t
0;s 0\d
0\r
0;s 0\w
0\n
0;y 1!a 9-a 1_a 0-Z 1;s 0\w
0\u 3\u 0;s 1\S
1\u 0\u 1;s 0\t
0\u 4\u 0;s 0\r
0\u 2\u 0;s 0\n
0\u 1\u 0

Pruébalo en línea!

Este es un desafío particularmente difícil de resolver en casi cualquier idioma, por lo que estoy muy contento de haber podido (finalmente, un montón de retoques durante bastante tiempo) hacer que esto funcione en Perl. Esperemos que el espacio en blanco adicional antes y después del número no sea un problema.

Seleccionar el orden de la secuencia fue particularmente complicado, pero por suerte s///y y///puede aceptar cualquier otro carácter como delimitador, por lo que fue posible usar letras, espacios, números, símbolos, que permiten s 0...0...0;y y 0...0...0;.

El primero que se requiere para la appraoch era sustituir _con !de modo que \wsólo habría que coincida [0-9a-zA-Z], vuelva a colocar todos los espacios en blanco ( \s) con \t, todos los dígitos con \ry todos los caracteres de palabra restantes ( \w) con \nuna fácil adaptación más adelante. Luego, usando el y///operador, todos los símbolos restantes se convierten a caracteres de palabra !a _y todos los demás caracteres (entre 9y a) se desplazan hacia abajo 9 lugares, convirtiéndolos en letras o números. Estos se reemplazan a través de \wcon 3y el otro, las sustituciones realizadas anteriormente se reemplazan con sus valores numerados.

Espacio en blanco , 1332 bytes

Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0! Y0!
Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! 

El orden es 1234/ LNSW(letra, dígito, símbolo, espacio en blanco).

Pruébelo en línea (ingrese como número entero que representa el unicode de un carácter).

Explicación:

El espacio en blanco es un lenguaje basado en la pila donde se ignoran todos los caracteres, excepto los espacios, las pestañas y las nuevas líneas. Aquí está el mismo programa sin el YO!( 333 bytes ):

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve][S N
S _Duplicate_input(9)][S N
S _Duplicate_input(10][S N
S _Duplicate_input(32)][S N
S _Duplicate_input(33-47)][S N
S _Duplicate_input(48-57)][S N
S _Duplicate_input(58-64)][S N
S _Duplicate_input(65-90)][S N
S _Duplicate_input(91-96)][S N
S _Duplicate_input(97-122)][S N
S _Duplicate_input(123-126)][S S S T    S S T   N
_Push_9][T  S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_WHITESPACE][S S S T S T S N
_Push_10][T S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_WHITESPACE][S S S T S S S S S N
_Push_32][T S S T   _Subtract][S N
S _Duplicate][N
T   S S N
_If_0_Jump_to_Label_WHITESPACE][N
T   T   S T N
_If_negative_Jump_to_Label_NONE][S S S T    T   S S S S N
_Push_48][T S S T   _Subtract][N
T   T   N
_If_negative_Jump_to_Label_SYMBOL][S S S T  T   T   S T S N
_Push_58][T S S T   _Subtract][N
T   T   S S N
_If_negative_Jump_to_Label_DIGIT][S S S T   S S S S S T N
_Push_65][T S S T   _Subtract][N
T   T   N
_If_negative_Jump_to_Label_SYMBOL][S S S T  S T T   S T T   N
_Push_91][T S S T   _Subtract][N
T   T   T   N
_If_negative_Jump_to_Label_LETTER][S S S T  T   S S S S T   N
_Push_97][T S S T   _Subtract][N
T   T   N
_If_negative_Jump_to_Label_SYMBOL][S S S T  T   T   T   S T T   N
_Push_123][T    S S T   _Subtract][N
T   T   T   N
_If_negative_Jump_to_Label_LETTER][S S S T  T   T   T   T   T   T   N
_Push_127][T    S S T   _Subtract][N
T   T   N
_If_negative_Jump_to_Label_SYMBOL][N
S N
S T N
_Jump_to_Label_NONE][N
S S S N
_Create_Label_WHITESPACE][S S S T   S S N
_Push_4][T  N
S T _Print_as_integer][N
N
N
_Exit][N
S S N
_Create_Label_SYMBOL][S S S T   T   N
_Push_3][T  N
S T _Print_as_integer][N
N
N
_Exit][N
S S S S N
_Create_Label_DIGIT][S S S T    S N
_Push_2][T  N
S T _Print_as_integer][N
N
N
_Exit][N
S S T   N
_Create_Label_LETTER][S S S T   N
_Push_1][T  N
S T _Print_as_integer][N
N
N
_Exit][N
S S S T N
_Create_Label_NONE][S S S N
_Push_0][T  N
S T _Print_as_integer]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébalo en línea.

Programa en pseudocódigo:

If the input is 9, 10 or 32: call function WHITESPACE()
Else-if the input is below 32: call function NONE()
Else-if the input is below 48: call function SYMBOL()
Else-if the input is below 58: call function DIGIT()
Else-if the input is below 65: call function SYMBOL()
Else-if the input is below 91: call function LETTER()
Else-if the input is below 97: call function SYMBOL()
Else-if the input is below 123: call function LETTER()
Else-if the input is below 127: call function SYMBOL()
Else (the input is 127 or higher): call function NONE()

WHITESPACE():
  Print 4
  Exit program
SYMBOL():
  Print 3
  Exit program
DIGIT():
  Print 2
  Exit program
LETTER():
  Print 1
  Exit program
NONE():
  Print 0
  (Implicit exit with error: Exit not defined)