Il y a 97 caractères ASCII que les gens rencontrent régulièrement. Ils se répartissent en quatre catégories:

1. Lettres (52 au total)

   ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
   

2. Nombres ou chiffres (10 au total)

   0123456789
   

3. Symboles et ponctuation (32 au total)

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

4. Espaces blancs (3 au total)

   Espace , tabulation \tet nouvelle ligne \n. (Nous traiterons les variantes de nouvelle ligne comme \r\nun seul caractère.)

Par souci de concision, nous appelons ces catégories L, N, S et W respectivement.

Choisissez l’une des 24 permutations des lettres que LNSWvous désirez et répétez-la indéfiniment pour vous constituer un modèle de programmation.

Par exemple, vous pouvez choisir la permutation NLWSafin que votre modèle de programmation soit:

NLWSNLWSNLWSNLWSNLWS...

Vous devez écrire un programme ou une fonction basé sur ce modèle, où:

1. Chaque Lest remplacé par une lettre ( ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz).

2. Chaque Nest remplacé par un nombre ( 0123456789).

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

4. Chaque West remplacé par n'importe quel caractère d'espacement ( \t\n).

Fondamentalement, votre code doit suivre le modèle

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

comme le suggère le titre de la question, si vous le souhaitez, vous pouvez choisir un ordre différent pour les quatre catégories de caractères.

Notez que:

• Les remplacements pour une catégorie peuvent être différents caractères. Par exemple, 9a ^8B\t~7c\n]conforme conforme au modèle NLWSNLWSNLWS( \tet \nserait leurs caractères littéraux).

• Il n'y a pas de restrictions de longueur de code. Par exemple 1A +2B -, 1A +2Bet 1A et 1tous sont conformes au modèle NLWSNLWSNLWS....

Votre code conforme au modèle doit prendre un caractère ASCII non étendu et générer un nombre compris entre 0 et 4 en fonction de la catégorie dont il est membre dans la catégorisation ci-dessus. C'est-à-dire, sortie 1si l'entrée est une lettre, 2si un nombre, 3si un symbole et 4si un espace. Sortie 0si l'entrée est nulle (un caractère de contrôle ).

Pour la saisie, vous pouvez également utiliser un nombre compris entre 0 et 127 qui représente le code du caractère ASCII saisi.

Les paires d’entrée (en tant que code de caractère) et de sortie que votre code doit avoir sont précisément les suivantes:

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

Les entrées 11, 12 et 13 correspondent à des caractères qui sont parfois considérés comme des espaces, par conséquent leurs sorties peuvent être 0ou 4comme vous le souhaitez.

Le code le plus court en octets gagne.

Haskell 300 octets

Ce code ne devrait pas avoir de fin de ligne. La fonction m1prend l'entrée en tant que Charet renvoie la réponse en tant que 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 "

Je ne pouvais pas résister à un défi que quelqu'un a qualifié d'impossible pour les langues "conventionnelles".

Vous pouvez contester que Haskell compte, mais la majorité des mots-clés et des identificateurs sont constitués de plusieurs caractères et ne peuvent pas être utilisés. Toutefois, les définitions de fonctions de niveau supérieur, les listes, les littéraux de chaîne, les comparaisons strictes, la recherche de motifs et la création de branches avec des gardes fonctionnent aussi longtemps que les lettres se trouvent juste avant les chiffres, et si les symboles viennent également avant les lettres, nous avons des caractères d'échappement tels que \tet \r. Malheureusement, les permutations qui fonctionnent pour la programmation générale n'autorisant pas les littéraux numériques, je ne pouvais donc pas obtenir de chiffres de manière utile.

Comment ça marche:

• Les intervalles des classes de caractères sont codés dans la chaîne sur la dernière ligne, avec des caractères de délimitation à la plupart des emplacements de symbole et les résultats dans la plupart des emplacements de chiffres, bien que certains se terminent par un remplissage.
• La fonction principale est m1.
• x1 est le personnage en cours d'analyse.
• La f1fonction coupe la chaîne avec la correspondance du modèle de liste et comporte trois branches: pour lorsque les limites sont des symboles plus grands que l'espace, pour lorsque les limites sont échappées, des caractères de contrôle plus petits que l'espace et pour gérer la comparaison finale avec l'espace lui-même. Les noms des morceaux de la liste sont mnémoniques pour la première branche: Lettre, Nombre, Sommeil, Somme, Restant.
• La b1fonction gère la création de branches pour deux caractères de limite s1 < b1à la fois.

Essayez-le en ligne

Rétine , 113 octets

Lettre, Nombre, Espace, Symbole, Répéter

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

Essayez-le en ligne!

Testez-le sur lui-même!

Retina semble être un bon outil pour ce travail: nous pouvons utiliser tous les types de caractères de manière flexible dans la configuration de la scène et nous disposons de classes de caractères prédéfinies qui peuvent être utiles.

Je pense que ce problème pourrait être résolu avec les étapes de remplacement ou de translittération; J'ai choisi les translittérations car elles sont plus flexibles et possèdent les classes de caractères les plus utiles. En ce qui concerne le motif de la source, j’ai été obligé de placer les symboles juste avant les lettres pour pouvoir les utiliser \ndans les nouvelles lignes (j’avais en fait une solution plus courte utilisant le plus pratique ¶ pour les nouvelles lignes, mais les caractères non ascii sont interdits).

Explication

