Existem 97 caracteres ASCII que as pessoas encontram regularmente. Eles se enquadram em quatro categorias:

1. Letras (52 total)

   ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
   

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

   0123456789
   

3. Símbolos e pontuação (32 total)

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

4. Espaço em branco (total de 3)

   Espaço , tabulação \te nova linha \n. (Trataremos as variantes de nova linha \r\ncomo um caractere.)

Por concisão, chamaremos essas categorias de L, N, S e W, respectivamente.

Escolha uma das 24 permutações das letras que LNSWvocê deseja e repita-a indefinidamente para formar um modelo de programação para você.

Por exemplo, você pode escolher a permutação NLWS, para que seu modelo de programação seja:

NLWSNLWSNLWSNLWSNLWS...

Você precisa escrever um programa ou função com base neste modelo, onde:

1. Todo Lé substituído por qualquer letra ( ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz).

2. Todo Né substituído por qualquer número ( 0123456789).

3. Todo Sé substituído por qualquer símbolo ( !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~).

4. Todos Wsão substituídos por qualquer caractere de espaço em branco ( \t\n).

Basicamente, seu código deve seguir o padrão

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

como o título da pergunta sugere, exceto que você pode escolher uma ordem diferente das quatro categorias de caracteres, se desejar.

Observe que:

• As substituições para uma categoria podem ter caracteres diferentes. por exemplo, em 9a ^8B\t~7c\n]conformidade com o modelo NLWSNLWSNLWS( \te \nseriam seus caracteres literais).

• Não há restrições de tamanho de código. por exemplo, 1A +2B -e 1A +2Be 1A e 1todos em conformidade com o modelo NLWSNLWSNLWS....

O que o código em conformidade com o modelo deve fazer é pegar um caractere ASCII não estendido e gerar um número de 0 a 4 com base em qual categoria ele é membro na categorização acima. Ou seja, saída 1se a entrada for uma letra, 2se um número, 3se um símbolo e 4se houver espaço em branco. Saída 0se a entrada não for uma dessas (um caractere de controle ).

Para entrada, você pode, alternativamente, inserir um número de 0 a 127 inclusive, que representa o código do caractere ASCII de entrada.

Os pares de entrada (como código de caracteres) e de saída que seu código deve ter são exatamente os seguintes:

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

As entradas 11, 12 e 13 correspondem a caracteres que às vezes são considerados espaços em branco, portanto, suas saídas podem ser 0ou 4como você deseja.

O código mais curto em bytes vence.

Haskell 300 bytes

Este código não deve ter uma nova linha à direita. A função m1pega a entrada como a Chare retorna a resposta comoChar .

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 "

Não pude resistir a um desafio que alguém alegou ser impossível para idiomas "convencionais".

Você pode contestar se Haskell conta, mas a maioria das palavras-chave e identificadores tem vários caracteres e não pode ser usada. No entanto, definições de função de nível superior, listas, literais de seqüência de caracteres, comparações estritas, correspondência de padrões e ramificação com guardas funcionam, desde que as letras cheguem antes dos dígitos e se os símbolos também vierem antes das letras, temos caracteres de escape como \te\r . Infelizmente, as permutações que funcionam para programação geral não permitem literais numéricos, então não consegui obter números de nenhuma maneira útil.

Como funciona:

• Os intervalos das classes de caracteres são codificados na sequência na última linha, com caracteres de limite na maioria dos locais dos símbolos e os resultados na maioria dos locais dos dígitos, embora alguns dos extremos estejam preenchidos.
• A função principal é m1 .
• x1 é o personagem que está sendo analisado.
• o f1 função divide a sequência com o padrão de lista correspondente e possui três ramificações: para quando os limites são símbolos maiores que o espaço, para quando os limites são escapados, controlam caracteres menores que o espaço e para manipular a comparação final com o próprio espaço. Os nomes das peças da lista são mnemônicos para o primeiro ramo: Letter, Number, sPace, sYmbol, Restante.
• A b1função lida com ramificação para dois caracteres de limite s1 < b1por vez.

Experimente online

Retina , 113 bytes

Letra, Número, Espaço, Símbolo, Repita

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

Experimente online!

Teste em si mesmo!

Retina parece ser uma boa ferramenta para este trabalho: podemos usar todos os tipos de caracteres de forma flexível na configuração do palco, e temos algumas classes de caracteres predefinidas que podem ser úteis.

Eu acho que esse problema poderia ser resolvido com os estágios de substituição ou de transliteração; Eu escolhi as Transliterações porque são mais flexíveis e possuem as classes de caracteres mais úteis. Em relação ao padrão da fonte, fui forçado a colocar símbolos antes das letras para usar \nem novas linhas (na verdade, eu tinha uma solução mais curta usando o mais prático ¶ para novas linhas, mas caracteres não-ascii são proibidos).

Explicação

