Herausforderung

Schreiben Sie ein Programm, das bei einer Zeichenfolge mit einer xLänge von 10 Zeichen und einem Zeichen die yHäufigkeit ausgibt, mit der Zeichen yin Zeichenfolgen vorkommen x.

Das kürzeste Programm in Bytes gewinnt.

Beispiel

Input: tttggloyoi, t
Output: 3

Input: onomatopoe, o
Output: 4

Pyth, 3 Bytes

/ww

Beispiellauf:

$ pyth -c '/ww'
sdhkfhjkkj
k
3

Natürlich kann der Benutzer bei der ersten Eingabe mehr oder weniger als 10 Buchstaben eingeben, aber wir müssen uns keine Gedanken darüber machen, was passiert, wenn der Benutzer die Spezifikation verletzt.

Pyth - 3 Bytes

Eine andere, weniger offensichtliche Pyth-Antwort derselben Größe. Es klappt über die Eingabe zu zählen.

/FQ

Test Suite .

JavaScript, 32

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

Bash, 24 Zeichen

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

Probelauf:

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

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

Retina , 12 Bytes

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

Einfach ein regulärer Ausdruck, der einem Zeichen entspricht, das dem letzten Zeichen in der Eingabe entspricht (außer sich selbst). Bei einem einzelnen regulären Ausdruck gibt Retina einfach die Anzahl der Übereinstimmungen zurück.

Labyrinth , 32 29 27 24 Bytes

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

Dies liest zuerst das einzelne Zeichen, gefolgt von der Zeichenfolge, in der gezählt werden soll, und geht davon aus, dass die Zeichenfolge keine Nullbytes enthält.

Erläuterung

Der Code beginnt mit ),}: Er setzt den unteren Rand des Stapels auf 1, liest das erste Zeichen und verschiebt es zur zukünftigen Verwendung in den Zusatzstapel. Das 1wird unser Zähler sein (der Versatz von 1 wird später abgebrochen und ist notwendig für die IP der erforderlichen Umdrehungen zu nehmen).

Die IP bewegt sich jetzt nach unten, um das erste Zeichen der Suchzeichenfolge mit zu lesen ,. Der Wert wird mit negiert `, um wieder das richtige Drehverhalten zu erhalten. Während wir Zeichen aus STDIN lesen, folgt die IP nun dieser Schleife:

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

{:}erstellt eine Kopie des gespeicherten Zeichencodes und +fügt ihn dem aktuellen Wert hinzu. Wenn das Ergebnis ist 0(dh das aktuelle Zeichen ist das, nach dem wir suchen), bewegt sich die IP geradeaus: Entfernt -einfach das 0, )erhöht den Zähler, {}ist ein No-Op.

Wenn das Ergebnis danach +jedoch ungleich Null ist, möchten wir das aktuelle Zeichen nicht zählen. Die IP biegt also stattdessen nach rechts ab. Das ist eine Sackgasse, so dass dort Code zweimal ausgeführt wird, einmal vorwärts und einmal rückwärts. Das heißt, der tatsächliche Code wird in diesem Fall );___;)+-){}. beseitigt nur die );Differenz ungleich Null, ___drückt 3 Nullen, ;verwirft aber eine von ihnen. )Inkrementiert eine der beiden verbleibenden zwei Nullen, +addiert sie zu einer einzelnen 1, -subtrahiert sie vom Zähler und )inkrementiert den Zähler. Mit anderen Worten, wir haben ein sehr aufwändiges No-Op erstellt.

Wenn wir EOF drücken, ,drückt das -1, und die IP `biegt nach 1rechts ab. -subtrahiert den 1vom Zähler (Aufheben des Anfangsoffsets). !druckt den Zähler aus und @beendet das Programm.

Python 3, 29 Bytes

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

Meh, das war einfach. Angenommen, es handelt sich bei der Eingabe um eine Zeichenfolge mit zehn Buchstaben.

Schneemann 1.0.2 , 16 Zeichen

~vgvgaSaLNdEtSsP

Überraschend kurz. Erläuterung:

~      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-Metaprogrammierung, 160 154 116 Bytes

Nur für das Kichern.

Danke an Ex-Bart fürs Golfen!

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;

Verwendung: Das erste Zeichen in der Template-Instanz ist das zu durchsuchende Zeichen.

