C#练习题答案: 49-6 49的LOTTO 6【难度：2级】--景越C#经典编程题库,1000道C#基础练习题等你来挑战

最新推荐文章于 2024-08-12 18:10:44 发布
最新推荐文章于 2024-08-12 18:10:44 发布
阅读量143 收藏
点赞数
分类专栏： C#编程训练习题答案 文章标签： csharp面试题库和答案 csharp编程练习 算法 基本的语言特点 基本原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45444821/article/details/102286305
版权

49-6 49的LOTTO 6【难度:2级】:

答案1:

using System;
using System.Collections.Generic;
using System.Linq;

public class LOTTO
{
  public static int[] NumberGenerator()
  {
    List<int> numbers = Enumerable.Range(1, 49).ToList();
    var rnd = new Random();
    
    numbers = numbers.OrderBy(x => rnd.Next()).ToList();
    numbers = numbers.Take(6).OrderBy(x=>x).ToList();   
    numbers.Add(new Random().Next(0,10));
    
    return numbers.ToArray();
  }
  
  public static int CheckForWinningCategory(int[] checkCombination, int[] winningCombination)
  {    
     var matches = checkCombination.Take(6).Intersect(winningCombination.Take(6)).Count();     
     var score = 2*(6-matches)+2;
     
     if(checkCombination[6] == winningCombination[6]) 
       score--;

      return score > 9 ? -1 : score;
  }
}​

答案2:

using System;
using System.Linq;

public class LOTTO
{
  private static Random rand = new Random();
  private static int[] numbers = Enumerable.Range(1,49).Select(i => i).ToArray();
  
  public static int[] NumberGenerator()
  {
    //return new int[0];
        
    return numbers.OrderBy(o => rand.Next(-1,2)).OrderBy(o => rand.Next(-1,2)).Take(6).OrderBy(o => o).Concat(new int[] { rand.Next(0, 10) }).ToArray();
  }
  
  public static int CheckForWinningCategory(int[] checkCombination, int[] winningCombination)
  {
    bool szIsCorrect = checkCombination[6] == winningCombination[6];
    var checkCombination6 = checkCombination.Take(6).ToArray();
    var count = 0;
    for(int i = 0; i < winningCombination.Length - 1; i++)
    {
      if(checkCombination6.Contains(winningCombination[i]))
      {
        count++;
      }
    }
    if(count == 6)
    {
      return szIsCorrect ? 1 : 2;
    }
    if(count == 5)
    {
      return szIsCorrect ? 3 : 4;
    }
    if(count == 4)
    {
      return szIsCorrect ? 5 : 6;
    }
    if(count == 3)
    {
      return szIsCorrect ? 7 : 8;
    }
    if(count == 2 &amp;&amp; szIsCorrect)
    {
      return 9;
    }
    
    return -1;
  }
}​

答案3:

using System;
using System.Linq;
using System.Collections.Generic;

public class LOTTO
{
    public static int[] NumberGenerator()
    {
        var rnd = new Random(DateTime.Now.Millisecond);
        int randomNumber;
        List<int> numbers = new List<int>(7);
        for (int i = 0; i < 6; i++)
        {
            while (numbers.Contains(randomNumber = rnd.Next(1, 50))) ;
            numbers.Add(randomNumber);
        }
        return numbers.OrderBy(n => n).Append(rnd.Next(0, 10)).ToArray();
        
    }

    public static int CheckForWinningCategory(int[] checkCombination, int[] winningCombination)
    {
        bool superZahlMatch = checkCombination[6] == winningCombination[6];
        int matches = checkCombination.Take(6).Intersect(winningCombination.Take(6)).Count();
        switch (matches)
        {
            case 6 : return superZahlMatch ? 1 : 2;
            case 5: return superZahlMatch ? 3 : 4;
            case 4: return superZahlMatch ? 5 : 6;
            case 3: return superZahlMatch ? 7 : 8;
            case 2: return superZahlMatch ? 9 : -1;
            default: return -1;
        }
    }
}​

答案4:

using System;
using System.Collections.Generic;
using System.Linq;
public class LOTTO
    {
        public static int CheckForWinningCategory(int[] checkCombination, int[] winningCombination)
        {
            var amountnumbersmatch = 0;
            var superzahlmatch = checkCombination[6] == winningCombination[6];

            for (int i = 0; i < 6; i++)
            {
                if (winningCombination.Contains(checkCombination[i]))
                {
                    amountnumbersmatch++;
                }
            }

            if (superzahlmatch)
            {
                if (amountnumbersmatch == 6) return 1;
                if (amountnumbersmatch == 5) return 3;
                if (amountnumbersmatch == 4) return 5;
                if (amountnumbersmatch == 3) return 7;
                if (amountnumbersmatch == 2) return 9;
            }
            else
            {
                if (amountnumbersmatch == 6) return 2;
                if (amountnumbersmatch == 5) return 4;
                if (amountnumbersmatch == 4) return 6;
                if (amountnumbersmatch == 3) return 8;
            }

            return -1;

        }

        public static int[] NumberGenerator()
        {
            var numbers = new int[7];
            var rand = new Random();
            var check = new HashSet<int>();

            for (var i = 0; i < 6; i++)
            {
                var curValue = rand.Next(1, 50);
                if (i == 0)
                {
                    curValue = rand.Next(1, 50);
                }
                while (check.Contains(curValue))
                {
                    curValue = rand.Next(1, 50);
                }
                numbers[i] = curValue;
                check.Add(curValue);
            }

            Array.Sort(numbers, 0, 6);

            numbers[6] = rand.Next(0, 10);

            return numbers;
        }
    }​

答案5:

using System;
using System.Linq;

    public class LOTTO
    {
        public static int[] NumberGenerator()
        {
            var sixOf49 = new int[6];

            while (sixOf49[5] == 0)
            {
                var oneOfThem = new Random((int)DateTime.Now.Ticks &amp; 0x0000FFFF).Next(1, 50);

                if (sixOf49.Where(x => x.Equals(oneOfThem)).Any())
                {
                    continue;
                }

                for (var i = 0; i < 6; i++)
                {
                    if (sixOf49[i] == 0)
                    {
                        sixOf49[i] = oneOfThem;
                        break;
                    }
                }
            }

            Array.Sort(sixOf49);
            Array.Resize(ref sixOf49, 7);

            sixOf49[6] = (new Random((int)DateTime.Now.Ticks &amp; 0x0000FFFF)).Next(0, 10);

            return sixOf49;
        }

        public static int CheckForWinningCategory(int[] checkCombination, int[] winningCombination)
        {
            var check = checkCombination.Take(6).ToArray();
            var win = winningCombination.Take(6).ToArray();

            var count = win.Where(number => check.Where(x => x.Equals(number)).Count() != 0).Aggregate(14, (current, number) => current - 2);

            /*// long variant, which replaced linq-chain
            var count = 14;

            foreach (int number in win)
            {
                if (check.Where(x => x.Equals(number)).Count() != 0)
                {
                    count -= 2;
                }
            }
            */

            if (checkCombination[6].Equals(winningCombination[6])) count--;

            if (count > 9) count = -1;

            return count;
        }
    }​

答案6:

using System;
using System.Collections.Generic;
using System.Linq;

public class LOTTO
{
    private static Random random = new Random();

    public static int[] NumberGenerator()
    {
        List<int> randomNumbers = new List<int>();
        
        for(int i = 0; i < 6; i++)
        {
            int randomNumber = 0;
            do
            {
                randomNumber = random.Next(1, 50);
            } while(randomNumbers.Contains(randomNumber));
            
            randomNumbers.Add(randomNumber);
        }
        
        randomNumbers.Sort();
        
        randomNumbers.Add(random.Next(0, 10));
        
        return randomNumbers.ToArray();
    }
    
    public static int CheckForWinningCategory(int[] checkCombination, int[] winningCombination)
    {
        var winningNumbers = winningCombination.Take(6);

        int matchNumber = Enumerable.Range(0, 6).Count(i => winningNumbers.Contains(checkCombination[i]));
        bool isSuperNumberMatch = checkCombination.Last() == winningCombination.Last();
        
        switch(matchNumber)
        {
            case 2:
                if (isSuperNumberMatch)
                {
                    return 9;
                }
                
                break;
            
            case 3:
                if (isSuperNumberMatch)
                {
                    return 7;
                }
                
                return 8;
            
            case 4:
                if (isSuperNumberMatch)
                {
                    return 5;
                }
                
                return 6;
            
            case 5:
                if (isSuperNumberMatch)
                {
                    return 3;
                }
                
                return 4;
            
            case 6:
                if (isSuperNumberMatch)
                {
                    return 1;
                }
                
                return 2;
            
            default:
                break;
        };
        
        return -1;
    }
}​

答案7:

using System;

