36

Ci sono 97 caratteri ASCII che le persone incontrano regolarmente. Si dividono in quattro categorie:

Lettere (52 in totale)

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Numeri o cifre (10 in totale)
```
0123456789
```
Simboli e punteggiatura (32 in totale)
```
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
```
Spazio bianco (3 in totale)

Spazio , tabulazione \te newline \n. (Tratteremo le varianti di newline \r\ncome un solo personaggio.)

Per concisione, chiameremo queste categorie L, N, S e W rispettivamente.

Scegli una delle 24 permutazioni delle lettere LNSWche desideri e ripeterla indefinitamente per formare un modello di programmazione per te stesso.

Ad esempio, potresti scegliere la permutazione NLWS, quindi il tuo modello di programmazione sarebbe:

NLWSNLWSNLWSNLWSNLWS...

Devi scrivere un programma o una funzione basati su questo modello, dove:

Ogni Lviene sostituito con qualsiasi lettera ( ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz).
Ogni Nviene sostituito con qualsiasi numero ( 0123456789).
Ogni Sviene sostituito con qualsiasi simbolo ( !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~).
Ognuno Wè sostituito da qualsiasi carattere di spazio bianco ( \t\n).

Fondamentalmente, il tuo codice deve seguire il modello

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

come suggerisce il titolo della domanda, salvo che tu possa scegliere un diverso ordinamento delle quattro categorie di caratteri, se lo desideri.

Nota che:

Le sostituzioni per una categoria possono essere caratteri diversi. ad esempio, si 9a ^8B\t~7c\n]conforma validamente al modello NLWSNLWSNLWS( \te \nsarebbero i loro caratteri letterali).
Non ci sono restrizioni sulla lunghezza del codice. ad es. 1A +2B -e 1A +2Be 1A e 1tutti conformi al modello NLWSNLWSNLWS....

Ciò che deve fare il codice conforme al modello è prendere un carattere ASCII non esteso e generare un numero compreso tra 0 e 4 in base alla categoria di cui è membro nella categoria precedente. Cioè, output 1se l'input è una lettera, 2se un numero, 3se un simbolo e 4se lo spazio bianco. Uscita 0se l'input è nessuno di questi (un carattere di controllo ).

Per l'input, puoi in alternativa prendere un numero compreso tra 0 e 127 compreso che rappresenta il codice del carattere ASCII di input.

Le coppie di input (come codice char) e output che il codice deve avere sono esattamente le seguenti:

Gli input 11, 12 e 13 corrispondono a caratteri che a volte sono considerati spazi bianchi, quindi i loro output possono essere 0o 4come desideri.

Vince il codice più breve in byte.

— Hobby di Calvin
fonte

5

Cookie per la prima risposta in una lingua 2d.

— Calvin's Hobbies,

2

Quindi usa BF e usa le lettere SSSS

— Christopher,

2

Ciò ha sostanzialmente escluso tutti i linguaggi di programmazione convenzionali 🙄 Inoltre, cosa fare con i linguaggi che utilizzano una propria tabella codici, ad esempio Jelly?

— kennytm,

1

Altri personaggi non sono ammessi.

— Calvin's Hobbies,

2

Unario vincerà!

— Christopher,

38

Haskell 300 byte

Questo codice non dovrebbe avere una nuova riga finale. La funzione m1accetta l'input come a Chare restituisce la risposta come 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 "

Non potevo resistere a una sfida che qualcuno sosteneva fosse impossibile per le lingue "convenzionali".

Puoi contestare se Haskell conta, ma la maggior parte delle parole chiave e degli identificatori sono più caratteri e non possono essere utilizzati. Tuttavia, le definizioni delle funzioni di livello superiore, gli elenchi, i letterali di stringa, i confronti rigorosi, la corrispondenza dei modelli e la ramificazione con le protezioni funzionano, purché le lettere arrivino appena prima delle cifre e se i simboli arrivano anche prima delle lettere, abbiamo caratteri di escape come \te \r. Sfortunatamente le permutazioni che funzionano per la programmazione generale non consentono valori letterali numerici, quindi non ho potuto ottenere numeri in alcun modo utile.

Come funziona:

