Ggthjy

Calculus Optimization - Point on graph closest to given point

LED on same Pin as Toggle Switch, not illuminating

Is there a familial term for apples and pears?

How does one intimidate enemies without having the capacity for violence?

I see my dog run

If Manufacturer spice model and Datasheet give different values which should I use?

How do I create uniquely male characters?

My colleague's body is amazing

How can bays and straits be determined in a procedurally generated map?

The magic money tree problem

A Journey Through Space and Time

Is it tax fraud for an individual to declare non-taxable revenue as taxable income? (US tax laws)

Email Account under attack (really) - anything I can do?

What is the meaning of "of trouble" in the following sentence?

Why don't electron-positron collisions release infinite energy?

Draw simple lines in Inkscape

How do we improve the relationship with a client software team that performs poorly and is becoming less collaborative?

Can Medicine checks be used, with decent rolls, to completely mitigate the risk of death from ongoing damage?

declaring a variable twice in IIFE

Are white and non-white police officers equally likely to kill black suspects?

Why has Russell's definition of numbers using equivalence classes been finally abandoned? ( If it has actually been abandoned).

What is the command to reset a PC without deleting any files

Extreme, but not acceptable situation and I can't start the work tomorrow morning

What defenses are there against being summoned by the Gate spell?

Find the majority element, which appears more than half the time

Perm-Missing-Elem: 100% functional score, but only 60% performanceDetermining the existence of string IntersectionsFind the dominator in an array of integersJavaScript : Search highest ID in JSON-structure. Increment & return itFind the most frequent element in a sequence without copying elementsReconstruct a string, given a list of subsequence tripletsReturn a sorted ordering of courses such that we can finish all coursesHash table solution to twoSumSum of a sublistFind the elements that appear only once

.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty{ margin-bottom:0;
}

10

$begingroup$

The task:

Given a list of elements, find the majority element, which appears
more than half the time (> floor(len(lst) / 2.0)).

You can assume that such element exists.

For example, given [1, 2, 1, 1, 3, 4, 0], return 1.

My solution:

const lst = [1, 2, 1, 1, 3, 4, 0];

const findMajorityElem = lst => lst.reduce((acc, x) => {

  acc[x] = acc[x] ? acc[x] + 1 : 1;

// If I can assume that such an element exists, then it's sufficient to check which element occurs the most.

  if (!acc.major || acc.major[1] < acc[x]) { acc.major = [x, acc[x]]; }

  return acc;

}, {major: null}).major[0];



console.log(findMajorityElem(lst));

javascript algorithm programming-challenge functional-programming

share|improve this question

edited Apr 1 at 12:08

thadeuszlay

asked Apr 1 at 12:00

thadeuszlaythadeuszlay

796416

$endgroup$

• 
  
  
  

  
  5
  

  
  
  
  
  
  

  
  $begingroup$
  In the example [1, 2, 1, 1, 3, 4, 0], 1 appears 3 times, floor(len(lst) / 2.0)) is 3, and since 3 is not more than 3, therefore 1 is not the majority element, and the example list doesn't have a majority element.
  $endgroup$
  – janos
  Apr 1 at 16:47
  
  
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @janos the example is inaccurate. However it explicitly says I can assume that there exists a majority element
  $endgroup$
  – thadeuszlay
  Apr 1 at 16:54
  

  
  
  
  

add a comment | 

10

$begingroup$

The task:

Given a list of elements, find the majority element, which appears
more than half the time (> floor(len(lst) / 2.0)).

You can assume that such element exists.

For example, given [1, 2, 1, 1, 3, 4, 0], return 1.

My solution:

const lst = [1, 2, 1, 1, 3, 4, 0];

const findMajorityElem = lst => lst.reduce((acc, x) => {

  acc[x] = acc[x] ? acc[x] + 1 : 1;

// If I can assume that such an element exists, then it's sufficient to check which element occurs the most.

  if (!acc.major || acc.major[1] < acc[x]) { acc.major = [x, acc[x]]; }

  return acc;

}, {major: null}).major[0];



console.log(findMajorityElem(lst));

javascript algorithm programming-challenge functional-programming

share|improve this question

edited Apr 1 at 12:08

