A parte simples: dada uma sequência de entrada contendo apenas caracteres ASCII imprimíveis (espaço - til), conte o número de ocorrências de cada caractere e retorne o resultado em qualquer formato conveniente. O resultado para uma string a%hda7adeve ser algo como: a:3, %:1, h:1, 7:1, d:1. A classificação é desnecessária, os delimitadores e os formatos são opcionais, mas deve ser facilmente entendido qual número corresponde a qual caractere. Você não deve incluir caracteres que não estejam na sequência de entrada ( a:3, b:0, c:0, d:1, ...não está correto).

O verdadeiro desafio:

Converta todos os caracteres do seu código em um número binário de 8 bits (ou 16 bits se você estiver usando UTF-16 ou similar) e enumere todos os caracteres começando em 0.

Para cada caractere ( ié o enumerador), o i%7-bit ¹ deve ser 1. Os bits são numerados da direita. Todos os outros bits podem ser o que você quiser.

Vamos usar o seguinte código como exemplo:

[f]-xif)#f

Convertendo isso para binário, obtemos a matriz abaixo. O primeiro número (representando [tem um 1na posição 0, de modo que um esteja OK. O segundo número (representando fpossui um 1na posição 1, de modo que também esteja bem. Continue assim, e você verá que o código acima é válido.

C 76543210 Número do 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 mudarmos o código para: ]f[-xif)#fobteremos o seguinte início da sequência:

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

Como vemos, o terceiro caractere [não possui um 1na 2ª posição (indexado a zero) e, portanto, esse código não é válido.

Casos de teste:

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

Qualquer formato de saída razoável está OK (o que for mais conveniente para você). Você poderia, por exemplo, ter: :7, !:1, ":2, #:3, &:1, /:1, T:1, a:2 ...ou [ ,7][!,1][",2][#,3][&,1].... A saída é feita de qualquer maneira padrão (retorno da função, impresso em STDOUT etc.)

¹i módulo 7.

Isso é código-golfe , então o código mais curto em bytes ganhará ^ref .

Pyke, 1 6 bytes

1cn;1c

Experimente aqui!

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

Metade deste código é apenas no-ops ...

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

Pitão, 12 8 7 bytes

^{-1 byte graças 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

representação binária

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

Experimente aqui

Befunge-93, 150 bytes

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

Experimente online!

Comecei escrevendo isso como um programa regular da Befunge, que jogava golfe o máximo possível. Adicionei preenchimento para garantir que os vários caracteres do programa aparecessem apenas nas posições permitidas. Esse preenchimento contava com o fato de os comandos não suportados serem ignorados no Befunge-93, então eu só precisava de uma sequência de caracteres não utilizados cujos bits estavam alinhados com as posições necessárias (a sequência que usei foi ={}{}{}).

O complicado foi que os vários ramos entre as linhas precisavam alinhar corretamente (por exemplo, a vseta em uma linha, precisaria alinhar com a <seta abaixo). Isso foi ainda mais complicado pelo fato de o comando bridge ( #) não poder ser separado da seta ramificada adjacente. Inicialmente, tentei gerar o preenchimento programaticamente, mas no final foi principalmente um processo manual.

Devido ao tamanho do programa, não vou listar a análise completa dos caracteres, mas esta é uma amostra do começo e do fim:

= 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

As quebras de linha são tratadas como caracteres de nova linha; portanto, elas estarão na posição 1 ou 3.

MATL , 17 bytes

u"G91x@=zD91x@uRD

Exibe a contagem e o caractere correspondente, todos separados por nova linha. Maior dificuldade é a @que é 0b01000000; Espero encontrar uma maneira de sobreviver sem isso.

Experimente online!

Explicação:

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 bytes (saída questionável)

Se apenas deixar dois vetores de linha na pilha for permitido (comportamento de função conforme este post do Meta), podemos descer para

u"G91x@=zv]v!Gu

Mas aqui, a saída não é tão bem ordenada.

CJam, 14 bytes

q__|_ @sfe=]zp

Experimente aqui.

O espaço antes @e o sdepois são caracteres de preenchimento inseridos para fazer com que os códigos ASCII se ajustem ao padrão exigido: o espaço não faz nada e sapenas converte uma string em uma string. Fora isso, esta é uma implementação bastante simples e direta da tarefa de desafio:

q_ "leia a entrada e faça uma cópia dela";
  _ "recolher caracteres repetidos na cópia";
    _ "salve uma cópia da string recolhida";
      @ "puxe a string de entrada original para o topo da pilha";
       s "(não faz nada aqui)";
        fe = "para cada caractere na sequência recolhida, conte o ...";
                 "... número de vezes que ocorre na string original";
           ] z "emparelhe as contagens com a cópia salva da string recolhida";
             p "imprime a representação em string do resultado";

Para a entrada foobar123, esse código gera [['f 1] ['o 2] ['b 1] ['a 1] ['r 1] ['1 2] ['2 2] ['3 1]]. Se simplesmente imprimir as contagens em uma linha e os caracteres correspondentes em outra, como em:

[1 2 1 1 1 2 2 1]
fobar123

for considerado um formato de saída aceitável, ]zpoderá ser omitido para salvar dois bytes, totalizando 12 bytes . Sim, o código reduzido ainda passará no requisito de padrão de bits.

Ps. Também escrevi um verificador de código-fonte simples para esse desafio. Dada uma linha de código como entrada, ela primeiro fará eco dessa linha e depois imprimirá a mesma linha com cada caractere substituído pelo seu ( n % 7) -simo bit ASCII. Se a segunda linha for uma só, a entrada é válida.

Jelly , 6 bytes na página de código de Jelly

ṢZṢṀŒr

Experimente online!

Esta é uma função que retorna uma lista de pares (caracteres, contagem). (Jelly representa essas listas como texto, por exemplo, se eles são enviados para a saída padrão, concatenando os elementos, e é por isso que você tem que tratar isso como uma função em vez de um programa completo. ( Aqui está o mesmo programa com algum código anexado a chame a função e imprima a estrutura interna na saída padrão, provando que a saída está em um formato inequívoco.)

Representação e explicação binária:

  76543210 

1011011 1    Classifique os caracteres da entrada
Z 010110 1 0 Transponha a lista (é 1D, portanto, ela a efetivamente em uma lista)
10110 1 11 Classifique a lista (no-op, pois possui apenas um elemento)
1100 1 000 Pegue o elemento maior (ou seja, apenas)
000 1 0011 Primeiro byte de um comando de dois bytes
r 01 1 10010 Código de execução

Pode-se ver que o segundo, terceiro e quarto caracteres se cancelam e estão lá apenas para manter o padrão de bits que precisamos. Œré muito conveniente, porém, e o preenchimento do programa para que possamos usá-lo provavelmente nos oferece um programa mais curto do que tentar resolver o problema sem o embutido.