Cette phrase utilise deux a, deux c, deux d, vingt-huit e, cinq f, trois g, huit h, onze i, trois l, deux m, deux m, treize n, neuf o, deux p, cinq r, vingt-cinq s, vingt-trois t, six v, dix w, deux x, cinq y et un z.

Ces phrases s'appellent des autogrammes . Votre tâche consiste à écrire un programme ou une fonction ayant une propriété similaire: il prend en entrée un octet et génère un entier représentant le nombre de fois que cet octet apparaît dans le code source du programme. Il devrait afficher 0 si son entrée n'apparaît pas dans sa source.

Votre programme ne doit pas lire son propre code source , directement ou indirectement, mais toutes les données dont il a besoin pour donner sa sortie doivent être codées en dur, style quine. Votre programme doit avoir au moins un octet de long.

C'est code-golf , donc l'entrée la plus courte (en octets) est gagnante. Je n'accepterai pas de réponse, alors n'hésitez pas à vous battre pour la solution la plus courte possible dans votre langue préférée.

Nous vous encourageons fortement à inclure une explication dans votre message.

Classements

Vous trouverez ci-dessous des classements pour le score global et par langue:

var QUESTION_ID=162408,OVERRIDE_USER=21034;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Octave , 44 octets

@(x)sum([[39,'(())*,239==@[[]]msuxx']]==x)*2

Essayez-le en ligne!

Le résultat de la fonction, lors de l'utilisation de chacun des caractères de la fonction en tant qu'entrée:

'  (  )  *  ,  2  3  9  =  @  [  ]  m  s  u  x  
2  4  4  2  2  2  2  2  4  2  4  4  2  2  2  4  

Tous les autres caractères saisis renvoient un zéro.

Le fait que je sois obligé de m'échapper 'a rallongé le processus. Afin de tenir compte des 4 parenthèses, je viens d'avoir un doublon dans la chaîne. Cependant, la duplication des apostrophes prend des apostrophes, donc cela nous éloigne du résultat correct. Par conséquent, je devais compter le nombre de ses apostrophes avec valeur ASCII, 39. Bien sûr, cela signifiait que je devais vérifier les caractères 3et 9aussi, ce qui prolongeait le processus beaucoup plus longtemps.

Excel, 84 octets

