La parte semplice: data una stringa di input contenente solo caratteri ASCII stampabili (spazio - tilde), conta il numero di occorrenze di ciascun carattere e restituisce il risultato in qualsiasi formato conveniente. Il risultato di una stringa a%hda7adovrebbe essere qualcosa del tipo: a:3, %:1, h:1, 7:1, d:1. L'ordinamento non è necessario, i delimitatori e i formati sono opzionali ma deve essere facilmente compreso quale numero corrisponde a quale carattere. Non includere caratteri che non si trovano nella stringa di input ( a:3, b:0, c:0, d:1, ...non è OK).

La vera sfida:

Converti tutti i caratteri nel tuo codice in un numero binario a 8 bit (o 16 bit se stai usando UTF-16 o simile), ed enumera ogni carattere a partire da 0.

Per ogni personaggio ( iè l'enumeratore), deve essere i%7-bit ¹ . I bit sono numerati da destra. Tutti gli altri bit possono essere quello che vuoi.1

Usiamo il seguente codice come esempio:

[f]-xif)#f

Convertendo questo in binario otteniamo l'array di seguito. Il primo numero (che rappresenta [ha a 1nella posizione 0, quindi uno va bene. Il secondo numero (che rappresenta fha una 1nella posizione 1, quindi anche uno va bene. Continua così, e vedrai che il codice sopra è valido.

C 76543210 Numero di bit
- -------- ----------
[0101101 1   0 - OK
f 011001 1 0 1 - OK
] 01011 1 01 2 - OK
- 0010 1 101 3 - OK
x 011 1 1000 4 - OK
i 01 1 01001 5 - OK
f 0 1 100110 6 - OK
) 0010100 1   0 - OK
# 001000 1 1 1 - OK
f 01100 1 10 2 - OK

Se cambiamo il codice in: ]f[-xif)#favremo il seguente inizio della sequenza:

