令人惊讶的，我们还没有一个简单的“找到最高位”的挑战，但我认为这是一个有点太微不足道了。

给定一个非负整数的输入，返回在整数中找到的最高的唯一（即不重复）数字。如果没有唯一数字，则您的程序可以执行任何操作（不确定的行为）。

输入可以作为单个整数，字符串或数字列表。

测试用例

12         -> 2
0          -> 0
485902     -> 9
495902     -> 5
999999     -> Anything
999099     -> 0
1948710498 -> 7

这是代码高尔夫球，因此每种语言中最少的字节会获胜！

code-golf number integer

— Skidsdev
source

2

我们可以将输入作为字符串吗？

— Kritixi Lithos

3

给定最后一个测试用例，我认为我们被迫将输入作为字符串...（前导零不能用整数表示）

— Leo

@Leo实际上是我的坏人，基本上将键盘上的数字混在一起，没有注意到前导零。但是可以，输入可以视为字符串

— -Skidsdev

25

@Adám“未定义的行为”通常意味着您可以做任何事情，包括从字节中召唤出无名的恐怖（如果可以节省字节数）。

— Martin Ender

22

@MartinEnder实际上，如果您的代码在没有唯一数字的情况下成功召唤了克苏鲁，我会很乐意敲掉您字节的50％；）

— Skidsdev

16

05AB1E，4 3字节

由于Xcoder先生通知数字列表是有效输入，因此节省了1个字节。

¢ÏM

在线尝试！

说明

¢     # count occurrences of each digit in input
 Ï    # keep only the digits whose occurrences are true (1)
  M   # push the highest

— 艾米尼亚
source

在05AB1E中如此等待，2这不是事实。只有1吗？：o

— HyperNeutrino

@HyperNeutrino：正确！

— Emigna

2

这看起来既有用又非常麻烦……很有意思：o：D

— HyperNeutrino

@HyperNeutrino：它通常派上用场，但是当挑战说返回真值时，当许多语言可以返回任何正整数甚至是非空字符串时，这可能是不利的。

— Emigna '17

号码上的删除线不容易看到！

— MrZander

15

Python 3，40个字节

由于movatica节省了2个字节。

lambda i:max(x*(i.count(x)<2)for x in i)

在线尝试！

42字节

适用于字符串和数字列表参数类型。抛出错误，表示没有唯一数字，这是对该规范的一种滥用：

lambda i:max(x for x in i if i.count(x)<2)

在线尝试！

说明

lambda i: -声明带有字符串或数字列表参数i的lambda函数。
max(...) -查找发生器的最大值。
x for x in i-遍历的字符/数字i。
if i.count(x)<2 -检查数字是否唯一。

— Xcoder先生
source

40个字节：lambda i:max(x*(i.count(x)<2)for x in i)

— movatica

1

@movatica谢谢！

— Xcoder先生

8

爱丽丝，15字节

/&.sDo
\i-.tN@/

在线尝试！

说明

/...
\.../

这是一个线性代码的简单框架，完全在Ordinal模式下运行（意味着该程序完全通过字符串处理工作）。展开的线性代码如下：

i..DN&-sto@

它能做什么：