thadeuszlay

asked Apr 1 at 12:00

thadeuszlaythadeuszlay

796416

$endgroup$

• 
  
  
  

  
  5
  

  
  
  
  
  
  

  
  $begingroup$
  In the example [1, 2, 1, 1, 3, 4, 0], 1 appears 3 times, floor(len(lst) / 2.0)) is 3, and since 3 is not more than 3, therefore 1 is not the majority element, and the example list doesn't have a majority element.
  $endgroup$
  – janos
  Apr 1 at 16:47
  
  
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  @janos the example is inaccurate. However it explicitly says I can assume that there exists a majority element
  $endgroup$
  – thadeuszlay
  Apr 1 at 16:54
  

  
  
  
  

add a comment | 

$begingroup$

The task:

Given a list of elements, find the majority element, which appears
more than half the time (> floor(len(lst) / 2.0)).

You can assume that such element exists.

For example, given [1, 2, 1, 1, 3, 4, 0], return 1.

My solution:

const lst = [1, 2, 1, 1, 3, 4, 0];

const findMajorityElem = lst => lst.reduce((acc, x) => {

  acc[x] = acc[x] ? acc[x] + 1 : 1;

// If I can assume that such an element exists, then it's sufficient to check which element occurs the most.

  if (!acc.major || acc.major[1] < acc[x]) { acc.major = [x, acc[x]]; }

  return acc;

}, {major: null}).major[0];



console.log(findMajorityElem(lst));

javascript algorithm programming-challenge functional-programming

share|improve this question

edited Apr 1 at 12:08

thadeuszlay

asked Apr 1 at 12:00

thadeuszlaythadeuszlay

796416

$endgroup$

const lst = [1, 2, 1, 1, 3, 4, 0];

const findMajorityElem = lst => lst.reduce((acc, x) => {

  acc[x] = acc[x] ? acc[x] + 1 : 1;

// If I can assume that such an element exists, then it's sufficient to check which element occurs the most.

  if (!acc.major || acc.major[1] < acc[x]) { acc.major = [x, acc[x]]; }

  return acc;

}, {major: null}).major[0];



console.log(findMajorityElem(lst));

share|improve this question

edited Apr 1 at 12:08

thadeuszlay

asked Apr 1 at 12:00

thadeuszlaythadeuszlay

796416

share|improve this question

edited Apr 1 at 12:08

thadeuszlay

asked Apr 1 at 12:00

thadeuszlaythadeuszlay

796416

asked Apr 1 at 12:00

thadeuszlaythadeuszlay

796416

asked Apr 1 at 12:00

thadeuszlaythadeuszlay

796416

3 Answers
3

active

oldest

votes

14

$begingroup$

If it is known that a majority element exists, then the efficient algorithm to use is the Boyer-Moore majority vote algorithm, which requires only O(1) space.

share|improve this answer

answered Apr 1 at 12:38

200_success200_success

131k17157422

$endgroup$

• 
  
  
  

  
  2
  

  
  
  
  
  
  

  
  $begingroup$
  That's a little deceptive... it's $Omega(log n)$ space in terms of bit complexity.
  $endgroup$
  – Charles
  Apr 1 at 20:44
  

  
  
  
  


• 
  
  
  

  
  2
  

  
  
  
  
  
  

  
  $begingroup$
  @Charles Why would you want to break it down in terms of bits?
  $endgroup$
  – 200_success
  Apr 2 at 1:18
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  I think the question should be, why hide the size of the space requirements? Calling O(1) is, IMO, deceptive: it makes it sound like a fixed amount of space suffices for arbitrarily large arrays, but the larger the array the larger the numbers you need to store, and the larger the numbers the larger the space they take up. Sure, only logarithmically so, but then let's call it logarithmic space, not constant space. It's only constant space in the sense that you use a constant number of words when the words themselves grow logarithmically, but then you're being tricky and hiding the real size.
  $endgroup$
  – Charles
  Apr 2 at 1:59
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  @Charles I don't understand why there's necessarily a correlation between the size of the array and the size of the values within it. To me those are completely orthogonal concerns. It also doesn't seem particularly relevant here anyway, since Javascript's numbers are fixed-size.
  $endgroup$
  – Kyle
  Apr 2 at 2:31
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  @Charles I don’t think that’s entirely fair. Unlike algorithms and structures that meaningfully depend on bit width (radix sort, van Emde Boas trees, ...), this one only has a dependence on it in that it needs to store an array index and an array element (an offline version can also get away with storing two indices instead). That is, it needs as much space as an array access, and you generally want to count this as O(1). Yes, that means you’re counting words, not bits, but that’s the standard cost model, and it makes perfect sense outside of specialized applications.
  $endgroup$
  – Alex Shpilkin
  Apr 2 at 14:17
  

  
  
  
  

 | 
