Sfida

Scrivi un programma che, data una stringa xlunga 10 caratteri e un carattere y, genera il numero di volte in cui il carattere si ypresenta nella stringa x.

Il programma più breve in byte per farlo vince.

Esempio

Input: tttggloyoi, t
Output: 3

Input: onomatopoe, o
Output: 4

Pyth, 3 byte

/ww

Esempio di esecuzione:

$ pyth -c '/ww'
sdhkfhjkkj
k
3

Ovviamente, l'utente potrebbe inserire più o meno di 10 lettere al primo input, ma non dobbiamo preoccuparci di ciò che accade quando l'utente viola le specifiche.

Pyth - 3 byte

Una risposta Pyth diversa, meno ovvia, della stessa dimensione. Piega contando sull'input.

/FQ

Test Suite .

JavaScript, 32

(p=prompt)().split(p()).length-1

Bash, 24 personaggi

x=${1//[^$2]}
echo ${#x}

Esecuzione di esempio:

bash-4.3$ bash letter-count.sh tttggloyoi t
3

bash-4.3$ bash letter-count.sh onomatopoe o
4

Retina , 12 byte

(.)(?=.*\1$)

Semplicemente una regex che corrisponde a un carattere uguale all'ultimo carattere nell'input (tranne se stesso). Quando viene data una singola regex, Retina restituisce semplicemente il numero di partite.

Labyrinth , 32 29 27 24 byte

),}{)-
@ ,  +);__
!-`{:}

Questo legge prima il singolo carattere, seguito dalla stringa in cui contare, e presuppone che non vi siano byte null nella stringa.

Spiegazione

Il codice inizia con ),}, che imposta la parte inferiore dello stack su 1, legge il primo carattere e lo sposta nello stack ausiliario per un uso futuro. Il 1sarà il nostro contatore (l'offset di 1 verrà cancellata entro ed è necessario per l'IP di prendere i giri necessari).

L'IP ora si sposterà verso il basso per leggere il primo carattere della stringa di ricerca con ,. Il valore viene negato con `, di nuovo per ottenere il corretto comportamento di svolta. Mentre stiamo leggendo personaggi da STDIN, l'IP ora seguirà questo ciclo:

  }{)-
  ,  +);__
  `{:}

{:}crea una copia del codice carattere memorizzato e lo +aggiunge al valore corrente. Se il risultato è 0(cioè il personaggio attuale è quello che stiamo cercando), l'IP si sposta dritto: -semplicemente si sbarazza di 0, )incrementa il contatore, {}è un no-op.

Tuttavia, se il risultato successivo +è diverso da zero, non vogliamo contare il carattere corrente. Quindi l'IP prende invece una svolta a destra. Questo è un vicolo cieco, quindi quel codice viene eseguito due volte, una volta in avanti e una volta all'indietro. Cioè, il codice effettivo in questo caso diventa );___;)+-){}. );elimina solo quella differenza diversa da zero, ___spinge 3 zero, ma ;scarta uno di essi. )incrementa uno dei due restanti due zero, +li aggiunge in un singolo 1, lo -sottrae dal contatore e )incrementa il contatore. In altre parole, abbiamo creato una no-op molto elaborata.

Quando colpiamo EOF, ,spinge -1, che `si trasforma 1e l'IP gira a destra. -sottrae il 1dal contatore (annullando l'offset iniziale). !stampa il contatore e @termina il programma.

Python 3, 29 byte

print(input().count(input()))

Meh, è ​​stato facile. Suppone che l'input sia una stringa di dieci lettere.

Snowman 1.0.2 , 16 caratteri

~vgvgaSaLNdEtSsP

Sorprendentemente breve. Spiegazione:

