这是功能吗？

47

给定一个列表(key, value)对，确定它是否代表一个函数，这意味着每个键都映射到一个一致的值。换句话说，每当两个条目具有相等的键时，它们也必须具有相等的值。重复输入即可。

例如：

# Not a function: 3 maps to both 1 and 6
[(3,1), (2,5), (3,6)]

# Function: It's OK that (3,5) is listed twice, and that both 6 and 4 both map to 4
[(3,5), (3,5), (6,4), (4,4)]

输入：(key, value)使用数字1到9 的成对有序序列。您可能不需要特定的排序。您也可以将键列表和值列表作为单独的输入。

输出：功能的一致值，非功能的一致值。

测试用例：前5个输入是函数，后5个不是。

[(3, 5), (3, 5), (6, 4), (4, 4)]
[(9, 4), (1, 4), (2, 4)]
[]
[(1, 1)]
[(1, 2), (2, 1)]

[(3, 1), (2, 5), (3, 6)]
[(1, 2), (2, 1), (5, 2), (1, 2), (2, 5)]
[(8, 8), (8, 8), (8, 9), (8, 9)]
[(1, 2), (1, 3), (1, 4)]
[(1, 2), (1, 3), (2, 3), (2, 4)]

它们是两个输入列表：

[[(3, 5), (3, 5), (6, 4), (4, 4)], [(9, 4), (1, 4), (2, 4)], [], [(1, 1)], [(1, 2), (2, 1)]]
[[(3, 1), (2, 5), (3, 6)], [(1, 2), (2, 1), (5, 2), (1, 2), (2, 5)], [(8, 8), (8, 8), (8, 9), (8, 9)], [(1, 2), (1, 3), (1, 4)], [(1, 2), (1, 3), (2, 3), (2, 4)]]

排行榜：

显示代码段

code-golf  decision-problem 
— 异或
source
排斥功能？
— 戳
@Poke不必一定是排斥的。
— xnor
输入是否可以是两个等长列表，一个用于键，一个用于值？
— 加尔文的业余爱好
2
像这样(key,value)对可以反转(value,key)吗？如果可以，我可以将答案减少几个字节。
— ymbirtt
1
@ymbirtt是的，您可以按任何顺序设置配对。
— xnor

Answers:

37

Python 2，34个字节

lambda x:len(dict(x))==len(set(x))

在线尝试！

根据输入创建字典和集合，并比较它们的长度。
字典不能有重复的键，因此所有非法（和重复）值都将被删除。

— 竿
source
5
Python lambda x:not dict(x).items()^x
— 3，30
21

Haskell，36个字节

f x=and[v==n|(k,v)<-x,(m,n)<-x,k==m]

在线尝试！

外部（-> (k,v)）和内部（-> (m,n)）在这些对上循环，并随时k==m收集的真值v==n。检查是否全部正确。

— 妮米
source
你太快了！：/
— 瑕疵的
18

Brachylog，5 4字节

dhᵐ≠

在线尝试！

完整程序。据我所知，它击败了大多数其他高尔夫语言的原因≠是Brachylog中内置的，而大多数其他高尔夫语言需要对其进行综合。

说明

dhᵐ≠
d     On the list of all unique elements of {the input},
 h    take the first element
  ᵐ     of each of those elements
   ≠  and assert that all those elements are different

作为一个完整的程序，我们true可以确定断言是否成功false。

15

Pyth，5个字节

我对此很满意。