show 2 more comments

3

$begingroup$

@200_success's suggestion seems like the right play here.

That said, I thought it was worth pointing out a couple small improvements to your approach:

• 
  major need only be the element itself (since you can look up its value in the accumulator)


• Since you tagged this functional-programming, you can use expressions everywhere, and avoid the if statement.

Revised code:

const findMajorityElem = lst => lst.reduce((acc, x) => {

  acc[x] = acc[x] ? acc[x] + 1 : 1;

  const maxCnt = acc[acc.major] || 0

  acc.major = acc[x] <= maxCnt ? acc.major : x

  return acc

}, {major: null}).major

And just for fun, again based on your tag, here's a single-expression solution in Ramda. Again, I don't recommend actually using this given that Boyer-Moore exists:

pipe(

  groupBy(identity), 

  map(length), 

  toPairs, 

  converge( reduce(maxBy(last)), [head, identity] ),

  head, 

  parseInt

)(lst)

You can try it here

share|improve this answer

answered Apr 1 at 13:03

JonahJonah

3,516718

$endgroup$

add a comment | 

1

$begingroup$

If the number exists, it should be done like this and shorter.

let result =

   [2,3,4,5,1,1,1,2,2,22,2,2,2,2,2,2,2,2,1,1,33,3,2,1,1,1,1,2,2,2,2,2].reduce( (a ,b) => {

  console.log(a)

return a.length == null  ? ( a != b ?  [] : a.concat(b)):

       a.length == 0  ? [b] :

       a[a.length-1] == b ?  a.concat(b)  :

       a.slice(0,a.length-2) ;

    })[0]



 console.log(result) //2

share|improve this answer

edited Apr 2 at 0:37

answered Apr 2 at 0:27

E.ComsE.Coms

1113

New contributor

E.Coms is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.

$endgroup$

• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  Welcome to Code Review! and shorter is a bit short on what deserves improvement in the code in the question and why the way proposed is better.
  $endgroup$
  – greybeard
  Apr 2 at 5:42
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  Shorter means in Javascript, you may write in a neater way. It’s an implementation of voter algorithm. Just compare the last element in result with a new element, if they are different, just cancel them. Then the final survived element will be the result. Time is o(n) and if in-place space is o(1).
  $endgroup$
  – E.Coms
  Apr 2 at 11:41
  

  
  
  
  

add a comment | 

Your Answer

StackExchange.ifUsing("editor", function () {
return StackExchange.using("mathjaxEditing", function () {
StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["\$", "\$"]]);
});
});
}, "mathjax-editing");

StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");

StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "196"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);

StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});

function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: false,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: null,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});


}
});

draft saved

draft discarded

Sign up or log in

StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});

Sign up using Google

Sign up using Facebook

Sign up using Email and Password

Post as a guest

Name

Email

Required, but never shown

StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f216648%2ffind-the-majority-element-which-appears-more-than-half-the-time%23new-answer', 'question_page');
}
);

Post as a guest

Name

Email

Required, but never shown

14

$begingroup$

If it is known that a majority element exists, then the efficient algorithm to use is the Boyer-Moore majority vote algorithm, which requires only O(1) space.

share|improve this answer

answered Apr 1 at 12:38

200_success200_success

131k17157422

$endgroup$

• 
  
  
  

  
  2
  

  
  
  
  
  
  

  
  $begingroup$
  That's a little deceptive... it's $Omega(log n)$ space in terms of bit complexity.
  $endgroup$
  – Charles
  Apr 1 at 20:44
  

  
  
  
  