~      make all vars active (even though we only need two, we don't really care)
vgvg   get two lines of input
aS     split first line on second line
aL     length of the new array
NdE    decrement (because ex. "axbxc""x"aS -> ["a" "b" "c"] which is length 3)
tSsP   to-string and print

C ++ Template-Metaprogramming, 160 154 116 byte

Solo per le risatine.

Grazie a ex-bart per averlo giocato a golf!

template<int w,int x,int y,int...s>class A:A<w+(x==y),x,s...>{};A<0,'t','t','t','t','g','g','l','o','y','o','i',0>a;

Utilizzo: il primo carattere nell'istanza del modello è il personaggio da cercare.

Complile con clang -std = c ++ 11 -c -> il risultato è all'inizio del messaggio di errore.

Occurences.cpp:1:66: error: too few template arguments for class template 'A'
template<int w,char x,char y,char...s>class A{static const int a=A<w+((x==y)?1:0),x,s...>::a;};
                                                             ^
Occurences.cpp:1:66: note: in instantiation of template class 'A<3, 't', '\x00'>' requested here
template<int w,char x,char y,char...s>class A{static const int a=A<w+((x==y)?1:0),x,s...>::a;};

Complile con gcc -std = c ++ 11 -c -> il risultato è nella parte inferiore del messaggio di errore.

Occurences.cpp: In instantiation of ‘const int A<3, 't', '\000'>::a’:
Occurences.cpp:1:64:   recursively required from ‘const int A<1, 't', 't', 't', 'g', 'g', 'l', 'o', 'y', 'o', 'i', '\000'>::a’
Occurences.cpp:1:64:   required from ‘const int A<0, 't', 't', 't', 't', 'g', 'g', 'l', 'o', 'y', 'o', 'i', '\000'>::a’
Occurences.cpp:2:62:   required from here
Occurences.cpp:1:64: error: wrong number of template arguments (2, should be at least 3)

Cerca A < 3 , 't', '\ 000'> e A < 3 , 't', '\ x00'>

Versione a 154 byte

template<int w,char x,char y,char...s>class A{static const int a=A<w+(x==y),x,s...>::a;};                          
int a=A<0,'t','t','t','t','g','g','l','o','y','o','i','\0'>::a;

Versione da 160 byte:

template<int w,char x,char y,char...s>class A{static const int a=A<w+((x==y)?1:0),x,s...>::a;};                          
int a=A<0,'t','t','t','t','g','g','l','o','y','o','i','\0'>::a;

Bash + grep, 26 byte

grep -o "$1"<<<"$2"|wc -l

Javascript (ES6), 26 byte

(a,b)=>a.split(b).length-1

Questa soluzione rapida e intuitiva definisce una funzione anonima. Per usarlo, aggiungi una dichiarazione variabile all'inizio. Provalo:

z=(a,b)=>(a.split(b)||[0]).length-1;

input1=document.getElementById("input1");
input2=document.getElementById("input2");
p=document.getElementById("a");
q=function(){
  setTimeout(function(){
    p.innerHTML=z(input1.value,input2.value)||0;
  },10);
};
input1.addEventListener("keydown",q);
input2.addEventListener("keydown",q);

<form>Text to search: <input type="text" id="input1" value="hello world!"/><br>Char to find: <input type="text" id="input2" value="l"/></form>

<h3>Output:</h3>
<p id="a">3</p>

EDIT: Oh, vedo che esiste già una soluzione molto simile. Spero vada bene.

Haskell, 21 byte

a!b=sum[1|x<-a,x==b]

C ++, 78 byte

int main(int,char**v){int c=0,i=0;while(i<10)v[1][i++]==*v[2]&&++c;return c;}

Chiama in questo modo:

$ g++ -std=c++14 -O2 -Wall -pedantic -pthread main.cpp && ./a.out tttggloyoi t; echo $?
3

Elemento , 23 byte

__);11'[)\
~="0 1@][+]`

La newline fa parte del programma. In realtà lo sto usando come nome variabile .

Questo programma funziona fondamentalmente memorizzando il carattere target in una variabile, mantenendo la stringa corrente nella parte superiore dello stack e quindi eseguendo il ciclo "chop, compare e sposta il risultato al di sotto", sommando i risultati alla fine.

