这道题的测试非常不科学。。。

difficult

Took a while for doing this, was stuck on the last test case.

I was struggling to solve this problem and then saw your solution. It was very elegent.

want to know an easy way

interesting

I really like your solution!

hello, i have problem understanding the code,
in:
for c=1:l
for r=c:l
if a(c)==a(r)
freq(c)=freq(c)+1
else
break
end
end
end
why didn't the c=1,r=5 satisfy the "a(c)==a(r)",in a(c)==a(r)
thanks a lot

hy,is there a problem with the above mentioned question

l=length(a);
freq=zeros(1,l);
for c=1:l
for r=c:l
if a(c)==a(r)
freq(c)=freq(c)+1;
else
break
end
end
end
M=max(freq);
idx=find(freq==M);
val=a(idx);

function val=longrun(a)
b = zeros(size(a));
old = a(1);
cnt = 0;
for idx = 1:length(a)
if a(idx) == old
cnt = cnt +1;
else
old = a(idx);
cnt = 1;
end
b(idx)=cnt;
end
bmax = max(b);
val = a(b==bmax);
end

function val=longrun(a)
a_len=length(a); % Calculate the length of a
c=ones(a_len,1); % Initialize the consecutive times of the corresponding position
for num_a=1:(a_len-1)
n_val=1;
for next_a=(num_a+1):a_len
if a(num_a)==a(next_a) % If this number is equal to the following number, then n_val+1, and the next cycle
n_val=n_val+1;
c(num_a)=n_val;
else
c(num_a)=n_val; % If this number is not equal to the following number, assign the current n_val to the corresponding number of consecutive times, and jump out of the inner for loop
break
end
end
end
a_conti=max(c); %Find the largest number of consecutive times in the c array
max_location=find(c==a_conti); % Corresponds to the position of the maximum consecutive times
val=a(max_location); % Find out the corresponding position in a
end

I can`t understand

Test 1 is error！
y_correct =[1 2];

This is the best solution I have seen. ????

Very clear solution!

Why is test 4 like that tho

Tricky one, but enjoyed solving it.

Tricky one.. but enjoyed it.

function val=longrun(a)
a_len=length(a); %计算a的长度
c=ones(a_len,1); %初始化对应位置的连续次数
for num_a=1:(a_len-1)
n_val=1;
for next_a=(num_a+1):a_len
if a(num_a)==a(next_a) %如果这个数字和后面的数字相等，则n_val+1，并进行下一次循环
n_val=n_val+1;
c(num_a)=n_val;
else
c(num_a)=n_val; %如果这个数字和后面数字不等，则把当前的n_val赋值给对应数字的连续次数，并跳出内层for循环
break
end
end
end
a_conti=max(c); %找出c数组中最大的连续次数
max_location=find(c==a_conti); %对应最大连续次数的位置
val=a(max_location); %找出对应在a中的位置
end

Test 1 and 4 are wrong

@Piero Cimule
Could you please comment on this method? It is very unlikely for me as a beginner in Matlab to have such a concise code. You are more than welcome to elaborate here or via my e-mail address zasevzasev42@gmail.com

Really succinct code. One of the best I saw so far in the contest. @Piero Cimule

@Jovan Krunic:

%
% find(vertcat(1,diff(a(:)),1))
% val=a(ans(diff(ans)==max(diff(ans))))
%
% the approach is:
% find the differences between the elements of the vector
% consecutive zero's mean there is a run of the same values
% get the indices of none zero elements of this vector
% get the differences of these indices (which are a measure for the length the run of consecutive zero's, the 'gap' resulting from removing the zeros)
% note that to make this work for vectors that start or end with the longest run we add a 1 to the beginning and the end of the first difference vector
% get the max value from this last result which is the max sequence length
% get the indices of these max values, that is, the first indices of the runs that have this max length
% note that this last result is always a column vector
% get the values of the first elements of the runs with max length from the original vector
% note that if the original vector was a row vector, the result will be a row vector and when it was a column vector the result is a column vector,
% as required in the problem description

function val=longrun(a)
val = [];
if length(a) > 0
% a(:) will convert a to a column vector
a_as_column_vector = a(:);
% differences between elements of a
diff_a = diff(a_as_column_vector);
% differences between elements of a enclosed in ones (to make sure first and last element are non zero)
vertcat_1_diff_a_1 = vertcat(1, diff_a, 1);
% non zero elements of vertcat_1_diff_a_1
find_vertcat_1_diff_a_1 = find(vertcat_1_diff_a_1);
% the difference between the non zero indices is equal to the length of the run of consecutive numbers
lengts_of_runs_of_consecutive_numbers = diff(find_vertcat_1_diff_a_1);
% set the elements that have the max length to one and the others to 0 - note that shift of indices as a result of diff is compensated by adding 1 at the front of the vector
indices_of_elements_that_have_max_length_run = lengts_of_runs_of_consecutive_numbers == max(lengts_of_runs_of_consecutive_numbers);
indices_of_first_elements_of_longest_run_of_consecutive_numbers = find_vertcat_1_diff_a_1(indices_of_elements_that_have_max_length_run);
values_of_first_elements_of_longest_run_of_consecutive_numbers = a(indices_of_first_elements_of_longest_run_of_consecutive_numbers);
val = values_of_first_elements_of_longest_run_of_consecutive_numbers;
end
end

Could you check this for me, please?
[ra,ca]=size(a);
if ra>ca
a=a';
end

j=1;
V=[a(1,1);1];
for i=2:size(a,2)
X=a(1,i);
if V(1,j)==X
V(2,j)=V(2,j)+1;
else
j=j+1;
V(1,j)=X;
V(2,j)=V(2,j)+1;
end

end

val=V(V(2,:)==max(V(2,:)))
if ra>ca
val=val';
end

How else could you solve in any other traditional programming language?

Its good,

It was not so easy...

very clever!

i cannot understand