[英]C# algorithm refactor splitting an array into 3 parts?
我有一個IEnumerable,我想使用以下業務邏輯將數據分成3列。 如果3個或更少的項目,每列1個項目,我希望將總項目除以3的任何其他東西在前兩個列之間分割剩余物(1或2個項目)。 現在這非常難看,但它確實起了作用。 我正在尋找更好地利用linq或可能消除switch語句的技巧。 任何改進代碼的建議或提示都表示贊賞。
var numItems = items.Count;
IEnumerable<JToken> col1Items,
col2Items,
col3Items;
if(numItems <=3)
{
col1Items = items.Take(1);
col2Items = items.Skip(1).Take(1);
col3Items = items.Skip(2).Take(1);
} else {
int remainder = numItems % 3,
take = numItems / 3,
col1Take,
col2Take,
col3Take;
switch(remainder)
{
case 1:
col1Take = take + 1;
col2Take = take;
col3Take = take;
break;
case 2:
col1Take = take + 1;
col2Take = take + 1;
col3Take = take;
break;
default:
col1Take = take;
col2Take = take;
col3Take = take;
break;
}
col1Items = items.Take(col1Take);
col2Items = items.Skip(col1Take).Take(col2Take);
col3Items = items.Skip(col1Take + col2Take).Take(col3Take);
最終我在mvc Razor視圖中使用它們
<div class="widgetColumn">
@Html.DisplayFor(m => col1Items, "MenuColumn")
</div>
<div class="widgetColumn">
@Html.DisplayFor(m => col2Items, "MenuColumn")
</div>
<div class="widgetColumn">
@Html.DisplayFor(m => col3Items, "MenuColumn")
</div>
在我的第一次嘗試中,我想擺脫colNItems和colNTake變量,但我無法弄清楚正確的算法,使其工作相同。
for (int i = 1; i <= 3; i++ )
{
IEnumerable<JToken> widgets = new List<JToken>();
var col = i;
switch(col)
{
case 1:
break;
case 2:
break;
case 3:
break;
}
}
列是固定寬度的嗎? 如果是這樣,那么就沒有必要對你的收藏做任何特別的事情了。 只需依靠瀏覽器為您完成。 有一個外部容器,其總寬度為3列,然后只為每個項目填充一個div(並向左浮動)。 將內部容器設置為寬度恰好為外部容器的1/3。
這是一個快速的小提琴
這是對風格的快速暗示
div#outer{
width:300px;
}
div#outer > div{
width:100px;
float:left;
}
你能不能做點什么?
int len = numItems / 3;
int rem = numItems % 3;
int col1Take = len + (rem > 0 ? 1 : 0);
int col2Take = len + (rem > 1 ? 1 : 0);
int col3Take = len;
編輯:
適用於任意數量列( COLUMNS
)的更通用的解決方案是:
int len = numItems / COLUMNS;
int rem = numItems % COLUMNS;
foreach (var i in Enumerable.Range(0, COLUMNS)) {
colTake[i] = len + (rem > i ? 1 : 0);
}
你可以概括:
int cols = 3;
IEnumerable<JToken> colItems[3]; // you can make this dynamic of course
int rem = numItems % cols;
int len = numItems / cols;
for (int col=0; col<cols; col++){
int colTake = len;
if (col < rem) colTake++;
colItems[col] = items.Skip(col*len).Take(colTake);
}
尚未測試,但這適用於任意數量的列。
此外,每當需要變量col1,col2,col3時,可以考慮col [0],col [1],col [2]。
所以你想要第一列中的前n / 3項,第二列中的下一個n / 3項等。
var concreteList = items.ToList();
var count = concreteList.Count;
var take1 = count/3 + (count % 3 > 0 ? 1 : 0);
var take2 = count/3 + (count % 3 > 1 ? 1 : 0);
var col1 = concreteList.Take(take1);
var col2 = concreteList.Skip(take1).Take(take2);
var col3 = concreteList.Skip(take1 + take2);
我制作了一個具體的列表,以避免多次迭代Enumerable
。 例如,如果你有:
items = File.ReadLines("foo.txt");
那么你將無法多次迭代它。
如果要循環填充列,可以使用:
int numColumns = 3;
var result = Enumerable.Range(1,numColumns).Select(c =>
items.Where((x,ix) => ix % numColumns == c-1).ToArray()
);
它可能有所幫助
IEnumerable<object> items = new Object[]{ "1", "2", "3", "4", "5", "6", "7","8", "9", "10", "11", "12","13", "14" };
IEnumerable<object> col1Items = new List<object>(),
col2Items = new List<object>(),
col3Items = new List<object>();
Object[] list = new Object[]{col1Items, col2Items, col3Items};
int limit = items.Count()/3;
int len = items.Count();
int col;
for (int i = 0; i < items.Count(); i++ )
{
if (len == 3) col = i;
else col = i / limit;
if (col >= 3) col = i%limit ;
((IList<object>)(list[col])).Add( items.ElementAt(i));
}
這不是很快,但它會做到這一點:
var col1Items = items.Select((obj, index) => new { Value = obj, Index = index })
.Where(o => o.Index % 3 == 0).Select(o => o.Value);
var col2Items = items.Select((obj, index) => new { Value = obj, Index = index })
.Where(o => o.Index % 3 == 1).Select(o => o.Value);
var col3Items = items.Select((obj, index) => new { Value = obj, Index = index })
.Where(o => o.Index % 3 == 2).Select(o => o.Value);
它使用包含索引參數的Select版本。 您可以使用GroupBy以幾行代碼為代價來加快速度。
如果你想要翻閱然后再看下面這個答案,如果你想要往下走,你就可以這樣做(使用下面的測試代碼看看它的工作而不是那里的var result
行:
var curCol = 0;
var iPer = items.Count() / 3;
var iLeft = items.Count() % 3;
var result = items.Aggregate(
// object that will hold items
new {
cols = new List<ItemElement>[3] { new List<ItemElement>(),
new List<ItemElement>(),
new List<ItemElement>(), },
},
(o, n) => {
o.cols[curCol].Add(n);
if (o.cols[curCol].Count() > iPer + (iLeft > (curCol+1) ? 1:0))
curCol++;
return new {
cols = o.cols
};
});
你可以用聚合做到這一點。 它看起來像這樣:
void Main()
{
List<ItemElement> items = new List<ItemElement>() {
new ItemElement() { aField = 1 },
new ItemElement() { aField = 2 },
new ItemElement() { aField = 3 },
new ItemElement() { aField = 4 },
new ItemElement() { aField = 5 },
new ItemElement() { aField = 6 },
new ItemElement() { aField = 7 },
new ItemElement() { aField = 8 },
new ItemElement() { aField = 9 }
};
var result =
items.Aggregate(
// object that will hold items
new {
cols = new List<ItemElement>[3] { new List<ItemElement>(),
new List<ItemElement>(),
new List<ItemElement>(), },
next = 0 },
// aggregate
(o, n) => {
o.cols[o.next].Add(n);
return new {
cols = o.cols,
next = (o.next + 1) % 3
};
});
result.Dump();
}
public class ItemElement
{
public int aField { get; set; }
}
最終得到一個包含3個列表數組的對象(每列一個)。
此示例將在linqPad中運行。 我推薦使用linqPad進行這類POC測試。 (linqPad.com)
LinqLib(nuget:LinqExtLibrary)有ToArray()的重載,它執行它:
using System.Collections.Generic;
using System.Linq;
using LinqLib.Array;
...
public void TakeEm(IEnumerable<int> data)
{
var dataAry = data as int[] ?? data.ToArray();
var rows = (dataAry.Length/3) + 1;
//var columns = Enumerable.Empty<int>().ToArray(3, rows);
// vvv These two lines are the ones that re-arrange your array
var columns = dataAry.ToArray(3, rows);
var menus = columns.Slice();
}
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.