Thử thách

Viết chương trình, cho một chuỗi xdài 10 ký tự và một ký tự y, xuất ra số lần ký tự yxảy ra trong chuỗi x.

Chương trình ngắn nhất tính bằng byte để làm như vậy sẽ thắng.

Thí dụ

Input: tttggloyoi, t
Output: 3

Input: onomatopoe, o
Output: 4

Bình thường, 3 byte

/ww

Chạy ví dụ:

$ pyth -c '/ww'
sdhkfhjkkj
k
3

Tất nhiên, người dùng có thể nhập nhiều hơn hoặc ít hơn 10 chữ cái cho lần nhập đầu tiên, nhưng chúng tôi không cần phải lo lắng về những gì xảy ra khi người dùng vi phạm thông số kỹ thuật.

Pyth - 3 byte

Một câu trả lời khác nhau, ít rõ ràng hơn, Pyth có cùng kích thước. Nó gấp đếm trên đầu vào.

/FQ

Phòng thử nghiệm .

JavaScript, 32

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

Bash, 24 ký tự

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

Chạy mẫu:

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

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

Võng mạc , 12 byte

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

Đơn giản chỉ là một regex khớp với một ký tự bằng với ký tự cuối cùng trong đầu vào (ngoại trừ chính nó). Khi được cung cấp một regex duy nhất, Retina chỉ cần trả về số lượng trận đấu.

Mê cung , 32 29 27 24 byte

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

Điều này đọc ký tự đơn trước, theo sau là chuỗi cần đếm và giả sử rằng không có byte rỗng trong chuỗi.

Giải trình

Mã bắt đầu bằng ),}, đặt đáy của ngăn xếp thành 1, đọc ký tự đầu tiên và di chuyển nó đến ngăn xếp phụ để sử dụng trong tương lai. Các 1sẽ được truy cập của chúng tôi (bù đắp trong tổng số 1 sẽ bị hủy bỏ sau đó và là cần thiết cho các IP để có những lượt yêu cầu).

Bây giờ IP sẽ di chuyển xuống để đọc ký tự đầu tiên của chuỗi tìm kiếm ,. Giá trị bị phủ định với `, một lần nữa để có được hành vi rẽ chính xác. Trong khi chúng ta đang đọc các ký tự từ STDIN, IP sẽ theo vòng lặp này:

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

{:}tạo một bản sao của mã ký tự được lưu trữ và +thêm nó vào giá trị hiện tại. Nếu kết quả là 0(tức là ký tự hiện tại là ký tự chúng ta đang tìm kiếm), IP sẽ di chuyển thẳng về phía trước: -chỉ cần thoát khỏi 0, )tăng bộ đếm, {}là không có.

Tuy nhiên, nếu kết quả sau +khác không, chúng tôi không muốn đếm ký tự hiện tại. Vì vậy, IP có một rẽ phải thay thế. Đó là một ngõ cụt, do đó mã ở đó được thực thi hai lần, một lần tiến và một lần lùi. Đó là, mã thực tế trong trường hợp này trở thành );___;)+-){}. );chỉ cần loại bỏ sự khác biệt khác không đó, ___đẩy 3 số 0, nhưng ;loại bỏ một trong số chúng. )tăng một trong hai số không còn lại, +thêm chúng vào một số 1, -trừ nó khỏi bộ đếm và )tăng bộ đếm. Nói cách khác, chúng tôi đã tạo ra một no-op rất công phu.

Khi chúng ta nhấn EOF, ,đẩy -1, nó `sẽ chuyển sang 1và IP rẽ phải. -trừ 1khỏi bộ đếm (hủy phần bù ban đầu). !in bộ đếm và @chấm dứt chương trình.

Python 3, 29 byte

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

Meh, điều này thật dễ dàng. Giả sử rằng đầu vào là một chuỗi mười chữ cái.

Người tuyết 1.0.2 , 16 ký tự

~vgvgaSaLNdEtSsP

Đáng ngạc nhiên ngắn. Giải trình:

~      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

Lập trình siêu mẫu C ++, 160 154 116 byte

Chỉ cho những tiếng cười khúc khích.

Cảm ơn ex-bart đã chơi 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;

Cách sử dụng: char đầu tiên trong instanciation mẫu là ký tự cần tìm.

Tuân thủ clang -std = c ++ 11 -c -> kết quả là ở đầu thông báo lỗi.

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

