아래 메서드 네개는 문자열 시퀀스를 정수 시퀀스로 파싱하고, 파싱된 정수 시퀀스 중에 가장 큰 두 개의 합을 구하고 있습니다. (결과는 모두 동일합니다)
이들을 가독성이 높은 순으로 나열해주세요. ^^
일종의 앙케이트 같은 것이니, 편안하게 본인의 의견을 말씀해주시면 좋겠습니다.
(소스 코드 출처는 선입견을 배제하기 위해, 나중에 밝히도록 하겠습니다)
int Method1(IEnumerable<string> items)
{
var all = new List<int>();
using var enumerator = items.GetEnumerator();
while(enumerator.MoveNext())
{
if(int.TryParse(enumerator.Current, out var number)) all.Add(number);
}
if(all.Count < 2) return -1;
int[] topTwo = { all[0], all[1] };
if( all[1] > all[0] )
{
topTwo[0] = all[1];
topTwo[1] = all[0];
}
for (int i = 2; i < all.Count; i++)
{
if(all[i] > topTwo[0])
{
topTwo[1] = topTwo[0];
topTwo[0] = all[i];
}
else if(all[i] > topTwo[1]){
topTwo[1] = all[i];
}
}
return topTwo[0] + topTwo[1];
}
int Method2(IEnumerable<string> items)
{
var all = new List<int>();
foreach (var item in items)
{
if(int.TryParse(item, out var num)) all.Add(num);
}
if(all.Count < 2) return -1;
var (a, b) = all[0] > all[1] ? ( all[0], all[1] )
: ( all[1], all[0] );
foreach (var num in all.Skip(2))
{
if (num > a) (a, b) = (num, a);
else if(num > b) b = num;
}
return a + b;
}
int Method3(IEnumerable<string> items)
{
var (a, b, count) = (0, 0, 0);
foreach (var item in items)
{
if(!int.TryParse(item, out var num)) continue;
(a, b, count) = count switch
{
0 => (num, 0, 1),
1 when num > a => (num, a, 2),
1 => (a, num, 2),
2 when num > a => (num, a, 2),
2 when num > b => (a, num, 2),
_ => (a, b, count),
};
}
return count < 2 ? -1 : a + b;
}
int Method4(IEnumerable<string> items) => items.Aggregate
(
( max: 0, next: 0, count: 0),
(a, item) => int.TryParse(item, out var num) ? a switch
{
(_, _, 0) => (num, 0, 1),
(var max, _, 1) when num > max => (num, max, 2),
(var max, _, 1) => (max, num, 2),
(var max, _, 2) when num > max => (num, max, 2),
(var max, var next, 2) when num > next => (max, num, 2),
_ => a,
}
: a,
(a) => a.count < 2 ? -1 : a.max + a.next
);