{IhM{
       implicit input
    {  removes duplicate pairs
  hM   first element of each pair
{I     checks invariance over deduplication (i.e. checks if no duplicates)

在线尝试！

— Notjagan
source
9

视网膜，25字节

1`({\d+,)(\d+}).*\1(?!\2)

在线尝试！

输入格式为{k,v},{k,v},...。打印0功能和1非功能。我可以使用换行符而不是输入格式的逗号来保存两个字节，但这很麻烦。

— 马丁·恩德
source
我认为，至少从技术角度来看，它被视为“严重错误”。
— FryAmTheEggman'5
8

Brachylog，13个字节

¬{⊇Ċhᵐ=∧Ċtᵐ≠}

在线尝试！

说明

¬{          }      It is impossible...
  ⊇Ċ               ...to find a subset of length 2 of the input...
   Ċhᵐ=            ...for which both elements have the same head...
       ∧           ...and...
        Ċtᵐ≠       ...have different tails.
— 致命
source
你能解释一下如何Ċhᵐ=和Ċtᵐ≠工作？
— CalculatorFeline
@CalculatorFeline大写字母是变量名。Ċ是一个称为Couple的特殊变量，它总是预先约束为两个元素的列表。ᵐ是一个元谓词，它立即将先前的谓词（h - head或t - tail此处）应用于输入的每个元素（此处为Ċ）。=并简单≠检查其输入是否包含所有相等/所有不同的元素。
— 致命
7

MATL，8字节

1Z?gs2<A

输入是：带有values 的数组，然后是带有keys 的数组。

输出1用于功能，0否则。

在线尝试！。或验证所有测试用例。

说明

1Z?

建立一个稀疏矩阵。最初，所有条目都包含0；和1被添加到每个条目(i, j)，其中j和i是输入key，value对。

g

矩阵转换为逻辑；也就是说，超过1（对应于重复key，value成对）的条目设置为1。

s

计算每列的总和。这是value每个的不同的数量key。

2<A

函数的所有此类总和小于2。

— 路易斯·门多
source
6

R，33个字节

这是我的R版本。它利用了该ave功能。通过在key和value参数上设置默认值，我允许空输入。 ave产生每个键值的平均值。幸运的是，它以与输入值相同的顺序返回均值，因此与输入的比较将指示是否存在不同的值。返回TRUE是否为函数。

function(k=0,v=0)all(ave(v,k)==v)

在线尝试！

— 米奇
source
6

05AB1E，11 9 7个字节

由于kalsowerus节省了2个字节。

Ùø¬DÙQ,

在线尝试！

说明

Ù           # remove duplicates
 ø          # zip
  ¬         # get the first element of the list (keys)
   D        # duplicate list of keys
    Ù       # remove duplicates in the copy
     Q      # compare for equality
      ,     # explicitly print result
— 艾米尼亚
source
@Riley：是的。我仍然很高兴，特殊情况只结束了该程序的三分之一：P
— Emigna
我认为您可以`\)^用head（¬）替换来节省3个字节：TIO
— kalsowerus
@kalsowerus：不幸的是：[]（
— Emigna '17
@Enigma哦，之所以有用，是因为在测试时，我最后仍然有剩余,。添加它，然后以某种方式可以使用[]。
— kalsowerus
更新的TIO
— kalsowerus
5

JavaScript（ES6），45 38字节

@Neil节省了6个字节

a=>a.some(([k,v])=>m[k]-(m[k]=v),m={})

分别返回false或true表示函数和非函数。

通过不断减去每个函数（m[k]）的旧值和新函数（m[k]=v，该值也存储新值）来工作。每次都有三种情况：

  • 如果没有旧值，则m[k]返回undefined。从中减去任何undefined结果都会导致NaN，这是错误的。
  • 如果旧值与新值相同，则m[k]-v结果为0，这是虚假的。
  • 如果旧值与新值不同，则m[k]-v得出一个非零整数，这是正确的。

因此，我们只需要确保它m[k]-(m[k]=v)永远都不是真实的。

— ETH生产
source
1
太久了。使用a=>!a.some(([x,y])=>m[x]-(m[x]=y),m=[])。
— 尼尔
@Neil Dang，我知道必须有某种方法来利用m[k]未定义的内容……谢谢！
— ETHproductions
5

Mathematica，24个字节

UnsameQ@@(#&@@@Union@#)&

说明：Union删除重复的对，然后#&@@@从每个对中获取第一个元素（例如，First/@但字节数较少）。如果这些第一个元素中有任何重复，则这些对不构成函数，我们使用进行检查UnsameQ。

（@在我编写的任何程序中，这可能具有最高的字符密度。）

— 不是树
source
2
@密度= 1/4
— CalculatorFeline
4

Bash + coreutils，17岁

sort -u|uniq -dw1

输入通过STDIN给出。 key和value被Tab分离，并且每一对是新行分隔。

sort删除重复的键值对。 uniq -d仅输出重复项，因此对于函数而言，输出空字符串，否则输出非空字符串-当存在重复的键映射到不同的值时。

在线尝试。

— 数字创伤
source
4

05AB1E，9个字节

码：

ãü-ʒ¬_}}Ë

说明：

ã            # Cartesian product with itself
 ü-          # Pairwise subtraction
   ʒ  }}     # Filter out elements where the following is not true:
    ¬_       #   Check whether the first digit is 0
        Ë    # Check if all equal

使用05AB1E编码。在线尝试！

— 阿德南
source
ʒ我马上就可以炫耀：)
— 艾米娜（Emigna）'17
@Emigna是的哈哈：p，但是我已经发现一个错误，导致我使用}}而不是}。
— 阿德南
4

果冻，6个字节

QḢ€µQ⁼

在线尝试！

说明