i    Read all input as a string.
..   Make two copies.
D    Deduplicate the characters in the top copy.
N    Get the multiset complement of this deduplicated string in the input.
     This gives us a string that only contains repeated digits (with one
     copy less than the original, but the number of them doesn't matter).
&-   Fold string subtraction over this string, which means that each of
     the repeated digits is removed from the input.
s    Sort the remaining digits.
t    Split off the last digit.
o    Print it.
@    Terminate the program.

— 马丁·恩德
source

-1，如果没有唯一数字，则不会“ 从虚无中召唤无名的恐怖 ”。;）（阅读：+1，一如既往的好答案。）

— Kevin Cruijssen

1

我尝试了@KevinCruijssen，但没有保存字节。也许“ 黑暗”可能是一种更合适的语言……

— 马丁·恩德

7

视网膜，16字节

O`.
(.)\1+

!`.$

在线尝试！

说明

O`.

排序数字。

(.)\1+

删除重复的数字。

!`.$

获取最后（最大）位数。

— 马丁·恩德
source

太糟糕的重复数据删除对这里没有帮助：(

— CalculatorFeline

7

木炭，18 12字节

Ｆχ¿⁼№θＩι¹ＰＩι

在线尝试！（链接到详细版本）

如果找不到解决方案，则不打印任何内容。诀窍在于，for循环将打印输入字符串中的每个唯一数字，但不移动光标，因此该值会不断重新打印自身，直到找到最终解决方案为止。

找不到解决方案时，以前的版本将字符A到Z打印，因此注释如下：

ＡααＦχＡ⎇⁼№θＩι¹Ｉιααα

在线尝试！（链接到详细版本）

— 查理
source

3

这是一个有趣的未定义行为：）

— Emigna

这对我来说是芬兰语：D

— fedorqui

2

@fedorqui很高兴在这里见到你！是的，但是木炭比Jelly或O5AB1E更易于学习，并且在ASCII艺术游戏中使用更有趣。:-)

— 查理

7

外壳，7个字节

→fo¬hgO

在线尝试！（测试套件，由于没有唯一数字，因此在最后一个测试用例上崩溃）

这是无点样式的功能组合（参数在任何地方都没有明确提及）。接受输入并以字符串形式返回输出，该字符串在Husk中等效于字符列表。

说明

Test case: "1948710498"

      O    Sort:                             "0114478899"
     g     Group consecutive equal elements: ["0","11","44","7","88","99"]
 fo¬h      Keep only those with length 1*:   ["0","7"]
→          Take the last element:            "7"

*对长度1的检查是通过获取列表的开头（除最后一个元素之外的所有元素）并将其取反（空列表是虚假的，非空列表是虚假的）来完成的。

— 狮子座
source

7

Haskell，37个字节

f s=maximum[x|x<-s,[x]==filter(==x)s]

在线尝试！

怎么运行的：

  [  |x<-s   ]          -- loop x through the input string s
    x                   -- and keep the x where
     [x]==filter(==x)s  -- all x extracted from s equal a singleton list [x]
maximum                 -- take the maximum of all the x

— 妮米
source

7

R，41个字节

function(x,y=table(x))max(names(y[y==1]))

匿名函数，采用数字列表，可以是整数或单个字符串。它预先计算y为可选参数，以避免对函数主体使用花括号。以字符串形式返回数字。这与其他R答案所采用的方法略有不同，最终变得最短！看来我的评论毕竟是错误的...

table计算列表中每个元素的出现，并names(table(x))作为x（中的字符串）中的唯一值。由于幸运的是，数字按字典顺序与数字顺序相同，因此我们仍然可以使用max。

在线尝试！

— 朱塞佩
source

真好！我没想到做某事table会更短（再加上我永远不记得如何开始names工作）。

— aPaulT

1

<2为另一个字节。计数永远不应为零。

— MickyT

1

y=table(scan());max(names(y[y<2]))短几个字节。

— JAD

6

JavaScript（ES6），46 41 40字节

将输入作为字符串。如果没有唯一数字，则返回RangeError。

s=>f=(i=9)=>s.split(i).length-2?f(--i):i

-7个字节，感谢Rick Hitchcock

-1个字节，感谢Shaggy

测试用例

显示代码段

let f =

s=>g=(i=9)=>s.split(i).length-2?g(--i):i


console.log(f("12")())         // 2
console.log(f("0")())          // 0
console.log(f("485902")())     // 9
console.log(f("495902")())     // 5
//console.log(f("999999")())   // RangeError
console.log(f("999099")())     // 0
console.log(f("1948710498")()) // 7

Expand snippet

— 冲喜
source

删除39个字节的警报： (s,i=9)=>s.split(i).length-2?f(s,--i):i。您可以避免42个字节的堆栈溢出： (s,i=9)=>s.split(i).length-2?i&&f(s,--i):i。

— 里克·希区柯克

用currying保存一个字节：s=>g=(i=9)=>s.split(i).length-2?g(--i):i然后用f("12")()

— Shaggy

5

Python 3，40个字节

lambda i:max(x+9-9*i.count(x)for x in i)

仅适用于数字列表。边缘保护套'990'可以正常工作:)