La nuova riga come nome di variabile deriva dall'uso della nuova riga alla fine dell'input tagliandola e memorizzandola. La nuova riga nel codice è dove ho letto da esso.

L'input è così:

qqqqwwweee
q

L'output è così

4

Julia, 26 25 byte

f(s,c)=endof(findin(s,c))

Il findin funzione restituisce gli indici nel primo argomento in cui si trova il secondo argomento come vettore. La lunghezza del vettore è il numero di occorrenze.

Salvato un byte grazie a Glen O.

APL, 7 3 byte

+/⍷

Questo crea un treno di funzioni. Funziona creando un vettore di zeri e quelli corrispondenti agli indici in cui il carattere appare nella stringa ( ⍷). Il vettore viene quindi sommato ( +/).

4 byte salvati grazie a kirbyfan64sos e NBZ!

Perl, 21 16 caratteri

(Codice di 13 caratteri + opzione della riga di comando di 3 caratteri.)

$_=0+s/$^I//g

Esecuzione di esempio:

bash-4.3$ perl -it -pe '$_=0+s/$^I//g' <<< tttggloyoi
3

bash-4.3$ perl -io -pe '$_=0+s/$^I//g' <<< onomatopoe
4

bash-4.3$ perl -i5 -pe '$_=0+s/$^I//g' <<< 1234
0

PHP, 36 35 byte

<?=substr_count($argv[1],$argv[2]);

Utilizzo:
chiama lo script con due argomenti.
php script.php qwertzqwertz q

PHP, 23 byte

Se registri variabili globali (possibile solo in PHP 5.3 e versioni successive) puoi risparmiare 12 byte (grazie a Martijn )

<?=substr_count($a,$b);

Utilizzo:
chiama lo script e dichiara le variabili globaliphp script.php?a=qwertzqwertz&b=q

Dyalog APL , 3 byte

      +/=

Vale a dire "La somma dei byte uguali". Per esempio:

      f ← +/=
      'onomatopoe' f 'o'
4

o solo

      'onomatopoe'(+/=)'o'
4

K non batte APL questa volta.

Provalo online.

T-SQL, 99 40 byte

SELECT 11-LEN(REPLACE(s,c,'')+'x')FROM t

Fa semplicemente una differenza tra la stringa di input e la stringa con il carattere rimosso. Accetta input dalla tabella t

Modifica modificata per rimuovere un problema con il conteggio degli spazi e per tenere conto degli input accettabili correnti per SQL. Grazie @BradC per tutte le modifiche e risparmi

Octave / Matlab, 33 byte

sum(input('','s')==input('','s'))

J, 5 byte

+/@:=

Sento che J avrebbe un built-in per questo, ma non sono stato in grado di trovarne uno - forse uno degli utenti J attivi può illuminarmi. Quindi invece questo vale prima =per gli input, trasformando ogni personaggio in 1se è uguale a quello richiesto o in 0altro modo. Quindi +/calcola la somma di tale elenco.

File batch, 121 byte

Perché sono un masochista ...

SET c=0
SET e=_
SET t=%1%%e%
:l
SET a=%t:~0,1%
IF "%a%"=="%2" SET /A c+=1
SET t=%t:~1%
IF NOT "%t%"=="%e%" GOTO l
ECHO %c%

Avviso: presuppone che _non si verifichi nella stringa di input. In tal caso, quindi la variabilee deve essere regolata in modo appropriato.

Questo imposta la nostra variabile counter ce la nostra demarcazione di fine stringa come _, prima di aggiungere quella alla nostra stringa di input %1e impostare la stringa concatenata su t. Quindi, stiamo entrando in loop :l, impostiamo una variabile di carattere temporaneo acome primo carattere di t, controlliamo se corrisponde alla nostra seconda stringa di input %2e incrementa cse vero, quindi taglia il primo carattere di t. La nostra condizione end-of-loop verifica la tnostra demarcazione end-of-string e, in caso contrario, ritorna indietro. Noi alloraecho scoperto il valore del nostro contatore.

