关于Stack Overflow的已删除问题有时可以使高尔夫球变得更好。

编写一个以非负整数作为输入的函数，如果该数字以10为基的所有数字都是唯一的，则返回true。例：

48778584 -> false
17308459 -> true

字符数仅包含功能。

如果选择用C或C ++回答：没有宏，没有未定义的行为；实现定义的行为和编译器警告都可以。

Golfscript， 8 7个字符：

{`..&=}

• ` -对参数进行字符串化
• .. -克隆两次
• & -与自己相交（删除重复项）
• = -检查是否平等。

如果该函数需要命名（109个字符）：

{`..&=}:a

如果程序足够了（54个字符）：

..&=

的Python 2（28）（32）

lambda n:10**len(set(`n`))>n

反引号采用字符串表示形式。转换为集合会删除重复项，我们通过比较10 ^ d（大于所有d位数字但没有（d + 1）位数字）来检查长度是否减小。

旧代码：

lambda n:len(set(`n`))==len(`n`)

杀伤人员地雷（6）

≡∘∪⍨∘⍕

APL中默认样式也较短的少数情况之一。

它的名字由8个字符组成，

f←≡∘∪⍨∘⍕

但这不是必须使用它：

      ≡∘∪⍨∘⍕ 199
0
      ≡∘∪⍨∘⍕ 198
1
      f←≡∘∪⍨∘⍕
      f¨ 198 199 200 201
1 0 0 1
      ≡∘∪⍨∘⍕¨ 198 199 200 201
1 0 0 1

Perl，19个字符

print<>!~/(\d).*\1/

Rebmμ（10个字符）

e? AtsAuqA

Rebmu的“诱人”技巧是不区分大小写的，因此字符可以一起运行。每当遇到案例转换时，都会拆分到下一个标记。通过使用过渡而不是CamelCase之类的东西，以大写开头的独特选择意味着“定词”。（虽然设置字可以在符号编程中用于其他目的，但默认情况下会将它们作为赋值进行评估）。

因此，此“取消”为：

e? a: ts a uq a

需要一定的空间，因为一旦开始了一系列交替的案例运行，除非开始新的运行，否则您将无法使用该技巧在第一个案例之后得到一个设置字。所以e?AtsAuqA本来可以让您e? a ts a uq a...没有任务。

（注意：出于特殊的原因，我倾向于重新考虑解决方案，以便在字符数相等的情况下不留空格。由于方括号，括号和字符串隐含在符号的末尾……通常很公平机会的数量）。

无论如何，当映射到它缩写的Rebol时：

equal? a: to-string a unique a

加上一些括号以帮助获得评估顺序的依据：

equal? (a: (to-string a)) (unique a)

因此，将前缀相等运算符应用于两个参数：第一个参数a是其自身的字符串版本分配给的结果，第二个是unique对该字符串运行的结果。碰巧的是，unique会按照传递它们的顺序将元素还给您...因此，例如“ 31214”的unique是“ 3124”。

使用以下命令运行它：

>> rebmu/args "e? AtsAuqA" 17308459             
== true

还有一些统计信息和调试信息：

>> rebmu/args/stats/debug "e? AtsAuqA" 48778584 
Original Rebmu string was: 10 characters.
Rebmu as mushed Rebol block molds to: 10 characters.
Unmushed Rebmu molds to: 15 characters.
Executing: [e? a: ts a uq a]
== false

如果要求必须定义一个已命名/可重用的函数，则可以创建一个“ A函数”，该函数隐式接受一个名为的参数with a|。（将创建一个B函数，b|并接受一个名为A的参数，然后接受一个名为B的参数）。这样会增加五个字符...假设您将函数称为“ f”

Fa|[e? AtsAugA]

“你笑！他们嘲笑爱因斯坦！或者等等……他们吗？我……不知道。”

FRACTRAN- 53 38个分数

47/10 3/5 106/47 3599/54272 53/61 2881/27136 2479/13568 2077/6784 1943/3392 1541/1696 1273/848 1139/424 871/212 737/106 469/53 142/3953 67/71 5/67 1/147 1/363 1/507 1/867 1/1083 1/1587 1/2523 1/2883 1/4107 1/5547 1/7 1/11 1/13 1/17 1/19 1/23 1/29 1/31 1/37 1/43

使用除法计算每个数字的出现次数。通过将n放入寄存器2并将寄存器5设置为1进行调用，将在寄存器3中输出（如果为false，则为0，如果为true，则为1）。另外，请确保程序的其余部分仅使用> 71的寄存器。

编辑25/12/14：它已经7个月以来，我们得到栈片断已经，所以这里的一个（使用我可以待更好的解释来测试代码在这里）。

var ITERS_PER_SEC=1E5;var TIMEOUT_MILLISECS=5E3;var ERROR_INPUT="Invalid input";var ERROR_PARSE="Parse error: ";var ERROR_TIMEOUT="Timeout";var ERROR_INTERRUPT="Interrupted by user";var running,instructions,registers,timeout,start_time,iterations;function clear_output(){document.getElementById("output").value="";document.getElementById("stderr").innerHTML=""};function stop(){running=false;document.getElementById("run").disabled=false;document.getElementById("stop").disabled=true;document.getElementById("clear").disabled=false}function interrupt(){error(ERROR_INTERRUPT)}function error(msg){document.getElementById("stderr").innerHTML=msg;stop()}function factorise(n){var factorisation={};var divisor=2;while(n>1){if(n%divisor==0){var power=0;while(n%divisor==0){n/=divisor;power+=1}if(power!=0)factorisation[divisor]=power}divisor+=1}return factorisation};function fact_accumulate(fact1,fact2){for(var reg in fact2)if(reg in fact1)fact1[reg]+=fact2[reg];else fact1[reg]=fact2[reg];return fact1};function exp_to_fact(expression){expression=expression.trim().split(/\s*\*\s*/);var factorisation={};for(var i=0;i<expression.length;++i){var term=expression[i].trim().split(/\s*\^\s*/);if(term.length>2)throw"error";term[0]=parseInt(term[0]);if(isNaN(term[0]))throw"error";if(term.length==2){term[1]=parseInt(term[1]);if(isNaN(term[1]))throw"error";}if(term[0]<=1)continue;var fact_term=factorise(term[0]);if(term.length==2)for(var reg in fact_term)fact_term[reg]*=term[1];factorisation=fact_accumulate(factorisation,fact_term)}return factorisation}function to_instruction(n,d){instruction=[];divisor=2;while(n>1||d>1){if(n%divisor==0||d%divisor==0){reg_offset=0;while(n%divisor==0){reg_offset+=1;n/=divisor}while(d%divisor==0){reg_offset-=1;d/=divisor}if(reg_offset!=0)instruction.push(Array(divisor,reg_offset))}divisor+=1}return instruction};function run(){clear_output();document.getElementById("run").disabled=true;document.getElementById("stop").disabled=false;document.getElementById("clear").disabled=true;timeout=document.getElementById("timeout").checked;var code=document.getElementById("code").value;var input=document.getElementById("input").value;instructions=[];code=code.trim().split(/[\s,]+/);for(i=0;i<code.length;++i){fraction=code[i];split_fraction=fraction.split("/");if(split_fraction.length!=2){error(ERROR_PARSE+fraction);return}numerator=parseInt(split_fraction[0]);denominator=parseInt(split_fraction[1]);if(isNaN(numerator)||isNaN(denominator)){error(ERROR_PARSE+fraction);return}instructions.push(to_instruction(numerator,denominator))}try{registers=exp_to_fact(input)}catch(err){error(ERROR_INPUT);return}running=true;iterations=0;start_time=Date.now();fractran_iter(1)};function regs_to_string(regs){reg_list=Object.keys(regs);reg_list.sort(function(a,b){return a-b});out_str=[];for(var i=0;i<reg_list.length;++i)if(regs[reg_list[i]]!=0)out_str.push(reg_list[i]+"^"+regs[reg_list[i]]);out_str=out_str.join(" * ");if(out_str=="")out_str="1";return out_str};function fractran_iter(niters){if(!running){stop();return}var iter_start_time=Date.now();for(var i=0;i<niters;++i){program_complete=true;for(var instr_ptr=0;instr_ptr<instructions.length;++instr_ptr){instruction=instructions[instr_ptr];perform_instr=true;for(var j=0;j<instruction.length;++j){var reg=instruction[j][0];var offset=instruction[j][1];if(registers[reg]==undefined)registers[reg]=0;if(offset<0&&registers[reg]<-offset){perform_instr=false;break}}if(perform_instr){for(var j=0;j<instruction.length;++j){var reg=instruction[j][0];var offset=instruction[j][1];registers[reg]+=offset}program_complete=false;break}}if(program_complete){document.getElementById("output").value+=regs_to_string(registers);stop();return}iterations++;if(timeout&&Date.now()-start_time>TIMEOUT_MILLISECS){error(ERROR_TIMEOUT);return}}setTimeout(function(){fractran_iter(ITERS_PER_SEC*(Date.now()-iter_start_time)/1E3)},0)};

<div style="font-size:12px;font-family:Verdana, Geneva, sans-serif;"><div style="float:left; width:50%;">Code:<br><textarea id="code" rows="4" style="overflow:scroll;overflow-x:hidden;width:90%;">47/10 3/5 106/47 3599/54272 53/61 2881/27136 2479/13568 2077/6784 1943/3392 1541/1696 1273/848 1139/424 871/212 737/106 469/53 142/3953 67/71 5/67 1/147 1/363 1/507 1/867 1/1083 1/1587 1/2523 1/2883 1/4107 1/5547 1/7 1/11 1/13 1/17 1/19 1/23 1/29 1/31 1/37 1/43</textarea><br>Input:<br><textarea id="input" rows="2" style="overflow:scroll;overflow-x:hidden;width:90%;">2^142857 * 5</textarea><p>Timeout:<input id="timeout" type="checkbox" checked="true"></input></p></div><div style="float:left; width:50%;">Output:<br><textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea><p><input id="run" type="button" value="Run" onclick="run()"></input><input id="stop" type="button" value="Stop" onclick="interrupt()" disabled="true"></input><input id="clear" type="button" value="Clear" onclick="clear_output()"></input>&nbsp;<span id="stderr" style="color:red"></span></p></div></div>

替换142857为另一个数字。输出应为3^1true，1 = 3^0否则为false。需要一段时间才能获取更大的数字（嗯，这是 FRACTRAN ...）。

JavaScript-23个字符

作为功​​能（ECMAScript 6）：

f=x=>!/(.).*\1/.test(x)

或从提示中输入（25个字符）

!/(.).*\1/.test(prompt())

C＃73 60 59

首先为我打高尔夫球...

编写一个将非负整数作为输入的函数

bool f(int i){return(i+"").Distinct().SequenceEqual(i+"");}

可以通过转换uint为来剥离另一个字符int，但是我宁愿从字面上看也要完成任务，而不是相反。 开始了 ...

Ruby（24字节）

使用正则表达式匹配“某些字符，后跟零个或多个字符，然后是相同字符”。

->(s){!!(s !~/(.).*\1/)}

如果接受真实或虚假的值，而不是文字true或false，那么我们得到20个字符：

->(s){s !~/(.).*\1/}

C（87）

因为我赢不了，所以我会追求效率。

功能码：

int u(uint32_t d){short s=0,f;while(d){f=1<<d%10;if(s&f)return 0;s|=f;d/=10;}return 1;}

Mathematica，35个 25个字符

（如果该函数需要一个名称，则为27。）

Unequal@@IntegerDigits@#&

编辑：感谢belisarius，保存了8个字符！

R，53 51 48 34字节

function(n)!grepl("(.).*\\1",n,,T)

在线尝试！

转换为字符串并拆分。转换为计数值减去1，总和与求和的表

受Alex 启发的最常见数字答案和Hugh的建议启发。

多亏了@plannapus，一对夫妇得以保存，@Gregor再次向其提供了帮助，还有一对夫妇使其成为匿名函数

现在有了@ J.Doe，它具有出色的正则表达式优点。这将查找与字符串中其他地方匹配的数字中的任何单个字符。该grepl命令返回一个逻辑，然后返回该逻辑。Perl样式正则表达式设置为True。

J（9）

假设要测试的值是可变的b （我知道这可以做成一个功能，但没有一个线索如何。J的混淆。任何帮助表示赞赏）谢谢马里努斯！

(-:~.)@":

检查已删除所有重复项的数字的字符串rep的长度是否与常规字符串rep的长度相同。

R（70，60，53，52）

谢谢大家的有用评论！您的评论已纳入答案。

### Version 70 chars
f=function(x)!any(duplicated(strsplit(as.character(x),split="")[[1]]))

### Version 60 chars
f=function(x)all(table(strsplit(as.character(x),"")[[1]])<2)

### Version 53 chars
f=function(x)all(table(strsplit(paste(x),"")[[1]])<2)

### Version 52 chars
f=function(x)all(table(strsplit(c(x,""),"")[[1]])<2)

f(48778584)
f(17308459)

Mathematica（20 19）

（22 21，如果函数需要一个名称）

Max@DigitCount@#<2&

要么

Max@DigitCount@#|1&

在哪里 ist输入为[Esc]除[Esc]

Brachylog，1个字节

≠

在线尝试！

C99，59个字符

a(x){int r=1,f[10]={};for(;x;x/=10)r&=!f[x%10]++;return r;}

Groovy（36个字符）

f={s="$it" as List;s==s.unique(!1)}

使用以下方法进行了测试：

println f(args[0].toInteger())

Haskell：

 import Data.List

 all ((== 1) . length) . group . sort . show

J（8）

与我先前的答案完全竞争。

*/@~:@":

R，66 65个字符

f=function(x)!sum(duplicated((x%%10^(i<-1:nchar(x)))%/%10^(i-1)))

使用整数除法和取模将数字分开，然后检查它们是否重复。

用法：

> f(48778584)
[1] FALSE
> f(17308459)
[1] TRUE

或者，按照@MickyT的建议，使用63个字符：

f=function(x)!anyDuplicated((x%%10^(i<-1:nchar(x)))%/%10^(i-1))

C，58字节

f;a(x){for(f=0;x;x/=10)f+=1<<x%10*3;return!(f&920350134);}

翻转前最多可以保留7个相同的数字。

在测试程序中（更容易看出它如何与八进制常量一起工作）

a(x){int f=0;for(;x;x/=10)f+=1<<x%10*3;return!(f&06666666666);}

main(){
scanf("%d",&r);
printf("%o\n",a(r));}

如果您碰巧拥有2的大乘方，则常数可以像 f&(1<<30)/7*6

Haskell，34个字节

import Data.List
((==)=<<nub).show

在线尝试！

Javascript 73个字符

function f(n){return !~(n+'').split('').sort().join('').search(/(\d)\1/)}

Befunge 98，17个字节

这是一个非竞争性的答案，因为Befunge没有功能。

~:1g1`j@1\1p3j@.1

1如果数字的数字都是唯一的，则打印一个；否则，它就结束了。

通过访问Funge空间中的单元格来工作，该单元格的x坐标是输入字符的ASCII值（按字符输入输入字符），y坐标为1。如果以前没有看到该数字，则该单元格的值为32（空格字符）。如果是这样，我将值设置为1。

作为奖励，这也适用于非数字。

PowerShell-26

!($args|sls '(.)(?=.*\1)')

Perl 6（19个字节）

{.comb.uniq==.comb}

.comb将字符串拆分为字符（例如，42.combGives "4", "2"）。.uniq删除所有非唯一字符。.comb字符串中的字符（最初我使用.chars，但是.comb更短）。==将列表转换成其中的元素数量，然后比较这些数字。在.不带对象的$_情况下使用时，默认为功能参数。{}是函数文字。

C，76

这并不是遥不可及的地方，但是无论如何我都会张贴它，以显示替代方法。

c;i;a[99];main(){while(~(c=getchar()))a[c]++;for(;i<99;)a[i++]>1&&puts("");}

如果为false，则打印新行；如果为true，则不打印任何行。

POSIX sh和egrep的（47，43，40）

f()([ ! `echo $1|egrep '([0-9]).*\1'` ])

• [-1字符]：使用!的，而不是-z用test-谢谢DigitalTrauma
• [-1个字符]：使用`CODE`代替$(CODE)-感谢DigitalTrauma
• [-2个字符]：使用fold -1代替grep -o .^_1-感谢DigitalTrauma。
• [-3个字符]：使用反向引用的正则表达式检查重复的数字。

如果POSIX兼容性不重要，echo PARAM |则可以替换为<<<PARAM，将功能长度减少到37：

f()([ ! `egrep '([0-9]).*\1'<<<$1` ])

用法：

$ if f 48778584; then echo true; else echo false; fi
false
$ if f 17308459; then echo true; else echo false; fi
true

^{_{1 在的某些版本中，该fold -N符号已弃用fold。}}

爪哇（131 59 57）

57个字符：

按照@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳的建议删除了^和$

boolean u(int n){return !(n+"").matches(".*(.).*\\1.*");}

59个字符（也可以使用负数！）：

boolean u(int n){return !(n+"").matches("^.*(.).*\\1.*$");}

79 78个字符（感谢@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳）：

使用for循环保存一些字符，并将int用作布尔数组。

使用＆代替&&来保存1个字符（事实是java允许它）。

boolean u(int n){for(int x=0;n>0&(x>>n%10&1)==0;n/=10)x|=1<<n%10;return n==0;}

131个字符（对负数返回true）：

boolean u(int n){int[] p=new int[]{2,3,5,7,11,13,17,19,32,29};double a=9001312320D;while(n>0){a/=p[n%10];n/=10;}return (long)a==a;}

有评论：

boolean unique(int n){
    int[] p=new int[]{2,3,5,7,11,13,17,19,32,29};//list of 10 first primes
    double a=9001312320D;//10 first primes multiplied
    while(n>0){
        a/=p[n%10];//divide by (n%10+1)th prime
        n/=10;//divide n by 10, next digit
    }
    return (long)a==a;//if a is integer then n has all digits unique
}

答案在技术上是正确的（字符数仅包含函数，不包括全局变量），但我认为这是作弊的29个字符：

boolean u(int i){return m[i];}

m []是布尔数组，其中包含所有32位整数的正确答案。