在线尝试！

— 亚历克斯·瓦尔加
source

欢迎来到PPCG！看起来您已经一败涂地了：）

— Stephen

4

Brachylog，8个字节

ọtᵒtᵍhth

在线尝试！

说明

Example input: 495902

ọ          Occurences:    [[4,1],[9,2],[5,1],[0,1],[2,1]]
 tᵒ        Order by tail: [[0,1],[2,1],[4,1],[5,1],[9,2]]
   tᵍ      Group by tail: [[[0,1],[2,1],[4,1],[5,1]],[[9,2]]]
     h     Head:          [[0,1],[2,1],[4,1],[5,1]]
      t    Tail:          [5,1]
       h   Head:          5

— 致命
source

4

外壳，9 8字节

感谢Leo建议在相同的字节数下稍微整洁的解决方案。

▲‡ȯf=1`#

在线尝试！

说明

  ȯ       Compose the following thre functions into one binary function.
      `#  Count the occurrences of the right argument in the left.
    =1    Check equality with 1. This gives 1 (truthy) for values that 
          appear uniquely in the right-hand argument.
   f      Select the elements from the right argument, where the function
          in the left argument is truthy.
          Due to the composition and partial function application this
          means that the first argument of the resulting function actually
          curries `# and the second argument is passed as the second
          argument to f. So what we end up with is a function which selects
          the elements from the right argument that appear uniquely in
          the left argument.
 ‡        We call this function by giving it the input for both arguments.
          So we end up selecting unique digits from the input.
▲         Find the maximum.

— 马丁·恩德
source

1

¬←可能更简单=1，虽然是相同的字节数：)

— Leo

1

@Leo Ah yeah，我太懒了，无法测试currying是否能在没有括号的情况下工作。我需要更多地信任类型推断。;）

— Martin Ender

4

Mathematica，41个字节

(t=9;While[DigitCount[#][[t]]!=1,t--];t)&

谢谢@马丁·恩德

这是马丁对我的回答的方法

Mathematica，35个字节

9//.d_/;DigitCount[#][[d]]!=1:>d-1&

— J42161217
source

4

R，45 43字节

function(x)max(setdiff(x,x[duplicated(x)]))

在线尝试！

将输入作为整数向量。查找重复的元素，将其删除，并采用最大值。（-Inf如果没有唯一的最大值，则返回警告。）

根据评论编辑成匿名函数

— 保罗
source

max(x[!duplicated(x)])短很多，但这是一个很好的答案。我知道我要做的方式并不是那么好。您也可以f=从头开始删除，因为匿名函数是完全有效的答案。另外，如果使用以下格式，则可以使用TIO测试功能：在线尝试！

— 朱塞佩

谢谢！我认为'duplicated'函数不会计算重复元素的首次出现，因此您的版本将无法正常工作

— PaulT，2013年

嗯，好点。我几乎从不使用，duplicated但实际上我想到了另一个简短的答案！

— 朱塞佩

3

Ruby，42个字节

->x{(?0..?9).select{|r|x.count(r)==1}[-1]}

在线尝试！

— 国标
source

Ruby将Python与::

— Xcoder先生17年

因为42总是答案。:-)

— GB

5

@GB还是这样：->x{x.chars.select{|r|x.count(r)<2}.max}

— Martin Ender

1

那将短2个字节，并破坏整个事情。:-)

— GB

3

APL（Dyalog Unicode），10个字符= 19个字节

方法：将多次出现的元素乘以零，然后对最高元素进行细化。

⌈/×∘(1=≢)⌸

⌸ 对于参数中的每个唯一元素及其索引：

× 乘以唯一元素

∘(…… ) 搭配：

1= 一个布尔值是否等于

≢ 索引计数（唯一元素出现多少次）

⌈/ 最大的

在线尝试！

APL（Dyalog Classic），15个字节

⌈/×∘(1=≢)⎕U2338

在线尝试！

与上述相同，但使用⎕U2338代替⌸。

— 亚当
source

3

Bash + coreutils，30个 28字节

-2个字节归功于Digital Trauma

fold -1|sort|uniq -u|tail -1

在线尝试！

Bash + coreutils，20个字节

sort|uniq -u|tail -1

在线尝试！

如果输入是数字列表，每行一个，我们可以跳过折叠阶段。感觉就像在作弊。

— 莱利
source

替换grep -o .为fold -1以保存2个字节。我同意以数字列表形式给出的输入整数会使规则扩展得太远。

— Digital Trauma

仅仅因为它是猛击而+1

— Anush

3

Python 2，39个字节

lambda l:max(1/l.count(n)*n for n in l)

在线尝试！

— 异或
source

我喜欢这个，太好了！

— 阿努什

3

C＃（.NET Core），27 97 86 58 57 75字节

using System.Linq;

n=>n.GroupBy(i=>i).Where(i=>i.Count()<2).Max(i=>i.Key)-48

在线尝试！

谢谢@CarlosAlejo

— 卡卡罗特
source

这不适用于“ 1948710498”作为输入（返回“ 9”而不是“ 7”），并且必须using System.Linq;加到字节数上。

— 查理

@CarlosAlejo糟糕！抱歉! 刚刚阅读了完整的规格。即将编辑解决方案。

— kakkarot

编辑。我可以进行任何优化吗？

— kakkarot

当然可以：例如尝试使用OrderBy(...).Last()代替.OrderByDescending(...).First()。甚至更好的是，.Max(i=>i.Key)在Where子句之后更改最后一部分。

— 查理

@CarlosAlejo Thanks! Edited.

— kakkarot

2

JavaScript (ES6), 52 50 bytes

Takes input as a list of digits. Returns 0 if there are no unique digits.

s=>s.reduce((m,c)=>m>c|s.filter(x=>x==c)[1]?m:c,0)

Test cases

Show code snippet

let f =

s=>s.reduce((m,c)=>m>c|s.filter(x=>x==c)[1]?m:c,0)

console.log(f([1,2]))                 // 2
console.log(f([0]))                   // 0
console.log(f([4,8,5,9,0,2]))         // 9
console.log(f([4,9,5,9,0,2]))         // 5
console.log(f([9,9,9,9,9,9]))         // (0)
console.log(f([9,9,9,0,9,9]))         // 0
console.log(f([1,9,4,8,7,1,0,4,9,8])) // 7

Expand snippet

— Arnauld
source

2

Japt, 12 11 10 bytes

Takes input as an array of digits.

k@¬èX ÉÃrw

Test it

Explanation

     :Implicit input of array U.
k    :Filter the array to the elements that return false when...
@    :Passed through a function that...
¬    :Joins U to a string and...
èX   :Counts the number of times the current element (X) appears in the string...
É    :Minus 1.
     :(The count of unique digits will be 1, 1-1=0, 0=false)
Ã    :End function.
r    :Reduce by...
w    :Getting the greater of the current element and the current value.
     :Implicit output of resulting single digit integer.

— Shaggy
source

2

Java (OpenJDK 8), 89 85 79 bytes

a->{int i=10,x[]=new int[i];for(int d:a)x[d]++;for(;i-->0&&x[i]!=1;);return i;}

Try it online!

-6 bytes thanks to @KevinCruijssen's insight!

— Olivier Grégoire
source

1

You can replace return i>0?i:0; with return i;. The output will be -1 for test case [9,9,9,9,9,9], but that is fine with the challenge: "If there are no unique digits, your program can do anything (undefined behavior).".

— Kevin Cruijssen

Indeed, I can since the current revision. Before I couldn't because of the test case 0. It's something I oversaw in the previous golf! :)

— Olivier Grégoire

2

APL (Dyalog), 14 bytes

-2 thanks toTwiNight.

⌈/⊢×1=(+/∘.=⍨)

⌈/ the largest of

⊢ the arguments

× multiplied by

1=(…) the Boolean for each where one equals

+/ the row sums of

∘.=⍨ their equality table

Try it online!

— Adám
source

Since 0 is never the highest unique digit except for 0 itself, you can save 1 byte using × instead of /⍨, then save another byte converting that into a train

— TwiNight

@TwiNight Nice! Thank you.

— Adám

2

PHP, 40 bytes

<?=array_flip(count_chars($argn))[1]-48;

Try it online!

PHP, 42 bytes

<?=chr(array_flip(count_chars($argn))[1]);

Try it online!

— Jörg Hülsermann
source

1

-2 bytes: <?=array_flip(count_chars($argn))[1]-48;

— Titus

2

Java (JDK), 67 bytes

s->{int i=9;for(s=" "+s+" ";s.split(i+"").length!=2;i--);return i;}

Try it online!

— Embodiment of Ignorance
source

1

Mathematica, 42 bytes

Max@Position[RotateRight@DigitCount@#,1]-1&

— J42161217
source

1

F#, 88 bytes

let f i=Seq.countBy(fun a->a)i|>Seq.maxBy(fun a->if snd a>1 then 0 else int(fst a))|>fst

Try it online!

An improved approach from my first effort, results in less bytes.

Points of interest: fst and snd return the first and second elements of a tuple respectively.

1

Jelly, 9 bytes

ṢŒrṪỊ$ÐfṀ

Try it online!

— Erik the Outgolfer
source

well

— Leaky Nun

@LeakyNun outgolfed, son

— Skidsdev

@Mayube but the core algorithm is the same

— Leaky Nun

@LeakyNun no, it's quite different.

— steenbergh

@LeakyNun I decided to post separately...basically a big difference is that in my case I just decide which to keep, while steenbergh takes some heads or something...

— Erik the Outgolfer

1

Pyth, 6 bytes

eS.m/Q

Test suite

Explanation:

eS.m/Q
eS.m/QbQ    Implicit variable introduction
  .m   Q    Find all minimal elements of the input by the following function:
    /Qb     Number of appearances in the input
eS          Take the maximum element remaining.

— isaacg
source

1

Perl 5, 59 bytes

for$x(split//,<>){$d[$x]++};for($x=11;--$d[--$x];){}print$x

Try it online!

— Felix Palmen
source

Shortened to 40 bytes: Try it online!. (you can look up -F flag on perlrun if needed)

— Dada

找到最高的唯一数字

测试用例

05AB1E，4 3字节

Python 3，40个字节

42字节

说明

爱丽丝，15字节

说明

视网膜，16字节

说明

木炭，18 12字节

外壳，7个字节

说明

Haskell，37个字节

R，41个字节

JavaScript（ES6），46 41 40字节

测试用例

Python 3，40个字节

Brachylog，8个字节

说明

外壳，9 8字节

说明

Mathematica，41个字节

Mathematica，35个字节

R，45 43字节

Ruby，42个字节

APL（Dyalog Unicode），10个字符= 19个字节

APL（Dyalog Classic），15个字节

Bash + coreutils，30个 28字节

Bash + coreutils，20个字节

Python 2，39个字节

C＃（.NET Core），27 97 86 58 57 75字节

JavaScript (ES6), 52 50 bytes

Test cases

Japt, 12 11 10 bytes

Explanation

Java (OpenJDK 8), 89 85 79 bytes

APL (Dyalog), 14 bytes

PHP, 40 bytes

PHP, 42 bytes

Java (JDK), 67 bytes

Mathematica, 42 bytes

F#, 88 bytes

Jelly, 9 bytes

Pyth, 6 bytes

Perl 5, 59 bytes