La parte simple: dada una cadena de entrada que contiene solo caracteres ASCII imprimibles (espacio - tilde), cuente el número de ocurrencias de cada carácter y devuelva el resultado en cualquier formato conveniente. El resultado de una cadena a%hda7adebe ser algo como: a:3, %:1, h:1, 7:1, d:1. La clasificación es innecesaria, los delimitadores y formatos son opcionales, pero debe entenderse fácilmente qué número corresponde a qué carácter. No debe incluir caracteres que no estén en la cadena de entrada ( a:3, b:0, c:0, d:1, ...no está bien).

El verdadero desafío:

Convierta cada carácter en su código a un número binario de 8 bits (o 16 bits si está utilizando UTF-16 o similar), y enumere cada carácter comenzando en 0.

Para cada carácter ( ies el enumerador), el i%7-bit ¹ debe ser 1. Los bits están numerados desde la derecha. Todos los demás bits pueden ser lo que quieras.

Usemos el siguiente código como ejemplo:

[f]-xif)#f

Al convertir esto a binario, obtenemos la matriz a continuación. El primer número (que representa [tiene un a 1en la posición 0, por lo que uno está bien. El segundo número (que representa ftiene un 1en la posición 1, por lo que uno también está bien. Continúe así, y verá que el código anterior es válido

C 76543210 Número de 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

Si cambiamos el código a: ]f[-xif)#fobtendremos el siguiente inicio de la secuencia:

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

Como vemos, el tercer carácter [no tiene un 1en la segunda posición (indexado a cero) y, por lo tanto, este código no es válido.

Casos de prueba:

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

Cualquier formato de salida razonable está bien (lo que sea más conveniente para usted). Podría, por ejemplo, tener: :7, !:1, ":2, #:3, &:1, /:1, T:1, a:2 ...o [ ,7][!,1][",2][#,3][&,1].... La salida está en cualquier forma estándar (retorno de la función, impreso en STDOUT, etc.)

¹i módulo 7.

Este es el código de golf , por lo que el código más corto en bytes ganará ^ref .

Pyke, 1 6 bytes

1cn;1c

Pruébalo aquí!

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

La mitad de este código es simplemente sin operaciones ...

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

Pyth, 12 8 7 bytes

^{-1 byte gracias 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

representación 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 {

Intenta aquí

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{}<_{@#
}{}{}={}{}{}={^.},\={<

Pruébalo en línea!

Comencé escribiendo esto como un programa Befunge regular, que jugué al golf lo más posible. Luego agregué relleno para asegurarme de que los diversos caracteres del programa solo aparecieran en las posiciones permitidas. Este relleno se basó en el hecho de que los comandos no compatibles se ignoran en Befunge-93, por lo que solo necesitaba una secuencia de caracteres no utilizados cuyos bits se alineaban con las posiciones requeridas (la secuencia que usé fue ={}{}{}).

La parte complicada era que las diversas ramas entre líneas necesitaban alinearse correctamente (por ejemplo, la vflecha en una línea, necesitaría alinearse con la <flecha debajo de ella). Esto se complicó aún más por el hecho de que el comando bridge ( #) no podía separarse de su flecha de ramificación adyacente. Inicialmente intenté generar el relleno mediante programación, pero al final fue principalmente un proceso manual.

Debido al tamaño del programa, no voy a enumerar el análisis de caracteres completo, pero esta es una muestra desde el principio y el final:

= 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

Los saltos de línea se tratan como caracteres de nueva línea, por lo que estarán en la posición 1 o 3.

MATL , 17 bytes

u"G91x@=zD91x@uRD

Muestra el recuento, luego el carácter correspondiente, todos separados por una nueva línea. La mayor dificultad es la @que es 0b01000000; Espero poder encontrar una manera de hacerlo sin él.

Pruébalo en línea!

Explicación:

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 (salida cuestionable)

Si solo se permite dejar dos vectores de fila en la pila (comportamiento similar a una función según esta publicación de Meta), podemos llegar a

u"G91x@=zv]v!Gu

Pero aquí, la salida no está tan ordenada.

CJam, 14 bytes

q__|_ @sfe=]zp

Pruébalo aquí

El espacio antes @y sdespués de él son caracteres de relleno insertados para que los códigos ASCII se ajusten al patrón requerido: el espacio no hace nada, y el ssolo convierte una cadena en una cadena. Aparte de eso, esta es una implementación bastante simple y directa de la tarea de desafío:

q_ "lee la entrada y haz una copia de ella";
  _ | "contraer caracteres repetidos en la copia";
    _ "guardar una copia de la cadena contraída";
      @ "tire de la cadena de entrada original a la parte superior de la pila";
       s "(no hace nada aquí)";
        fe = "para cada carácter en la cadena contraída, cuente el ...";
                 "... número de veces que ocurre en la cadena original";
           ] z "emparejar los recuentos con la copia guardada de la cadena contraída";
             p "imprime la representación de cadena del resultado";

Para la entrada foobar123, este código sale [['f 1] ['o 2] ['b 1] ['a 1] ['r 1] ['1 2] ['2 2] ['3 1]]. Si simplemente imprime los recuentos en una línea y los caracteres correspondientes en otra, como en:

[1 2 1 1 1 2 2 1]
fobar123

se considera un formato de salida aceptable, entonces ]zse puede omitir para guardar dos bytes, para un total de 12 bytes . Sí, el código acortado aún pasará el requisito del patrón de bits.

PD. También escribí un simple verificador de código fuente para este desafío. Dada una línea de código como entrada, primero hará eco de esa línea y luego imprimirá la misma línea con cada carácter reemplazado por su ( n % 7) -ésimo bit ASCII. Si la segunda línea es todas, la entrada es válida.

Jelly , 6 bytes en la página de códigos de Jelly

ṢZṢṀŒr

Pruébalo en línea!

Esta es una función que devuelve una lista de pares (caracteres, recuento). (Jelly representa tales listas como texto, por ejemplo, si se envían a la salida estándar, concatenando los elementos, por lo que debe tratar esto como una función en lugar de un programa completo. ( Aquí está el mismo programa con algún código agregado a llame a la función y luego imprima la estructura interna a la salida estándar, demostrando que la salida está en un formato inequívoco).

Representación binaria y explicación:

  76543210 

10 1011011 1    Ordenar los caracteres de la entrada
Z 010110 1 0 Transponer la lista (es 1D, por lo que esto efectivamente lo envuelve en una lista)
10 10110 1 11 Ordenar la lista (no operativa , ya que solo tiene un elemento)
M 1,100 1 000 Tome el elemento más grande (es decir, sólo)1 
000 1 0011 Primer byte de un comando de dos bytes
r 01 1 10010 Codificación de longitud de ejecución

Se puede ver que los caracteres segundo, tercero y cuarto se cancelan entre sí y solo están allí para mantener el patrón de bits que necesitamos. ŒrSin embargo, es demasiado conveniente, y rellenar el programa para que podamos usarlo probablemente nos da un programa más corto que tratar de resolver el problema sin la solución incorporada.