Desafío

Escriba un programa que, dada una cadena de x10 caracteres de longitud y un carácter y, muestre el número de veces que el carácter yaparece en la cadena x.

El programa más corto en bytes para hacerlo gana.

Ejemplo

Input: tttggloyoi, t
Output: 3

Input: onomatopoe, o
Output: 4

Pyth, 3 bytes

/ww

Ejemplo de ejecución:

$ pyth -c '/ww'
sdhkfhjkkj
k
3

Por supuesto, el usuario podría ingresar más o menos de 10 letras en la primera entrada, pero no debemos preocuparnos por lo que sucede cuando el usuario viola la especificación.

Pyth - 3 bytes

Una respuesta Pyth diferente, menos obvia, del mismo tamaño. Se pliega contando sobre la entrada.

/FQ

Test Suite .

JavaScript, 32

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

Bash, 24 caracteres

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

Ejecución de muestra:

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

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

Retina , 12 bytes

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

Simplemente una expresión regular que coincide con un carácter que es igual al último carácter de la entrada (excepto a sí mismo). Cuando se le da una sola expresión regular, Retina simplemente devuelve el número de coincidencias.

Laberinto , 32 29 27 24 bytes

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

Esto lee primero el carácter único, seguido de la cadena en la que se debe contar, y supone que no hay bytes nulos en la cadena.

Explicación

El código comienza con ),}, que establece la parte inferior de la pila en 1, lee el primer carácter y lo mueve a la pila auxiliar para su uso futuro. El 1será nuestro contador (el desplazamiento de 1 será cancelada más tarde y es necesario que el IP para tomar las vueltas necesarias).

La IP ahora se moverá hacia abajo para leer el primer carácter de la cadena de búsqueda con ,. El valor se niega con `, nuevamente, para obtener el comportamiento de giro correcto. Mientras leemos caracteres de STDIN, la IP ahora seguirá este ciclo:

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

{:}realiza una copia del código de caracteres almacenado y lo +agrega al valor actual. Si el resultado es 0( es decir, el personaje actual es el que estamos buscando), la IP se mueve hacia adelante: -simplemente se deshace de él 0, )incrementa el contador, {}no funciona.

Sin embargo, si el resultado posterior +no es cero, no queremos contar el carácter actual. Entonces, la IP toma un giro a la derecha en su lugar. Eso es un callejón sin salida, por lo que el código allí se ejecuta dos veces, una hacia adelante y otra hacia atrás. Es decir, el código real en este caso se convierte );___;)+-){}. );simplemente se deshace de esa diferencia que no es cero, ___empuja 3 ceros, pero ;descarta uno de ellos. )incrementa uno de los dos ceros restantes, los +suma en uno solo 1, lo -resta del contador e )incrementa el contador. En otras palabras, hemos creado un no-op muy elaborado.

Cuando golpeamos EOF, ,empuja -1, que se `convierte 1y la IP gira a la derecha. -resta el 1del contador (cancelando el desplazamiento inicial). !imprime el contador y @finaliza el programa.

Python 3, 29 bytes

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

Meh, esto fue fácil. Asume que la entrada es una cadena de diez letras.

Muñeco de nieve 1.0.2 , 16 caracteres

~vgvgaSaLNdEtSsP

Sorprendentemente corto. Explicación:

~      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-Metaprogramación, 160 154 116 bytes

Solo por las risas.

¡Gracias a ex-bart por jugar 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;

Uso: El primer carácter en la instancia de plantilla es el personaje a buscar.

Cumple con clang -std = c ++ 11 -c -> el resultado está al comienzo del mensaje de error.

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

Cumple con gcc -std = c ++ 11 -c -> el resultado está en la parte inferior del mensaje de error.

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)

Busque A < 3 , 't', '\ 000'> y A < 3 , 't', '\ x00'>

Versión 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;

Versión 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

Esta solución rápida y fácil define una función anónima. Para usarlo, agregue una declaración de variable al principio. Pruébalo:

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>

EDITAR: Oh, veo que ya hay una solución muy similar. Espero que esté bien.

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

Llame así:

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

Elemento , 23 bytes

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

La nueva línea es parte del programa. En realidad lo estoy usando como un nombre de variable .

Básicamente, este programa funciona almacenando el carácter de destino en una variable, manteniendo la cadena actual en la parte superior de la pila y luego haciendo un bucle en el proceso "cortar, comparar y mover el resultado debajo", sumando los resultados al final.

La nueva línea como nombre de variable proviene del uso de la nueva línea al final de la entrada cortándola y almacenándola. La nueva línea en el código es donde leí.

La entrada es así:

qqqqwwweee
q

La salida es así

4

Julia, 26 25 bytes

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

La findinfunción devuelve los índices en el primer argumento en el que el segundo argumento se encuentra como un vector. La longitud del vector es el número de ocurrencias.

Guardado un byte gracias a Glen O.

APL, 7 3 bytes

+/⍷

Esto crea un tren de funciones. Funciona creando un vector de ceros y unos correspondientes a los índices en los que aparece el carácter en la cadena ( ⍷). El vector se suma ( +/).

