Nella tipografia, un contatore è l'area di una lettera che è interamente o parzialmente racchiusa da una forma di lettera o un simbolo. Un contatore chiuso è un contatore che è interamente racchiuso da una lettera o un simbolo. È necessario scrivere un programma accetta una stringa come input e stampa il numero totale di contatori chiusi nel testo.

Il tuo input:

• Può essere un input da riga di comando o da STDIN, ma è necessario specificare quale.

• Sarà costituito interamente da caratteri ASCII stampabili, ovvero tutti i valori ASCII compresi tra 32 e 126 inclusi. Questo include gli spazi. Maggiori informazioni.

Ora, questo varia leggermente tra i caratteri. Ad esempio, il carattere in cui stai leggendo questo considera 'g' avere un contatore chiuso, mentre il carattere google ha 'g' con due contatori chiusi. Affinché questo non sia un problema, ecco il numero ufficiale di segnalini chiusi per personaggio.

Tutti i simboli senza contatori chiusi:

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

Si noti che questo include lo spazio.

Ecco tutti i simboli con un contatore chiuso:

#0469@ADOPQRabdegopq

E qui ci sono tutti i simboli con 2 contatori chiusi:

$%&8B

E, ultimo ma non meno importante, ecco alcuni input e output di esempio.

Programming Puzzles and Code-Golf dovrebbe stampare 13

4 8 15 16 23 42 dovrebbe stampare 5

All your base are belong to us dovrebbe stampare 12

Standard loopholes apply dovrebbe stampare 12

Shortest answer in bytes is the winner! dovrebbe stampare 8

Pyth, 31 byte

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

Dimostrazione.

Si noti che il codice potrebbe non essere visualizzato correttamente a causa dell'uso di caratteri non ASCII. Il codice corretto è al link.

Ho creato una tabella di ricerca dell'output desiderato per ciascun carattere di input, l'ho ruotato di 32 per utilizzare l'indicizzazione modulare di Pyth, ho bloccato un 1 all'inizio e l'ho interpretato come un numero di base 3, fornendo il numero 2229617581140564569750295263480330834137283757. Ho quindi convertito questo numero in base 256 e l'ho convertito in una stringa, che è la stringa utilizzata nella risposta.

Python 3, 63

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

Un approccio semplice. Scorre ogni personaggio con un segnalino chiuso, sommando il numero di occorrenze, facendolo due volte per i personaggi con due segnalini chiusi. Sarebbe la stessa lunghezza invece di scrivere

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

Python 3 è necessario per evitare raw_input.

CJam, 41 39 37 34 byte

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

Grazie a @ jimmy23013 per giocare a golf con 3 byte!

Provalo online.

Come funziona

"$%&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

Con l'aiuto del golf di @manatwork e @TobySpeight:

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

Ingresso da STDIN. Con questa meta-domanda in mente , l'output è in unario:

$ 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

41caratteri +1 per la -pbandiera.

Questo utilizza y /// per contare i caratteri.

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

GNU APL, 39 byte

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

Provalo in rete in GNU APL.js .

Come funziona

                                      ⍞ 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

I / O tramite popup. Eseguire il frammento in qualsiasi d recente browser per 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 byte

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

Taglia 5 byte grazie a @JohnE!

Versione precedente:

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

Originale:

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

C, 127 byte

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);}

Abbastanza diretto. Versione non golfata:

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);
}

Provalo qui

Se gli argomenti delle funzioni non sono consentiti, la stdinversione richiede fino a 141 byte:

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);}

Si noti che la versione precedente presuppone che l'input abbia una lunghezza massima di 98 caratteri.

Provalo qui

Versione degli argomenti della riga di comando (143 byte):

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);}

Provalo qui

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

Non riesco a pensare ad altro modo per farlo ... è quello che avrei pensato fino a quando non avrei visto la soluzione di xnor. Pubblicherò comunque quello che avevo.

Grazie a FryAmTheEggman per aver salvato 6 byte

Bene, ora sono contento di questo.

Grazie a xnor per il trucco della ricerca, risparmiando 4 byte.

Aggiunti due byte poiché l'input deve essere racchiuso tra virgolette.

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());}}

Beh, se deve essere un programma completo ... È solo un liner che abbina i caratteri e li sostituisce con una stringa più lunga. Quindi, restituisce la differenza di lunghezza dall'originale. Sfortunatamente, Java non ha davvero nulla per contare solo il numero di partite.

Eccolo con le interruzioni di riga:

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

Pyth - 35 byte

Utilizza il metodo ovvio di in first + * 2 in second. Grazie @FryTheEggman.

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

Provalo qui online .

Javascript, 114 95 byte

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

Grazie a Ismael Miguel per avermi aiutato a giocare a golf.

Rubino, 59 byte

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

Input dalla riga di comando o stdin. Il più breve finora utilizzando un linguaggio non esoterico.

Aggiornamento: chilemagic mi ha battuto

Retina , 44 byte

1

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

Fornisce output in unario.

Ogni riga dovrebbe andare nel suo file oppure puoi usare il -sflag. Per esempio:

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

Le coppie di linee (pattern - coppie sostitutive) eseguono i seguenti passaggi di sostituzione:

• Rimuovere 1s'
• Sostituire le lettere di 1 contatore con 1
• Sostituire le lettere di 2 contatori con 11
• Rimuovi tutto tranne quello 1di

J, 43

Come una funzione:

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

46 byte (riga di comando)

Come programma da riga di comando autonomo:

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

Salvare la linea sopra come counter2.ijse chiamare dalla riga di comando:

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

Julia, 77 74 byte

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

Questo legge il testo da STDIN e stampa il risultato su STDOUT.

Ungolfed + spiegazione:

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

Esempio:

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

rs , 56 byte

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

Dimostrazione dal vivo.

GNU APL, 37 caratteri

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

costruire un vettore di caratteri che contenga due caratteri di 2 contatori due volte (30⍴)

confronta ogni carattere di input con ogni carattere nel vettore (∘. =)

sommare le partite irritate (+ /,)

Javascript 159 , 130 byte

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})};

unminified:

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
    })
};

Con l'aiuto di @ 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 è una funzione c :: Int -> String -> Intche accetta un contatore e una stringa e passa la stringa una lettera alla volta verificando se la lettera corrente è un membro dell'array a 1 punto o dell'array a 2 punti e si chiama per il resto della stringa dopo l'incremento il contatore l'importo appropriato.

Chiama con contatore = 0 in 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);}

Ungolfed:

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);
}

Convertire la stringa in un array di caratteri, quindi vedere se ciascun carattere si trova in uno dei due contatori. Se è nella seconda, devo solo incrementare di nuovo il contatore.

Erlang, 103 byte

Questo è un programma completo che funziona usando escript. La prima riga del file deve essere vuota (aggiungendo 1 byte).

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

Esecuzione di esempio:

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

C, 99 byte

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

Spiegazione

Ho ulteriormente golfato la risposta di Cool Guy ; ci è voluto troppo tempo per essere un commento. Invece di if/ else, ho approfittato della !conversione di un puntatore in bool. Ho anche fatto oincludere in tmodo da poter aggiungere "is in o" e "is in t" per il numero totale di contatori.

Codice espanso

#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;
    }
}

L'output è attivo num, che deve essere cancellato prima di ogni chiamata.

Programma di test e risultati

#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++);}

Il codice stesso contiene 37 contatori per la propria metrica.