• 
  
  
  

  
  2
  

  
  
  
  
  
  

  
  $begingroup$
  @Charles Why would you want to break it down in terms of bits?
  $endgroup$
  – 200_success
  Apr 2 at 1:18
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  I think the question should be, why hide the size of the space requirements? Calling O(1) is, IMO, deceptive: it makes it sound like a fixed amount of space suffices for arbitrarily large arrays, but the larger the array the larger the numbers you need to store, and the larger the numbers the larger the space they take up. Sure, only logarithmically so, but then let's call it logarithmic space, not constant space. It's only constant space in the sense that you use a constant number of words when the words themselves grow logarithmically, but then you're being tricky and hiding the real size.
  $endgroup$
  – Charles
  Apr 2 at 1:59
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  @Charles I don't understand why there's necessarily a correlation between the size of the array and the size of the values within it. To me those are completely orthogonal concerns. It also doesn't seem particularly relevant here anyway, since Javascript's numbers are fixed-size.
  $endgroup$
  – Kyle
  Apr 2 at 2:31
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  @Charles I don’t think that’s entirely fair. Unlike algorithms and structures that meaningfully depend on bit width (radix sort, van Emde Boas trees, ...), this one only has a dependence on it in that it needs to store an array index and an array element (an offline version can also get away with storing two indices instead). That is, it needs as much space as an array access, and you generally want to count this as O(1). Yes, that means you’re counting words, not bits, but that’s the standard cost model, and it makes perfect sense outside of specialized applications.
  $endgroup$
  – Alex Shpilkin
  Apr 2 at 14:17
  

  
  
  
  

 | 
show 2 more comments

14

$begingroup$

If it is known that a majority element exists, then the efficient algorithm to use is the Boyer-Moore majority vote algorithm, which requires only O(1) space.

share|improve this answer

answered Apr 1 at 12:38

200_success200_success

131k17157422

$endgroup$

• 
  
  
  

  
  2
  

  
  
  
  
  
  

  
  $begingroup$
  That's a little deceptive... it's $Omega(log n)$ space in terms of bit complexity.
  $endgroup$
  – Charles
  Apr 1 at 20:44
  

  
  
  
  


• 
  
  
  

  
  2
  

  
  
  
  
  
  

  
  $begingroup$
  @Charles Why would you want to break it down in terms of bits?
  $endgroup$
  – 200_success
  Apr 2 at 1:18
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  I think the question should be, why hide the size of the space requirements? Calling O(1) is, IMO, deceptive: it makes it sound like a fixed amount of space suffices for arbitrarily large arrays, but the larger the array the larger the numbers you need to store, and the larger the numbers the larger the space they take up. Sure, only logarithmically so, but then let's call it logarithmic space, not constant space. It's only constant space in the sense that you use a constant number of words when the words themselves grow logarithmically, but then you're being tricky and hiding the real size.
  $endgroup$
  – Charles
  Apr 2 at 1:59
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  @Charles I don't understand why there's necessarily a correlation between the size of the array and the size of the values within it. To me those are completely orthogonal concerns. It also doesn't seem particularly relevant here anyway, since Javascript's numbers are fixed-size.
  $endgroup$
  – Kyle
  Apr 2 at 2:31
  

  
  
  
  


• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  @Charles I don’t think that’s entirely fair. Unlike algorithms and structures that meaningfully depend on bit width (radix sort, van Emde Boas trees, ...), this one only has a dependence on it in that it needs to store an array index and an array element (an offline version can also get away with storing two indices instead). That is, it needs as much space as an array access, and you generally want to count this as O(1). Yes, that means you’re counting words, not bits, but that’s the standard cost model, and it makes perfect sense outside of specialized applications.
  $endgroup$
  – Alex Shpilkin
  Apr 2 at 14:17
  

  
  
  
  

 | 
show 2 more comments

$begingroup$

If it is known that a majority element exists, then the efficient algorithm to use is the Boyer-Moore majority vote algorithm, which requires only O(1) space.

share|improve this answer

answered Apr 1 at 12:38

200_success200_success

131k17157422

$endgroup$

share|improve this answer

answered Apr 1 at 12:38

