Desafio

Escreva um programa que, com uma sequência de x10 caracteres e um caractere y, produza o número de vezes que o caractere yocorre na sequência x.

O programa mais curto em bytes para fazer isso vence.

Exemplo

Input: tttggloyoi, t
Output: 3

Input: onomatopoe, o
Output: 4

Pitão, 3 bytes

/ww

Exemplo de execução:

$ pyth -c '/ww'
sdhkfhjkkj
k
3

Obviamente, o usuário pode inserir mais ou menos de 10 letras na primeira entrada, mas não precisamos nos preocupar com o que acontece quando o usuário viola as especificações.

Pitão - 3 bytes

Uma resposta Pyth diferente, menos óbvia, do mesmo tamanho. Dobra contando sobre a entrada.

/FQ

Conjunto de Teste .

JavaScript, 32

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

Bash, 24 caracteres

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

Exemplo de execução:

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

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

Retina , 12 bytes

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

Simplesmente uma regex que corresponde a um caractere igual ao último caractere na entrada (exceto ele próprio). Quando recebe uma única regex, o Retina simplesmente retorna o número de correspondências.

Labirinto , 32 29 27 24 bytes

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

Isso lê o caractere único primeiro, seguido pela sequência na qual contar e assume que não há bytes nulos na sequência.

Explicação

O código começa com ),}, que define a parte inferior da pilha 1, lê o primeiro caractere e o move para a pilha auxiliar para uso futuro. O 1contador será nosso (o deslocamento de 1 será cancelado posteriormente e é necessário que o IP faça as curvas necessárias).

O IP agora será movido para baixo para ler o primeiro caractere da string de pesquisa ,. O valor é negado com `, novamente, para obter o comportamento correto de rotação. Enquanto estivermos lendo caracteres do STDIN, o IP agora segue este loop:

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

{:}faz uma cópia do código de caractere armazenado e o +adiciona ao valor atual. Se o resultado for 0(ou seja, o personagem atual é o que estamos procurando), o IP avança: -simplesmente se livra do 0, )incrementa o contador, {}é um não-op.

No entanto, se o resultado depois +for diferente de zero, não queremos contar o caractere atual. Portanto, o IP vira à direita. Esse é um beco sem saída, para que o código seja executado duas vezes, uma para frente e outra para trás. Ou seja, o código real nesse caso se torna );___;)+-){}. );apenas se livra dessa diferença diferente de zero, ___pressiona 3 zeros, mas ;descarta um deles. )incrementa um dos dois zeros restantes, os +adiciona em um único 1, -subtrai do contador e )incrementa o contador. Em outras palavras, criamos um no-op muito elaborado.

Quando atingimos o EOF, ,empurra -1, que `se transforma 1e o IP vira à direita. -subtrai o 1do contador (cancelando o deslocamento inicial). !imprime o contador e @finaliza o programa.

Python 3, 29 bytes

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

Meh, isso foi fácil. Supõe que a entrada seja uma sequência de dez letras.

Boneco de neve 1.0.2 , 16 caracteres

~vgvgaSaLNdEtSsP

Surpreendentemente curto. Explicação:

~      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

Metaprogramação de modelos em C ++, 160 154 116 bytes

Apenas pelas risadinhas.

Obrigado ao ex-bart por jogar golfe!

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;

Uso: O primeiro caractere na instanciação do modelo é o caractere a ser pesquisado.

Conclua com clang -std = c ++ 11 -c -> o resultado está no início da mensagem de erro.

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

Conclua com gcc -std = c ++ 11 -c -> o resultado está na parte inferior da mensagem de erro.

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)

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

Versão de 154 bytes

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;

Versão de 160 bytes:

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 bytes

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

Javascript (ES6), 26 bytes

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

Essa solução rápida e fácil define uma função anônima. Para usá-lo, adicione uma declaração de variável ao início. Experimente:

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: Ah, vejo que já existe uma solução muito semelhante. Espero que esteja tudo bem.

Haskell, 21 bytes

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

C ++, 78 bytes

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

Ligue assim:

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

Elemento , 23 bytes

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

A nova linha faz parte do programa. Na verdade, estou usando-o como um nome de variável .

Esse programa basicamente funciona armazenando o caractere de destino em uma variável, mantendo a string atual no topo da pilha e, em seguida, repetindo o processo "cortar, comparar e mover o resultado por baixo", somando os resultados no final.

A nova linha como um nome de variável vem do uso da nova linha no final da entrada, cortando-a e armazenando nela. A nova linha no código é onde eu li.

A entrada é assim:

qqqqwwweee
q

A saída é assim

4

Julia, 26 25 bytes

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

A findinfunção retorna os índices no primeiro argumento no qual o segundo argumento é encontrado como um vetor. O comprimento do vetor é o número de ocorrências.

Guardou um byte graças a Glen O.

APL, 7 3 bytes

+/⍷

Isso cria um trem de função. Ele funciona criando um vetor de zeros e aqueles correspondentes aos índices nos quais o caractere aparece na string ( ⍷). O vetor é então somado ( +/).