public class LOTTO
{
  public static int[] NumberGenerator()
  {
    int[] arrayNumeros = new int[50]; //From 1 to 49.
    int[] arrayTemp = new int[6];
    int[] arrayFinal = new int[7];
    int numero = 0;
    int alea = 0;
  
    for (int intI = 0; intI <= 49; intI++) arrayNumeros[intI] = intI;
    Random rnd = new Random();
    for (int intI = 0; intI < 6; intI++)
    {
        numero = rnd.Next(1, 49); //between 1 and 49.
        alea = arrayNumeros[intI];
        arrayNumeros[intI] = arrayNumeros[numero];
        arrayNumeros[numero] = alea;
    }
    
    for (int intI = 0; intI < 6; intI++) arrayTemp[intI]=arrayNumeros[intI];
    Array.Sort(arrayTemp);
    
    for (int intI = 0; intI < 6; intI++) arrayFinal[intI]=arrayTemp[intI];
    arrayFinal[6]=rnd.Next(0, 10); //between 0 and 9.
    
    return arrayFinal;
  }
  
  public static int CheckForWinningCategory(int[] checkCombination, int[] winningCombination)
  {
    int premios6 = 0;
    for (int intCombi = 0; intCombi <= 5; intCombi++)
    {
        for (int intI = 0; intI <= 5; intI++)
        {
            if (checkCombination[intCombi] == winningCombination[intI])
            {
                premios6++;
                break;
            }
        }
    }
    bool Superzahl = false;
    if (checkCombination[6] == winningCombination[6]) Superzahl = true;
    switch(premios6)
    {
      case 6:
          if (Superzahl) return 1;
          else return 2;
          break;
      case 5:
          if (Superzahl) return 3;
          else return 4;
          break;
      case 4:
          if (Superzahl) return 5;
          else return 6;
          break;
      case 3:
          if (Superzahl) return 7;
          else return 8;
          break;
      case 2:
          if (Superzahl) return 9;
          break;
    }
  
    return -1;
  }
}​

答案8:

using System;
using System.Linq;

public class LOTTO {

    private static int[] _numbers1 = Enumerable.Range( 1, 49 ).ToArray( );

    private static int[] _numbers2 = Enumerable.Range( 0, 10 ).ToArray( );

    public static int[] NumberGenerator( ) {
        Shuffle( _numbers1 );
        Shuffle( _numbers2 );
        return _numbers1.Take( 6 ).OrderBy( _ => _ ).Concat( new[] {_numbers2 [ 0 ]} ).ToArray( );
    }

    public static int CheckForWinningCategory( int[] checkCombination, int[] winningCombination ) {
        var n = winningCombination.Length;
        if ( checkCombination.Length != n ) {
            return -1;
        }
        var matches = CountMatches( checkCombination, winningCombination );
        var superzahlMatch = checkCombination [ n - 1 ] == winningCombination [ n - 1 ];
        switch ( matches ) {
            case 6:
                return superzahlMatch ? 1 : 2;
            case 5:
                return superzahlMatch ? 3 : 4;
            case 4:
                return superzahlMatch ? 5 : 6;
            case 3:
                return superzahlMatch ? 7 : 8;
            case 2:
                return superzahlMatch ? 9 : -1;
            default:
                return -1;
        }
    }

    private static int CountMatches( int[] checkCombination, int[] winningCombination ) {
        var matches = 0;
        for ( int i = 0; i < winningCombination.Length - 1; i++ ) {
            for ( int j = 0; j < checkCombination.Length - 1; j++ ) {
                if ( checkCombination [ j ] == winningCombination [ i ] ) {
                    matches += 1;
                }
            }
        }
        return matches;
    }

    private static void Shuffle( int[] array ) {
        var random = new Random( );
        for ( int i = 0; i < array.Length; i++ ) {
            var j = i + random.Next( array.Length - i );
            var t = array [ j ];
            array [ j ] = array [ i ];
            array [ i ] = t;
        }
    }

}​

答案9:

using System;
using System.Linq;
    public class LOTTO
    {
        public static int[] NumberGenerator()
        {
            int[] res = new int[] { -1, -1, -1, -1, -1, -1, 50 };
            for(int i = 0; i < 6; i++)
            {
                int temp = new Random().Next(1, 50);
                if (res.Any(x => x == temp)) i--;
                else res[i] = temp;
            }
            res = res.OrderBy(x => x).ToArray();
            res[6] = new Random().Next(0, 10);
            return res;
        }

        public static int CheckForWinningCategory(int[] checkCombination, int[] winningCombination)
        {
            int res = 0;
            int[] temp = winningCombination.Take(6).ToArray();
            for(int i = 0; i < 6; i++)
            {
                if (temp.Any(x => x == checkCombination[i])) res++;
            }
            int bonus = 0;
            if (winningCombination[6] == checkCombination[6]) bonus++;
            if (res > 2) res = (7 - res) * 2 - bonus;
            else return -1;
            return res;
        }
    }​