¡Guardado 4 bytes gracias a kirbyfan64sos y NBZ!

Perl, 21 16 caracteres

(Código de 13 caracteres + opción de línea de comando de 3 caracteres).

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

Ejecución de muestra:

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:
llame al script con dos argumentos.
php script.php qwertzqwertz q

PHP, 23 bytes

Si registra Variables globales (solo posible en PHP 5.3 y versiones posteriores) puede guardar 12 bytes (gracias a Martijn )

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

Uso:
llame al script y declare variables globalesphp script.php?a=qwertzqwertz&b=q

Dyalog APL , 3 bytes

      +/=

Es decir, "La suma de los bytes iguales". P.ej:

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

o solo

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

K no supera a APL esta vez.

Pruébalo en línea.

T-SQL, 99 40 bytes

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

Simplemente hace una diferencia entre la cadena de entrada y la cadena con el carácter eliminado. Toma información de la tabla t

Editar cambiado para eliminar un problema con los espacios de conteo y para tener en cuenta las entradas aceptables actuales para SQL. Gracias @BradC por todos los cambios y ahorros

Octava / Matlab, 33 bytes

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

J, 5 bytes

+/@:=

Siento que J tendría una función incorporada para esto, pero no he podido encontrar una, tal vez uno de los usuarios activos de J puede iluminarme. Por lo tanto, esto primero se aplica =a las entradas, convirtiendo cada carácter en 1si es igual al solicitado o 0no. Luego +/calcula la suma de esa lista.

Archivo por lotes, 121 bytes

Porque soy 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%

Advertencia: Asume que eso _no ocurre en la cadena de entrada. Si lo hace, entonces la variablee debe ajustarse adecuadamente.

Esto configura nuestra variable de contador c, y nuestra demarcación de fin de cadena como _, antes de agregar eso a nuestra cadena de entrada %1y establecer la cadena concatenada en t. Luego, estamos ingresando al bucle :l, establecemos una variable de caracteres temporal apara que sea el primer carácter t, verificamos si coincide con nuestra segunda cadena de entrada %2e incrementamos csi es verdadero, luego recortamos el primer carácter t. Nuestra condición de fin de ciclo se compara tcon nuestra demarcación de fin de cadena, y se repite si no. Nosotros entoncesecho sacamos el valor de nuestro contador.

Probablemente sería posible usar un FORbucle en su lugar, pero eso requeriría habilitar DelayedExpansion , que creo que en realidad será más largo en bytes que esto. La verificación de eso se deja como ejercicio para el lector.

CJam, 5 bytes

ll/,(

Explicación

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

PowerShell, 32 bytes

¡Un cuatro por uno! ¡Y todos tienen la misma longitud! :)

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

o

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

Alternativamente,

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

o

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

Los dos primeros estilos usan el operador en línea -split , mientras que los dos siguientes arrojan implícitamente el primer argumento como una cadena y usan el .Split()operador basado en cadenas. En todos los casos, se devuelve una matriz, donde debemos disminuir Count por uno, ya que estamos recuperando un elemento de matriz más que las ocurrencias del segundo argumento.

_{Este fue un poco divertido ...}

Julia, 21 bytes

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

Tenga en cuenta que requiere que csea ​​un carácter, no una cadena de un solo carácter. Entonces lo usa como f("test me",'e')(que devuelve 2) y no f("test me","e")(que devuelve 0, porque 'e'!="e").

> <> (Pescado) , 30 bytes

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

Toma la cadena, luego el personaje para contar. La entrada no está separada (al menos en el intérprete en línea). Pruébelo en el intérprete en línea: http://fishlanguage.com Conté los bytes a mano, así que avíseme si me equivoco.

Explicación

En primer lugar,> <> es bidimensional y recorre una línea o columna hasta que golpea un ; error. Esto significa que si continúa de izquierda a derecha (como lo hace al comienzo de un programa), se ajustará a la línea si llega al final y no se mueve o se le dice que detenga el programa. Algunos caracteres por línea se repetirán porque tienen diferentes funciones dependiendo de la dirección del puntero, y la cuarta línea tendrá caracteres en orden inverso porque el puntero se mueve de derecha a izquierda.

A continuación se proporciona un resumen del programa. Mira las instrucciones enumeradas para> <> en esolangs para ver qué hace cada personaje individual.

Línea 1: 0&v

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

Línea 2: =?\ilb

(comenzando donde la línea 1 mueve el puntero, es decir, el tercer carácter)

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

línea 3: =?\:@=&+&l1

(a partir del tercer personaje)

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

Línea 4: n&/;

(a partir del tercer personaje)

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

Ruby, 22 20 bytes

p gets.count(gets)-1

Demostración: http://ideone.com/MEeTd2

Esto -1se debe al hecho de que getsrecupera la entrada, más un carácter de nueva línea. Ruby String#countcuenta la cantidad de veces que cualquier carácter del argumento ocurre en la cadena.

Por ejemplo, para la entrada [ test\n, t\n], tocurre dos veces y \nocurre una vez, y debe restarse.

Rubí, 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'

Japt , 2 bytes

èV

Pruébalo en línea!