Ergänzen Sie mit clang -std = c ++ 11 -c -> das Ergebnis steht am Anfang der Fehlermeldung.

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

Kompilieren Sie mit gcc -std = c ++ 11 -c -> das Ergebnis steht am Ende der Fehlermeldung.

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)

Suchen Sie nach A < 3 , 't', '\ 000'> und A < 3 , 't', '\ x00'>

154-Byte-Version

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;

160-Byte-Version:

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 Byte

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

Diese schnelle und einfache Lösung definiert eine anonyme Funktion. Fügen Sie dazu am Anfang eine Variablendeklaration hinzu. Versuch es:

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, ich sehe, es gibt bereits eine sehr ähnliche Lösung. Ich hoffe das ist ok

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

Rufen Sie wie folgt an:

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

Element , 23 Bytes

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

Die Newline ist Teil des Programms. Ich benutze es tatsächlich als Variablenname .

In diesem Programm wird das Zielzeichen in einer Variablen gespeichert, wobei die aktuelle Zeichenfolge oben im Stapel bleibt. Anschließend wird der Vorgang "Zerhacken, Vergleichen und Ergebnis darunter verschieben" in einer Schleife ausgeführt, wobei die Ergebnisse am Ende addiert werden.

Die neue Zeile als Variablenname stammt aus der Verwendung der neuen Zeile am Ende der Eingabe, indem sie abgeschnitten und darin gespeichert wird. Die neue Zeile im Code ist, wo ich daraus gelesen habe.

Die Eingabe ist wie folgt:

qqqqwwweee
q

Die Ausgabe ist wie folgt

4

Julia, 26 25 Bytes

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

Das findin Funktion gibt die Indizes im ersten Argument zurück, bei denen sich das zweite Argument als Vektor befindet. Die Länge des Vektors ist die Anzahl der Vorkommen.

Dank Glen O. ein Byte gespart

APL, 7 3 Bytes

+/⍷

Dies schafft einen Funktionszug. Dabei wird ein Vektor aus Nullen und Einsen erstellt, der den Indizes entspricht, an denen das Zeichen in der Zeichenfolge ( ⍷) angezeigt wird . Der Vektor wird dann summiert ( +/).

4 Bytes gespart dank kirbyfan64sos und NBZ!

Perl, 21 16 Zeichen

(13 Zeichen Code + 3 Zeichen Befehlszeilenoption.)

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

Probelauf:

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

Verwendung:
Rufen Sie das Skript mit zwei Argumenten auf.
php script.php qwertzqwertz q

PHP, 23 Bytes

Wenn Sie globale Variablen registrieren (nur in PHP 5.3 und niedriger möglich), können Sie 12 Bytes einsparen (dank Martijn )

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

Verwendung:
Rufen Sie das Skript auf und deklarieren Sie globale Variablenphp script.php?a=qwertzqwertz&b=q

Dyalog APL , 3 Bytes

      +/=

Dh "Die Summe der gleichen Bytes". Z.B:

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

oder nur

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

K schlägt diesmal APL nicht.

Probieren Sie es online aus.

T-SQL, 99 40 Bytes

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

Macht einfach einen Unterschied zwischen der Eingabezeichenfolge und der Zeichenfolge, bei der das Zeichen entfernt ist. Übernimmt die Eingabe aus Tabelle t

Die Bearbeitung wurde geändert, um ein Problem beim Zählen von Leerzeichen zu entfernen und die aktuell akzeptablen Eingaben für SQL zu berücksichtigen. Vielen Dank an @BradC für alle Änderungen und Einsparungen

Oktave / Matlab, 33 Bytes

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

J, 5 Bytes

+/@:=

Ich habe das Gefühl, dass J eine integrierte Funktion dafür hat, aber ich konnte keine finden - vielleicht kann mich einer der aktiven J-Benutzer aufklären. Dies gilt stattdessen zunächst für =die Eingaben und wandelt jedes Zeichen in ein Zeichen 1um, das dem angeforderten entspricht, oder in ein 0anderes. Dann +/berechnet die Summe dieser Liste.

Batch-Datei, 121 Bytes

Weil ich ein Masochist bin ...

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%

Warnung: Es wird davon ausgegangen, dass _dies in der Eingabezeichenfolge nicht vorkommt. Wenn ja, dann die Variablee entsprechend angepasst werden.

