Programmes Autogram

34

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 , 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:

Nathaniel
la source
5
Bac à sable . (Ça y est depuis 2014!)
Nathaniel
Les fonctions sont-elles autorisées ou uniquement les programmes complets?
Uriel
1
Remarque: les réponses similaires à celle-ci ne sont plus considérées comme valides.
user202729
1
FWIW, la définition correcte de quine est un peu plus forte que ce que je voudrais vraiment pour ce défi. Par exemple, je serais très heureux de voir un programme qui utilise tous les caractères dans une plage contiguë et ne génère qu'un 1 si son entrée est dans cette plage, même si elle ne comporte pas "une section du programme qui code une autre partie du programme ". Pour cette raison, j'aurais été prêt à autoriser l'exemple de la rétine, bien qu'il aurait été décevant de dissuader d'autres personnes de poster, car elles n'avaient déjà qu'un octet. (@ user202729)
Nathaniel
1
En raison de mon commentaire ci-dessus, j'ai supprimé la déclaration selon laquelle les règles Quine s'appliquent. (J'ai gardé la partie sur le fait de ne pas lire le code source.)
Nathaniel

Réponses:

15

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.

Stewie Griffin
la source
2
C'est le genre de chose que j'espère voir plus souvent. (Optimisation du problème, plutôt que de simplement prendre une quine standard et d’ajouter du code pour compter les caractères.)
Nathaniel
7

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.

Rôti d'ingénieur
la source
5

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!

Arnauld
la source
Vous pouvez raccourcir ceci un peu en retravaillant un peu pour réduire le nombre de caractères distincts: i=>'36335633'[i='\\36=\'i|&()25.>[]Odefx~n'.indexOf(i)]||~i&&2(8 octets enregistrés)
Yair Rand
5

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.

Leo
la source
5

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

Hyarus
la source
Belle approche! +1 de moi. Vous pouvez économiser des octets en supprimant les parenthèses (a)=>et en prenant l'entrée sous forme de chaîne au lieu de caractère, de sorte que ce .ToString()ne soit plus nécessaire (et a+""aurait pu être utilisé également pour les défis de code-golf dont vous n'aurez jamais besoin .ToString()). De plus, comme .Containscontient déjà un a, vous pouvez faire de la variable d'entrée un caractère différent non utilisé (comme xou q) afin qu'il en ait 3 pour chaque caractère au lieu de 4. EDIT: Peu importe la dernière partie, je vois qu'elle "est également utilisée 4 fois maintenant.
Kevin Cruijssen
@KevinCruijssen Merci pour le conseil. Mais la chaîne est-elle valide en tant qu'entrée? Considérant que OP a demandé un octet comme entrée?
Hyarus
Tant que c'est une chaîne de caractères unique, je suis sûr que c'est. De toute façon, la plupart des langues ne peuvent saisir que des valeurs de chaîne, et certaines avec des caractères choisissent toujours de saisir une chaîne (comme Java, JavaScript et Japt par exemple). Les formats d'entrée et de sortie sont généralement assez flexibles. Mais vous pouvez toujours demander à OP de commentaire si vous
doutez
1
@KevinCruijssen semble raisonnable. Et si nous échappons à l'un des ", nous pouvons même atteindre le nombre souhaité de 3 par personnage
Hyarus
2
Les chaînes de caractères uniques en entrée me conviennent parfaitement.
Nathaniel
4

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

ბიმო
la source
3

Python 2 , 54 52 32 octets

-20 octets grâce aux ovs

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

Essayez-le en ligne!

Barre
la source
1
Comment se fait-il que vous n'ayez ni lambda ni entrée?
Stewie Griffin
2
@StewieGriffin Python lie automatiquement une référence de méthode, "xxx".countest donc équivalent à lambda c:"xxx".count(c).
Neil
@StewieGriffin et vous utilisez les deux de la même manière -> f="xxx".countet f=lambda c:"xxx".count(c)s'appellera commef('a')
Rod
3

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
ბიმო
la source
1
Vous pouvez gérer les guillemets plus facilement en doublant la chaîne avant de l'afficher: Essayez-le en ligne!
Leo
3

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

:

  • 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.
Kevin Cruijssen
la source
3

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.

Laikoni
la source
3

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.

Hans-Martin Mosner
la source
1
Bienvenue chez PPCG!
Martin Ender
2

JavaScript, 31 octets

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

Essayez-le en ligne

Hirsute
la source
1
Je pense que cela lit son propre code source, n'est-ce pas? C'est explicitement interdit, en gras, dans la question.
Nathaniel
1
@Nathaniel, voir ici .
Shaggy
2
Hmm. Bien honnêtement, je pense que c'est stupide, mais je ne peux pas vraiment être en désaccord avec le méta-consensus, je suppose.
Nathaniel
1
@Nathaniel Pour tous les programmes qui facilitent l’évaluation, ils le facilitent également.
user202729
1
@ user202729 Je ne pense pas que cela suive, n'est-ce pas? Vous ne pouvez pas faire la même chose en Python, par exemple. Ceci est une évaluation inverse, pas une évaluation
Nathaniel
2

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.

Assistant de blé
la source
: | ce qui est arrivé à votre orthographe dans l'explication
ASCII uniquement
2

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).

Kevin Cruijssen
la source
1
C'est un très bon langage pour ce défi.
Qwr
2

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!

Lente
la source
2

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.

b_jonas
la source
2

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 :)

X1M4L
la source
2

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.

LambdaBeta
la source
Je peux économiser un octet en déplaçant la constante numérique après le zéro, 0*84332211comme dans l'autre réponse C, mais je peux aussi sauvegarder des octets en le remaniant pour qu'il soit plus petit, je ne vais donc pas m'inquiéter.
LambdaBeta
Pouvez-vous économiser des octets en utilisant une vérification de plage pour les nombres moins communs? c'est-à-dire que si nous supposons que les caractères 4-9 sont rares, nous pouvons les traiter tous en même temps avec une vérification conditionnelle.
Qwr
Presque certainement. Nous pourrions probablement en supprimer encore plus en choisissant des noms astucieux pour éviter que certains symboles n'apparaissent ou pour que les motifs binaires puissent être utilisés (par exemple, J&1?pour faire correspondre tous les caractères impairs). Je peux continuer à jouer au golf si je trouve le temps de le faire.
LambdaBeta
2

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
l4m2
la source
2
Est-ce que cette lecture n'est pas son propre code?
Razvan Socol
@RazvanSocol Je pense que c'est comme la solution JavaScript
l4m2
@RazvanSocol et bien, il n'est pas nécessaire de sauvegarder dans un fichier, donc ça va. beaucoup de fungeoids et JS le font aussi
ASCII seulement
Je soutiens que vous lisez du code qui est exécuté et qui compte pour "lire son propre code source". Maintenant, vous pourriez soutenir qu'une copie du programme sous forme de chaîne, comme le font la plupart des solutions ici, est également "lecture du code source", mais que la chaîne n'est pas exécutée.
Qwr
1

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
Hirsute
la source
1

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
Ellie
la source
1

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  |................|
qwr
la source
1

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.

TwiNight
la source
1

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!

JayCe
la source
0

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.

histocrate
la source