스택 오버플로에서 삭제 된 질문은 때때로 훌륭한 골프 자료를 만듭니다.

음수가 아닌 정수를 입력으로 사용하는 함수를 작성하고 해당 숫자의 밑이 10 인 표현의 모든 숫자가 고유 한 경우 true를 리턴합니다. 예:

48778584 -> false
17308459 -> true

문자 수에는 기능 만 포함됩니다.

C 또는 C ++에서 응답하기로 선택한 경우 : 매크로 없음, 정의되지 않은 동작 없음; 구현 정의 동작 및 컴파일러 경고는 좋습니다.

골프 공, 8 7 자 :

{`..&=}

• ` -인수를 문자열 화
• .. -두 번 복제
• & -자체와 교차 (중복 제거)
• = -평등을 확인하십시오.

함수의 이름을 지정해야하는 경우 (109 자 ) :

{`..&=}:a

프로그램이 충분하면 (54 자 ) :

..&=

파이썬 2 (28) (32)

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

백틱은 문자열 표현을 사용합니다. 집합으로 변환하면 중복이 제거되고 모든 d 자리 숫자보다 크지 만 (d + 1) 숫자는없는 10 ^ d와 비교하여 길이가 감소하는지 확인합니다.

오래된 코드 :

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

APL (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

펄, 19 자

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

Rebmμ (10 자)

e? AtsAuqA

Rebmu의 "mushing"트릭은 대소 문자를 구분하지 않으므로 문자가 함께 실행됩니다. 사례 전환 이 이루어질 때마다 다음 토큰으로 분할됩니다. 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"의 고유 한 값은 "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

명명 된 / 재사용 가능한 함수를 정의해야하는 요구 사항이있는 경우 암시 적으로 with라는 매개 변수를 사용하는 "A- 함수"를 작성할 수 있습니다 a|. (B 함수는 b|A라는 매개 변수를 사용하여 만든 다음 B라는 매개 변수를 사용합니다). 문자 5 개를 더 추가하면 "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에 출력이 제공됩니다 (거짓이면 0, 참이면 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^1참 1 = 3^0이면 거짓 이어야합니다 . 많은 수의 시간이 걸립니다 (물론,이 입니다 ... FRACTRAN).

자바 스크립트-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는 있지만 다른 방법보다 너무 문자 그대로 작업을 수행합니다. 여기 우리는 간다 ...

루비 (24 바이트)

정규식을 사용하여 "일부 문자 다음에 0 개 이상의 문자, 그 다음에 동일한 문자"를 찾습니다.

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

truthy 또는 falsy 값은 문자 그대로가 아닌, 인정하는 경우 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가 어떻게 혼동 되는지 에 대한 실마리는 없습니다 . 감사합니다. Marinus!

(-:~.)@":

모든 중복이 제거 된 숫자의 문자열 담당자의 길이가 일반 문자열 담당자의 길이와 같은지 확인합니다.

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)

매스 매 티카 (20 19)

(22 함수에 이름이 필요한 경우 21)

Max@DigitCount@#<2&

또는

Max@DigitCount@#|1&

어디 | [Esc] 나눗셈으로 입력되지 않음 [Esc]

Brachylog , 1 바이트

≠

온라인으로 사용해보십시오!

C99, 59 자

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

그루비 (36 문자)

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

다음을 사용하여 테스트했습니다.

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

하스켈 :

 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 자리까지 유지할 ​​수 있습니다.

테스트 프로그램에서 (8 진수 상수로 어떻게 작동하는지 쉽게 알 수 있습니다)

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

하스켈 , 34 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 73 자

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

Befunge 98, 17 바이트

Befunge에는 기능이 없기 때문에 경쟁이 아닌 답변입니다.

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

1숫자의 숫자가 모두 고유 한 경우 a를 인쇄합니다 . 그렇지 않으면 그냥 끝납니다.

그 Funge 공간에서 셀을 액세스하여 작업이 x좌표 입력 된 문자의 ASCII 값이된다 (문자 입력 문자 소요)와 그 y좌표이다 1. 이전에 숫자가 표시되지 않은 경우 셀 값은 32(공백 문자)입니다. 그렇다면 값을 1로 설정하십시오.

보너스로, 이것은 숫자가 아닌 경우에도 작동합니다.

PowerShell-26

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

펄 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 and egrep ( 47 , 43 , 40)

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

• [-1 문자] : 사용 !대신 -z에 test- 감사 DigitalTrauma
• [-1 문자] :`CODE` 대신 사용 $(CODE)-Thanks DigitalTrauma
• [-2 자] : ^₁fold -1 대신 사용 -Thanks DigitalTrauma.grep -o .
• [-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 -Nfold}}

자바 ( 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 자 (음수의 경우 참) :

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 비트 정수에 대한 정답을 포함하는 부울 배열입니다.