Gli intervalli delle classi di caratteri sono codificati nella stringa sull'ultima riga, con i caratteri di confine nella maggior parte dei punti dei simboli e i risultati nella maggior parte dei punti delle cifre, sebbene alcune estremità siano riempite.
La funzione principale è m1.
x1 è il personaggio che viene analizzato.
La f1funzione interrompe la stringa con la corrispondenza del modello di elenco e ha tre rami: per quando i confini sono simboli più grandi dello spazio, per quando i confini sono sfuggiti controllano caratteri più piccoli dello spazio e per gestire il confronto finale con lo spazio stesso. I nomi delle parti dell'elenco sono mnemonici per il primo ramo: Lettera, Numero, sPace, sYmbol, Remainder.
La b1funzione gestisce la ramificazione per due caratteri s1 < b1al contorno per volta.

Provalo online

— Ørjan Johansen
fonte

1

Benvenuti nel sito! La mia ipotesi è che questo sarà più breve della maggior parte delle lingue non convenzionali che possono effettivamente ottenere il risultato richiesto.

— Jonathan Allan,

Rispondi! Ho provato a usare Haskell ma dopo un po '

— ho rinunciato

14

Retina , 113 byte

Lettera, Numero, Spazio, Simbolo, Ripeti

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

Provalo online!

Provalo su se stesso!

Retina sembra uno strumento utile per questo lavoro: possiamo usare tutti i tipi di personaggi in modo flessibile nella configurazione dello stage e abbiamo alcune classi di caratteri predefinite che possono essere utili.

Penso che questo problema potrebbe essere risolto con le fasi di sostituzione o di traslitterazione; Ho scelto le traslitterazioni perché sono più flessibili e hanno le classi di caratteri più utili. Per quanto riguarda il modello della fonte, sono stato costretto a mettere i simboli proprio prima delle lettere per usarli \nper le newline (in realtà avevo una soluzione più breve usando il più pratico ¶ per le newline, ma i caratteri non ascii sono vietati).

Spiegazione

Le prime fasi sono traslitterazioni. Usiamo +e 1come opzioni per mantenere attivo lo schema ma non influenzeranno il risultato del palcoscenico. La sintassi è T`from`todi mappare ciascun personaggio fromal personaggio nella stessa posizione in to. Se toè più corto di from, il suo carattere finale viene ripetuto quanto basta. Se fromha caratteri ripetuti, viene considerata solo la prima occorrenza di ciascuno. Alcune lettere corrispondono a classi di caratteri, ad esempio dè equivalente a 0123456789.

T1 `a0 @a0 `b   :D0

Con questo mappiamo alcuni personaggi ad altri personaggi della stessa classe per "fare spazio" per le seguenti traslitterazioni. ( a-> b, 0-> 1, space-> tab, @-> ;). La finale :D0è solo una faccina: D0

+T1 `d9 `a2

Iniziamo con le cifre, dè la classe di caratteri 0-9, qui stiamo trasformando 0-> a, 1-9-> 2, space-> 2: le traslitterazioni per 0e spacesono sbagliate, ma quei caratteri sono stati eliminati dalla precedente traslitterazione.

+T1 `a9 \n9 `a4

Lo spazio bianco, trasformare a-> a, ( 9, tab, \n, space) -> 4. 9era già stato rimosso nella fase precedente.

+T1 `l9 @L9 `a1

Lettere, qui usiamo due diverse classi di caratteri (per mancanza di una più completa): lper lettere minuscole e Llettere maiuscole. Vengono tutti mappati 1, insieme ad alcuni altri personaggi che sono stati trattati nelle fasi precedenti

+T1 `d9 @p9 `d3

Simboli. Poiché ogni altra classe è stata trasformata in una cifra, qui mappiamo tutte le cifre a se stesse con d-> d, quindi tutti i caratteri stampabili a 3con p-> 3. Anche le cifre sono tra i caratteri stampabili, ma vince la prima traslitterazione.

Ora dobbiamo assegnare 0per controllare i personaggi, ma non ho trovato alcun modo valido per indirizzare esplicitamente quella classe. Invece, convertiremo ogni cifra in unaria: i caratteri di controllo non sono cifre e quindi sono considerati come stringa vuota, che equivale 0a unaria. Sfortunatamente, il comando di conversione unaria in retina è $*, che sono due simboli uno accanto all'altro, quindi convertiremo invece "manualmente" usando le sostituzioni.

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

