인쇄 가능한 ASCII 문자 로 구성된 문자열이 제공 되면 고유 한 문자 로 구성된 출력을 원래 순서대로 생성하십시오 . 즉, 출력은 문자가 이전에 나타난 경우 제거된다는 점을 제외하고 입력과 동일합니다.

배열에서 고유 한 요소를 찾기위한 기본 제공 기능 을 사용할 수 없습니다 (예 : MATLAB에는이를 수행하는 unique기능이 있습니다). 아이디어는 수동으로 수행하는 것입니다.

자세한 내용은 :

• 어느 기능이나 프로그램을 사용할 수 있습니다.
• 입력 및 출력은 함수 인수, stdin / stdout (함수의 경우에도) 또는 이들의 혼합 형식 일 수 있습니다 .
• stdin 또는 stdout을 사용하는 경우 문자열은 chars 시퀀스로만 이해됩니다 . 함수 인수를 사용하는 경우, 문자의 순서가 될 필요가있다 동봉 인용 부호 또는 이에 상응하는 문자의 문자열을 정의하기위한 선택 용도의 프로그래밍 언어가.
• 출력은 입력의 고유 문자 만 포함 하는 문자열이어야합니다 . 따라서 추가 줄 바꿈, 공백 등은 없습니다. 유일한 예외는 다음과 같습니다. 출력이 표준 출력으로 표시되는 경우 대부분의 표시 함수는 후행을 추가합니다 \n(문자열을 다음에 나오는 것과 분리). 따라서 stdout에는 하나의 후행 \n이 허용됩니다 .
• 가능 하면 다른 사람들이 귀하의 코드를 시도 할 수 있도록 온라인 인터프리터 / 컴파일러에 대한 링크를 게시 하십시오.

이것은 코드 골프 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

stdin 및 stdout을 가정하면 몇 가지 예 는 다음과 같습니다.

1. 입력 문자열 :

   Type unique chars!
   

   출력 문자열 :

   Type uniqchars!
   

2. 입력 문자열

   "I think it's dark and it looks like rain", you said
   

   출력 문자열

   "I think'sdarloe,yu
   

3. 입력 문자열

   3.1415926535897932384626433832795
   

   출력 문자열

   3.14592687
   

GolfScript, 2 바이트

.&

또는 대안 적으로 :

.|

나는 이것을 GolfScript 스레드의 골프 팁에 얼마 전에 게시했습니다 . 입력 문자열 (GolfScript 인터프리터에 의해 자동으로 스택에 배치되고 문자 배열처럼 대부분의 방식으로 작동 함)을 복제 한 다음 자체적으로 설정된 교차점 ( &) 또는 공용체 ( |)를 가져옵니다. 배열 (또는 문자열)에 집합 연산자를 적용하면 모든 중복이 축소되지만 요소의 순서는 유지됩니다.

CJam, 3 바이트

qL|

빈 목록이있는 입력 또는 설정 CJam 세트 작업은 요소 순서를 유지합니다.

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

C # 6, 18 + 67 = 85 바이트

이 using진술 이 필요 합니다 :

using System.Linq;

실제 방법 :

string U(string s)=>string.Concat(s.Where((x,i)=>s.IndexOf(x)==i));

이 방법은 함수를 lambda로 정의하여 일부 문자를 저장 합니다.이 함수 는 C # 6에서 지원됩니다. 이것은 C # pre-6 (그러나 ungolfed)에서 보이는 방식입니다.

string Unique(string input)
{
    return string.Concat(input.Where((x, i) => input.IndexOf(x) == i));
}

작동 방식 : 문자열에 대해 두 개의 인수가있는 람다로 Where메서드 를 호출합니다 x. 현재 요소를 i나타내며 해당 요소의 색인을 나타냅니다. IndexOf는 항상 전달 된 char의 첫 번째 인덱스를 반환하므로의 첫 번째 인덱스와 i같지 않으면 x중복 char이므로 포함해서는 안됩니다.

레티 나 , 14 바이트