Dies richtet unsere Zählervariable cund unsere Zeichenfolgenendeabgrenzung wie _folgt ein, bevor diese an unsere Eingabezeichenfolge angehängt %1und die verkettete Zeichenfolge auf festgelegt wird t. Dann geben wir eine Schleife ein :l, setzen eine temporäre Zeichenvariable aals erstes Zeichen von t, prüfen, ob sie mit unserer zweiten Eingabezeichenfolge übereinstimmt %2und erhöhen sie, cwenn sie wahr ist, und schneiden das erste Zeichen von ab t. Unsere End-of-Loop-Bedingung vergleicht sich mit tunserer End-of-String-Abgrenzung und führt, falls nicht, eine Schleife zurück. Wir haben dann echoden Wert unserer Theke raus.

Es wäre wahrscheinlich möglich, FORstattdessen eine Schleife zu verwenden, aber dies würde die Aktivierung von DelayedExpansion erfordern , was meiner Meinung nach tatsächlich länger byteweise sein wird. Die Überprüfung bleibt dem Leser überlassen.

CJam, 5 Bytes

ll/,(

Erläuterung

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

PowerShell, 32 Bytes

Ein Vier-für-Eins! Und sie sind alle gleich lang! :)

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

oder

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

Alternative,

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

oder

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

Die ersten beiden Stile verwenden den Inline-Operator -split, während die zweiten beiden implizit das erste Argument als String umwandeln und den verwenden.Split() stringbasierten Operator verwenden. In allen Fällen wird ein Array zurückgegeben, in dem Count um eins dekrementiert werden muss, da ein Arrayelement mehr zurückgegeben wird als das zweite Argument.

_{Dieser hat ein bisschen Spaß gemacht ...}

Julia, 21 Bytes

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

Beachten Sie, dass es sich hierbei cum ein Zeichen und nicht um eine Zeichenfolge mit nur einem Zeichen handeln muss. Sie verwenden es also als f("test me",'e')(was 2 zurückgibt) und nicht als f("test me","e")(was 0 zurückgibt, weil 'e'!="e").

> <> (Fisch) , 30 Bytes

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

Nimmt die Zeichenfolge und dann das zu zählende Zeichen. Die Eingabe wird nicht getrennt (zumindest im Online-Interpreter). Probieren Sie es mit dem Online-Interpreter aus: http://fishlanguage.com Ich habe die Bytes von Hand gezählt. Lassen Sie es mich wissen, wenn ich falsch liege.

Erläuterung

Zunächst ist> <> zweidimensional und durchläuft eine Zeile oder Spalte, bis sie auf a trifft ; oder ein Fehler auftritt. Dies bedeutet, dass, wenn es von links nach rechts verläuft (wie zu Beginn eines Programms), es sich um die Zeile dreht, wenn es das Ende erreicht und nicht bewegt oder angewiesen wird, das Programm zu stoppen. Einige Zeichen pro Zeile werden wiederholt, da sie abhängig von der Richtung des Zeigers unterschiedliche Funktionen haben, und die vierte Zeile enthält Zeichen in umgekehrter Reihenfolge, da sich der Zeiger von rechts nach links bewegt.

Eine Zusammenfassung des Programms finden Sie weiter unten. Sehen Sie sich die Anweisungen für> <> auf Esolangs an, um zu sehen, was die einzelnen Zeichen tun .

Linie 1: 0&v

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

Zeile 2: =?\ilb

(Beginnend dort, wo Zeile 1 den Zeiger bewegt, dh das dritte Zeichen)

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

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

(ab dem dritten Zeichen)

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

Zeile 4: n&/;

(ab dem dritten Zeichen)

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

Ruby, 22 bis 20 Bytes

p gets.count(gets)-1

Demo: http://ideone.com/MEeTd2

Das -1ist aufgrund der Tatsache , dass getsErmittelt die Eingabe, sowie ein Zeilenende- Zeichen. Ruby's String#countzählt, wie oft ein Zeichen aus dem Argument in der Zeichenfolge vorkommt.

Beispielsweise tritt für die Eingabe [ test\n, t\n] das tzweimal und das \neinmal auf und muss subtrahiert werden.

Ruby, 18 Bytes

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

Verwendung:

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

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

Japt , 2 Bytes

èV

Probieren Sie es online!