Défi

Écrivez un programme qui, étant donné une chaîne de x10 caractères et un caractère y, renvoie le nombre de fois où le caractère yapparaît dans la chaîne x.

Le programme le plus court en octets pour ce faire gagne.

Exemple

Input: tttggloyoi, t
Output: 3

Input: onomatopoe, o
Output: 4

Pyth, 3 octets

/ww

Exemple d'exécution:

$ pyth -c '/ww'
sdhkfhjkkj
k
3

Bien sûr, l'utilisateur peut entrer plus ou moins de 10 lettres sur la première entrée, mais nous n'avons pas à nous soucier de ce qui se passe lorsque l'utilisateur viole la spécification.

Pyth - 3 octets

Une réponse Pyth différente, moins évidente, de la même taille. Il se replie en comptant sur l'entrée.

/FQ

Suite de tests .

JavaScript, 32

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

Bash, 24 caractères

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

Exemple d'exécution:

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

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

Rétine , 12 octets

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

Simplement une expression régulière qui correspond à un caractère qui est égal au dernier caractère de l'entrée (sauf lui-même). Lorsqu'une seule expression régulière est donnée, Retina renvoie simplement le nombre de correspondances.

Labyrinthe , 32 29 27 24 octets

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

Cela lit d'abord le caractère unique, suivi de la chaîne dans laquelle compter, et suppose qu'il n'y a pas d'octets nuls dans la chaîne.

Explication

Le code commence par ),}, qui définit le bas de la pile sur 1, lit le premier caractère et le déplace vers la pile auxiliaire pour une utilisation future. Le 1sera notre compteur (le décalage de 1 sera annulé plus tard et est nécessaire pour que l'IP prenne les tours nécessaires).

L'IP va maintenant descendre pour lire le premier caractère de la chaîne de recherche avec ,. La valeur est annulée avec `, encore une fois pour obtenir le comportement de braquage correct. Pendant que nous lisons des caractères de STDIN, l'IP suivra maintenant cette boucle:

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

{:}crée une copie du code de caractère stocké et l' +ajoute à la valeur actuelle. Si le résultat est 0(c'est-à-dire que le caractère actuel est celui que nous recherchons), l'IP se déplace tout droit: -se débarrasse simplement du 0, )incrémente le compteur,{} est un no-op.

Cependant, si le résultat après +est différent de zéro, nous ne voulons pas compter le caractère actuel. L'IP prend donc un virage à droite à la place. C'est une impasse, de sorte que le code y est exécuté deux fois, une fois en avant et une en arrière. Autrement dit, le code réel dans ce cas devient );___;)+-){}. );se débarrasse simplement de cette différence non nulle, ___pousse 3 zéros, mais ;supprime l'un d'eux. )incrémente l'un des deux zéros restants, les +ajoute en un seul 1, le -soustrait du compteur et) incrémente le compteur. En d'autres termes, nous avons créé un no-op très élaboré.