Les premières étapes sont des translittérations. Nous utilisons +et 1comme options pour maintenir le modèle, mais ils n’affecteront pas le résultat de la scène. La syntaxe consiste T`from`toà mapper chaque caractère de fromau caractère situé à la même position dans to. Si toest plus court que from, son caractère final est répété autant que nécessaire. Si fromcomporte des caractères répétés, seule la première occurrence de chacun est prise en compte. Certaines lettres correspondent à des classes de caractères, par exemple dest équivalent à 0123456789.

T1 `a0 @a0 `b   :D0

Avec cela, nous mappons des caractères sur d'autres caractères de la même classe afin de "faire de la place" pour suivre les translittérations. ( a-> b, 0-> 1, space-> tab, @-> ;). La finale :D0est juste un smiley: D0

+T1 `d9 `a2

Nous commençons par les chiffres, dc’est la classe de caractères 0-9, ici nous transformons 0-> a, 1-9-> 2, space-> 2: les translittérations pour 0et spacesont fausses, mais ces caractères ont été éliminés par la translittération précédente.

+T1 `a9 \n9 `a4

Les espaces blancs, transformer a-> a, ( 9, tab, \n, space) -> 4. 9était déjà enlevé à l'étape précédente.

+T1 `l9 @L9 `a1

Lettres, nous utilisons ici deux classes de caractères différentes (faute d’une classe plus complète): lles lettres minuscules et Lles lettres majuscules. Ils sont tous mis en correspondance 1avec d'autres personnages traités dans les étapes précédentes.

+T1 `d9 @p9 `d3

Symboles. Comme toutes les autres classes ont été converties en chiffres, nous mappons ici tous les chiffres avec d-> d, puis tous les caractères imprimables 3avec p-> 3. Les chiffres font également partie des caractères imprimables, mais la première translittération est gagnante.

Nous devons maintenant affecter 0des caractères de contrôle, mais je n’ai trouvé aucun moyen valide de s’adresser explicitement à cette classe. Au lieu de cela, nous convertirons chaque chiffre en unary: les caractères de contrôle ne sont pas des chiffres et sont donc considérés comme une chaîne vide, ce qui équivaut 0à unary. Malheureusement, la commande de conversion unaire dans Retina est $*, qui sont deux symboles proches l'un de l'autre. Nous allons donc convertir "manuellement" en utilisant des substitutions.

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

Notre chiffre unaire est $n, qui est un modèle de remplacement pour les nouvelles lignes. \bcorrespond à une "limite", où un mot alphanumérique commence ou se termine: dans notre cas, cela correspond toujours avant tout nombre. Nous remplaçons fondamentalement chaque numéro npar un Newline Plus n-1.

\n

Au final, nous comptons le nombre de nouvelles lignes et obtenons le résultat souhaité.

Cardinal 2240 2224 octets

Modèle utilisé 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

Le code a un retour à la ligne.

Comment ça marche:

Ce code a beaucoup de caractères qui ne sont pas utilisés.
% libère un pointeur dans toutes les directions. 3 d'entre eux viennent de frapper le bout d'une ligne et meurent.
Le dernier pointeur prend une entrée sur le:
Cette entrée est ensuite comparée à chaque valeur de 0 à 127.

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

Opérations utilisées:
J = Ignorer la prochaine opération si non nul
^ = Changer le sens de la marche
> = Changer le sens de la
main gauche - = Décrémenter
= = Incrémenter
= = Prendre la saisie
% = Créer des pointeurs au début du programme
x = Supprimer le pointeur
0 = Activer valeur du pointeur sur 0

Essayez-le en ligne

Perl 5 , 293 octets

291 octets code + 2 pour -0p.

On m'a informé que les indicateurs de ligne de commande étaient gratuits, mais je les ai ajoutés ici pour plus de visibilité, car le lien TIO ne comprend pas -0, pour faciliter les tests.

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

Essayez-le en ligne!

C'est un défi particulièrement difficile à résoudre dans presque toutes les langues. Je suis donc ravi d'avoir pu (enfin, bricoler et bricoler longtemps) pour que cela fonctionne en perl. Espérons que les espaces supplémentaires avant et après le nombre ne sont pas un problème.

La sélection de l'ordre de la séquence était particulièrement délicate, mais heureusement s///et y///peut accepter n'importe quel autre caractère comme délimiteur, il est donc possible d'utiliser une lettre, un espace, un nombre, un symbole, ce qui permet s 0...0...0;et y 0...0...0;.

La première chose nécessaire à l’approche consistait à remplacer _par «de !manière à ce \wqu’elle corresponde uniquement» [0-9a-zA-Z], puis à remplacer tous les espaces blancs ( \s) par \t, tous les chiffres \ret tous les caractères restants ( \w) par \ndes correspondances ultérieures. Puis, en utilisant l' y///opérateur, tous les symboles restants sont convertis en caractères de mot !à _et tous les autres caractères (entre 9et a) sont décalées vers le bas 9 places, les transformant en lettres ou des chiffres. Celles-ci sont ensuite remplacées via \wavec 3et les autres, les substitutions effectuées précédemment sont remplacées par leurs valeurs numérotées.

Espace blanc , 1332 octets

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

L'ordre est 1234/ LNSW(lettre, chiffre, symbole, espace).

Essayez-le en ligne (entrez sous forme d'entier représentant l'unicode d'un caractère).

Explication:

Les espaces sont un langage basé sur la pile où chaque caractère, à l'exception des espaces, des tabulations et des nouvelles lignes, est ignoré. Voici le même programme sans YO!( 333 octets ):

[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]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté comme explication seulement.

Essayez-le en ligne.

Programme en pseudo-code:

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)