小编Tho*_*ing的帖子

我喜欢这样的挑战,我希望很快能提交我的答案.

哪位牌手拥有最好的7张牌？

给出9张牌的无序列表(以空格分隔),找出哪个牌手有最好的扑克牌. 这是扑克手牌排名列表.输入示例:

2C 5H AS KS 2D 4D QD KH 3S
(ie: [[2C 5H] [AS KS] [2D 4D QD KH 3S]])

阵列中的前2张牌代表牌手1的牌,阵列中的第2张牌代表牌手2的牌.最后5张牌代表社区牌,两张牌都分享.实际上,两个玩家都有7张牌,你必须确定哪个玩家拥有最好的5张扑克牌.

卡片被定义为一个字符串,第一个字符代表卡片值,第二个值代表西装.总是大写的.没有卡可能出现两次.

该函数将计算手牌是否为任何一名球员的平局或胜利.它将在输入结束时输出总数.输出格式稍后在本文中定义.

例子

2C 5H AS KS 2D 4D QD KH 3S
(ie: [[2C 5H] [AS KS] [2D 4D QD KH 3S]])
Player 2 wins this hand.  Player 1 has a pair of 2's, player 2 has a pair of kings.

5S 6S 8H 9D 7S 8S JH TS 2H
(ie: [[5S 6S] …

我一直在看很多文章提到ambient declarations.例如这篇文章.这些是什么？有人可以提供一个例子吗？环境声明是在现有的原型文件之外创建但在这些文件中使用的类型的声明吗？所有声明都是环境声明吗？

据我所知ambient declarations,不生成任何JavaScript代码,并使用declare关键字定义.这是环境声明的唯一情况还是其他情况？

在GHC-7.7(和7.8)中,介绍了封闭式家庭:

封闭类型族在一个地方定义了所有方程,不能扩展,而开放族可以在模块之间分布实例.封闭族的优点是按顺序尝试其方程,类似于术语级函数定义

我想问你,为什么下面的代码不能编译？GHC应该能够推断所有类型 - GetTheType仅针对类型定义X,如果我们注释掉标记的行,则代码编译.

这是GHC中的一个错误或封闭类型的家庭没有这样的优化吗？

码:

{-# LANGUAGE TypeFamilies #-}

data X = X 

type family GetTheType a where
    GetTheType X = X

class TC a where
    tc :: GetTheType a -> Int

instance TC X where
    tc X = 5 

main = do
    -- if we comment out the following line, the code compiles
    let x = tc X
    print "hello"

错误是:

Couldn't match expected type ?GetTheType a0’ with actual type ?X’
The type variable …

我有一个T * pValues我想要查看的指针T (&values)[N]

在这个SO答案/sf/answers/184449611/中,建议的方法是

T (&values)[N] = *static_cast<T(*)[N]>(static_cast<void*>(pValues));

我对此的担忧是.在他的例子中,pValues以下面的方式初始化

T theValues[N];
T * pValues = theValues;

我的问题是,如果pValues来自以下任何构造,则构造构造是否合法:

1:

T theValues[N + M]; // M > 0
T * pValues = theValues;

2:

T * pValues = new T[N + M]; // M >= 0

说我有两个不同的cpp文件.两者都声明具有相同名称的类,但可能是完全不同的结构(或者可能是相同的结构,不同的实现).这些类不会出现在头文件中.(例如,假设它们是不同列表类的Node类.)

我看到这些类冲突了.这是标准的预期吗？这个问题有什么解决方案？

更新:

正如答案/评论所暗示的那样,匿名命名空间就是我所寻求的.

我想实现以下stripPrefixBy功能:

-- psuedo code signature
stripPrefixBy :: forall a. [forall b. a -> Maybe b] -> [a] -> Maybe [a]
stripPrefixBy [] xs = Just xs
stripPrefixBy _ [] = Nothing
stripPrefixBy (p:ps) (x:xs) = case p x of
  Just _ -> stripPrefixBy ps xs
  Nothing -> Nothing

res :: Maybe String
res = stripPrefixBy [const (Just 0), Just] "abc"

wantThisToBeTrue :: Bool
wantThisToBeTrue = case res of
  Just "c" -> True
  _ -> False

我已经尝试使用ImpredicativeTypes和 …

如何找到代码的哪些部分需要很长时间才能编译？

我已经在为所有标题使用预编译头文件,它们肯定会提高编译速度.然而,每当我对我的C++源文件进行更改时,编译它需要很长时间(这是CPU /内存绑定,而不是 I/O绑定 - 它都是缓存的).此外,这是不相关的连接部分,只是编译部分.

我试过打开/showIncludes,但当然,因为我使用的是预编译的头文件,所以后面没有任何内容stdafx.h.所以我知道只有源代码需要一段时间才能编译,但我不知道它的哪一部分.

我也试过做一个最小的构建,但它没有帮助.也没有/MP,因为它无论如何都是单个源文件.

我可以尝试通过添加/删除源代码来解析源代码并确定哪个部分是瓶颈,但这是一个痛苦而且无法扩展.此外,很难删除某些东西,仍然让代码编译 - 错误消息,如果有的话,几乎立即回来.

有没有更好的方法来弄清楚什么会减慢编译速度？

或者,如果没有办法:是否有任何语言结构(例如模板？)需要花费更长的时间来编译？

我在C++源代码中有什么:

• 三个(相对较大的)ATL对话框类(包括定义/逻辑).

  它们很可能是原因,但无论如何它们都是程序的核心部分,所以显然每当我更改它们时都需要重新编译它们.

• 随机单行(或类似小)实用程序函数,例如字节数组到十六进制转换器

• 对我的头文件中找到的(内联)类的引用.(其中一个头文件是巨大的,但它只使用最少的模板,当然它是预编译的.另一个是TR1 regex- 它很大,但它几乎没用过.)

注意:

我正在寻找技术,我可以更一般地应用这些问题的原因,而不是针对我的特殊情况的具体建议.希望这对其他人也更有用.

我有以下代码编译在我的程序中:

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}

class (Show (Data a)) => HasData (a :: *) where
    type Data a :: *

data Foo :: * -> * where
    Foo :: (HasData a) => String -> Data a -> Int -> Foo a -- bunch of args

deriving instance Show (Foo a)

由于Foo构造函数的参数数量可以很多,我想使用记录语法编写代码,但我无法弄清楚如何使用GADT语法(GHC弃用的数据类型上下文,所以我试图避免它们) :

data Foo :: * -> * where
    Foo {
        getStr …

为什么这会导致冲突？

class Foo a b | b -> a where
  foo :: a -> b -> Bool

instance Eq a => Foo a a where
  foo = (==)

instance Eq a => Foo a (a -> a) where
  foo x f = f x == x

请注意,如果我删除功能依赖性,代码将编译.

我的印象是功能依赖只应该禁止像下面这样的东西,实际上,它编译!

class Foo a b | b -> a where
  foo :: a -> b -> Bool

instance Eq a => Foo a a where
  foo = (==)

instance Eq a => Foo …

我想获得一个用于C++的AST,然后我可以使用外部程序进行解析.哪些程序适合为C++生成AST？我不关心它实现的语言或输出格式(只要它易于解析).

我的总体目标是将C++单元测试台转换为相应的C#包装器测试台.