Os primeiros estágios são transliterações. Usamos +e 1como opções para manter o padrão, mas eles não afetam o resultado do estágio. A sintaxe é T`from`tomapear cada caractere frompara o caractere na mesma posição em to. Se tofor menor que from, seu caractere final será repetido quantas vezes forem necessárias. Se fromhouver caracteres repetidos, apenas a primeira ocorrência de cada um será considerada. Algumas letras correspondem às classes de caracteres, por exemplo, dé equivalente a 0123456789.

T1 `a0 @a0 `b   :D0

Com isso, mapeamos alguns caracteres para outros da mesma classe, a fim de "criar espaço" para as seguintes transliterações. ( a-> b, 0-> 1, space-> tab, @-> ;). A final :D0é apenas um smiley: D0

+T1 `d9 `a2

Começamos com dígitos, dé a classe de caracteres 0-9, aqui estamos transformando 0-> a, 1-9-> 2, space-> 2: as transliterações para 0e spaceestão erradas, mas esses caracteres foram eliminados pela transliteração anterior.

+T1 `a9 \n9 `a4

Espaços em branco, transformar a-> a, ( 9, tab, \n, space) -> 4. 9já foi removido no estágio anterior.

+T1 `l9 @L9 `a1

Letras, aqui usamos duas classes de caracteres diferentes (por falta de uma mais completa): lpara letras minúsculas e Lletras maiúsculas. Todos eles são mapeados 1, junto com alguns outros personagens que foram tratados nos estágios anteriores

+T1 `d9 @p9 `d3

Símbolos Como todas as outras classes foram transformadas em um dígito, aqui mapeamos todos os dígitos para si mesmos com d-> de, em seguida, todos os caracteres imprimíveis para 3com p-> 3. Os dígitos também estão entre os caracteres imprimíveis, mas a primeira transliteração vence.

Agora precisamos atribuir 0para controlar caracteres, mas não encontrei uma maneira válida de abordar explicitamente essa classe. Em vez disso, converteremos cada dígito em unário: os caracteres de controle não são dígitos e, portanto, são considerados como a sequência vazia, que é igual a 0unário. Infelizmente, o comando de conversão unário na retina é $*, que são dois símbolos próximos um do outro, portanto, converteremos "manualmente" usando substituições.

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

Nosso dígito unário é $n, que é um padrão de substituição para novas linhas. \bcorresponde a um "limite", onde uma palavra alfanumérica começa ou termina: no nosso caso, isso sempre corresponderá antes de qualquer número. Estamos basicamente substituindo cada número npor uma nova linha mais n-1.

\n

No final, contamos o número de novas linhas e obtemos o resultado desejado.

Cardinal 2240 2224 bytes

Modelo usado 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

O código tem uma nova linha à direita.

Como funciona:

Este código possui muitos caracteres que não são usados.
% libera um ponteiro em todas as direções. 3 deles atingiram o final de uma linha e morreram.
O último ponteiro recebe uma entrada no:
Esta entrada é comparada a cada valor de 0 a 127.

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

Operações usadas:
J = Pule a próxima operação se diferente de zero
^ = Altere a direção para cima
> = Altere a direção para a esquerda
- = Decremento
+ = Incremento
: = Aceite a entrada
% = Crie ponteiros no início do programa
x = Remova o ponteiro
0 = Defina ativo valor do ponteiro para 0

Experimente online

Perl 5 , 293 bytes

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

Fui avisado que os sinalizadores da linha de comando são gratuitos, mas os adicionei aqui para visibilidade, como o link TIO não inclui -0, para testes mais fáceis.

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

Experimente online!

Este é um desafio particularmente difícil de resolver em quase qualquer idioma, então estou muito feliz por ter conseguido (finalmente, mexer bastante durante algum tempo) fazer isso funcionar no Perl. Esperamos que o espaço em branco adicional antes e depois do número não seja um problema.

A seleção da ordem da sequência foi particularmente complicada, mas felizmente s///e y///pode aceitar qualquer outro caractere como delimitador, de modo que foi possível usar letra, espaço, número, símbolo, o que permite s 0...0...0;ey 0...0...0; .

A primeira coisa necessária para a abordagem foi substituir _por, !para que \wcorrespondesse apenas [0-9a-zA-Z], em seguida, substitua todo o espaço em branco ( \s) por \t, todos os dígitos com \re todos os caracteres restantes da palavra ( \w) por, \npara facilitar a correspondência posteriormente. Em seguida, usando o y///operador, todos os símbolos restantes são convertidos em caracteres de palavra !para _e todos os outros caracteres (entre 9e a) são deslocados para 9 lugares, transformando-os em letras ou números. Estes são então substituídos por \wcom 3e os outros substituições feitas anteriormente são substituídos por seus valores numerados.

Espaço em branco , 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! 

A ordem é 1234/ LNSW(letra, dígito, símbolo, espaço em branco).

Experimente on-line (insira como número inteiro representando o unicode de um caractere).

Explicação:

Espaço em branco é uma linguagem baseada em pilha onde todos os caracteres, exceto espaços, tabulações e novas linhas, são ignorados. Aqui está o mesmo programa sem o 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]

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online.

Programa em pseudo-có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)