Lorsque nous frappons EOF, ,pousse -1, qui `se transforme en 1et l'IP prend un virage à droite. -soustrait le 1du compteur (annulation du décalage initial). !imprime le compteur et @termine le programme.

Python 3, 29 octets

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

Meh, c'était facile. Suppose que l'entrée est une chaîne de dix lettres.

Snowman 1.0.2 , 16 caractères

~vgvgaSaLNdEtSsP

Étonnamment court. Explication:

~      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-Métaprogrammation, 160 154 116 octets

Juste pour les rires.

Merci à ex-bart de l'avoir joué au 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;

Utilisation: Le premier caractère de l'instanciation du modèle est le caractère à rechercher.

Compléter avec clang -std = c ++ 11 -c -> le résultat est au début du message d'erreur.

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

Complétez avec gcc -std = c ++ 11 -c -> le résultat est au bas du message d'erreur.

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)

Recherchez A < 3 , 't', '\ 000'> et A < 3 , 't', '\ x00'>

Version 154 octets

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;

Version 160 octets:

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 octets

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

Javascript (ES6), 26 octets

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

Cette solution quick'n'easy définit une fonction anonyme. Pour l'utiliser, ajoutez une déclaration de variable au début. Essaye le:

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, je vois qu'il y a déjà une solution très similaire. J'espère que ça va.

Haskell, 21 octets

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

C ++, 78 octets

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

Appelez comme ceci:

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

Élément , 23 octets

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

La nouvelle ligne fait partie du programme. Je l'utilise en fait comme nom de variable .

Ce programme fonctionne essentiellement en stockant le caractère cible dans une variable, en gardant la chaîne actuelle en haut de la pile, puis en bouclant le processus "hacher, comparer et déplacer le résultat en dessous", en additionnant les résultats à la fin.

La nouvelle ligne en tant que nom de variable provient de l'utilisation de la nouvelle ligne à la fin de l'entrée en la coupant et en la stockant. La nouvelle ligne du code est l'endroit où je l'ai lu.

L'entrée est comme ceci:

qqqqwwweee
q

La sortie est comme ça

4

Julia, 26 25 octets

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

le findin fonction renvoie les indices du premier argument auxquels le deuxième argument est trouvé comme vecteur. La longueur du vecteur est le nombre d'occurrences.

Un octet enregistré grâce à Glen O.

APL, 7 3 octets

+/⍷

Cela crée un train de fonctions. Il fonctionne en créant un vecteur de zéros et de uns correspondant aux indices auxquels le caractère apparaît dans la chaîne ( ⍷). Le vecteur est ensuite additionné (+/ ).

4 octets enregistrés grâce à kirbyfan64sos et NBZ!

Perl, 21 16 caractères

(Code de 13 caractères + option de ligne de commande à 3 caractères.)

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

Exemple d'exécution:

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 octets

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

Utilisation:
appelez le script avec deux arguments.
php script.php qwertzqwertz q

PHP, 23 octets

Si vous enregistrez des variables globales (uniquement possible en PHP 5.3 et inférieur), vous pouvez économiser 12 octets (grâce à Martijn )

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

Usage:
appeler le script et déclarer des variables globalesphp script.php?a=qwertzqwertz&b=q

Dyalog APL , 3 octets

      +/=

C'est-à-dire "La somme des octets égaux". Par exemple:

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

ou juste

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

K ne bat pas APL cette fois.

Essayez-le en ligne.

T-SQL, 99 40 octets

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

Fait simplement une différence entre la chaîne d'entrée et la chaîne avec le caractère supprimé. Prend l'entrée du tableau t

Modifier a été modifié pour supprimer un problème de comptage des espaces et pour prendre en compte les entrées acceptables actuelles pour SQL. Merci @BradC pour tous les changements et économies

Octave / Matlab, 33 octets

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

J, 5 octets

+/@:=

Je pense que J aurait un intégré pour cela, mais je n'ai pas pu en trouver un - peut-être qu'un des utilisateurs actifs de J peut m'éclairer. Au lieu de cela, cela s'applique d'abord =aux entrées, transformant chaque caractère en 1s'il est égal à celui demandé ou 0autrement. +/Calcule ensuite la somme de cette liste.

Fichier de commandes, 121 octets

Parce que je suis masochiste ...

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%

Avertissement: suppose que _cela ne se produit pas dans la chaîne d'entrée. Si c'est le cas, la variable edoit être ajustée de manière appropriée.

Ceci configure notre variable de compteur c, et notre démarcation de fin de chaîne comme _, avant d'ajouter cela à notre chaîne d'entrée %1et de définir la chaîne concaténée sur t. Ensuite, nous entrons dans la boucle :l, nous définissons une variable de caractère temporaire apour être le premier caractère de t, vérifions si elle correspond à notre deuxième chaîne d'entrée %2et incrémentons csi vrai, puis coupons le premier caractère de t. Notre condition de fin de boucle vérifie tnotre démarcation de fin de chaîne et reboucle sinon. Nous sortons ensuite echola valeur de notre compteur.

It would probably be possible to use a FOR loop instead, but that would necessitate enabling DelayedExpansion, which I think will actually be longer byte-wise than this. Verification of that is left as an exercise to the reader.

CJam, 5 bytes

ll/,(

Explanation

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

PowerShell, 32 Bytes

A four-for-one! And they're all the same length! :)

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

or

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

Alternatively,

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

or

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

The first two styles use the inline operator -split, while the second two implicitly casts the first argument as a String and uses the .Split() string-based operator. In all instances an array is returned, where we must decrement Count by one, since we're getting back one more array item than occurrences of the second argument.

_{This one was kinda fun...}

Julia, 21 bytes

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

Note that it requires that c be a char, not a single-character string. So you use it as f("test me",'e') (which returns 2) and not f("test me","e") (which returns 0, because 'e'!="e").

><> (Fish), 30 bytes

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

Takes the string, then character to count. Input isn't separated (at least in the online interpreter). Try it on the online interpreter: http://fishlanguage.com I counted the bytes by hand, so let me know if I'm wrong.

Explanation

First off, ><> is 2 dimensional and and loops through a line or column until it hits a ; or error. This means that if it's proceeding left to right (like it does at the beginning of a program), it will wrap around the line if it reaches the end and is not moved or told to stop the program. Some characters per line will be repeated because they have different functions depending on the direction of the pointer, and the fourth line will have characters in reverse order because the pointer moves right to left.

A summary of the program is provided below. Look at the instructions listed for ><> on esolangs to see what each individual character does.

Line 1: 0&v

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

Line 2: =?\ilb

(starting where line 1 moves the pointer to, i.e. the third character)

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

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

(starting at the third character)

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

Line 4: n&/;

(starting at the third character)

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

Ruby, 22 20 bytes

p gets.count(gets)-1

Demo: http://ideone.com/MEeTd2

The -1 is due to the fact that gets retrieves the input, plus a newline character. Ruby's String#count counts the number of times any character from the argument occurs in the string.

For example, for the input [test\n, t\n], the t occurs twice and the \n occurs once, and needs to be subtracted.

Ruby, 18 bytes

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

Usage:

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

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

Japt, 2 bytes

èV

Try it online!