Meydan okuma

x10 karakter uzunluğunda bir dize ve bir karakter verildiğinde , karakterin dizede ykaç kez yoluştuğunu veren bir program yazın x.

Bayt cinsinden yapılan en kısa program kazanır.

Misal

Input: tttggloyoi, t
Output: 3

Input: onomatopoe, o
Output: 4

Pyth, 3 bayt

/ww

Örnek çalışma:

$ pyth -c '/ww'
sdhkfhjkkj
k
3

Elbette, kullanıcı ilk girişe 10 harften fazla veya daha az harf girebilir, ancak kullanıcı spesifikasyonu ihlal ettiğinde ne olacağı konusunda endişelenmemize gerek yoktur.

Pyth - 3 bayt

Aynı boyutta farklı, daha az belirgin bir Pyth cevabı. Girdi üzerinde sayım katlar.

/FQ

Test Takımı .

JavaScript, 32

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

Bash, 24 karakter

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

Örnek çalışma:

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

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

Retina , 12 bayt

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

Girişteki son karaktere (kendisi hariç) eşit olan bir karakterle eşleşen bir normal ifade. Tek bir normal ifade verildiğinde, Retina sadece eşleşme sayısını döndürür.

Labirent , 32 29 27 24 bayt

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

Bu, önce tek karakteri okur, ardından sayılacak dizeyi okur ve dizede boş bayt olmadığını varsayar.

açıklama

Kod ),}, yığının altını olarak ayarlayan 1ilk karakteri okur ve ileride kullanmak üzere yardımcı yığına taşır. Sayacımız 1olacak (1 ofseti daha sonra iptal edilecektir ve IP'nin gerekli dönüşleri yapması için gereklidir).

IP artık arama dizesinin ilk karakterini okumak için aşağı hareket edecektir ,. `Doğru döndürme davranışını elde etmek için değer ile reddedilir . STDIN'den karakterler okurken, IP şimdi şu döngüyü takip edecek:

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

{:}saklanan karakter kodunun bir kopyasını oluşturur +ve geçerli değere ekler. Sonuç ise 0(yani şimdiki karakter aradığımız biridir), dosdoğru IP hamle: -basitçe kurtulur 0, )artışlarla sayacı, {}no-operasyon.

Ancak, sonraki sonuç +sıfırdan farklıysa , geçerli karakteri saymak istemiyoruz. IP bunun yerine sağa dönüyor. Bu bir çıkmaz sokak, bu nedenle kod iki kez, bir kez ileri ve bir kez geri yürütülür. Yani, bu durumda gerçek kod olur );___;)+-){}. );sıfır olmayan farktan kurtulur, ___3 sıfır basar, ancak ;bunlardan birini atar. )geri kalan iki iki sıfır artışlarla bir, +tek olarak ekler 1, -sayaç ve substratlar bu )artışlarla sayacı. Başka bir deyişle, çok ayrıntılı bir işlem yapmadık.

EOF'a bastığımızda, ,iter -1, `dönüşür 1ve IP sağa döner. sayaçtan -çıkarılır 1(ilk ofseti iptal eder). !sayacı yazdırır ve @programı sonlandırır.

Python 3, 29 bayt

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

Meh, bu kolaydı. Girdinin on harfli bir dize olduğunu varsayar.

Kardan adam 1.0.2 , 16 karakter

~vgvgaSaLNdEtSsP

Şaşırtıcı derecede kısa. Açıklama:

~      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 ++ Şablon-metaprogramming, 160 154 116 bayt

Sadece kıkırdamalar için.

Aşağı golf için eski bart için teşekkürler!

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;

Kullanım: Şablon örneğindeki ilk karakter, aranacak karakterdir.

Clang -std = c ++ 11 -c -> ile uyumlu sonuç hata iletisinin başındadır.

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

Gcc -std = c ++ 11 -c -> ile uyumludur , sonuç hata mesajının altındadır .

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)

A < 3 , 't', '\ 000'> ve A < 3 , 't', '\ x00'>

154 baytlık sürüm

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 baytlık sürüm:

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 bayt

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

Javascript (ES6), 26 bayt

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

Bu quick'n'easy çözümü anonim bir işlevi tanımlar. Bunu kullanmak için, başlangıcına değişken bir bildirim ekleyin. Denemek:

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>

DÜZENLE: Oh, zaten çok benzer bir çözüm olduğunu görüyorum. Umarım bu iyidir.

Haskell, 21 bayt

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

C ++, 78 bayt

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

Bu şekilde arayın:

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

Öğe , 23 bayt

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

Yeni satır, programın bir parçasıdır. Aslında bir değişken adı olarak kullanıyorum .

Bu program temel olarak hedef karakteri bir değişkende saklayarak, geçerli dizeyi yığının üstünde tutarak ve ardından sonucu doğrayarak sonuçları doğrayın ve sonucu doğrayın.

Değişken adı olarak yeni satır, satır sonunu girip içine kaydederek satır sonunu kullanmaktan gelir. Koddaki yeni satır ondan okuduğum yer.

Girdi şöyle:

qqqqwwweee
q

Çıktı böyle

4

Julia, 26 25 bayt

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

findinİşlev ikinci bağımsız bir vektör olarak bulunan edildiği İlk bileşen olarak endeksleri döndürür. Vektörün uzunluğu oluşum sayısıdır.

Glen O. sayesinde bir bayt kurtardı

APL, 7 3 bayt

+/⍷

Bu bir fonksiyon dizisi yaratır. Sıfırların ve karakterin dizede göründüğü dizinlere karşılık gelen bir vektör oluşturarak çalışır⍷ ) . Vektör daha sonra toplanır ( +/).