C  76543210  Bit number
-  --------  ----------
]  01011101  0   <- OK
f  01100110  1   <- OK
[  01011011  2   <- Not OK
-  00101101  3   <- OK

Come vediamo, il terzo carattere [non ha un 1in 2a posizione (indicizzato a zero) e quindi questo codice non è valido.

Casi test:

Input:
This is a string containing some symbols: ".#!".#&/#

Output:
   !  "  #  &  /  :  T  a  b  c  e  g  h  i  l  m  n  o  r  s  t  y  .
7  1  2  3  1  1  1  1  2  1  1  1  2  1  5  1  2  4  3  1  6  2  1  2

Qualsiasi formato di output ragionevole è OK (qualunque sia il più conveniente per te). Ad esempio potresti avere: :7, !:1, ":2, #:3, &:1, /:1, T:1, a:2 ...o [ ,7][!,1][",2][#,3][&,1].... L'output è in qualsiasi modo standard (ritorno dalla funzione, stampato su STDOUT ecc.)

¹i modulo 7.

Questo è code-golf , quindi il codice più breve in byte vincerà ^ref .

Pyke, 1 6 byte

1cn;1c

Provalo qui!

1c     - chunk(size=1, input)
  n;1  - noop. 
     c - count(^)

La metà di questo codice è solo no-ops ...

00110001 - 1
01100011 - c
01101110 - n
00111011 - ;
00110001 - 1
01100011 - c

Pyth, 12 8 7 byte

^{-1 byte grazie a @Loovjo}

m+d/Qd{
      { # remove all duplicated elements from the (implicit) input
m       # map each element (d) of the parameter (the set from previous operation)
   /Qd  # count the occurrences of d in Q
 +d     # concatenate with d

rappresentazione binaria

0110110 1 m
001010 1 1 +
01100 1 00 d
0010 1 111 /
010 1 0001 Q
01 1 00100 d
0 1 111011 {

Prova qui

Befunge-93, 150 byte

={<{p+}3/}*77\%*7{7:\+{}{1g}+3/*77\%*7{7:}=:_{}{}={}{}{v#{}{}`x1:~
}-}=*}{2*}97}:<$}={$_v#}!:-*84g+3/*77\%*7{7:}=:}:}+}1{}<_{@#
}{}{}={}{}{}={^.},\={<

Provalo online!

Ho iniziato scrivendo questo come un normale programma Befunge, che ho giocato a golf il più possibile. Ho quindi aggiunto il padding per assicurarmi che i vari personaggi del programma apparissero solo nelle posizioni consentite. Questo riempimento si basava sul fatto che i comandi non supportati sono ignorati in Befunge-93, quindi avevo solo bisogno di una sequenza di caratteri inutilizzati i cui bit fossero allineati con le posizioni richieste (la sequenza che ho usato era ={}{}{}).

La parte complicata era che i vari rami tra le linee dovevano allinearsi correttamente (ad es. La vfreccia su una linea, avrebbe dovuto allinearsi con la <freccia sotto di essa). Ciò è stato ulteriormente complicato dal fatto che il comando bridge ( #) non poteva essere separato dalla sua freccia ramificata adiacente. Inizialmente ho provato a generare il riempimento in modo programmatico, ma alla fine si è trattato principalmente di un processo manuale.

A causa delle dimensioni del programma non ho intenzione di elencare l'analisi completa dei caratteri, ma questo è un esempio dall'inizio e dalla fine:

= 00111101 0
{ 01111011 1
< 00111100 2
{ 01111011 3
p 01110000 4
+ 00101011 5
} 01111101 6
3 00110011 0
/ 00101111 1
...
{ 01111011 1
^ 01011110 2
. 00101110 3
} 01111101 4
, 00101100 5
\ 01011100 6
= 00111101 0
{ 01111011 1
< 00111100 2

Le interruzioni di riga vengono trattate come caratteri di nuova riga, quindi saranno in posizione 1 o 3.

MATL , 17 byte

u"G91x@=zD91x@uRD

Visualizza il conteggio, quindi il carattere corrispondente, tutti separati da newline. La più grande difficoltà è quella @che è 0b01000000; Spero di poter trovare un modo per farne a meno.

Provalo online!

Spiegazione:

u"  % Implicit input. Take (u)nique characters and loop (") over them.
G   % Take the input a(G)ain
91x % Filler: push 91, delete immediately.
@   % Push current character of loop
=   % Check for equality with earlier G
z   % Count number of equal characters
D   % Display
91x % More filler!
@   % Get loop character again
uR  % Filler: two NOPs for the single-character @
D   % Display. Implicitly end loop.

MATL, 15 byte (output discutibile)

Se è consentito lasciare solo due vettori di riga nello stack (comportamento simile a una funzione come da questo post Meta), possiamo scendere a

u"G91x@=zv]v!Gu

Ma qui, l'output non è altrettanto ordinato.

CJam, 14 byte

q__|_ @sfe=]zp

Provalo qui.

Lo spazio prima di @e sdopo sono i caratteri di riempimento inseriti per far sì che i codici ASCII si adattino al modello richiesto: lo spazio non fa nulla e il sgiusto converte una stringa in una stringa. Oltre a ciò, questa è un'implementazione piuttosto semplice e diretta dell'attività di sfida:

q_ "leggi l'input e creane una copia";
  _ | "comprimi i caratteri ripetuti nella copia";
    _ "salva una copia della stringa compressa";
      @ "tira la stringa di input originale in cima allo stack";
       s "(non fa nulla qui)";
        fe = "per ogni carattere nella stringa compressa, conta il ...";
                 "... numero di volte che si verifica nella stringa originale";
           ] z "accoppia i conteggi con la copia salvata della stringa compressa";
             p "stampa la rappresentazione in forma di stringa del risultato";

Per l'input foobar123, questo codice emette [['f 1] ['o 2] ['b 1] ['a 1] ['r 1] ['1 2] ['2 2] ['3 1]]. Se si stampa semplicemente i conteggi su una riga e i caratteri corrispondenti su un'altra, come in:

[1 2 1 1 1 2 2 1]
fobar123

è considerato un formato di output accettabile, quindi ]zpuò essere omesso per salvare due byte, per un totale di 12 byte . Sì, il codice abbreviato passerà comunque il requisito del modello di bit.

Ps. Ho anche scritto un semplice controllo del codice sorgente per questa sfida. Data una riga di codice come input, prima riecheggerà quella riga e quindi stamperà la stessa riga con ogni carattere sostituito dal suo ( n % 7) -th bit ASCII. Se la seconda riga è tutta una, l'input è valido.

Jelly , 6 byte nella tabella codici di Jelly

ṢZṢṀŒr

Provalo online!

Questa è una funzione che restituisce un elenco di coppie (carattere, conteggio). (La gelatina rappresenta elenchi come testo, ad esempio se vengono inviati all'output standard, concatenando gli elementi, motivo per cui è necessario considerare questo come una funzione anziché come un programma completo. ( Ecco lo stesso programma con un codice aggiunto a chiama la funzione e quindi stampa la struttura interna sull'output standard, dimostrando che l'output è in un formato non ambiguo.)

Rappresentazione binaria e spiegazione:

  76543210 

Ṣ 1011011 1    Ordinare i caratteri dell'input
Z 010110 1 0 Trasponi l'elenco (è 1D, quindi questo lo avvolge efficacemente in un elenco)
Ṣ 10110 1 11 Ordina l'elenco (un no-op, in quanto ha un solo elemento)
Ṁ 1100 1 000 Prendi l'elemento più grande (cioè solo)
Π000 1 0011 Primo byte di un comando a due byte
r 01 1 10010 Codifica run-length

Si può vedere che il secondo, il terzo e il quarto carattere si annullano a vicenda e sono lì solo per mantenere lo schema di bit di cui abbiamo bisogno. Œrè semplicemente troppo conveniente, tuttavia, e riempire il programma in modo che possiamo usarlo probabilmente ci dà un programma più breve rispetto al tentativo di risolvere il problema senza il builtin.