答案10:

using System;
using System.Collections.Generic;
public class LOTTO
{
        public static int[] NumberGenerator()
        {
            var random = new Random();
            var list = new List<int>();
            while (list.Count<6)
            {
                var r = random.Next(1, 50);
                if(!list.Contains(r)) list.Add(r);
            }
            list.Sort();
            list.Add(random.Next(0,10));
            return list.ToArray();
        }

        public static int CheckForWinningCategory(int[] checkCombination, int[] winningCombination)
        {
            var count = 0;
            for (int i = 0; i < checkCombination.Length-1; i++)
                if (Array.BinarySearch(winningCombination, 0, winningCombination.Length - 1, checkCombination[i]) >= 0) count++;
            
            var s = checkCombination[checkCombination.Length - 1] == winningCombination[winningCombination.Length - 1]?-1:0;
            switch (count)
            {
                case 6: return 2 + s;
                case 5: return 4 + s;
                case 4: return 6 + s;
                case 3: return 8 + s;
                case 2: if (s == -1) return 9;break;
            }
            return -1;
        }
}​



goodview andyldm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
csharp进阶练习题:49-6 49的LOTTO 6【难度：2级】--景越C#经典编程题库,不同难度C#练习题，适合自学C#的新手进阶训练
景越c#经典编程题库(csharp programming training)
10-08 395
csharp进阶练习题:49-6 49的LOTTO 6【难度:2级】: 在德国,我们有"六合彩6 AUS 49".这意味着,49 6的数字绘制为成功的组合.结果 还有一个"Superzahl",其他号码,它可以增加你中奖类别. 在这习题,你必须写两个方法. 公共静态INT [] NumberGenerator() 公共静态INT CheckForWinningCategory(INT [] ch...
simple_lotto：c＃excel编程以制作随机的乐透号码并检查
02-11
simple_lotto：c＃excel编程以制作随机的乐透号码并检查
Bit-M五月【LOTTO11 ——逢11必送币】，三重惊喜等你来
Bit-M News
05-11 199
为了回馈广大用户对Bit-M平台一直以来的支持与厚爱,【LOTTO11 ——逢11必送币】活动将伴随着5月12日母亲节浓浓的爱意，在五月展开重磅福利。 福利活动一——交易赛 在5月12日15:00——5月20日15:00期间，凡在Bit-M平台进行交易的用户，我们将按照交易量的排名，选取前10名，获得USDT+BMB奖励。 第 1 名： 1000 USDT + 1000 BMB 第 2 名...
【DFS+输出N个升序的数中选6个的所有排列】HDU-1342 Lotto
zhanggirlzhangboy的博客
08-22 122
注解 1、题意很简单，从N个升序的数中选6个出来，问总共有多少种方案，并按字典序输出。 2、典型的DFS，DFS的写法是递归，满足条件就是找到了6个数（定义一个b数组存放选中的数）。否则的话，就设置一个vis数组，看该数是否访问过。如果没访问过，就先访问，然后把该数加到b数组里。继续DFS找下一个数。DFS结束后，该数的访问标记恢复为0，方便下一次的访问。 代码 #include <io...
Ninety-Nine Scala Problems 不错的scala入门练习题
Shadow
07-02 1062
不错的scala入门练习题。 原站网址：http://wiki.summercode.com/s_99_ninety_nine_scala_problems P01 (*) Find the last element of a list. Example: scala> last(List(1, 1, 2, 3, 5, 8)) res0: Int = 8import scala.col
C++ Primer Plus（第6版）---编程作业完成（第七章）
plain_rookie的博客
01-27 389
第七章 #include <iostream> using namespace std; //符号常量 const int Golf_Num = 10; struct box { char maker[40]; float height; float width; float length; float volume; }; //函数原型 double average_0(double,double); void arr_input(double arr[Golf_Num], in
vue使用lottie-web实现web动画
@必意玲
10-23 2212
Lottie是一个库，可以解析使用AE制作的动画（需要用bodymovie导出为json格式）,支持web、ios、android、flutter和react native。在web端，lottie-web库可以解析导出的动画json文件，并将其以svg或者canvas的方式将动画绘制在我们的页面上.找到我们想要的动画，然后点击后，弹出窗口，点击下载，格式为JSON。然后就能把这个动画的json数据用到我们自己的项目里边去了。
pwnable 题目解析：[Toddler's Bottle]-lotto 逻辑漏洞
个人笔记
02-27 356
0x10 题目描述 Mommy! I made a lotto program for my homework. do you want to play? ssh lotto@pwnable.kr -p2222 (pw:guest) 本题是 pwnable 中的入门级试题，代码本身不含漏洞，而是逻辑问题。时至今日，很多传统的堆栈溢出漏洞不再那么容易找到，而那些设计问题或者代码中的逻辑问题，往往...
oh-my-lotto
shinygod的博客
04-22 657
知识点：改变环境变量绕过wget md5爆破 import hashlib for i in range(1000000000): a = hashlib.md5(str(i).encode('utf-8')).hexdigest() if a[0:6] == '0c5fbf': print(i) print(a) 关键是三个路由。 result路由，返回一个他给定的值，也就是我们要预测的值。 @app.route("/result", methods
python-lucky-dip-lotto:模拟每周一次的幸运大抽奖
03-20
python-lucky-dip-lotto模拟每周一次的幸运大抽奖使用PyCharm 2020.3.3（社区版）创建和提交程序模拟连续的每周幸运抽奖彩票。 [英国彩票使用数字0-59]每场比赛代表每周购买一张票。该程序具有代表彩票的七个数字的...
Juego-de-lotto:Es un programa en el cual puedes comprar cartones y realizar juegos de bingo o bien sea de loteria
03-05
Juego-de-lotto ES程序集可编辑的纸箱和实物图，可升级为可升级的界面。 可保存的电子文件（.exe）：Juego-de-lotto / lotto / bin / Debug / lotto.exe
gen-lotto-num:乐透号码生成器项目
04-12
乐透号码生成器 乐透号码生成器项目。 链接： ： 当前功能 产生随机的乐透号码 选择要包括的号码 选择要排除的数字 查看创建的号码集总数 查看每周创建的号码集数量 有待开发的功能 有关是否赢得生成的号码的统计...
lotto-generator
03-16
lotto-generator
day 9 回溯算法
m0_73924943的博客
08-08 310
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
代码随想录算法训练营day36：动态规划04：1049.最后一块石头的重量II；494.目标和；474.一和零
weixin_65180740的博客
08-07 925
力扣题目链接(opens new window)有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。输入：[2,7,4,1,8,1]输出：1。
浙大版《C语言程序设计（第3版）》题目集
qq_67330059的博客
08-09 311
其中a和b是用户传入的参数，函数返回的是两者中较大的数。
算法学习day32
最新发布
2301_78191305的博客
08-12 812
2.如果遍历到的数字可以和放一个数字构成一个有效的大写字母的ASCII值，是对dp[i+1]有用的，(这个有用是指多了dp[i-1]种分割方法）那么dp[i+1]+=dp[i-1];现在1有与3，5相乘的资格，2有与2，3，5相乘的资格，但是2×3和2×5是没必要比较的，因为有比它更小的1可以同3，5相乘，所以我们只需要比较1×3，1×5，2×2。即n=2*x+3*y+5*z。如果nums[i]==nums[i-1]&&nums[i-1]==nums[i-2] 那么dp[i]+=dp[i-1]+1;
算法日记day 33（动归之斐波那契数|爬楼梯）
m0_74980681的博客
08-08 364
要求每次可以爬1阶或者2阶，逆向思维可以理解为，当我们上到最后一阶楼梯时，可以迈一阶楼梯dp[n-1]，或者迈两阶楼梯上dp[n-2]，因此可得最终爬上去n阶台阶的方法共有dp[n-1]+dp[n-2]种方法，dp的方法是爬到第n阶台阶总共有多少种方法，而不是走了几步，因此递推关系仍是斐波那契数列。已知斐波那契数列递推式为dp[i]=dp[i-1]+dp[i-2]，因此求第n个数只需要逐渐相加获得。1. 1 阶 + 1 阶 + 1 阶。1. 1 阶 + 1 阶。2. 1 阶 + 2 阶。
In a Lotto I have ever played, one has to select 6 numbers from the set {1,2,...,49}. A popular strategy to play Lotto - although it doesn't increase your chance of winning - is to select a subset S containing k (k>6) of these 49 numbers, and then play several games with choosing numbers only from S. For example, for k=8 and S = {1,2,3,5,8,13,21,34} there are 28 possible games: [1,2,3,5,8,13], [1,2,3,5,8,21], [1,2,3,5,8,34], [1,2,3,5,13,21], ... [3,5,8,13,21,34]. Your job is to write a program that reads in the number k and the set S and then prints all possible games choosing numbers only from S.
06-07
- It then uses the `combinations` function from the `itertools` module to generate all possible games of 6 numbers that can be chosen from `S`. This is done by passing `S` and `6` as arguments to the ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值