Guardado 4 bytes graças a kirbyfan64sos e NBZ!

Perl, 21 16 caracteres

(Código de 13 caracteres + opção de linha de comando de 3 caracteres.)

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

Exemplo de execução:

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 bytes

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

Uso:
chame o script com dois argumentos.
php script.php qwertzqwertz q

PHP, 23 bytes

Se você registrar Variáveis ​​globais (somente possível no PHP 5.3 e abaixo), poderá salvar 12 bytes (graças a Martijn )

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

Uso:
chame o script e declare variáveis ​​globaisphp script.php?a=qwertzqwertz&b=q

Dyalog APL , 3 bytes

      +/=

Ou seja, "A soma dos bytes iguais". Por exemplo:

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

ou apenas

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

K não vence APL neste momento.

Experimente online.

T-SQL, 99 40 bytes

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

Simplesmente faz a diferença entre a string de entrada e a string com o caractere removido. Recebe informações da tabela t

A edição foi alterada para remover um problema na contagem de espaços e levar em consideração as entradas aceitáveis ​​atuais para o SQL. Obrigado @BradC por todas as alterações e economias

Oitava / Matlab, 33 bytes

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

J, 5 bytes

+/@:=

Sinto que J teria um built-in para isso, mas não consegui encontrar um - talvez um dos usuários ativos de J possa me esclarecer. Então, ao invés disso, isso se aplica primeiro =às entradas, transformando cada caractere 1se for igual ao solicitado ou 0não. Então +/calcula a soma dessa lista.

Arquivo em lote, 121 bytes

Porque eu sou masoquista ...

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%

Aviso: Supõe que _isso não ocorra na sequência de entrada. Nesse caso, a variável eprecisa ser ajustada adequadamente.

Isso configura nossa variável de contador c, e nossa demarcação de fim de sequência como _, antes de anexá-la à nossa sequência de entrada %1e definir a sequência concatenada como t. Então, estamos entrando em loop :l, definimos uma variável de caractere temporário apara ser o primeiro caractere t, verifique se ela corresponde à nossa segunda string de entrada %2e incrementoc se true, e apare o primeiro caractere t. Nossa condição de fim de loop é tcomparada à demarcação de fim de string e retorna, se não. Em seguida, echoeliminamos o valor do nosso contador.

Provavelmente seria possível usar um FORloop, mas isso exigiria a ativação da DelayedExpansion , que eu acho que será mais longa em bytes do que isso. A verificação disso é deixada como um exercício para o leitor.

CJam, 5 bytes

ll/,(

Explicação

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

PowerShell, 32 bytes

Um quatro por um! E eles são todos do mesmo comprimento! :)

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

ou

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

Alternativamente,

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

ou

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

Os dois primeiros estilos usam o operador inline -split, enquanto os dois segundos lançam implicitamente o primeiro argumento como uma String e usam o.Split() operador baseado em string. Em todos os casos, uma matriz é retornada, onde devemos decrementar Count por um, pois estamos recebendo de volta mais um item da matriz do que as ocorrências do segundo argumento.

_{Esse foi meio divertido ...}

Julia, 21 bytes

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

Observe que exige que cseja um caractere, não uma sequência de caracteres únicos. Então você o usa como f("test me",'e')(que retorna 2) e não f("test me","e")(que retorna 0, porque 'e'!="e").

> <> (Peixe) , 30 bytes

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

Pega a string e, em seguida, o caractere para contar. A entrada não está separada (pelo menos no intérprete online). Experimente no intérprete on-line: http://fishlanguage.com Eu contei os bytes manualmente, então, deixe-me saber se estou errado.

Explicação

Primeiro,> <> é bidimensional ee percorre uma linha ou coluna até encontrar um ;erro. Isso significa que, se continuar da esquerda para a direita (como acontece no início de um programa), ele contornará a linha se chegar ao fim e não for movido ou instruído para interromper o programa. Alguns caracteres por linha serão repetidos porque têm funções diferentes, dependendo da direção do ponteiro, e a quarta linha terá caracteres na ordem inversa, porque o ponteiro se move da direita para a esquerda.

Um resumo do programa é fornecido abaixo. Veja as instruções listadas para> <> nos esolangs para ver o que cada caractere individual faz.

Linha 1: 0&v

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

Linha 2: =?\ilb

(começando onde a linha 1 move o ponteiro para, ou seja, o terceiro caractere)

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

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

(começando no terceiro caractere)

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

Linha 4: n&/;

(começando no terceiro caractere)

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

Ruby, 22 20 bytes

p gets.count(gets)-1

Demonstração: http://ideone.com/MEeTd2

O -1é devido ao fato de que getsrecupera a entrada, além de um caractere de nova linha. Ruby String#countconta o número de vezes que qualquer caractere do argumento ocorre na string.

Por exemplo, para a entrada [ test\n, t\n], tocorre duas vezes e \nocorre uma vez e precisa ser subtraído.

Ruby, 18 bytes

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

Japonês , 2 bytes

èV

Experimente online!