+`((.).*)\2
$1

각 줄은 별도의 파일로 들어가거나 -s플래그를 사용하여 한 파일에서 읽을 수 있습니다 .

이를 설명하기 위해 더 길지만 간단한 버전을 사용합니다.

+`(.)(.*)\1
$1$2

첫 번째 줄은 일치시킬 정규식입니다 ( +`모든 교체가 이루어질 때까지 계속 실행되는 구성 문자열입니다). 정규 표현식은 문자를 찾고 (C라고 함) 임의의 문자가 0 개 이상이고 C가 뒤에옵니다. 괄호는 캡처 그룹을 나타내므로 일치를 C ( $1)로 바꾸고 ( ) 사이의 문자를 대체합니다 $2. C의 복제본 제거

입력 문자열이 있다면 예를 들어 unique, 첫 번째 실행이 일치 것 uniqu으로, u그리고 niq같은 $1과 $2각각. 그런 다음 원래 입력에서 일치하는 하위 문자열을으로 바꾸고을 uniq제공 uniqe합니다.

Perl, 21 (20 바이트 + -p)

s/./!$h{$&}++&&$&/eg

용법:

perl -pe 's/./!$h{$&}++&&$&/eg' <<< 'Type unique chars!'
Type uniqchars!

마카로니 0.0.2 , 233 바이트

set i read set f "" print map index i k v return label k set x _ set _ slice " " length index f e 1 1 set f concat f wrap x return label e set _ slice " " add _ multiply -1 x 1 1 return label v set _ unwrap slice i _ add 1 _ 1 return

• "골프 방지"언어 만들기 : 확인
• 어쨌든 골프 : 확인

STDIN에서 입력하고 STDOUT에서 출력하는 전체 프로그램입니다.

미적 가치를위한 포장 버전 :

set i read set f "" print map index i k v return label k set x _ set _ slice "
" length index f e 1 1 set f concat f wrap x return label e set _ slice " " add
_ multiply -1 x 1 1 return label v set _ unwrap slice i _ add 1 _ 1 return

그리고 심하게 "설명"되고 ungolfed 버전 (Macaroni에는 주석이 없으므로 베어 문자열 리터럴을 사용합니다) :

set input read                  "read line from STDIN, store in 'input' var"
set found ""                    "we need this for 'keep' below"
print map index input keep val  "find indeces to 'keep', map to values, print"
return

label keep
    "we're trying to determine which indeces in the string to keep. the special
     '_' variable is the current element in question, and it's also the value
     to be 'returned' (if the '_' variable is '0' or empty array after this
     label returns, the index of the element is *not* included in the output
     array; otherwise, it is"
    set x _ set _ slice
        " "
        length index found exists
        1
        1
    "now we're using 'index' again to determine whether our '_' value exists in
     the 'found' array, which is the list of letters already found. then we
     have to apply a boolean NOT, because we only want to keep values that do
     NOT exist in the 'found' array. we can 'invert' a boolean stored as an
     integer number 'b' (hence, 'length') with 'slice(' ', b, 1, 1)'--this is
     equivalent to ' '[0:1], i.e. a single-character string which is truthy, if
     'b' was falsy; otherwise, it results in an empty string if 'b' was truthy,
     which is falsy"
    set found concat found wrap x  "add the letter to the 'found' array"
return

label exists
    set _ slice
        " "
        add _ multiply -1 x
        1
        1
    "commentary on how this works: since 0 is falsy and every other number is
     truthy, we can simply subtract two values to determine whether they are
     *un*equal. then we apply a boolean NOT with the method described above"
return

label val
    set _ unwrap slice input _ add 1 _ 1  "basically 'input[_]'"
return

(이것은 최초의 실제 Macaroni 프로그램입니다 (실제로 수행하는 작업입니다)! \ o /)

자바 스크립트 ES7, 37 33 25 바이트

ES6 Set및 ES7 어레이 이해 확산 연산자를 사용하는 매우 간단한 접근 방식 :

s=>[...new Set(s)].join``

indexOf접근 방식 보다 22 바이트가 적습니다 . 소수의 테스트 사례에서 작업했습니다.

C # 6-18 + 46 = 64

using System.Linq;

그리고

string f(string s)=>string.Concat(s.Union(s));

Enumerable.Union요소는 원래 순서대로 리턴되는 확장 방법 지정

이 메소드에 의해 돌려 주어진 오브젝트가 열거되면, Union 은 그 순서로 1 , 2 를 열거 해, 아직 산출되지 않은 각 요소를 산출합니다.

고유 한 값을 찾기 위해 특별히 의도되지 않은 집합 연산은 다른 답변으로 판단 할 수있는 것으로 보입니다.

자바 스크립트 ES6, 47 바이트

f=s=>s.replace(/./g,(e,i)=>s.indexOf(e)<i?'':e)

아래 테스트는 모든 브라우저에서 작동합니다.

f=function(s){
  return s.replace(/./g,function(e,i){
    return s.indexOf(e)<i?'':e
  })
}

run=function(){document.getElementById('output').innerHTML=f(document.getElementById('input').value)};document.getElementById('run').onclick=run;run()

<input type="text" id="input" value="Type unique chars!" /><button id="run">Run</button><br />
<pre id="output"></pre>

MATLAB, 23

 @(n)union(n,n,'stable')

정렬되지 않은 'stable'메소드를 사용하여 입력 문자열의 "집합 설정"을 수행 한 다음 인쇄합니다.

union병합 후 중복되지 않은 값만 반환 하기 때문에 작동 합니다. 따라서 본질적으로 union문자열 자체가 있으면 먼저 다음과 같은 문자열을 생성합니다.Type unique chars!Type unique chars! 다음 정렬하지 않고 모든 중복 항목을 제거합니다.

필요 없음 unique:)

> <> , 16 바이트

i:0(?;:::1g?!o1p

> <>에는 문자열이 없으므로 코드 상자를 사용합니다. > <>의 토 로이드 특성으로 인해 다음이 루프에서 실행됩니다.

i         Read a char
:0(?;     Halt if EOF
:::       Push three copies of the char
1g        Get the value at (char, 1), which is 0 by default
?!o       Print the char if the value was nonzero
1p        Set the value at (char, 1) to char

이것은 ASCII 0이있는 경우 작동하지 않으므로 입력에 인쇄 가능한 ASCII 만 포함한다는 사실을 사용합니다.

빔 , 23 18 바이트

v<H
vs)
rS
g@S
>u^

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

요소 , 22 19 18 바이트

_'{"(3:~'![2:`];'}

