高手请进,关于循环取数

Question

如下数据:
TYPE productNum
001    4
002    1
003    3
004    2按顺序循环取数,每次从productNum取1,取到8的时候不再取.4 1 1 1 此时4还剩1
1 1 0 
3 1 1   此时3还剩1
2 1 1最后结果如下:
TYPE productNum
001    3
001    1
002    1
003    2
003    1
004    2请问大家是怎么考虑的?

Answer 1

在.net中用程序实现,放到datatable中

Answer 2

按顺序循环取数,每次从productNum取1,取到8的时候不再取. 
TYPE productNum 
001  4 1 1 1
002  1 1 0 
003  3 1 1  
004  2 1 1 这时候已经等于8了,就不往下取了.那此时4取了3次1,还剩1,3取了2次1也剩下1了.

Answer 3

还是没看明白!
问题1.
 8是从哪里来?
问题2:
 4取了3次1,还剩1,3取了2次1也剩下1了? 没明白! TYPE productNum 
001  4 +1 +1 +1=7 
002  1 +1+ 0=2 
003  3 +1 +1=5  
004  2 +1+ 1=4 
LZ,你就给出,你完整最原始的数据. 
然后,贴出你要的结果形式!什么取什么取的,看了N遍还是没明白!

Answer 4

不知道是不是这个意思：            DataTable dt = new DataTable();
            dt.Columns.AddRange(new DataColumn[] { new DataColumn("TYPE", typeof(string)), new DataColumn("productNum", typeof(int)) });
            dt.Rows.Add("001", 4);
            dt.Rows.Add("002", 1);
            dt.Rows.Add("003", 3);
            dt.Rows.Add("004", 2);
            int count = 0;
            int index = 0;
            while (count < 8)
            {
                if (Convert.ToInt32(dt.Rows[index][1]) > 0)
                {
                    dt.Rows[index][1] = Convert.ToInt32(dt.Rows[index][1]) - 1;
                    count++;
                }
                index++;
                if (index > 3)
                    index = 0;
            }
            foreach (DataRow dr in dt.Rows)
                Console.WriteLine("{0}:{1}", dr[0], dr[1]);

Answer 5

8是我定义的一个值,常量,这个不用管.
我的原始数据是:
TYPE productNum 
001    4 
002    1 
003    3 
004    2 过程:TYPE productNum 第一次循环 第二次循环                              第三次循环  剩余
001    4         1        1                                    1         1
002    1         1        0(此时不可能再是1了,因为原来值就是1)              0
003    3         1        1                                              1
004    2         1        1                                              0第三次循环时,已经1+1+1+1+1+0+1+1+1+1=8了,所以不往下取了.最后结果如下: 
TYPE productNum 
001    3  
002    1 
003    2 
004    2 
001    1
003    1 

Answer 6

8是我定义的一个值,常量,这个不用管. 
我的原始数据是: 
TYPE productNum 
001    4 
002    1 
003    3 
004    2 过程: TYPE productNum 第一次循环 第二次循环                              第三次循环  
001    4        1        1                                    1        
002    1        1        0(此时不可能再是1了,因为原来值就是1)              
003    3        1        1                                              
004    2        1        1                                              第三次循环时,已经1+1+1+1+1+0+1+1+1+1=8了,所以不往下取了. 那么001取了3次1,剩下了4-3=1,003取了2次1,剩下了3-2=1.其他都没有余下.最后结果如下: 
TYPE productNum 
001    3  
002    1 
003    2 
004    2 
001    1 
003    1 

Answer 7

好象15楼ojlovecd的答案靠谱,明天试一下

Answer 8

楼主的意思是我明白了
就是遍历 001～004 的 productNum --，然后将 productNum 减去的值累加 得到一个值count（如果productNum ==0 那就不在自减,count也不累加）没做一次遍历就判断 count!=8

Answer 9

using System;
using System.Collections.Generic;
using System.Text;namespace consoleQueue
{
    class Program
    {
        static void Main(string[] args)
        {
            Queue<int> pX = new Queue<int>();
            pX.Enqueue(4);
            pX.Enqueue(1);
            pX.Enqueue(3);
            pX.Enqueue(2);
            Queue<string> pY = new Queue<string>();
            pY.Enqueue("T001");
            pY.Enqueue("T002");
            pY.Enqueue("T003");
            pY.Enqueue("T004");
            int i=0;
            int count=0;
            string tempstr = string.Empty;
            while (pX.GetEnumerator().MoveNext())
            {
                i= pX.Dequeue();
                tempstr= pY.Dequeue();                pX.Enqueue (--i<=0?0:i);
                pY.Enqueue(tempstr);                if (i > 0)
                { Console.WriteLine("{0}  {1}", tempstr, i); }                count += i < 0 ? 0 : 1;
                if (count == 8)
                { break; }
            }
        }
    }
}

Answer 10

15是对的，把输出改点儿就行            int[] temp = new int[] { 4, 1, 3, 2 };
            int i = 0;
            foreach (DataRow dr in dt.Rows)
            {
                if ((int)dr[1] == 0)
                {
                    Console.WriteLine("{0}:{1}", dr[0], temp[i]);
                }
                else
                {
                    Console.WriteLine("{0}:{1}", dr[0], temp[i] - (int)dr[1]);
                    Console.WriteLine("{0}:{1}", dr[0], dr[1]);
                }
                i++;
            }

Answer 11

修正下楼主最后结果
最后结果如下: （原）
TYPE productNum 
001    3 
001    1 
002    1 
003    2 
003    1 
004    2 
=>
最后结果如下: （新）
TYPE productNum 
001    3 
001    2 
001    1
003    2 
003    1 
004    1