Probabilmente sarebbe invece possibile utilizzare un FORloop, ma ciò richiederebbe l'abilitazione di DelayedExpansion , che a mio avviso sarà in realtà più lunga di byte. La verifica di ciò è lasciata come esercizio al lettore.

CJam, 5 byte

ll/,(

Spiegazione

l      e# read x
 l     e# read y
  /    e# split x by y
   ,   e# count
    (  e# subtract one

PowerShell, 32 byte

Un quattro per uno! E sono tutti della stessa lunghezza! :)

($args[0]-split$args[1]).Count-1

o

param($a,$b)($a-split$b).Count-1

In alternativa,

$args[0].Split($args[1]).Count-1

o

param($a,$b)$a.Split($b).Count-1

I primi due stili usano l'operatore inline -split, mentre i secondi due implicitamente lanciano il primo argomento come stringa e usano l' .Split()operatore basato su stringa. In tutti i casi viene restituito un array, in cui è necessario ridurre il conteggio di uno, poiché stiamo recuperando un altro elemento dell'array rispetto alle ricorrenze del secondo argomento.

_{Questo è stato abbastanza divertente ...}

Julia, 21 byte

f(s,c)=sum(i->c==i,s)

Si noti che richiede che csia un carattere, non una stringa di un carattere. Quindi lo usi come f("test me",'e')(che restituisce 2) e non f("test me","e")(che restituisce 0, perché 'e'!="e").

> <> (Pesce) , 30 byte

0&v
=?\ilb
=?\:@=&+&l1
n&/;

Prende la stringa, quindi il carattere da contare. L'input non è separato (almeno nell'interprete online). Provalo sull'interprete online: http://fishlanguage.com Ho contato i byte a mano, quindi fammi sapere se sbaglio.

Spiegazione

Prima di tutto,> <> è bidimensionale e scorre in una linea o colonna fino a quando non colpisce a ; errore o. Ciò significa che se procede da sinistra a destra (come accade all'inizio di un programma), avvolgerà la linea se raggiunge la fine e non viene spostato o gli viene detto di interrompere il programma. Alcuni caratteri per riga verranno ripetuti perché hanno funzioni diverse a seconda della direzione del puntatore e la quarta riga avrà caratteri in ordine inverso perché il puntatore si sposta da destra a sinistra.

Di seguito viene fornito un riepilogo del programma. Guarda le istruzioni elencate per> <> su esolangs per vedere cosa fa ogni singolo personaggio.

Linea 1: 0&v

0&v -put 0 into the register and change direction to down-up

Linea 2: =?\ilb

(a partire da dove la riga 1 sposta il puntatore su, ovvero il terzo carattere)

\ -reflect the pointer and make it move left-right
i -read input
lb=?\ -reflect downwards if there are 11 values in the stack

linea 3: =?\:@=&+&l1

(a partire dal terzo carattere)

:@ -duplicate y and shift the stack e.g. ['x','y','y'] -> ['y','x','y']
=&+& -increment the register if the character popped from x = y
l1=?\ -reflect downwards if there is 1 value in the stack

Linea 4: n&/;

(a partire dal terzo carattere)

/ -reflect right-left
&n; -print value of the register

Rubino, 22 20 byte

p gets.count(gets)-1

Demo: http://ideone.com/MEeTd2

Ciò -1è dovuto al fatto che getsrecupera l'input, oltre a un carattere di nuova riga. Ruby String#countconta il numero di volte che un carattere dell'argomento compare nella stringa.

Ad esempio, per l'input [ test\n, t\n], si tverifica due volte e si \nverifica una volta e deve essere sottratto.

Rubino, 18 byte

->s,c{p s.count c}

Uso:

->s,c{p s.count c}.call 'tttggloyoi', 't'

->s,c{p s.count c}.call 'onomatopoe', 'o'

Japt , 2 byte

èV

Provalo online!