En typographie, un compteur est l'aire d'une lettre qui est entièrement ou partiellement entourée d'une forme de lettre ou d'un symbole. Un compteur fermé est un compteur entièrement entouré d'une lettre ou d'un symbole. Vous devez écrire un programme prend une chaîne en entrée et imprime le nombre total de compteurs fermés dans le texte.

Votre contribution:

• Il peut s'agir d'une entrée de ligne de commande ou de STDIN, mais vous devez spécifier laquelle.

• Comprendra entièrement les caractères ASCII imprimables, c'est-à-dire toutes les valeurs ASCII comprises entre 32 et 126 inclus. Cela inclut les espaces. Plus d'information.

Maintenant, cela varie légèrement entre les polices. Par exemple, la police dans laquelle vous lisez ceci considère que «g» a un compteur fermé, tandis que la police Google a «g» avec deux compteurs fermés. Pour que ce ne soit pas un problème, voici le nombre officiel de compteurs fermés par personnage.

Tous les symboles sans compteurs fermés:

 !"'()*+,-./12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\]^_`cfhijklmnrstuvwxyz{|}~

Notez que cela inclut l'espace.

Voici tous les symboles avec un compteur fermé:

#0469@ADOPQRabdegopq

Et voici tous les symboles avec 2 compteurs fermés:

$%&8B

Enfin, voici quelques exemples d'entrées et de sorties.

Programming Puzzles and Code-Golf devrait imprimer 13

4 8 15 16 23 42 devrait imprimer 5

All your base are belong to us devrait imprimer 12

Standard loopholes apply devrait imprimer 12

Shortest answer in bytes is the winner! devrait imprimer 8

Pyth, 31 octets

sm@tjC"cúÁ-ÈN%³rØ|­"3Cdz

Manifestation.

Notez que le code peut ne pas s'afficher correctement en raison de l'utilisation de caractères non ASCII. Le bon code se trouve sur le lien.

J'ai fait une table de recherche de la sortie souhaitée pour chaque caractère d'entrée, l'ai tournée de 32 pour utiliser l'indexation modulaire de Pyth, ai collé un 1 au début et l'ai interprété comme un nombre de base 3, donnant le nombre 2229617581140564569750295263480330834137283757. J'ai ensuite converti ce nombre en base 256 et l'ai converti en chaîne, qui est la chaîne utilisée dans la réponse.

Python 3, 63

print(sum(map(input().count,"#0469@ADOPQRabdegopq$%&8B$%&8B")))

Une approche simple. Itère sur chaque personnage avec un compteur fermé, sommant le nombre d'occurrences, le faisant deux fois pour les personnages avec deux compteurs fermés. Ce serait la même longueur pour écrire à la place

"#0469@ADOPQRabdegopq"+"$%&8B"*2

Python 3 est nécessaire pour éviter raw_input.

CJam, 41 39 37 34 octets

"$%&8Badopq#0469@Rbeg"_A<eu+qfe=1b

Merci à @ jimmy23013 pour avoir joué au golf sur 3 octets!

Essayez-le en ligne.

Comment ça fonctionne

"$%&8Badopq#0469@Rbeg"             e# Push that string.
                      _A<          e# Retrieve the first 10 characters.
                         eu+       e# Convert to uppercase and append.
                                   e# This pushes "$%&8Badopq#0469@Rbeg$%&8BADOPQ".
                            q      e# Read from STDIN.
                             fe=   e# Count the occurrences of each character. 
                                1b e# Base 1 conversion (sum).

sed, 51

Avec l'aide au golf de @manatwork et @TobySpeight:

s/[$%&8B]/oo/g
s/[^#0469@ADOPQRabdegopq]//g
s/./1/g

Entrée de STDIN. Avec cette méta-question à l'esprit , la sortie est unaire:

$ echo 'Programming Puzzles and Code-Golf
4 8 15 16 23 42
All your base are belong to us
Standard loopholes apply
Shortest answer in bytes is the winner!' | sed -f countercounter.sed
1111111111111
11111
111111111111
111111111111
11111111
$ 

Perl, 41

$_=y/#0469@ADOPQRabdegopq//+y/$%&8B//*2

41caractères +1 pour le -pdrapeau.

Cela utilise y /// pour compter les caractères.

echo 'Programming Puzzles and Code-Golf' | perl -pe'$_=y/#0469@ADOPQRabdegopq//+y/$%&8B//*2'

GNU APL, 39 octets

+/⌈20÷⍨26-'$%&8B#0469@ADOPQRabdegopq'⍳⍞

Essayez en ligne dans GNU APL.js .

Comment ça fonctionne

                                      ⍞ Read input.
          '$%&8B#0469@ADOPQRabdegopq'⍳  Compute the indexes of the input characters
                                        in this string. Indexes are 1-based.
                                        26 == 'not found'
       26-                              Subtract each index from 26.
   20÷⍨                                 Divide those differences by 20.
  ⌈                                     Round up to the nearest integer.
+/                                      Add the results.

JavaScript, 86

E / S via popup. Exécutez l'extrait dans tout d navigateur récent de test.

for(c of prompt(t=0))c='$%&8B#0469@ADOPQRabdegopq'.indexOf(c),~c?t+=1+(c<5):0;alert(t)

K, 54 43 42 37 octets

+//(30#"$%&8B#0469@ADOPQRabdegopq"=)'

Coupez 5 octets grâce à @JohnE!

Ancienne version:

f:+/(#&"#0469@ADOPQRabdegopq$%&8B$%&8B"=)'

Original:

f:+/{2-(5="$%&8B"?x;20="#0469@ADOPQRabdegopq"?x;0)?0}'

C, 127 octets

n;f(char*i){char*o="#0469@ADOPQRabdegopq",*t="$%&8B";for(;*i;i++)if(strchr(o,*i))n++;else if(strchr(t,*i))n+=2;printf("%d",n);}

Assez simple. Version non golfée:

int num = 0;
void f(char* input)
{
    char *one="#0469@ADOPQRabdegopq";
    char *two="$%&8B";

    for(;*input;input++)
        if(strchr(one, *input))     //If current character is found in first array
            num ++;
        else if(strchr(two, *input))//If cuurent character is found in second array
            num += 2;

    printf("%d", num);
}

Testez-le ici

Si les arguments de fonction ne sont pas autorisés, la stdinversion prend jusqu'à 141 octets:

n;f(){char*o="#0469@ADOPQRabdegopq",*t="$%&8B",i[99],*p;gets(i);for(p=i;*p;p++)if(strchr(o,*p))n++;else if(strchr(t,*p))n+=2;printf("%d",n);}

Notez que la version ci-dessus suppose que l'entrée comporte au maximum 98 caractères.

Testez-le ici

Version des arguments de ligne de commande (143 octets):

n;main(c,v)char**v;{char*o="#0469@ADOPQRabdegopq",*t="$%&8B",*p=v[1];for(;*p;p++)if(strchr(o,*p))n++;else if(strchr(t,*p))n+=2;printf("%d",n);}

Testez-le ici

Python 2, 96 90 75 67 + 2 = 69 octets

Je ne peux pas penser à une autre façon de faire cela ... c'est ce que j'aurais pensé jusqu'à ce que je voie la solution de xnor. Je posterai de toute façon ce que j'avais.

Merci à FryAmTheEggman pour avoir économisé 6 octets

D'accord, maintenant j'en suis satisfait.

Merci à xnor pour la recherche, économisant 4 octets.

Ajout de deux octets car l'entrée doit être placée entre guillemets.

print sum('#0469@ADOPQRabdegopq$%&8B'.find(x)/20+1for x in input())

Java, 162

class C{public static void main(String[]a){System.out.print(-a[0].length()+a[0].replaceAll("[#0469@ADOPQRabdegopq]","..").replaceAll("[$%&8B]","...").length());}}

Eh bien , si elle a être un programme complet ... C'est juste une ligne qui correspond aux caractères et les remplace par une chaîne plus longue. Retourne ensuite la différence de longueur par rapport à l'original. Malheureusement, java n'a vraiment rien pour compter le nombre de correspondances.

Le voici avec des sauts de ligne:

class C{
    public static void main(String[]a){
        System.out.print(
                -a[0].length() +
                a[0].replaceAll("[#0469@ADOPQRabdegopq]","..")
                .replaceAll("[$%&8B]","...")
                .length()
                        );
    }
}

Pyth - 35 octets

Utilise la méthode évidente de in first + * 2 in second. Merci @FryTheEggman.

s/Lz+"#0469@ADOPQRabdegopq"*2"$%&8B

Essayez-le ici en ligne .

Javascript, 114 95 octets

alert(prompt().replace(/[#046@ADOPQRabdegopq]/g,9).replace(/[$%&8B]/g,99).match‌​(/9/g).length)

Merci à Ismael Miguel de m'avoir aidé à jouer au golf.

Rubis, 59 octets

a=gets;p a.count('#0469@ADOPQRabdegopq')+2*a.count('$%&8B')

Entrée depuis la ligne de commande ou stdin. Jusqu'à présent, le plus court utilise un langage non ésotérique.

Mise à jour: chilemagic m'a battu

Rétine , 44 octets

1

[#0469@ADOPQRabdegopq]
1
[$%&8B]
11
[^1]
<empty line>

Donne la sortie en unaire.

Chaque ligne doit aller dans son propre fichier ou vous pouvez utiliser l' -sindicateur. Par exemple:

> echo "pp&cg"|retina -s counter
11111

Les paires de lignes (motif - paires de substitution) effectuent les étapes de substitution suivantes:

• Retirer 1 les
• Remplacez 1 contre-lettre par 1
• Remplacez 2 contre-lettres par 11
• Retirez tout sauf les 1« s

J, 43

En tant que fonction:

   f=:[:+/[:,30$'$%&8B#0469@ADOPQRabdegopq'=/]
   f 'text goes here'
6

46 octets (ligne de commande)

En tant que programme de ligne de commande autonome:

echo+/,30$'$%&8B#0469@ADOPQRabdegopq'=/>{:ARGV

Enregistrez la ligne ci-dessus sous counter2.ijset appelez à partir de la ligne de commande:

$ jconsole counter2.ijs 'Programming Puzzles and Code Golf'
13

Julia, 77 74 octets

t=readline();length(join(t∩"#0469@ADOPQRabdegopq")*join(t∩"\$%&8B")^2)

Cela lit le texte de STDIN et imprime le résultat dans STDOUT.

Non golfé + explication:

# Read text from STDIN
t = readline()

# Print (implied) to STDOUT the length of the intersection of t with the
# 1-closed counter list joined with the duplicated intersection of t with
# the 2-closed counter list
length(join(t ∩ "#0469@ADOPQRabdegopq") * join(t ∩ "\$%&8B")^2)

Exemple:

julia> t=readline();length(join(t∩"#0469@ADOPQRabdegopq")*join(t∩"\$%&8B")^2)
Programming Puzzles and Code Golf
13

rs , 56 octets

_/
[#0469@ADOPQRabdegopq]/_
[$%&8B]/__
[^_]/
(_+)/(^^\1)

Démo en direct.

GNU APL, 37 caractères

+/,⍞∘.=30⍴'$%&8B#0469@ADOPQRabdegopq'

construire un vecteur de caractères contenant deux fois 2 caractères (30⍴)

comparer chaque caractère d'entrée avec chaque caractère du vecteur (∘. =)

résumer les matchs ravelés (+ /,)

Javascript 159 , 130 octets

function c(b){return b.split("").map(function(a){return-1!="$%&8B".indexOf(a)?2:-1!="#0469@ADOPQRabdegopq".indexOf(a)?1:0}).reduce(function(a,b){return a+b})};

non minifié:

function c(b) {
    return b.split("").map(function(a) {
        return -1 != "$%&8B".indexOf(a) ? 2 : -1 != "#0469@ADOPQRabdegopq".indexOf(a) ? 1 : 0
    }).reduce(function(a, b) {
        return a + b
    })
};

Avec l'aide de @ edc65:

function c(b){return b.split('').reduce(function(t,a){return t+(~"$%&8B".indexOf(a)?2:~"#0469@ADOPQRabdegopq".indexOf(a)?1:0)},0)}

Haskell, 117

a="#0469@ADOPQRabdegopq"
b="$%&8B"
c n[]=n
c n(x:s)
 |e a=f 1
 |e b=f 2
 |True=f 0
 where
 e y=x`elem`y
 f y=c(n+y)s

c est une fonction c :: Int -> String -> Int qui prend un compteur et une chaîne et parcourt la chaîne une lettre à la fois pour vérifier si la lettre actuelle est membre du tableau à 1 point ou du tableau à 2 points et s'appelle pour le reste de la chaîne après incrémentation le compteur le montant approprié.

Appel avec compteur = 0 en ghci:

ghci> c 0 "All your base are belong to us"
12

C #, 157

void Main(string s){int v=0;v=s.ToCharArray().Count(c=>{return "#0469@ADOPQRabdegopq".Contains(c)||"$%&8B".Contains(c)?++v is int:false;});Console.Write(v);}

Non golfé:

void Main(string s)
{
    int v = 0;

    v = s.ToCharArray()
    .Count(c => 
    {
        return "#0469@ADOPQRabdegopq".Contains(c) || "$%&8B".Contains(c) ? ++v is int:false;
    });

    Console.Write(v);
}

Convertir la chaîne en un tableau de caractères, puis voir si chaque caractère se trouve dans l'un ou l'autre des compteurs. Si c'est dans le second, je viens de l'incrémenter à nouveau.

Erlang, 103 octets

Il s'agit d'un programme complet qui s'exécute en utilisant escript. La première ligne du fichier doit être vide (en ajoutant 1 octet).

main([L])->io:write(c(L,"#0469@ADOPQRabdegopq")+2*c(L,"$%&8B")).
c(L,S)->length([X||X<-L,S--[X]/=S]).

Exemple d'exécution:

$ escript closed.erl 'Shortest answer in bytes is the winner!'
8$

C, 99 octets

n;f(char*i){for(char*o="#0469@ADOPQRabdegopq$%&8B",*t=o+20;*i;)n+=2-!strchr(o,*i)-!strchr(t,*i++);}

Explication

J'ai encore joué à la réponse de Cool Guy ; c'est devenu trop long pour être un commentaire. Au lieu de if/ else, j'ai profité de la !conversion d'un pointeur en bool. J'ai également fait oinclure tafin que je puisse ajouter "est dans o" et "est danst " pour le nombre total de compteurs.

Code développé

#include <string.h>
int num = 0;

void f(char* input)
{
    char *one = "#0469@ADOPQRabdegopq"  "$%&8B";
    char *two = strchr(one, '$');

    while (*input) {
        num += 2 - !strchr(one, *input) - !strchr(two, *input));
        ++input;
    }
}

La sortie est en num , qui doit être effacée avant chaque appel.

Programme de test et résultats

#include <stdio.h>
int main() {
    const char* a[] = {
        "Programming Puzzles and Code-Golf",
        "4 8 15 16 23 42",
        "All your base are belong to us",
        "Standard loopholes apply",
        "Shortest answer in bytes is the winner!",
        NULL
    };
    for (const char** p = a;  *p;  ++p) {
        n=0;f(*p);
        printf("%3d: %s\n", n, *p);
    }
    return 0;
}

 13: Programming Puzzles and Code-Golf
  5: 4 8 15 16 23 42
 12: All your base are belong to us
 12: Standard loopholes apply
  8: Shortest answer in bytes is the winner!
 37: n;f(char*i){for(char*o="#0469@ADOPQRabdegopq$%&8B",*t=o+20;*i;)n+=2-!strchr(o,*i)-!strchr(t,*i++);}

Le code lui-même contient 37 compteurs par sa propre métrique.