首页 诗词 字典 板报 句子 名言 友答 励志 学校 网站地图
当前位置: 首页 > 教程频道 > .NET > C# >

c#基础算法,两数相除的实例应用,考考你的C#算法功底解决方案

2013-01-26 
c#基础算法,两数相除的实例应用,考考你的C#算法功底包装要求输入要打印的总数量sum(取1到int.max之间的任

c#基础算法,两数相除的实例应用,考考你的C#算法功底
包装要求输入要打印的总数量sum(取1到int.max之间的任意数),每包需包装数量为item(取值为1到1000之间),输出每包数量,余数为尾数包。
请给出算法,至少3种?
例:这次共生产的sum总数为151,输出每包item数量应为
50
50
50
1

[解决办法]
int x = 151, y = 50;
foreach (int i in Enumerable.Repeat(y, x / y).Concat(x % y == 0 ? new int[] {} : new int[] { x % y}))
    Console.WriteLine(i);
[解决办法]
            int x = 151, y = 50;
            while (x > 0)
            {
                Console.WriteLine(x);
                x -= y;
            }
[解决办法]

引用:
引用:int x = 151, y = 50;
            while (x > 0)
            {
                Console.WriteLine(x);
                x -= y;
            }
不好意思,樓上的答案不對,具體問題述描可以看4樓。……


丢人了,没实际做一下。。修改并debug确认过了

            int x = 151, y = 50;
            while (x > y)
            {
                Console.WriteLine(y);
                x -= y;
            }
            Console.WriteLine(x);
[解决办法]
引用:
引用:貌似不需要用除法

真的想请教一下16楼,不用除法,如何实现?



int x = 151, y = 50;
            while (x > 0)
            {
                Console.WriteLine((x >  y ? y : x).ToString());
                x -= y;
            }
 

[解决办法]
搞出来了,用了2分半
   
         int m = 151, n = 50; 


            int step = m / n;
            for (int i = 0; i < step; i++)
            {
                Console.WriteLine(n);
            }
            if (step * n < m)
                Console.WriteLine(m - step * n);
            Console.ReadKey();



时间用了2分半,主要是因为他不写了好几遍都达不到7行的要求,最后实在没办法给加了一句 Console.ReadKey();给硬凑了一个7行出来(呵呵,这小家伙还挺有急智滴嘛)
[解决办法]
struct NODE
{
public int a;
public int b;
}

static NODE Div(int dividend, int divisor)
{
NODE ret = new NODE();
string binDiv = Convert.ToString(dividend, 2);
int cur = 0;
int res = 0;
for (int i = 0; i < binDiv.Length; i++)
{
cur = binDiv[i] == '1' ? (cur << 1) + 1 : cur << 1;
if (cur < divisor)
{
res <<= 1;
continue;
}
cur -= divisor;
res = (res << 1) + 1;
}
ret.a = res;
ret.b = cur;
return ret;
}

static void Main(string[] args)
{
NODE res = Div(151, 50);
Console.WriteLine(res.a.ToString() + " " + res.b.ToString());
}

临时写的,没有测试太多数据,不过不知道楼主认为位移算不算“除法”,代码很乱,轻喷……
[解决办法]
        static void Main(string[] args)
        {
            Random rd = new Random();
            List<int> pags = new List<int>();
            //int sum = rd.Next(1,int.MaxValue);
            //int pag = rd.Next(1, 1000);
            int sum = 151;
            int pag =50;
            int tempSum = sum;
            while (tempSum / pag > 0)
            {
                pags.Add(pag);
                tempSum -= pag;
            }
            pags.Add(tempSum);


            foreach (int i in pags)
            {
                Console.WriteLine(i);
            }
            Console.ReadKey();
        }
[解决办法]
草:
int leave=151;
int item=50;

while(leave-item>0)
{
    leave-=item;
    WriteLine(item);
}
WriteLine(Leave);

用得着除法吗?用得着IF-Else吗
[解决办法]
while(leave-item>0) 改成while(leave-item>=0)。
如果非要7行以内代码,把大括号放上面就OK。c#基础算法,两数相除的实例应用,考考你的C#算法功底解决方案
[解决办法]
呵呵,如果是我自己,我会和cao版一样,写点比较有意思的东西

  Func<int,int, int> func = null;
            func = (m, n) =>
                {
                    Console.WriteLine(m < n ? m : n);
                    return m < n ? m : func(m - n, n);

                };
            func(151, 50);

话说在c#里写函数式的东西还是木有F#里面方便,尾递归还要单独申明一个null
[解决办法]
客串下编译器的语法分析器,直接用表达式树写一个:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            /*
                    int l = x % y == 0 ? x / y : x / y + 1;
                    int[] r = new int[l];
                    for (int i = 0; i < l - 1; i++)
                        r[i] = y;
                    if (x % y != 0) r[l - 1] = x % y; else r[l - 1] = y;
                    return r;


             */
            var p1 = Expression.Parameter(typeof(int), "x");
            var p2 = Expression.Parameter(typeof(int), "y");
            var declarel = Expression.Variable(typeof(int), "l");
            var xdevy = Expression.Divide(p1, p2);
            var xmody = Expression.Modulo(p1, p2);
            var test = Expression.Equal(xmody, Expression.Constant(0));
            var letl = Expression.Assign(declarel, Expression.Condition(test, xdevy, Expression.Add(xdevy, Expression.Constant(1))));
            var newarr = Expression.NewArrayBounds(typeof(int), declarel);
            var declarer = Expression.Variable(typeof(int[]), "r");
            var letr = Expression.Assign(declarer, newarr);
            var declarei = Expression.Variable(typeof(int), "i");
            var letiequalzero = Expression.Assign(declarei, Expression.Constant(0));
            var loopstart = Expression.ArrayAccess(declarer, declarei);
            var setarray = Expression.Assign(loopstart, p2);
            var inci = Expression.Assign(declarei, Expression.Add(declarei, Expression.Constant(1)));
            var loopstartlabel = Expression.Label();
            var loopendlabel = Expression.Label();
            var isbreak = Expression.IfThenElse(Expression.LessThan(declarei, Expression.Subtract(declarel, Expression.Constant(1))), Expression.Goto(loopstartlabel), Expression.Return(loopendlabel, declarer));
            var lastindex = Expression.Subtract(declarel, Expression.Constant(1));
            var lastval = Expression.Condition(Expression.NotEqual(xmody, Expression.Constant(0)), xmody, p2);
            var setlast = Expression.Assign(Expression.ArrayAccess(declarer, lastindex), lastval);
            var body = Expression.Block(new ParameterExpression[] { declarel, declarei, declarer }, letl, letr, Expression.Label(loopstartlabel), setarray, inci, isbreak, Expression.Label(loopendlabel), setlast, declarer);
            var foo = Expression.Lambda(body, p1, p2);


            foreach (int i in (foo as LambdaExpression).Compile().DynamicInvoke(new object[] { 151, 50 }) as int[])
                Console.WriteLine(i);
        }
    }
}



现在我们换一个角度看编程语言吧,你看到对象foo(一个表达式树对象)包括了执行这个逻辑的全部信息,如果你写一个对表达式树的序列化/反序列化程序,那么那些序列化后的数据就是“源代码”,什么是编译器(前端部分),那就是一个特殊的序列化文件(源代码)和一个将它序列化成语法树(中间代码在内存的表示)的解析器。

热点排行