200_success200_success

131k17157422

answered Apr 1 at 12:38

200_success200_success

131k17157422

answered Apr 1 at 12:38

200_success200_success

131k17157422

3

$begingroup$

@200_success's suggestion seems like the right play here.

That said, I thought it was worth pointing out a couple small improvements to your approach:

• 
  major need only be the element itself (since you can look up its value in the accumulator)


• Since you tagged this functional-programming, you can use expressions everywhere, and avoid the if statement.

Revised code:

const findMajorityElem = lst => lst.reduce((acc, x) => {

  acc[x] = acc[x] ? acc[x] + 1 : 1;

  const maxCnt = acc[acc.major] || 0

  acc.major = acc[x] <= maxCnt ? acc.major : x

  return acc

}, {major: null}).major

And just for fun, again based on your tag, here's a single-expression solution in Ramda. Again, I don't recommend actually using this given that Boyer-Moore exists:

pipe(

  groupBy(identity), 

  map(length), 

  toPairs, 

  converge( reduce(maxBy(last)), [head, identity] ),

  head, 

  parseInt

)(lst)

You can try it here

share|improve this answer

answered Apr 1 at 13:03

JonahJonah

3,516718

$endgroup$

add a comment | 

3

$begingroup$

@200_success's suggestion seems like the right play here.

That said, I thought it was worth pointing out a couple small improvements to your approach:

• 
  major need only be the element itself (since you can look up its value in the accumulator)


• Since you tagged this functional-programming, you can use expressions everywhere, and avoid the if statement.

Revised code:

const findMajorityElem = lst => lst.reduce((acc, x) => {

  acc[x] = acc[x] ? acc[x] + 1 : 1;

  const maxCnt = acc[acc.major] || 0

  acc.major = acc[x] <= maxCnt ? acc.major : x

  return acc

}, {major: null}).major

And just for fun, again based on your tag, here's a single-expression solution in Ramda. Again, I don't recommend actually using this given that Boyer-Moore exists:

pipe(

  groupBy(identity), 

  map(length), 

  toPairs, 

  converge( reduce(maxBy(last)), [head, identity] ),

  head, 

  parseInt

)(lst)

You can try it here

share|improve this answer

answered Apr 1 at 13:03

JonahJonah

3,516718

$endgroup$

add a comment | 

$begingroup$

@200_success's suggestion seems like the right play here.

That said, I thought it was worth pointing out a couple small improvements to your approach:

• 
  major need only be the element itself (since you can look up its value in the accumulator)


• Since you tagged this functional-programming, you can use expressions everywhere, and avoid the if statement.

Revised code:

const findMajorityElem = lst => lst.reduce((acc, x) => {

  acc[x] = acc[x] ? acc[x] + 1 : 1;

  const maxCnt = acc[acc.major] || 0

  acc.major = acc[x] <= maxCnt ? acc.major : x

  return acc

}, {major: null}).major

And just for fun, again based on your tag, here's a single-expression solution in Ramda. Again, I don't recommend actually using this given that Boyer-Moore exists:

pipe(

  groupBy(identity), 

  map(length), 

  toPairs, 

  converge( reduce(maxBy(last)), [head, identity] ),

  head, 

  parseInt

)(lst)

You can try it here

share|improve this answer

answered Apr 1 at 13:03

JonahJonah

3,516718

$endgroup$

const findMajorityElem = lst => lst.reduce((acc, x) => {

  acc[x] = acc[x] ? acc[x] + 1 : 1;

  const maxCnt = acc[acc.major] || 0

  acc.major = acc[x] <= maxCnt ? acc.major : x

  return acc

}, {major: null}).major

pipe(

  groupBy(identity), 

  map(length), 

  toPairs, 

  converge( reduce(maxBy(last)), [head, identity] ),

  head, 

  parseInt

)(lst)

share|improve this answer

answered Apr 1 at 13:03

JonahJonah

3,516718

answered Apr 1 at 13:03

JonahJonah

3,516718

answered Apr 1 at 13:03

JonahJonah

3,516718

1

$begingroup$

If the number exists, it should be done like this and shorter.

