La partie simple: étant donné une chaîne d'entrée contenant uniquement des caractères ASCII imprimables (espace - tilde), comptez le nombre d'occurrences de chaque caractère et retournez le résultat dans n'importe quel format pratique. Le résultat d'une chaîne a%hda7adoit être quelque chose comme: a:3, %:1, h:1, 7:1, d:1. Le tri n'est pas nécessaire, les délimiteurs et les formats sont facultatifs mais il faut comprendre facilement quel numéro correspond à quel caractère. Vous ne devez pas inclure de caractères qui ne sont pas dans la chaîne d'entrée ( a:3, b:0, c:0, d:1, ...n'est pas OK).

Le vrai défi:

Convertissez chaque caractère de votre code en un nombre binaire 8 bits (ou 16 bits si vous utilisez UTF-16 ou similaire) et énumérez chaque caractère à partir de 0.

Pour chaque caractère ( iest l'énumérateur), le i%7-bit ¹ doit être 1. Les bits sont numérotés à droite. Tous les autres bits peuvent être ce que vous voulez.

Prenons le code suivant comme exemple:

[f]-xif)#f

En convertissant cela en binaire, nous obtenons le tableau ci-dessous. Le premier nombre (représentant [a un 1dans la position 0, de sorte que l'un est OK. Le deuxième numéro (représentant fa un 1dans la position 1, de sorte que l'un est OK aussi. Continuez comme ceci, et vous verrez que le code ci-dessus est valide.

C 76543210 Numéro 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 nous changeons le code en: ]f[-xif)#fnous obtiendrons le début suivant de la séquence:

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

Comme nous le voyons, le troisième caractère [n'a pas 1de deuxième position (indexé zéro), et ce code n'est donc pas valide.

Cas de 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

Tout format de sortie raisonnable est OK (celui qui vous convient le mieux). Vous pourriez par exemple avoir: :7, !:1, ":2, #:3, &:1, /:1, T:1, a:2 ...ou [ ,7][!,1][",2][#,3][&,1].... La sortie se fait de n'importe quelle manière standard (retour de la fonction, imprimé sur STDOUT etc.)

¹i module 7.

Il s'agit de code-golf , donc le code le plus court en octets gagnera ^ref .

Pyke, 1 6 octets

1cn;1c

Essayez-le ici!

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

La moitié de ce code est juste sans opération ...

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

Pyth, 12 8 7 octets

^{-1 octet grâce à @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

représentation binaire

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

Essayez ici

Befunge-93, 150 octets

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

Essayez-le en ligne!

J'ai commencé par écrire cela comme un programme Befunge régulier, que j'ai joué autant que possible. J'ai ensuite ajouté un rembourrage pour m'assurer que les différents caractères du programme n'apparaissent qu'aux positions autorisées. Ce remplissage reposait sur le fait que les commandes non prises en charge sont ignorées dans Befunge-93, donc j'avais juste besoin d'une séquence de caractères inutilisés dont les bits étaient alignés avec les positions requises (la séquence que j'utilisais était ={}{}{}).

Le plus compliqué était que les différentes branches entre les lignes devaient s'aligner correctement (par exemple la vflèche sur une ligne, devrait s'aligner avec la <flèche en dessous). Cela était encore compliqué par le fait que la commande bridge ( #) ne pouvait pas être séparée de sa flèche de branchement adjacente. Au départ, j'ai essayé de générer le remplissage par programmation, mais à la fin, c'était surtout un processus manuel.

En raison de la taille du programme, je ne vais pas énumérer l'analyse complète des caractères, mais voici un échantillon du début et de la fin:

= 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

Les sauts de ligne sont traités comme des caractères de nouvelle ligne, ils seront donc en position 1 ou 3.

MATL , 17 octets

u"G91x@=zD91x@uRD

Affiche le nombre, puis le caractère correspondant, tous séparés par des sauts de ligne. La plus grande difficulté est celle @qui est 0b01000000; J'espère pouvoir trouver un moyen de m'en passer.

Essayez-le en ligne!

Explication:

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 octets (sortie discutable)

Si le simple fait de laisser deux vecteurs de ligne sur la pile est autorisé (comportement semblable à une fonction selon ce message Meta), nous pouvons passer à

u"G91x@=zv]v!Gu

Mais ici, la sortie n'est pas aussi bien ordonnée.

CJam, 14 octets

q__|_ @sfe=]zp

Essayez-le ici.

L'espace avant @et saprès ce sont des caractères de remplissage insérés pour que les codes ASCII correspondent au modèle requis: l'espace ne fait rien et sconvertit simplement une chaîne en chaîne. En dehors de cela, il s'agit d'une implémentation assez simple et directe de la tâche de défi:

q_ "lire l'entrée et en faire une copie";
  _ | "réduire les caractères répétés dans la copie";
    _ "enregistrer une copie de la chaîne réduite";
      @ "tirez la chaîne d'entrée d'origine vers le haut de la pile";
       s "(ne fait rien ici)";
        fe = "pour chaque caractère de la chaîne réduite, comptez le ...";
                 "... nombre de fois où cela se produit dans la chaîne d'origine";
           ] z "associe les nombres à la copie enregistrée de la chaîne réduite";
             p "afficher la représentation sous forme de chaîne du résultat";

Pour l'entrée foobar123, ce code sort [['f 1] ['o 2] ['b 1] ['a 1] ['r 1] ['1 2] ['2 2] ['3 1]]. Si vous imprimez simplement les comptes sur une ligne et les caractères correspondants sur une autre, comme dans:

[1 2 1 1 1 2 2 1]
fobar123

est considéré comme un format de sortie acceptable, le ]zpeut être omis pour enregistrer deux octets, pour un total de 12 octets . Oui, le code raccourci passera toujours l'exigence de modèle de bits.

Ps. J'ai également écrit un vérificateur de code source simple pour ce défi. Étant donné une ligne de code en entrée, il fera d'abord écho à cette ligne, puis imprimera la même ligne avec chaque caractère remplacé par son ( n % 7) -ème bit ASCII. Si la deuxième ligne est entièrement une, l'entrée est valide.

Jelly , 6 octets dans la page de codes de Jelly

ṢZṢṀŒr

Essayez-le en ligne!

Il s'agit d'une fonction qui renvoie une liste de paires (caractère, nombre). (Jelly représente de telles listes sous forme de texte, par exemple si elles sont envoyées vers une sortie standard, en concaténant les éléments, c'est pourquoi vous devez traiter cela comme une fonction plutôt que comme un programme complet. ( Voici le même programme avec du code ajouté à appeler la fonction, puis imprimer la structure interne sur la sortie standard, prouvant que la sortie est dans un format non ambigu.)

Représentation et explication binaires:

  76543210 

Ṣ 1011011 1    Triez les caractères de l'entrée
Z 010110 1 0 Transpose la liste (c'est 1D, donc cela l'enroule efficacement dans une liste)
Ṣ 10110 1 11 Trier la liste (un no-op, car il n'a qu'un seul élément)
Ṁ 1100 1 000 Prendre l'élément le plus grand (c'est-à-dire uniquement)
Œ 000 1 0011 Premier octet d'une commande à deux octets
r 01 1 10010 Codage à longueur de ligne

On peut voir que les deuxième, troisième et quatrième caractères s'annulent et ne sont là que pour maintenir la configuration binaire dont nous avons besoin. Œrest tout simplement trop pratique, cependant, et le remplissage du programme afin que nous puissions l'utiliser nous donne probablement un programme plus court que d'essayer de résoudre le problème sans le faire.