입력 / 출력 예 : hello world->helo wrd

문자열을 한 번에 한 문자 씩 처리하고 이전에 본 문자를 추적하여 작동합니다.

_'{"(3:~'![2:`];'}
_                        input line
 '                       use as conditional
  {              }       WHILE loop
   "                     retrieve string back from control (c-) stack
    (                    split to get the first character of (remaining) string
     3:                  a total of three copies of that character
       ~                 retrieve character's hash value
        '                put on c-stack
         !               negate, gives true if undef/empty string
          [   ]          FOR loop
           2:`           duplicate and output
               ;         store character into itself
                '        put remaining string on c-stack as looping condition

파이썬 2, 42 바이트

익명 함수와을 사용합니다 reduce.

lambda s:reduce(lambda x,y:x+y[y in x:],s)

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

파이썬 3, 44

r=''
for c in input():r+=c[c in r:]
print(r)

입력 문자열 을 아직 보지 못한 경우에만 r문자 c를 포함하여 문자별로 출력 문자열을 작성 합니다 .

파이썬 2는 47이 될 것 raw_input입니다 print.

APL, 3

∊∪/

이것은 벡터의 각 요소 사이에 합집합 (∪)을 적용하여 중복을 제거하는 효과가있는 반복을 얻습니다.

tryapl.org에서 테스트

오래된 것:

~⍨\

인수의 각 요소 사이에 ~ ((를 사용하여 인수를 반대로 사용)를 사용합니다. 결과적으로 각 요소에 대해 이미 목록에있는 경우 지워집니다.

펄, 54 27 바이트

map{$h{$_}||=print}<>=~/./g
123456789012345678901234567

테스트:

$ echo Type unique chars! | perl -e 'map{$h{$_}||=print}<>=~/./g'
Type uniqchars!
$

PHP, 72 바이트 84 바이트

<?foreach(str_split($argv[1])as$c)$a[$c]=0;echo join('',array_keys($a));

문자를 연관 배열의 키로 사용하고 키를 인쇄합니다. 배열 요소의 순서는 항상 삽입 순서입니다.

str_split제안에 대해 Ismael Miguel에게 감사드립니다 .

Pyth, 7 바이트

soxzN{z

의사 코드 :

z = 입력

z의 집합에 대한 N의 순서별 색인의 합.

줄리아, 45 42 바이트

s->(N="";[i∈N?N:N=join([N,i])for i=s];N)

구 버전:

s->(N={};for i=s i∈N||(N=[N,i])end;join(N))

코드는 새 문자를 추가하여 새 문자열을 만든 다음 join 끝에 적절한 문자열로 묶습니다. 새 버전은 배열 이해를 통해 반복하여 일부 문자를 저장합니다. 할당 대신 대괄호가 필요하지 않으므로 ?:대신 사용하여 바이트를 저장하십시오 ||.

재귀 및 정규식을 사용하는 대체 솔루션, 45 바이트 :

f=s->s!=(s=replace(s,r"(.).*\K\1",""))?f(s):s

줄리아, 17 바이트

(대체 버전)

s->join(union(s))

이것은 union기본적으로 대용으로 사용 unique합니다. "이것을"실제 "답변으로 간주하지 않습니다. unique" 사용하지 않음 "은"독특한 값을 반환하는 효과가있는 내장 함수 하나를 사용하지 않음 "을 의미합니다. 집단".

자바, 78 바이트

String f(char[]s){String t="";for(char c:s)t+=t.contains(c+"")?"":c;return t;}

이미 존재하는 문자의 출력을 확인하는 동안 간단한 루프. 입력을로 수락합니다 char[].

C, 96 바이트

#include<stdio.h> 
int c,a[128];main(){while((c=getchar())-'\n')if(!a[c])a[c]=1,putchar(c);}

ASCII 문자 번호로 색인 된 정수 배열을 사용합니다. 배열의 해당 위치가 FALSE로 설정된 경우에만 문자가 인쇄됩니다. 각각의 새 문자가 발견되면 배열의 해당 위치가 TRUE로 설정됩니다. 이것은 표준 입력에서 줄 바꿈으로 끝나는 텍스트 줄을 가져옵니다. ASCII가 아닌 문자는 무시합니다.

언 골프 드 :

#include<stdio.h>
#include<stdbool.h>

int main(void)
{
  int i, c;
  int ascii[128];
  for (i = 0; i < 128; ++i) {
    ascii[i] = false;
  }
  while ((c = getchar()) != '\n') {
    if (ascii[c] == false) {
      ascii[c] = true;
      putchar(c);
    }
  }
  puts("\n");
  return(0);
}

C-58

많은 문자를 저장해 준 @hvd와 @AShelly에게 감사합니다. 원본보다 훨씬 짧게 만드는 여러 가지 방법이 있습니다.

// @hvd     - always copy to q but only increment q if not found
g(char*s,char*r){char*q=r;for(;*q=*s;q+=q==strchr(r,*s++));}

// @AShelly - keep a histogram of the usage of each character
h(char*s){int a[128]={0};for(;*s;s++)a[*s]++||putchar(*s);}

// @hvd     - modify in place
i(char*s){char*q=s,*p=s;for(;*q=*p;q+=q==strchr(s,*p++));}

// original version - requires -std=c99
void f(char*s,char*r){for(char*q=r;*s;s++)if(!strchr(r,*s))*q++=*s;}

보시다시피 수정하는 것이 가장 짧은 것 같습니다 (지금까지!) 테스트 프로그램은 다음을 사용하여 경고없이 컴파일합니다. gcc test.c

#include <stdlib.h> // calloc
#include <string.h> // strchr
#include <stdio.h>  // puts, putchar

// 000000111111111122222222223333333333444444444455555555556666666666
// 456789012345678901234567890123456789012345678901234567890123456789

// @hvd     - always copy to q but only increment q if not found
g(char*s,char*r){char*q=r;for(;*q=*s;q+=q==strchr(r,*s++));}

// @AShelly - keep a histogram of the usage of each character
h(char*s){int a[128]={0};for(;*s;s++)a[*s]++||putchar(*s);}

// @hvd     - modify in place
i(char*s){char*q=s,*p=s;for(;*q=*p;q+=q==strchr(s,*p++));}

/* original version - commented out because it requires -std=c99
void f(char*s,char*r){for(char*q=r;*s;s++)if(!strchr(r,*s))*q++=*s;}
*/

// The test program:
int main(int argc,char*argv[]){
  char *r=calloc(strlen(argv[1]),1); // make a variable to store the result
  g(argv[1],r);                      // call the function
  puts(r);                           // print the result

  h(argv[1]);                        // call the function which prints result
  puts("");                          // print a newline

  i(argv[1]);                        // call the function (modifies in place)
  puts(argv[1]);                     // print the result
}

모든 도움에 감사드립니다. 너무 짧게 해주신 모든 조언에 감사드립니다!

루비, 30 24 자

(23 자 코드 + 1 자 명령 행 옵션)

gsub(/./){$`[$&]?"":$&}

샘플 실행 :

bash-4.3$ ruby -pe 'gsub(/./){$`[$&]?"":$&}' <<< 'hello world'
helo wrd

CJam, 9

Lq{1$-+}/

문자열을 집합으로 변환하지는 않지만 문자열에서 문자가 있는지 확인하기 위해 일종의 집합 차이를 수행합니다. 온라인으로 사용해보십시오

설명:

L       push an empty array/string
q       read the input
{…}/    for each character in the input
  1$    copy the previous string
  -     subtract from the character (set difference),
         resulting in the character or empty string
  +     append the result to the string

다른 버전, 13 바이트 :

Lq{_2$#)!*+}/

이것은 세트와 관련된 어떤 것도하지 않습니다. 온라인으로 사용해보십시오

설명:

L       push an empty array/string
q       read the input
{…}/    for each character in the input
  _     duplicate the character
  2$    copy the previous string
  #)    find the index of the character in the string and increment it
  !     negate, resulting in 0 if the character was in the string and 1 if not
  *     repeat the character that many times
  +     append the result to the string

TI-BASIC, 49 바이트

Input Str1
"sub(Str1,X,1→Y₁
Y₁(1
For(X,2,length(Str1
If not(inString(Ans,Y₁
Ans+Y₁
End
Ans

방정식 변수는 저장하는 데 5 바이트가 걸리기 때문에 거의 유용하지 않지만 3 바이트를 절약하여 문자열의 문자 Y₁로 편리하게 사용할 수 있습니다 X. TI-BASIC에서 빈 문자열에 추가 할 수 없으므로 Str1의 첫 문자로 문자열을 시작한 다음 나머지 문자열을 반복하여 아직 발생하지 않은 모든 문자를 추가합니다.

prgmQ
?Why no empty st
rings? Because T
I...
Why noemptysrig?Bcau.

Matlab, 46 바이트

함수 인수를 입력 및 출력으로하여 익명 함수를 사용합니다.

@(s)eval('s(~any(triu(bsxfun(@eq,s,s''),1)))')

(Octave 온라인 통역사에서 작동시키지 못했습니다.)

사용 예 :

>> @(s)eval('s(~any(triu(bsxfun(@eq,s,s''),1)))')
ans = 
    @(s)eval('s(~any(triu(bsxfun(@eq,s,s''),1)))')

>> ans('Type unique chars!')
ans =
Type uniqchars!

Befunge -93, 124 바이트

v
<v1p02-1
0_v#`g00: <0_@#+1::~p
 1>:1+10p2+0g-!#v_v
g `#v_10g0^       >:10g00
 ^0g 00$        <
 ^  >:,00g1+:00p1+:1+01-\0p

이 온라인 통역사 에서 테스트하십시오 .

이것은 내가 예상했던 것보다 더 어려웠다. 누군가가 원한다면 내일 더 자세한 설명을 게시 할 것이지만 여기 내 코드의 기능에 대한 개요가 있습니다.

• 지금까지 본 고유 문자는 첫 번째 행에 저장됩니다. 2,0 오른쪽 하여 오른쪽으로 확장됩니다. 현재 문자가 복제인지 확인합니다.
• 지금까지 본 고유 문자 수는에 저장되고 0,0중복 확인 루프 카운터는에 저장됩니다 1,0.
• 고유 한 문자가 보이면 첫 번째 행에 저장되고 인쇄되며 카운터가 0,0 이 증가합니다.
• 존재하는 공백 (ASCII 32)의 읽기 문제를 피하기 위해 다음 고유 문자의 다음 슬롯에 -1 (실제로 65536)에 해당하는 문자를 넣습니다.

PHP, 56 54

// 56 bytes
<?=join('',array_flip(array_flip(str_split($argv[1]))));

// 54 bytes
<?=join(!$a='array_flip',$a($a(str_split($argv[1]))));

두 번째 버전을 사용 하여 @fschmengler의 대답 을 알아 내기 array_flip-두 번째 버전은 변수 메서드를 사용하고 문자열을 true로 캐스팅하고 false로 무시한 다음 첫 번째 인수에서 빈 문자열로 다시 캐스팅하여 두 번째 바이트에 두 바이트를 저장합니다. 싼!

하스켈 , 29 바이트

중첩 가능하고 변수가없는 이름의 라이너 1 개 :

foldr(\x->(x:).filter(x/=))[]

f최상위 계수로 명명 된 함수에 저장된 동일한 개수 :

f(x:t)=x:f[y|y<-t,x/=y];f_=[]

근사한 정신으로 만들지 않은 약간의 부정 행위 최적화가 있습니다.이 도전 규칙에서 기술적으로 여전히 문자열에 다른 입력 및 출력 인코딩을 사용하는 것이 허용됩니다. 어떤 표시하여 string그 일부 실용 교회 부호화 \f -> foldr f [] string :: (a -> [b] -> [b]) -> [b](함수에 의해 제공된 전단 사 함수의 다른면 ($ (:))이 아래 golfed 도착) ($ \x->(x:).filter(x/=))만 24 문자.

위의 솔루션은 위의 인터프리터에서 시도 될 수 foldr(\x->(x:).filter(x/=))[]"Type unique chars!"있지만 골프 솔루션은 대신 작성 되므로 24 자 응답을 공식 답변으로 게시하지 않았습니다.

($ \x->(x:).filter(x/=))$ foldr (\x fn f->f x (fn f)) (const []) "Type unique chars!"

리터럴 선언에 대한 속기로서 더 열악한 것입니다.

($ \x->(x:).filter(x/=))$ \f->f 'T'.($f)$ \f->f 'y'.($f)$ \f->f 'p'.($f)$ \f->f 'e'.($f)$ \f->f ' '.($f)$ \f->f 'u'.($f)$ \f->f 'n'.($f)$ \f->f 'i'.($f)$ \f->f 'q'.($f)$ \f->f 'u'.($f)$ \f->f 'e'.($f)$ \f->f ' '.($f)$ \f->f 'c'.($f)$ \f->f 'h'.($f)$ \f->f 'a'.($f)$ \f->f 'r'.($f)$ \f->f 's'.($f)$ \f->f '!'.($f)$ const[]

그러나 순수한 함수로 표현 된 데이터 구조의 완벽하게 유효한 버전입니다. 물론 물론 사용할 \f -> foldr f [] "Type unique chars!"수도 있지만 실제로는 데이터를 저장하기 위해 목록을 사용하기 때문에 불법으로 간주되므로 폴더 부분은 아마도 "응답"기능으로 구성되어 24자를 초과해야합니다.