=IFERROR(MID("65496331125442343343233",FIND(A1,"""123456789,()=MINORFADEOMEN"),1),0)

Find()cherchera la valeur dans la cellule A1de la chaîne "123456789,()=MINORFADEOMEN( """la première chose à faire est d'échapper au caractère et sera évaluée comme si de rien n'était ").

En fonction du résultat de Find(), la Mid()fonction renverra le caractère correspondant dans la chaîne de nombres. Cette chaîne a été créée par itération jusqu'à ce qu'elle cesse de changer.

Si le caractère dans A1n'est pas trouvé, Find()retourne une erreur afin que la IfError()fonction lui échappe pour revenir à la 0place.

Les lettres OMENà la fin de la chaîne recherchée dans la Find()fonction sont des doublons. Par conséquent, leur position ne sera jamais renvoyée, mais elles étaient nécessaires pour ajuster le nombre de caractères. Sans eux, il y avait une boucle sans fin de comptes changeants. La disposition des lettres est un choix stylistique.

JavaScript (ES6), 70 octets

Ne lit pas la source de la fonction, mais c'est assez long. Prend l'entrée sous la forme d'une chaîne de 1 caractère.

i=>~(n='\\34=\'in(|)0257?:.>[]Odefx~'.indexOf(i))?'3733544333'[n]||2:0

Essayez-le en ligne!

Rétine , 1 octet

Cela ne serait pas valable si vous respectiez strictement les règles de quine, mais le PO le permettait explicitement dans un commentaire .

x

Essayez-le en ligne!

Dans Retina, un programme sur une seule ligne compte les occurrences de cette expression rationnelle dans l’entrée. Ce défi est résolu par un caractère ASCII unique sauf `, ., +, *, ?, [, (, ), ^, $, \et retour à la ligne.

C # (compilateur Visual C #) , 88 57 octets

x=>"\\\"(())==>>??..::3300CCaaiinoossttx".Contains(x)?3:0

Essayez-le en ligne!

Renvoie 3 si la chaîne contient le caractère transmis, sinon renvoie 0. La chaîne contient chaque caractère du code au moins une fois et exactement la quantité requise pour que le caractère 3 soit présent. fois dans le code.

-31 octets grâce à Kevin Cruijssen

Haskell , 66 octets

Les deux premières versions sont essentiellement une quine qui filtre les caractères requis puis prend la longueur:

q c=length.filter(==c)$id<>show$"q c=length.filter(==c)$id<>show$"

Essayez-le en ligne ou testez-le avec tous les personnages! ^*

Alternative sans (<>), 72 octets

q c=length.filter(==c)$(++)<*>show$"q c=length.filter(==c)$(++)<*>show$"

Essayez-le en ligne ou testez-le avec tous les personnages!

Alternative non quine, 87 86 octets

Peut-être sera-t-il encore amélioré, mais je suis heureux de l'avoir réduite à trois groupes différents.

J'aime celui-ci le meilleur, même s'il compte le plus d'octets. Il calcule le nombre de caractères / octets comme une somme de 2,3 et 7 (notez comment certains caractères sont dans plusieurs groupes):

u t=sum[fst e|e<-[(2," ()-237<=dflnst|"),(3," ()[\\]`mstu"),(7,"\",ee")],t`elem`snd e]

Essayez-le en ligne outestez-le avec tous les personnages!

^{* importations (<>)parce que la version GHC de TIO est 8.0.2}

Python 2 , 54 52 32 octets

^{-20 octets grâce aux ovs}

("''+.23cnotu()"*2+'"*'*3).count

Essayez-le en ligne!

Husk , 11 10 8 octets

Merci Leo pour -2 octets!

#sD"#sD"

Essayez-le en ligne!

Explication

Cela permet de s’assurer qu’il n’utilise que l’ASCII (car ce showserait gâché) et que chaque caractère est contenu deux fois:

#sD"#sD"  -- character as input, eg. '"'
   "#sD"  -- string literal (note the redundant '"'): "#sD"
  D       -- double: "#sD#sD"
 s        -- show: "\"#sD#sD\""
#         -- number of occurences: 2

Extension quine standard, 11 octets

#hS+s"#hS+s

Essayez-le en ligne!

Explication

#hS+s"#hS+s  -- character as input, eg. '"'
     "#hS+s  -- string literal: "#hS+s"
  S+         -- join with itself: ("#hS+s"++)
    s        -- | and itself shown: "\"#hS+s\""
             -- : "#hS+s\"#hS+s\""
 h           -- init: "#hS+s\"#hS+s"
#            -- number of occurences in string: 1

Java 10, 164 81 57 octets

q->"q-->>\\\"..ccoonttaaiiss(())??33::00".contains(q)?3:0

Port de Hyarus 'C # répond , assurez-vous donc de le revendre!

Explication:

Essayez-le en ligne.

q->      // Method with String parameter and integer return-type
  "q->\\\"..ccoonttaaiiss(())??33::00".contains(q)?
         //  If the string above contains the input character
   3     //   Return 3
  :      //  Else:
   0     //   Return 0

Ancien quine 164 octets réponse:

c->{var s="c->{var s=%c%s%1$c;return s.format(s,34,s).replaceAll(%1$c[^%1$c+c+']',%1$c%1$c).length();}";return s.format(s,34,s).replaceAll("[^"+c+']',"").length();}

Explication:

Essayez-le en ligne.