Tuân thủ gcc -std = c ++ 11 -c -> kết quả nằm ở cuối thông báo lỗi.

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)

Tìm kiếm A < 3 , 't', '\ 000'> và A < 3 , 't', '\ x00'>

Phiên bản 154 byte

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;

Phiên bản 160 byte:

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 byte

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

Javascript (ES6), 26 byte

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

Giải pháp nhanh chóng này xác định một chức năng ẩn danh. Để sử dụng nó, thêm một khai báo biến vào đầu. Dùng thử:

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: Ồ, tôi thấy đã có một giải pháp rất giống nhau. Tôi hy vọng điều đó ổn.

Haskell, 21 byte

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

C ++, 78 byte

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

Gọi như thế này:

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

Phần tử , 23 byte

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

Dòng mới là một phần của chương trình. Tôi thực sự sử dụng nó như là một tên biến .

Chương trình này về cơ bản hoạt động bằng cách lưu trữ ký tự đích trong một biến, giữ chuỗi hiện tại trên đỉnh của ngăn xếp, sau đó lặp quá trình "cắt, so sánh và di chuyển kết quả bên dưới", thêm kết quả cuối cùng.

Dòng mới dưới dạng tên biến xuất phát từ việc sử dụng dòng mới ở cuối đầu vào bằng cách cắt nó ra và lưu trữ vào đó. Dòng mới trong mã là nơi tôi đọc từ nó.

Đầu vào là như thế này:

qqqqwwweee
q

Đầu ra là như thế này

4

Julia, 26 25 byte

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

Các findinchức năng trả về các chỉ số trong số đầu tiên mà tại đó các lập luận thứ hai được tìm thấy như là một vector. Độ dài của vectơ là số lần xuất hiện.

Đã lưu một byte nhờ Glen O.

APL, 7 3 byte

+/⍷

Điều này tạo ra một chức năng đào tạo. Nó hoạt động bằng cách tạo một vectơ số không và các số tương ứng với các chỉ số mà ký tự xuất hiện trong chuỗi ( ⍷). Vectơ sau đó được tính tổng ( +/).

Đã lưu 4 byte nhờ kirbyfan64sos và NBZ!

Perl, 21 16 ký tự

(Mã 13 ký tự + tùy chọn dòng lệnh 3 ký tự.)

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

Chạy mẫu:

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 byte

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

Cách sử dụng:
Gọi tập lệnh với hai đối số.
php script.php qwertzqwertz q

PHP, 23 byte

Nếu bạn đăng ký Biến toàn cục (chỉ có thể có trong PHP 5.3 trở xuống), bạn có thể lưu 12 byte (nhờ Martijn )

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

Cách sử dụng:
Gọi tập lệnh và khai báo các biến toàn cụcphp script.php?a=qwertzqwertz&b=q

APL Dyalog , 3 byte

      +/=

Tức là "Tổng số byte bằng nhau". Ví dụ:

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

hoặc chỉ

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

K không đánh bại APL lần này.

Hãy thử trực tuyến.

T-SQL, 99 40 byte

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

Đơn giản chỉ cần thực hiện một sự khác biệt giữa chuỗi đầu vào và chuỗi với ký tự được loại bỏ. Lấy đầu vào từ bảng t

Chỉnh sửa đã thay đổi để loại bỏ một vấn đề với việc đếm không gian và tính đến các đầu vào hiện tại có thể chấp nhận được cho SQL. Cảm ơn @BradC vì tất cả các thay đổi và tiết kiệm

Octave / Matlab, 33 byte

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

J, 5 byte

+/@:=

Tôi cảm thấy như J sẽ tích hợp sẵn cho việc này, nhưng tôi chưa thể tìm thấy - có lẽ một trong những người dùng J tích cực có thể khai sáng cho tôi. Vì vậy, thay vào đó, lần đầu tiên áp dụng =cho các đầu vào, biến mỗi ký tự thành 1nếu nó bằng với yêu cầu hoặc 0cách khác. Sau đó +/tính tổng của danh sách đó.

Tập tin hàng loạt, 121 byte

Bởi vì tôi là một masochist ...

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%

Cảnh báo: Giả sử _không xảy ra trong chuỗi đầu vào. Nếu có, thì biến ecần phải được điều chỉnh cho phù hợp.