Kirbyfan64sos ve NBZ sayesinde 4 bayt tasarruf etti!

Perl, 21 16 karakter

(13 karakter kod + 3 karakter komut satırı seçeneği.)

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

Örnek çalışma:

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 bayt

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

Kullanım:
Komut dosyasını iki argümanla çağırın.
php script.php qwertzqwertz q

PHP, 23 bayt

Global Değişkenleri kaydederseniz (sadece PHP 5.3 ve daha önceki sürümlerde mümkündür ) 12 bayt tasarruf edebilirsiniz ( Martijn sayesinde )

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

Kullanımı:
Komut dosyasını çağırın ve global değişkenleri bildirinphp script.php?a=qwertzqwertz&b=q

Dyalog APL , 3 bayt

      +/=

Yani "Eşit baytların toplamı". Örneğin:

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

ya da sadece

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

K bu sefer APL'yi yenmez.

Çevrimiçi deneyin.

T-SQL, 99 40 Bayt

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

Girdi dizesi ile karakter kaldırılmış olan dize arasında bir fark vardır. Tablo t'den girdi alır

Düzenleme , boşluk sayma ile ilgili bir sorunu gidermek ve SQL için geçerli kabul edilebilir girdileri dikkate almak için değiştirildi. Tüm değişiklikler ve tasarruflar için @BradC'a teşekkürler

Oktav / Matlab, 33 bayt

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

J, 5 bayt

+/@:=

J'nin bunun için yerleşik bir şey olduğunu hissediyorum, ancak bir tane bulamadım - belki de aktif J kullanıcılarından biri beni aydınlatabilir. Bunun yerine bu ilk =olarak girişler için geçerlidir , her karakteri 1istenen karaktere eşit veya 0başka bir değere dönüştürür. Sonra +/bu listenin toplamını hesaplar.

Toplu Dosya, 121 Bayt

Çünkü ben mazoşistim ...

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%

Uyarı: _Giriş dizesinde gerçekleşmeyen varsayımlar . Varsa, değişkenin euygun şekilde ayarlanması gerekir.

Bu, giriş değişkenimize eklemeden ve birleştirilmiş dizgiyi ayarlamadan önce sayaç değişkenimizi cve dize sonu sınırlamamızı _şu şekilde %1ayarlar t. Sonra, döngüye giriyoruz , ilk karakter olarak :lgeçici bir karakter değişkeni ayarladık , ikinci girdi dizgimizle eşleşip eşleşmediğini kontrol edin ve true değerini artırın, ardından ilk karakteri kesin . Döngü sonu durumumuz, dize sonu sınırlandırmamıza karşı kontrol eder ve değilse geri döner. Sonra sayacımızın değerini çıkarırız.at%2cttecho

Muhtemelen FORbunun yerine bir döngü kullanmak mümkün olacaktır , ancak bu aslında bundan daha uzun byte-wise olacağını düşündüğüm DelayedExpansion'u etkinleştirmeyi gerektirecektir . Bunun doğrulanması okuyucuya bir alıştırma olarak bırakılmıştır.

CJam, 5 bayt

ll/,(

açıklama

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

PowerShell, 32 Bayt

Bire bir! Ve hepsi aynı uzunlukta! :)

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

veya

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

Alternatif olarak,

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

veya

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

İlk iki stil satır içi işleci -splitkullanırken ikinci ikisi ilk bağımsız değişkeni bir String olarak verir ve .Split()dize tabanlı işleci kullanır . Tüm örneklerde, ikinci argümanın örneklerinden bir dizi öğe daha geri aldığımızdan, Count sayısını bir azaltmamız gerektiği bir dizi döndürülür.

_{Bu biraz eğlenceliydi ...}

Julia, 21 bayt

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

Bunun ctek karakterli bir dize değil bir karakter olması gerektiğini unutmayın . Bu yüzden f("test me",'e')(2 döndürür) olarak (değil f("test me","e"), 0 döndürür 'e'!="e") olarak kullanırsınız.

> <> (Balık) , 30 bayt

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

Dizeyi alır, sonra sayılacak karakteri. Girdi ayrılmamış (en azından çevrimiçi yorumlayıcıda). Çevrimiçi yorumlayıcıda deneyin: http://fishlanguage.com Baytları elle saydım, bu yüzden yanlış olduğumu bana bildirin.

açıklama

Öncelikle,> <> 2 boyutludur ve bir ;veya hataya ulaşana kadar bir çizgi veya sütundan geçer . Bu, soldan sağa doğru ilerlerse (bir programın başlangıcında olduğu gibi), sonuna ulaşırsa ve hareket ettirilmez veya programı durdurması söylenmezse çizginin etrafına sarılır. İşaretçi yönüne bağlı olarak farklı işlevlere sahip oldukları için satır başına bazı karakterler tekrarlanacaktır ve işaretçi sağdan sola hareket ettiği için dördüncü satırın tersi karakterler olacaktır.

Programın bir özeti aşağıda verilmiştir. Bak esolangs üzerinde> <> için listelenen talimatları tek tek her karakter ne yaptığını görmek için.

Satır 1: 0&v

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

Hat 2: =?\ilb

(1. satırın işaretçiyi, yani üçüncü karaktere taşıdığı yerden başlayarak)

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

satır 3: =?\:@=&+&l1

(üçüncü karakterden başlayarak)

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

Satır 4: n&/;

(üçüncü karakterden başlayarak)

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

Yakut, 22 20 bayt

p gets.count(gets)-1

Demo: http://ideone.com/MEeTd2

Bunun -1nedeni gets, girişi alan bir satırsonu karakteri içermesidir. Ruby , bağımsız değişkenden herhangi bir karakterin dizede gerçekleşme String#countsayısını sayar .

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!