c->{                                  // Method with char parameter and integer return-type
  var s="c->{var s=%c%s%1$c;return s.format(s,34,s).replaceAll(%1$c[^%1$c+c+']',%1$c%1$c).length();}";
                                      //  Unformatted source code
  return s.format(s,34,s)             //  Create the formatted source code (the quine),
          .replaceAll("[^"+c+']',"")  //  remove all characters not equal to the input,
          .length();}                 //  and return the length

quine :

• La ficelle s contient le code source non formaté.
• %s est utilisé pour entrer cette chaîne en soi avec le s.format(...) .
• %c, %1$cEt34 sont utilisés pour formater les guillemets.
• s.format(s,34,s) met tout cela ensemble

Défi:

• .replaceAll("[^"+c+']',"") supprime tous les caractères sauf ceux égaux à l'entrée.
• .length() prend alors la longueur de cette chaîne.

NOTE: .split(c).length(avec Stringentrée au lieu dechar ) peut sembler plus court, mais a deux problèmes:

1. Le premier caractère donne un résultat incorrect. Par conséquent, si vous entrez c(avec la c->partie principale), il renverra incorrectement un caractère de trop peu. Cela peut être corrigé en ajoutant +(c==99?1:0)à la fois le code source et le code source non formaté. String (et en modifiant.split(c) en.split(c+"") , mais nous avons toujours le problème suivant:
2. Si un caractère regex (ie $) est entré, il .splitsera interprété comme une regex, donnant un résultat incorrect.

Haskell , 58 octets

f c=sum[2|x<-succ '!':"f c=sum[2|x<-succ '!':,x==c]",x==c]

Essayez-le en ligne! ou vérifier la solution .

Alternatives au même nombre d'octets:

f c=sum[2|x<-tail$show"f c=sum[2|x<-tail$show,x==c]",x==c]
f c=sum[1|x<-id<>show$"f c=sum[1|x<-id<>show$,x==c]",x==c]

Haskell , 90 octets

sum.($zip"1234\"$,.[\\]opu+()iklmsz652"$[4,4,11,3,3,3,16,5,3,3,3,3,3,3,3]++[2,2..]).lookup

Essayez-le en ligne! ou vérifier la solution . Utilise le fait que sum Nothing = 0et par exemple sum (Just 4) = 4.

Smalltalk , 112 132 octets

Smalltalk n'est pas connu pour son aptitude au golf :-)

Méthode définie dans la classe Character (testée dans VA Smalltalk et Squeak, devrait également fonctionner dans d'autres dialectes tels que VisualWorks et Pharo):

a^(0to:6),#(10 18)at:(#('' ',[]^|+68cForu' '#0adefln' '1it' '()' ':s' ' ' '''')findFirst:[:s|s includes:self])+1

Les caractères apparaissant dans la source sont regroupés par nombre d'occurrences. Les groupes sont testés pour le premier qui contient le destinataire et le nombre d'occurrences correspondant est renvoyé.

Ancienne méthode:

a^('''''((((())))):::[[[[]]]]^^^^^0000066666aaaacccccdddddeefffFFFFFiiilllnnnnnrrrrrsssTTTTTuuuu'includes:self)ifTrue:[6]ifFalse:[0]

Chaque caractère qui apparaît dans la méthode apparaît exactement 6 fois (en étant répété dans la constante chaîne), ainsi la méthode vérifie simplement si le destinataire est contenu dans la chaîne et renvoie 6 si c'est le cas, 0 sinon.

Après avoir défini la méthode comme ci-dessus, vous pouvez la valider à l'aide de

| code |
code := Character sourceCodeAt: #a.
((0 to: 255) collect: [:b | b asCharacter]) reject: [:c | c a = (code occurrencesOf: c)]

Le résultat devrait être vide.

JavaScript, 31 octets

f=c=>~-`f=${f}`.split(c).length

Essayez-le en ligne

Python 2 , 57 octets

lambda c,s='lambda c,s=%r:(s%%s).count(c)':(s%s).count(c)

Essayez-le en ligne!

05AB1E , 17 octets

2"D34çýs¢"D34çýs¢

Essayez-le en ligne!

Haskell , 96 octets

n"n"=15;n"="=14;n" "=2;n";"=13;n"\\"=3;n"\""=25;n"0"=2;n"1"=4;n"2"=4;n"3"=4;n"4"=5;n"5"=5;n n3=0

Essayez-le en ligne!

Haskell , 109 octets

n 'n'=15;n '='=14;n ' '=14;n ';'=13;n '\\'=3;n '\''=25;n '0'=2;n '1'=5;n '2'=4;n '3'=4;n '4'=5;n '5'=5;n n3=0

Essayez-le en ligne!

Haskell , 122 octets

n 'n'=21
n '='=14
n ' '=14
n '\n'=12
n '\\'=4
n '\''=32
n '0'=2
n '1'=5
n '2'=5
n '3'=3
n '4'=5
n '5'=5
n nnnnnn4'''''''=0

Essayez-le en ligne!

Des explications

Ces réponses ne sont pas très sophistiquées. C'est une série de déclarations, une pour chaque caractère présent dans le programme. À la fin, nous avons un catch all qui renvoie 0 pour les caractères non présents dans le programme.

J'utilise quelques astuces pour minimiser le nombre de caractères nécessaires dans le programme. À partir de là, j'ai bricolé avec des trucs jusqu'à ce que les chiffres soient corrects. Vous pouvez voir que j'ai ajouté le nom de la variable dans la dernière déclaration, dans les trois. La différence entre les 3 programmes est de savoir si j'ai choisi d'utiliser une nouvelle ligne ou ;des sauts de ligne et si j'ai choisi de prendre les caractères en entrée ou en chaînes. L' ;approche ne semble pas intrinsèquement supérieure aux autres, elle a simplement de la chance et est plus courte. Cependant, il semble que l'utilisation de chaînes soit une meilleure idée que les caractères car les caractères nécessitent des espaces après le nom de la fonction et non les chaînes.

Espaces blancs , 140 octets

[S S S N
_Push_0][S N
S _Duplicate][S N
S _Duplicate][T N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S S S T  S S T   N
_Push_9][T  S S T   _Subtract][S N
S _Duplicate][N
T   S S T   N
_If_0_Jump_to_Label_TAB][S S S T    N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][N
T   S S N
_If_0_Jump_to_Label_NEWLINE][S S S T    S T T   S N
_Push_22][T S S T   _Subtract][N
T   S T N
_If_0_Jump_to_Label_SPACE][N
S T N
_Jump_to_Label_PRINT][N
S S S T N
_Create_Label_TAB][S S S T  S S T   S T N
_Push_37][N
S T N
_Jump_to_Label_PRINT][N
S S S N
_Create_Label_NEWLINE][S S S T  S S S S T   N
_Push_33][N
S T N
_Jump_to_Label_PRINT][N
S S T   N
_Create_Label_SPACE][S S S T    S S S T T   S N
_Push_70][N
S S N
_Create_Label_PRINT][T  N
S T _Print_as_integer]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté comme explication seulement.

70 espaces, 37 tabulations et 33 nouvelles lignes utilisées.

En général , j'utilise le créer des étiquettes dans l'ordre NSSN, NSSSN, NSSTN, NSSSSN, NSSSTN, NSSTSN,NSSTTN , etc. Mais parce que l' impression d' un numéro où le binaire S=0/ T=1est utilisé affecte le nombre que j'ai besoin à la sortie, j'ai utilisé les étiquettes NSSN,NSSSN , NSSTNet au NSSSTNlieu, qui a donné la quantité parfaite d'espaces / onglets à imprimer avec les nombres binaires SSSTSSSSTN(33; quantité de nouvelles lignes), SSSTSSTSTN(37; quantité d'onglets), etSSSTSSSTTSN (70; quantité d'espaces).

Explication en pseudo-code:

Character c = STDIN-input as character
If c is a tab:
  Print 37
Else if c is a new-line:
  Print 33
Else if c is a space:
  Print 70
Else
  Print 0

Exemple fonctionne:

Entrée: espace

Command       Explanation                   Stack       Heap     STDIN   STDOUT   STDERR

SSSN          Push 0                        [0]
SNS           Duplicate top (0)             [0,0]
SNS           Duplicate top (0)             [0,0,0]
TNTS          Read STDIN as character       [0,0]       {0:32}   \n
TTT           Retrieve                      [0,32]      {0:32}
SSSTSSTN      Push 9                        [0,32,9]    {0:32}
TSST          Subtract top two (32-9)       [0,23]      {0:32}
SNS           Duplicate top (23)            [0,23,23]   {0:32}
NTSSTN        If 0: Jump to Label_TAB       [0,23]      {0:32}
SSSTN         Push 1                        [0,23,1]    {0:32}
TSST          Subtract top two (23-1)       [0,22]      {0:32}
SNS           Duplicate top (22)            [0,22,22]   {0:32}
NTSSN         If 0: Jump to Label_NEWLINE   [0,22]      {0:32}
SSSTSTTSN     Push 22                       [0,22,22]   {0:32}
TSST          Subtract top two (22-22)      [0,0]       {0:32}
NTSTN         If 0: Jump to Label_SPACE     [0]         {0:32}
NSSTN         Create Label_SPACE            [0]         {0:32}
SSSTSSSTTSN   Push 70                       [0,70]      {0:32}
NSTN          Jump to Label_PRINT           [0,70]      {0:32}
NSSN          Create Label_PRINT            [0,70]      {0:32}
TNST          Print as integer              [0]         {0:32}            70
                                                                                  error

Le programme s’arrête avec une erreur: Aucune sortie définie.
Essayez-le en ligne (avec des espaces bruts, des onglets et des nouvelles lignes uniquement).

Entrée: onglet

STDIN sera à la place \t( 9), auquel cas ce sera 0lors de la première If 0vérification, passe àLABEL_TAB / NSSSTN, et poussera et imprimera37 place.

Essayez-le en ligne (avec des espaces bruts, des onglets et des nouvelles lignes uniquement).

Entrée: nouvelle ligne

STDIN sera à la place \n( 10), auquel cas ce sera 0à la deuxième If 0vérification, ira à Label_NEWLINE/ NSSSN, et poussera et imprimera33 place.

Essayez-le en ligne (avec des espaces bruts, des onglets et des nouvelles lignes uniquement).

Entrée: autre chose

Tout autre caractère d’entrée suffira NSTN(Passez à Label_PRINT) après le troisième If 0contrôle en imprimant0 qui était encore sur la pile (que nous avons dupliqué au tout début).

Essayez-le en ligne (avec des espaces bruts, des onglets et des nouvelles lignes uniquement).

Japt , 27 octets

\Ua"" a a a " ÄU\\\"a "aU Ä
            " ÄU\\\"a "     // Given this string literal,
                       aU   // find the last index of the input
                          Ä // and add +1.
\Ua"" a a a                 // Do nothing useful, but make the results match.

Plus longue que la réponse Japt existante, mais utilise une approche différente.
A la limitation inhérente que tous les caractères doivent se produire un nombre unique de fois.

Prend l'entrée sous forme de chaîne.

Essayez-le en ligne!

Perl, 130 octets

+print+0+((0)x40,6,6,0,3,43,0,0,0,22,12,6,3,5,2,4,0,1,0,0,0,1,0,1,(0)x28,1,0,1,(0)x6,1,(0)x4,1,(0)x4,1,1,1,0,2,0,1,0,0,0,5)[ord<>]

N'a pas de nouvelle ligne ou autre espace. Lit une ligne à partir de la sortie standard, mais ne se préoccupe que de ses premiers octets, puis imprime le nombre d'occurrences de cet octet dans son propre code source sous forme décimale, sans nouvelle ligne.

Le programme est simple. La majeure partie du code source est occupée par une table littérale qui donne la réponse pour chaque octet possible. Les zéros de fin sont omis et les zéros adjacents sont compressés au moment de l'exécution, mais il n'y a pas d'autre astuce à part. Le reste du programme lit simplement l'entrée et recherche la réponse dans le tableau.

Par exemple, la partie 22, 12, 6, 3, 5, 2, 4, 0, 1, 0dans le code source donne la fréquence des chiffres, il y a donc 22 zéros, 12 uns, 6 deux, etc. dans le code source. En conséquence, si vous entrez 0dans l'entrée standard du programme, le programme sera imprimé 22.

C (gcc) , 1033 octets

#include <stdio.h>
int main(int argc,char *argv[]){int r=0*14811;switch((int)argv[1][0]){case' ':r=6;break;case'"':r=3;break;case'#':r=2;break;case'%':r=2;break;case'\'':r=101;break;case'(':r=5;break;case')':r=5;break;case'*':r=5*1*1;break;case'.':r=2;break;case':':r=51;break;case';':r=103;break;case'<':r=2;break;case'=':r=52;break;case'>':r=2;break;case'[':r=4;break;case'\\':r=3;break;case']':r=4;break;case'0':r=11;break;case'1':r=20;break;case'2':r=20;break;case'3':r=9;break;case'4':r=7;break;case'5':r=12;break;case'6':r=3;break;case'7':r=2;break;case'8':r=5;break;case'9':r=2;break;case'a':r=106;break;case'b':r=51;break;case'c':r=55;break;case'd':r=4;break;case'e':r=102;break;case'f':r=2;break;case'g':r=4;break;case'h':r=4;break;case'i':r=10;break;case'k':r=51;break;case'l':r=2;break;case'm':r=2;break;case'n':r=8;break;case'o':r=2;break;case'p':r=2;break;case'r':r=108;break;case's':r=53;break;case't':r=8;break;case'u':r=2;break;case'v':r=3;break;case'w':r=2;break;case'{':r=3;break;case'}':r=3;break;}printf("%d",r);}

Essayez-le en ligne!

Ce n’est pas une réponse au golf, mais c’était amusant d’essayer de relever ce défi dans une langue que je ne connais pas bien. Ce n'était pas un défi particulièrement difficile jusqu'à ce que vienne le temps de trouver les chiffres, maintenant CELA était un défi. J'ai dû faire un peu d'équilibre créatif :)

C (gcc) , 192 octets

F(J){J=J-70?J-40?J-41?J-74?J-'{'?J-'}'?J-39?J-48?J-49?J-50?J-51?J-52?J-53?J-54?J-55?J-56?J-57?J-47?J-61?J-63?J-45?J-58?J-59?0:1:23:23:23:1:2:3:3:4:4:14:14:10:10:15:6:4:2:2:25:1:1:1;}//84332211

Essayez-le en ligne!

Probablement possible de jouer au golf plus loin. Utilise un commentaire à la fin comme "espace de travail" pour ajouter des chiffres supplémentaires. Lorsque je dois changer un chiffre de X à Y, je remplace l'un des Y du zéro par un X pour compenser. Autre que cela, c'est juste une fonction qui prend un entier, en utilisant l'astuce d'affectation pour renvoyer une valeur basée sur un conditionnel ternaire volumineux.

x86 .COM, 17 octets, controversé

0120 BF2001        MOV     DI,0120 (120 be the current address)
0123 B91100        MOV     CX,0011
0126 AE            SCASB
0127 7502          JNZ     012B
0129 FEC4          INC     AH
012B E2F9          LOOP    0126
012D C1E808        SHR     AX,8
0130 C3            RET

36 octets

0100 BF????        MOV     DI,(an copy of this code)
0103 B91200        MOV     CX,0012
0106 AE            SCASB
0107 7503          JNZ     010C
0109 80C402        ADD     AH,02
010C E2F8          LOOP    0106
010E C1E808        SHR     AX,8
0111 C3            RET

Japt , 14 octets

Qi"QiUè² " ²èU

L'essayer

Explication

                   :Implicit input of character string U
  "QiUè² "         :String literal
Qi                 :Append a quotation mark
           ²       :Repeat twice
            èU     :Count the occurrences of U

V , 12 octets

ñéÑ~"qpxøÖa

Essayez-le en ligne!

Hexdump:

00000000: f1e9 d17e 2271 7078 f8d6 1261            ...~"qpx...a

Gelée , 16 octets

“;⁾w⁸a2”;⁾“”w⁸a2

Essayez-le en ligne!

Chaque personnage apparaît exactement deux fois.

“;⁾w⁸a2”;⁾“”w⁸a2
“;⁾w⁸a2”;⁾“”     the string ;⁾w⁸a2“”
            w⁸a2 return 2 if input in string

x86, 42 à 40 octets

Ici, j'utilise la même stratégie que les autres: créer une copie de chaîne du programme avec des octets uniques, puis renvoyer 2 en alsi l'entrée alest dans la chaîne. Si nous nous permettons de lire le code réellement exécuté, nous obtenons la solution de 14 m2 .

Je dois utiliser une instruction de chaîne sympa scasb. À ma connaissance, il n'y a pas d'octets en double, mais c'est quelque chose que je pourrais facilement bousiller. Chargement l'adresse de chaîne prend 5 octets , mais je ne suis pas au courant d'une solution plus courte (64 bits leaderip avec un décalage prend 6 octets).

-2 en sautant en arrière pour éviter d'utiliser 02deux fois.

.section .text
.globl main
main:
        mov     $0xff, %eax

start:
        push    $20             # program length
        pop     %ecx            # counter
        mov     $str, %edi      # load string

loop:
        scasb                   # if (al == *(edi++))  
        jne     loop1           
        mov     $2, %al         # ret 2
end:    ret             
loop1:
        loop    loop            # do while (--counter)
        xor     %eax, %eax      # ret 0
        jmp     end

str:    .byte 0x6a,0x14,0x59,0xbf,0xf4,0x83,0x04,0x08 
        .byte 0xae,0x75,0x03,0xb0,0x02,0xc3,0xe2,0xf8
        .byte 0x31,0xc0,0xeb,0xf9 

Hexdump (du format de fichier binaire elf32-i386, car le fichier obj a malheureusement des 00octets pour l' stradresse):

000003e0  6a 14 59 bf f4 83 04 08  ae 75 03 b0 02 c3 e2 f8  |j.Y......u......|
000003f0  31 c0 eb f9 6a 14 59 bf  f4 83 04 08 ae 75 03 b0  |1...j.Y......u..|
00000400  02 c3 e2 f8 31 c0 eb f9                           |....1...|

x86, 256 octets

Réponse ennuyeuse qui équivaut à un commentaire géant. Entrée cl, renvoie immédiatement 1 dans al. Je vais donner une réponse réelle quand j'ai le temps libre.

00000039  b0 01 c3 00 02 03 04 05  06 07 08 09 0a 0b 0c 0d  |................|
00000049  0e 0f 10 11 12 13 14 15  16 17 18 19 1a 1b 1c 1d  |................|
00000059  1e 1f 20 21 22 23 24 25  26 27 28 29 2a 2b 2c 2d  |.. !"#$%&'()*+,-|
00000069  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
00000079  3e 3f 40 41 42 43 44 45  46 47 48 49 4a 4b 4c 4d  |>?@ABCDEFGHIJKLM|
00000089  4e 4f 50 51 52 53 54 55  56 57 58 59 5a 5b 5c 5d  |NOPQRSTUVWXYZ[\]|
00000099  5e 5f 60 61 62 63 64 65  66 67 68 69 6a 6b 6c 6d  |^_`abcdefghijklm|
000000a9  6e 6f 70 71 72 73 74 75  76 77 78 79 7a 7b 7c 7d  |nopqrstuvwxyz{|}|
000000b9  7e 7f 80 81 82 83 84 85  86 87 88 89 8a 8b 8c 8d  |~...............|
000000c9  8e 8f 90 91 92 93 94 95  96 97 98 99 9a 9b 9c 9d  |................|
000000d9  9e 9f a0 a1 a2 a3 a4 a5  a6 a7 a8 a9 aa ab ac ad  |................|
000000e9  ae af b1 b2 b3 b4 b5 b6  b7 b8 b9 ba bb bc bd be  |................|
000000f9  bf c0 c1 c2 c4 c5 c6 c7  c8 c9 ca cb cc cd ce cf  |................|
00000109  d0 d1 d2 d3 d4 d5 d6 d7  d8 d9 da db dc dd de df  |................|
00000119  e0 e1 e2 e3 e4 e5 e6 e7  e8 e9 ea eb ec ed ee ef  |................|
00000129  f0 f1 f2 f3 f4 f5 f6 f7  f8 f9 fa fb fc fd fe ff  |................|

APL (Dyalog Classic) , 30 octets

⊢⊢⊢11-11-11-'''''''1''⊢-⍳⍳0'⍳⊢

Essayez-le en ligne!

Explication

Dans APL, les guillemets simples dans les chaînes sont évités en doublant, de même que '''''''1''⊢-⍳⍳0'la chaîne'''1'⊢-⍳⍳0 qui contient tous les caractères utilisés dans le programme.

Les tableaux APL sont par défaut indexés 1, et la fonction index-of, retourne 1 + max index si l'élément n'est pas trouvé.

Donc, en utilisant index-of sur la chaîne et les retours en entrée

Input    Index    Count
'        1        10
1        4        7
⊢        6        5
-        7        4
⍳        8        3
0        10       1
<other>  11       0

Comme on peut le voir, 11 - indexdonne le nombre de caractères dans le programme. Donc, l'algorithme de base est

11-'''''''1''⊢-⍳⍳0'⍳⊢

Le reste gonfle le nombre de personnages pour leur permettre de bien s'intégrer dans les fentes.

R , 135 octets

Inspiré par cette réponse Python .

Les versions précédentes étaient cassées. Merci à @ Giuseppe d’avoir fait remarquer que cela pasten’était pas nécessaire, cela permettait d’économiser environ 18 octets. lengths(regmatches(z,gregexpr(x,z)))est de cette réponse .

function(x,z=rep(c("afilo2679=:","hmpu15'","nstxz","cgr","e","()",'"',","),c(2:5,7,9,15,16)))sum(lengths(regmatches(z,gregexpr(x,z))))

Essayez-le en ligne!

Pari / GP , 36 octets

f=(x)->#[x|c<-Vec(Str("f=",f)),x==c]

Essayez-le en ligne!

Ruby, 48 octets

->x{%q[->x{%q[].count(x.chr)*2}].count(x.chr)*2}

%q[str]est un moyen plus pratique d'écrire un littéral de chaîne que "str"parce qu'il peut être imbriqué à l'intérieur de lui-même sans échappement. Donc, je viens de mettre le code entier à l'exception de la copie à l'intérieur, puis double le compte.

Gelée , 12 à 10 octets

“;Ṿċƈ”;Ṿċƈ

Essayez-le en ligne!

Lit un personnage de STDIN.

12 octets

Ḣ“Ḣċ;Ṿ¤”;Ṿ¤ċ

Essayez-le en ligne!

Utilisation de l’argument de la ligne de commande

Aussi 12 octets:

ẇ“Ṿẇ¤Ḥ”Ṿ¤Ḥ“”

Essayez-le en ligne!