QḢ€µQ⁼
Q      - Remove duplicate pairs
 Ḣ€    - Retrieve the first element of each pair
   µ   - On the output of what came before..
     ⁼ - Are the following two equal (bit returned)?
    Q  - The output with duplicates removed
       - (implicit) the output.

这是另一种方法，也是6个字节：

QḢ€ṢIẠ

在线尝试！

而不是通过删除重复的键进行测试，而是对（Ṣ）进行排序，并检查项（I）之间的差异是否全部为真（Ạ）

— 火烈鸟241
source
4

R，95 66字节

function(k,v)any(sapply(k,function(x){length(unique(v[k==x]))-1}))

由于Jarko Dubbeldam节省了29个字节。

匿名函数。FALSE如果有功能TRUE则输出，否则输出（抱歉）。像这样，将键列表和值列表作为参数。

> f(c(1,2,5,1,2),c(2,1,2,2,5))
[1] TRUE # not a function

遍历所有键并获取该键的唯一值集的长度。如果any它们> 1，则返回TRUE。

这被MickyT的答案以及Giuseppe的答案所击败。支持其中之一。

— BLT
source
为什么要创建一个数据框，然后仅引用刚放入该数据框的向量？function(k=0,v=0)any(sapply(k,function(x){length(unique(v[k==x]))-1}))应该完成同样的事情。
— JAD
因为我还在学习！至少其他R个答案中的一个或多或少都像您所描述的那样做了。
— BLT
抱歉，如果我说的有点苛刻:)您提交的内容与其他R回答有所不同，并且如果您要删除多余的data.frame，则可以进行更好的比较。
— JAD
4

J-uby，48 33 25 21字节

-3个字节感谢Jordan！ 

:size*:==%[:to_h,~:|]

说明

:size*:==%[:to_h,~:|]

# "readable"
(:size * :==) % [:to_h, ~:|]