La nostra cifra unaria è $n, che è un modello sostitutivo per le nuove linee. \bcorrisponde a un "confine", dove inizia o finisce una parola alfanumerica: nel nostro caso questa corrisponderà sempre prima di qualsiasi numero. Sostanzialmente stiamo sostituendo ogni numero ncon un plus di nuova riga n-1.

\n

Alla fine, contiamo il numero di nuove righe e otteniamo il risultato desiderato.

— Leo
fonte

11

Cardinale 2240 2224 byte

Modello utilizzato 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

Il codice ha una nuova riga finale.

Come funziona:

Questo codice contiene molti caratteri che non vengono utilizzati.
% rilascia un puntatore in tutte le direzioni. 3 di loro hanno appena raggiunto la fine di una linea e muoiono.
L'ultimo puntatore accetta un input in:
Questo input viene quindi confrontato con ciascun valore compreso tra 0 e 127.

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

Operazioni utilizzate:
J = Salta operazione successiva se diversa da zero
^ = Cambia direzione verso l'alto
> = Cambia direzione verso sinistra
- = Decremento
+ = Incremento
: = Accetta input
% = Crea puntatori all'inizio del programma
x = Rimuovi puntatore
0 = Imposta attivo valore del puntatore su 0

Provalo online

— fənɛtɪk
fonte

7

Perl 5 , 293 byte

291 byte codice + 2 per -0p.

Mi è stato consigliato che i flag della riga di comando sono gratuiti, ma li ho aggiunti qui per la visibilità, poiché il collegamento TIO non include -0, per test più facili.

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

Provalo online!

Questa è una sfida particolarmente complicata da risolvere in quasi tutte le lingue, quindi sono abbastanza felice di essere riuscito (finalmente, un sacco di armeggi e spegnimenti per un po 'di tempo) a farlo funzionare in Perl. Eventualmente lo spazio bianco aggiuntivo prima e dopo il numero non è un problema.

La selezione dell'ordine delle sequenze è stata particolarmente complicata, ma in modo univoco s///e y///può accettare qualsiasi altro carattere come delimitatore, quindi è stato possibile utilizzare lettere, spazi, numeri, simboli, che consente s 0...0...0;ey 0...0...0; .

La prima cosa richiesta per l'appraoch era sostituire _con in !modo che \wcorrispondesse solo [0-9a-zA-Z], quindi sostituire tutto lo spazio bianco ( \s) con \t, tutte le cifre con \re tutti i caratteri di parole rimanenti ( \w) con \nper una facile corrispondenza in seguito. Quindi, utilizzando l' y///operatore, tutti i simboli rimanenti vengono convertiti in caratteri di parole !in _e tutti gli altri caratteri (tra 9e a) vengono spostati in basso di 9 posizioni, trasformandoli in lettere o numeri. Queste vengono quindi sostituite \wcon 3e le sostituzioni effettuate in precedenza vengono sostituite con i loro valori numerati.

— Dom Hastings
fonte

1

Spazio bianco , 1332 byte

Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0! Y0!
Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0! Y0! Y0!
Y0! Y0! Y0! Y0! Y0! Y0!
Y0! Y0!
Y0! Y0! Y0!
Y0!
Y0!
Y0!
Y0! Y0! Y0! Y0!
Y0! Y0! 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'ordine è 1234/ LNSW(lettera, cifra, simbolo, spazio).

Provalo online (inserisci come numero intero che rappresenta l'unicode di un personaggio).

Spiegazione:

Lo spazio bianco è un linguaggio basato su stack in cui vengono ignorati tutti i caratteri tranne spazi, tabulazioni e nuove righe. Ecco lo stesso programma senza YO!( 333 byte ):

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

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online.

Programma in pseudo-codice:

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)

— Kevin Cruijssen
fonte

Lettera, Numero, Simbolo, Spazio, Ripeti

Haskell 300 byte

Come funziona:

Retina , 113 byte

Spiegazione

Cardinale 2240 2224 byte

Come funziona:

Perl 5 , 293 byte

Spazio bianco , 1332 byte