let result =

   [2,3,4,5,1,1,1,2,2,22,2,2,2,2,2,2,2,2,1,1,33,3,2,1,1,1,1,2,2,2,2,2].reduce( (a ,b) => {

  console.log(a)

return a.length == null  ? ( a != b ?  [] : a.concat(b)):

       a.length == 0  ? [b] :

       a[a.length-1] == b ?  a.concat(b)  :

       a.slice(0,a.length-2) ;

    })[0]



 console.log(result) //2

share|improve this answer

edited Apr 2 at 0:37

answered Apr 2 at 0:27

E.ComsE.Coms

1113

New contributor

E.Coms is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.

$endgroup$

• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  Welcome to Code Review! and shorter is a bit short on what deserves improvement in the code in the question and why the way proposed is better.
  $endgroup$
  – greybeard
  Apr 2 at 5:42
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  Shorter means in Javascript, you may write in a neater way. It’s an implementation of voter algorithm. Just compare the last element in result with a new element, if they are different, just cancel them. Then the final survived element will be the result. Time is o(n) and if in-place space is o(1).
  $endgroup$
  – E.Coms
  Apr 2 at 11:41
  

  
  
  
  

add a comment | 

1

$begingroup$

If the number exists, it should be done like this and shorter.

let result =

   [2,3,4,5,1,1,1,2,2,22,2,2,2,2,2,2,2,2,1,1,33,3,2,1,1,1,1,2,2,2,2,2].reduce( (a ,b) => {

  console.log(a)

return a.length == null  ? ( a != b ?  [] : a.concat(b)):

       a.length == 0  ? [b] :

       a[a.length-1] == b ?  a.concat(b)  :

       a.slice(0,a.length-2) ;

    })[0]



 console.log(result) //2

share|improve this answer

edited Apr 2 at 0:37

answered Apr 2 at 0:27

E.ComsE.Coms

1113

New contributor

E.Coms is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.

$endgroup$

• 
  
  
  

  
  1
  

  
  
  
  
  
  

  
  $begingroup$
  Welcome to Code Review! and shorter is a bit short on what deserves improvement in the code in the question and why the way proposed is better.
  $endgroup$
  – greybeard
  Apr 2 at 5:42
  

  
  
  
  


• 
  
  
  

  
  

  
  
  
  
  
  

  
  $begingroup$
  Shorter means in Javascript, you may write in a neater way. It’s an implementation of voter algorithm. Just compare the last element in result with a new element, if they are different, just cancel them. Then the final survived element will be the result. Time is o(n) and if in-place space is o(1).
  $endgroup$
  – E.Coms
  Apr 2 at 11:41
  

  
  
  
  

add a comment | 

$begingroup$

If the number exists, it should be done like this and shorter.

let result =

   [2,3,4,5,1,1,1,2,2,22,2,2,2,2,2,2,2,2,1,1,33,3,2,1,1,1,1,2,2,2,2,2].reduce( (a ,b) => {

  console.log(a)

return a.length == null  ? ( a != b ?  [] : a.concat(b)):

       a.length == 0  ? [b] :

       a[a.length-1] == b ?  a.concat(b)  :

       a.slice(0,a.length-2) ;

    })[0]



 console.log(result) //2

share|improve this answer

edited Apr 2 at 0:37

answered Apr 2 at 0:27

E.ComsE.Coms

1113

New contributor

E.Coms is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.

$endgroup$

let result =

   [2,3,4,5,1,1,1,2,2,22,2,2,2,2,2,2,2,2,1,1,33,3,2,1,1,1,1,2,2,2,2,2].reduce( (a ,b) => {

  console.log(a)

return a.length == null  ? ( a != b ?  [] : a.concat(b)):

       a.length == 0  ? [b] :

       a[a.length-1] == b ?  a.concat(b)  :

       a.slice(0,a.length-2) ;

    })[0]



 console.log(result) //2

share|improve this answer

edited Apr 2 at 0:37

answered Apr 2 at 0:27

E.ComsE.Coms

1113

New contributor

E.Coms is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.

answered Apr 2 at 0:27

E.ComsE.Coms

1113

New contributor

E.Coms is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.

answered Apr 2 at 0:27

E.ComsE.Coms

1113