# transform :% to explicit lambda
->(x){ (:size * :==).(:to_h ^ x, ~:| ^ x)

# apply explicit x to functions
->(x){ (:size * :==).(x.to_h, x|x) }

# expand :* (map over arguments)
->(x){ :==.(:size.(x.to_h), :size.(x|x) }

# simplify symbol calls to method calls
->(x){ x.to_h.size == (x|x).size }

# :| is set union for arrays; x|x just removes duplicates, like :uniq but shorter
->(x){ x.to_h.size == x.uniq.size }

第一种方法，33字节

-[:[]&Hash,:uniq]|:*&:size|:/&:==

这个版本比等效的Ruby解决方案要长，但是制作起来很有趣。

尝试通过转换为Ruby进行解释：

-[:[]&Hash,:uniq]|:*&:size|:/&:==

# "readable"
-[:[] & Hash, :uniq] | (:* & :size) | (:/ & :==)                  

# turn into explicit lambda
->(x){ (:/ & :==) ^ ((:* & :size) ^ (-[:[] & Hash, :uniq] ^ x)) } 

# simplify expressions now that we have an explicit x
->(x){ :== / (:size * [Hash[x], x.uniq]) }                          

# translate to equivalent Ruby code
->(x) { [Hash[x], x.uniq].map(&:size).reduce(:==) }               

# simplify reduce over explicit array
->(x) { Hash[x].size == x.uniq.size }

我可以通过更换节省2个字节的新版本:uniq与~:|

— 乔斯
source
3

Mathematica，35个字节

(l=Length)@Union@#==l@<|Rule@@@#|>&

纯函数，将有序对列表作为输入并返回True或False。利用了以下事实：Union@#删除重复的有序对，但是<|Rule@@@#|>（关联）删除具有特定第一个元素的除一个有序对之外的所有对。因此，我们可以只比较Length两个输出的s来检查输入列表是否为函数。

— 格雷格·马丁
source
3

果冻，6个字节

nþ`ḄCȦ

在线尝试！

这个怎么运作

nþ`ḄCȦ  Main link. Argument: M (n×2 matrix)

nþ`     Construct the table of (a != b, c != d) with (a, b) and (c, d) in M.
   Ḅ    Unbinary; map (0, 0), (0, 1), (1, 0), (1, 1) to 0, 1, 2, 3 (resp.).
    C   Complement; map each resulting integer x to 1 - x.
     Ȧ  All; test if all resulting integers are non-zero.
— 丹尼斯
source
3

CJam，19 17字节

感谢Martin Ender，节省了2个字节

0l~$2ew{:.=~!&|}/

0功能和1非功能的输出。

在线尝试！

说明

0                     e# Push a 0. We need it for later.
 l~                   e# Read and eval a line of input.
   $                  e# Sort it by the keys.
    2ew               e# Get all consecutive pairs of the sorted list.
       {              e# For each pair of pairs:
        :.=           e#  Check if the keys are equal and if the values are equal.
           ~!&        e#  Determine if the keys are equal AND the values are not equal.
              |       e#  OR with 0. If any pair indicates that the input is not a function,
                      e#  this will become 1 (and remain 1), otherwise it will be 0.
               }/     e# (end block)
— 商务猫
source
3

APL（Dyalog），16 12 11 9字节

(∪≡⊢)⊃¨∘∪

在线尝试！

说明

∪             Unique, remove duplicates; (3 5) (3 5) => (3 5)
¨∘            For each element
⊃             Pick the first sub element (3 5) (2 3) => 3 

 ≡            Check whether the arguments (listed below) are the same
  ⊢           The right argument
∪             And the right argument with duplicates removed

打印0为假和1为真

— 克里特西·里索斯
source
哇，你真的很好。
— 阿达姆（Adám）'17年
3

实际上，4个字节

╔♂F═

在线尝试！

说明：

╔♂F═
╔     uniquify (remove duplicate pairs)
 ♂F   take first items in each pair (keys)
   ═  are all of the keys unique?
— 麦高
source
3

brainfuck，71个字节

,[[-[->>+<<]+>>],>[[->+<<->]<[<<]>]>[-<+>]<<[->+<]+[-<<]>>,]-[--->+<]>.

在线尝试！

输入被视为一个扁平字符串：例如，第一个测试用例为35356444。要获得原始问题中所示的表示形式，只需在正确的位置向程序中添加总共六个逗号即可。

输出U用于功能和V非功能。

说明

对于任何ASCII码点n，f（n）存储在单元2n + 1中。单元2n和2n + 2是工作空间，而0、2、4、6，... 2n-2是返回到单元0的面包屑轨迹。当输入被证明不是函数时，f（ 0）设置为1（包括各种副作用）。

,                  input first key
[                  start main loop
 [-[->>+<<]+>>]    move to cell 2n, leaving a trail of breadcrumbs
 ,                 input value corresponding to current key
 >[                if key already has a value:
   [->+<<->]<      copy existing value, and compare to new value
   [<<]            if values are different, go to cell -2
   >               go back to cell 2n+1 (or -1 if mismatch)
 ]
 >[-<+>]           move existing value back to cell 2n+1 (NOP if no existing value, move the 1 from cell 0 to cell -1 if mismatch)
 <<[->+<]          copy new value to cell 2n+1 (NOP if there was already a value)
 +[-<<]>>          follow breadcrumbs back to cell 0 (NOP if mismatch)
 ,                 input next key
]                  (if mismatch, cell -2 becomes the next "cell 0", and the next key is also effectively changed by the breadcrumbs left lying around)
-[--->+<]>.        add 85 to cell 1 and output the result
— 硝化龙
source
2

Pyth- 9 8个字节

ql.d{Ql{

试试吧

它的工作原理是先删除所有重复的对（{Q）; 然后将列表的长度与从列表创建的字典的长度进行比较（如果同一x值出现多次，则字典构造函数仅使用最后一个，导致字典比列表短）

— 玛利亚
source
2

MATL，12字节

iFFvXu1Z)SdA

输入为2列矩阵，其中第一列为键，第二列为值。

在线尝试！

说明

i     % Input: 2-column matrix
FFv   % Postpend a row with two zeros. This handles the empty case
Xu    % Unique rows. This removes duplicate (key, value) pairs
1Z)   % Select first column, that is, key. We need to check if all
      % keys surviving at this point are different
S     % Sort
d     % Consecutive differences
A     % Are all values nonzero?
— 路易斯·门多
source
2

PHP，49字节

foreach($_GET as[$x,$y])($$x=$$x??$y)-$y&&die(n);

不打印任何功能和n非功能。

— 用户名
source
1

CJam，14 11 9字节

_&0f=__&=

在线尝试！

将输入作为键/值对在堆栈上的数组，返回1输入是否为函数，是否为函数0。

该解决方案基于片段_&，该片段通过获取数组与自身的交集来对数组进行重复数据删除。我这样做两次，首先是在完整的输入上（摆脱任何完全重复的键/值对），然后才是在键上（看看在第一次重复数据删除之后是否还有任何重复的键）。

这是带有注释的完整代码：

_&           "remove duplicate key/value pairs from input";
  0f=        "remove the values, leaving only the keys";
     _       "make a copy of the array of keys";
      _&     "remove duplicate keys from the copy";
        =    "compare the de-duplicated key array with the original";
— 伊尔马里·卡洛宁（Ilmari Karonen）
source
众所周知，e#CJam是专用的行注释语法。
— 硕果累累
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.