Điều này thiết lập biến đếm của chúng tôi cvà phân định cuối chuỗi của chúng tôi như _trước khi gắn nó vào chuỗi đầu vào của chúng tôi %1và đặt chuỗi nối vào t. Sau đó, chúng tôi đang nhập vòng lặp :l, chúng tôi đặt biến ký tự tạm thời là ký tự ađầu tiên t, kiểm tra xem nó có khớp với chuỗi đầu vào thứ hai của chúng tôi không %2và cnếu tăng, nếu đúng, sau đó cắt bỏ ký tự đầu tiên t. Điều kiện kết thúc vòng kiểm tra tcủa chúng tôi chống lại việc phân định kết thúc chuỗi của chúng tôi và lặp lại nếu không. Chúng tôi sau đó echora giá trị của quầy của chúng tôi.

Có thể có thể sử dụng một FORvòng lặp thay thế, nhưng điều đó bắt buộc phải kích hoạt DelayedExpansion , mà tôi nghĩ rằng sẽ thực sự dài hơn byte so với điều này. Xác minh điều đó được để lại như một bài tập cho người đọc.

CJam, 5 byte

ll/,(

Giải trình

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

PowerShell, 32 byte

Một bốn cho một! Và tất cả chúng đều có cùng chiều dài! :)

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

hoặc là

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

Ngoài ra,

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

hoặc là

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

Hai kiểu đầu tiên sử dụng toán tử nội tuyến -split , trong khi hai kiểu thứ hai ngầm định thực hiện đối số thứ nhất dưới dạng Chuỗi và sử dụng .Split()toán tử dựa trên chuỗi. Trong tất cả các trường hợp, một mảng được trả về, trong đó chúng ta phải giảm số lượng theo một, vì chúng ta sẽ nhận lại một mục mảng nhiều hơn các lần xuất hiện của đối số thứ hai.

_{Đây là một niềm vui ...}

Julia, 21 byte

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

Lưu ý rằng nó yêu cầu phải clà char, không phải chuỗi ký tự đơn. Vì vậy, bạn sử dụng nó như f("test me",'e')(trả về 2) và không f("test me","e")(trả về 0, bởi vì 'e'!="e").

> <> (Cá) , 30 byte

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

Lấy chuỗi, sau đó ký tự để đếm. Đầu vào không tách rời (ít nhất là trong trình thông dịch trực tuyến). Hãy dùng thử trên trình thông dịch trực tuyến: http : // fishl Language.com Tôi đã đếm các byte bằng tay, vì vậy hãy cho tôi biết nếu tôi sai.

Giải trình

Trước hết,> <> là 2 chiều và lặp qua một dòng hoặc cột cho đến khi chạm ; lỗi hoặc. Điều này có nghĩa là nếu nó tiến hành từ trái sang phải (giống như khi bắt đầu chương trình), nó sẽ quấn quanh dòng nếu đến cuối và không được di chuyển hoặc yêu cầu dừng chương trình. Một số ký tự trên mỗi dòng sẽ được lặp lại vì chúng có các chức năng khác nhau tùy theo hướng của con trỏ và dòng thứ tư sẽ có các ký tự theo thứ tự ngược lại vì con trỏ di chuyển từ phải sang trái.

Một bản tóm tắt của chương trình được cung cấp dưới đây. Nhìn vào hướng dẫn được liệt kê cho> <> trên esolang để xem mỗi nhân vật làm gì.

Dòng 1: 0&v

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

Dòng 2: =?\ilb

(bắt đầu nơi dòng 1 di chuyển con trỏ đến, tức là ký tự thứ ba)

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

dòng 3: =?\:@=&+&l1

(bắt đầu từ ký tự thứ ba)

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

Dòng 4: n&/;

(bắt đầu từ ký tự thứ ba)

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

Ruby, 22 20 byte

p gets.count(gets)-1

Bản trình diễn: http://ideone.com/MEeTd2

Điều -1này là do thực tế là getslấy ra đầu vào, cộng với một ký tự dòng mới. Ruby String#countđếm số lần bất kỳ ký tự nào trong đối số xảy ra trong chuỗi.

Ví dụ: đối với đầu vào [ test\n, t\n], txảy ra hai lần và \nxảy ra một lần và cần được trừ.

Ruby, 18 byte

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

Sử dụng:

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

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

Japt , 2 byte

èV

Hãy thử trực tuyến!