소개

다음 문자열을 관찰하십시오.

AABBCCDDEFFGG

문자를 제외한 모든 문자가 복제 된 것을 볼 수 있습니다 E. 그것은 편지 E가 중복 제거 되었음을 의미합니다 . 따라서 여기서 수행해야 할 유일한 것은 해당 프로세스를 취소하는 것입니다. 이렇게하면 중복되지 않은 다음 문자열이 나타납니다.

AABBCCDDEEFFGG

더 어려운 예를 들어 보자.

AAAABBBCCCCDD

연속 수가 고르지 B않다는 것을 알 수 있습니다. 즉, 하나의 BB문자열이 원래 문자열에서 중복 제거 되었음을 의미 합니다. 이 서한을 중복 제거하면됩니다.

AAAABBBBCCCCDD

도전

영문자로만 구성되고 (대문자 만 또는 소문자 만) 비어 있지 않은 중복 제거 된 문자열이 제공되면 중복 제거 되지 않은 문자열을 반환 합니다. 문자열에는 항상 하나 이상의 중복 제거 된 문자가 있다고 가정 할 수 있습니다.

테스트 사례

AAABBBCCCCDDDD    -->    AAAABBBBCCCCDDDD
HEY               -->    HHEEYY
AAAAAAA           -->    AAAAAAAA
N                 -->    NN
OOQQO             -->    OOQQOO
ABBB              -->    AABBBB
ABBA              -->    AABBAA

이것은 code-golf 이므로 바이트 단위의 가장 짧은 유효한 제출이 승리합니다!

MATL , 7 바이트

Y'to+Y"

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

'ABBA'입력 예를 들어 보겠습니다 .

Y'   % Implicit input. Run-length decoding
     % STACK: 'ABA', [1 2 1]
t    % Duplicate top of the stack
     % STACK: 'ABA', [1 2 1], [1 2 1]
o    % Modulo 2
     % STACK: 'ABA', [1 2 1], [1 0 1]
+    % Add, element-wise
     % STACK: 'ABA', [2 2 2]
Y"   % Run-length encoding. Implicit display
     % STACK: 'AABBAA'

레티 나 , 11 바이트

(.)\1?
$1$1

온라인으로 사용해보십시오 - 모든 테스트 사례가 포함되어 있습니다

펄, 16 바이트

15 바이트의 코드 + -p플래그.

s/(.)\1?/$1$1/g

그것을 실행하려면 :

perl -pe 's/(.)\1?/$1$1/g' <<< 'HEY'

하스켈, 36 바이트

u(a:b:c)=a:a:u([b|a/=b]++c)
u x=x++x

사용 예 : u "OOQQO"-> "OOQQOO".

문자열에 요소가 두 개 이상인 경우 첫 번째 사본을 두 개 가져 와서 재귀 호출을 추가하십시오.

• 처음 두 요소가 다르면 두 번째 요소와 나머지
• 나머지 만

요소가 2 개 미만 (1 개 또는 0 개) 인 경우 목록의 두 복사본을 가져옵니다.

Brachylog , 17 바이트

@b:{~b#=.l#e,|}ac

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

설명

Example input: "ABBB"

@b                  Blocks: Split into ["A", "BBB"]
  :{          }a    Apply the predicate below to each element of the list: ["AA", "BBBB"]
                c   Concatenate: "AABBBB"

    ~b#=.             Output is the input with an additional element at the beginning, and
                        all elements of the output are the same (e.g. append a leading "B")
        .l#e,         The length of the Output is an even number
             |        Or: Input = Output (i.e. do nothing)

루비, 21 바이트

20 바이트 + -p플래그.

gsub(/(.)\1?/){$1*2}

자바 스크립트 (ES6), 37 30 바이트

훨씬 더 효율적으로 '$ 1 $ 1'처럼 사용하여 7 바이트를 저장 한 [기타] [답변] 한

s=>s.replace(/(.)\1?/g,'$1$1')

테스트 사례

let f =

s=>s.replace(/(.)\1?/g,'$1$1')

console.log(f("AAABBBCCCCDDDD"));   //  -->  AAAABBBBCCCCDDDD
console.log(f("HEY"));              //  -->  HHEEYY
console.log(f("AAAAAAA"));          //  -->  AAAAAAAA
console.log(f("N"));                //  -->  NN
console.log(f("OOQQO"));            //  -->  OOQQOO
console.log(f("ABBB"));             //  -->  AABBBB
console.log(f("ABBA"));             //  -->  AABBAA

수학, 41 바이트

s=StringReplace;s[s[#,a_~~a_->a],b_->b~~b]&

문자열을 입력하고 문자열을 출력하는 이름이없는 함수입니다. 중복 제거 후 완전히 중복 제거하십시오. 짧지는 않지만 지금은 더 잘할 수 없었습니다.

Befunge 98 , 24 바이트

#@~#;:::#@,~-:!j;$,;-\,;

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

$로 쉽게 교체 할 수 있고 -, 2 @를 로 대체 할 수 있습니다 ;.

나는 (또는 위) 와의 -시작 부분 으로 인해 더 골프를 칠 수 있다고 생각합니다 .-,$,-\,

방법?

Stack notation:  bottom [A, B, C, D] top

#@~     Pushes the first character onto the stack (C henceforth) and ends if EOF
#;      No-op to be used later
:::     Now stack is [C, C, C, C]

#@,~    Prints C, and if EOF is next (odd consecutive Cs), prints again and ends
        Lets call the next character D

-       Now stack is [C, C, C-D]
:!j;    If C == D, go to "$," Else, go to "-\,"

===(C == D)===

$,      C == D (i.e. a pair of Cs) so we discard top and print C (Stack is now [C])
;-\,;   Skipped, IP wraps, and loop starts again

===(C != D)===

-       Stack is [C, C-(C-D)]  By expanding: [C, C - C + D] or just [C, D]
\,      Prints C (Stack is now [D])

;#@~#;  This is skipped, because we already read the first character of a set of Ds,
        and this algorithm works by checking the odd character in a set of
        consecutive similar characters. We already read D, so we don't
        need to read another character.

자바 7, 58 바이트

String c(String s){return s.replaceAll("(.)\\1?","$1$1");}

언 골프 드 :

String c(String s){
  return s.replaceAll("(.)\\1?", "$1$1");
}

테스트 코드 :

여기에서 시도하십시오.

class M{
  static String c(String s){return s.replaceAll("(.)\\1?","$1$1");}

  public static void main(String[] a){
    System.out.println(c("AABBCCDDEFFGG"));
    System.out.println(c("AAAABBBCCCCDD"));
    System.out.println(c("AAABBBCCCCDDDD"));
    System.out.println(c("HEY"));
    System.out.println(c("AAAAAAA"));
    System.out.println(c("N"));
    System.out.println(c("OOQQO"));
    System.out.println(c("ABBB"));
    System.out.println(c("ABBA"));
  }
}

산출:

AABBCCDDEEFFGG
AAAABBBBCCCCDD
AAAABBBBCCCCDDDD
HHEEYY
AAAAAAAA
NN
OOQQOO
AABBBB
AABBAA

PHP, 65 바이트, 정규 표현식 없음

while(""<$c=($s=$argv[1])[$i])if($c!=$s[++$i]||!$k=!$k)echo$c.$c;

명령 행 인수에서 입력을받습니다. 로 실행하십시오 -r.

정규식? PHP에서 대부분의 답변에 사용되는 정규 표현식은 모든 문자를 복제합니다. 44 바이트입니다 :

<?=preg_replace("#(.)\1?#","$1$1",$argv[1]);

Brain-Flak 69 바이트

에 +3 포함 -c

{((({}<>))<>[({})]<(())>){((<{}{}>))}{}{(<{}{}>)}{}}<>{({}<>)<>}<>

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

설명:

Part 1:
{((({}<>))<>[({})]<(())>){((<{}{}>))}{}{(<{}{}>)}{}}<>

{                                                  }   # loop through all letters
 (   {}     [ {} ]<(())>){((<{}{}>))}{}                # equals from the wiki   
                                                       # but first:
  ((  <>))<>                                           # push the top letter on the other 
                                                       # stack twice  
             (  )                                      # push the second letter back on
                                       {        }      # if they were equal:
                                        (<    >)       # push a 0 to exit this loop
                                          {}{}         # after popping the 1 from the 
                                                       # comparison and the next letter
                                                       # (the duplicate)
                                                 {}    # pop the extra 0
                                                    <> # switch stacks

Part 2 (at this point, everything is duplicated in reverse order):
{({}<>)<>}<>

{        }   # for every letter:
 ({}<>)      # move the top letter to the other stack
       <>    # and switch back
          <> # Finally switch stacks and implicitly print

젤리 , 9 바이트

Œgs€2ṁ€€2

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

V 10 바이트

ͨ.©±½/±±

TryItOnline

스레드의 나머지 부분과 마찬가지로 정규식을 찾아서 바꾸십시오. 유일한 차이점은 \앞에 ascii 값이 같은 문자가 있지만 높은 비트 세트가있는 문자로 바꿀 수 있다는 것 입니다. (따라서 (00101000은 ¨10101000이됩니다)

펄 6 , 17 바이트

s:g/(.)$0?/$0$0/

-p 명령 줄 스위치 사용

예:

$ perl6 -pe 's:g/(.)$0?/$0$0/' <<< 'AAABBBCCCCDDDD
> HEY
> AAAAAAA
> N
> OOQQO
> ABBB
> ABBA'
AAAABBBBCCCCDDDD
HHEEYY
AAAAAAAA
NN
OOQQOO
AABBBB
AABBAA

라켓 261 바이트

(let((l(string->list s))(r reverse)(c cons)(e even?)(t rest)(i first))(let p((l(t l))(ol(c(i l)'())))
(cond[(empty? l)(list->string(if(e(length ol))(r ol)(r(c(i ol)ol))))][(or(equal?(i ol)(i l))(e(length ol)))
(p(t l)(c(i l)ol))][(p(t l)(c(i l)(c(i ol)ol)))])))

언 골프 드 :

(define (f s)
  (let ((l (string->list s)))
    (let loop ((l (rest l))
               (ol (cons (first l) '())))
      (cond
        [(empty? l)
         (list->string(if (even? (length ol))
                          (reverse ol)
                          (reverse (cons (first ol) ol))))]
        [(or (equal? (first ol) (first l)) 
             (even? (length ol)))
         (loop (rest l) (cons (first l) ol))]
        [else
         (loop (rest l) (cons (first l) (cons (first ol) ol)))] ))))

테스트 :

(f "ABBBCDDEFFGGG")

산출:

"AABBBBCCDDEEFFGGGG"

05AB1E , 10 바이트

.¡vy¬ygÉ×J

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

설명

.¡           # split string into groups of the same char
  v          # for each group
   y         # push the group
    ¬        # push the char the group consists of
     yg      # push the length of the group
       É     # check if the length of the group is odd
        ×    # repeat the char is-odd times (0 or 1)
         J   # join to string

Python3, 102 94 바이트

from collections import*
lambda s:"".join(c*(s.count(c)+1&-2)for c in OrderedDict.fromkeys(s))

8 바이트를 절약 한 xnor 에게 감사 합니다! -> bithack.

R, 81 바이트

r=rle(el(strsplit(scan(,""),"")));cat(do.call("rep",list(r$v,r$l+r$l%%2)),sep="")

stdin에서 문자열을 읽고 문자 벡터로 스 플린하고 실행 길이 인코딩 (rle)을 수행합니다. 이어서 rle의 각 값, 길이와 길이의 합 mod를 반복하십시오.2 .

공백으로 분리 된 입력을 읽을 수 있으면 (암시 적으로 벡터 / 문자 배열로) 분할 부분을 건너 뛸 수 있으며 프로그램은 64 바이트로 줄어 듭니다.

r=rle(scan(,""));cat(do.call("rep",list(r$v,r$l+r$l%%2)),sep="")

> <> (물고기) 39 바이트

0v ;oo:~/:@@:@=?!voo
 >i:1+?!\|o !:  !<

다른 기술을 사용하여 골프를 많이 할 수 있다고 확신하십시오.

입력을 받아서 현재 스택 항목과 비교합니다. 다른 경우 첫 스택 항목을 두 번 인쇄합니다. 동일한 경우 두 항목을 모두 인쇄합니다.

비어있을 때 스택에 0이 제공되므로 아무 것도 인쇄하지 않으므로 언제든지 추가 할 수 있습니다.

Pyth, 15 바이트

Vrz8p*+hN%hN2eN

여기에서 모든 테스트 사례를 확인하십시오.

Luis Mendo 덕분에방법론에 대한 에게 .

설명

Vrz8p*+hN%hN2eN    z autoinitializes to the input
 rz8               run-length encode the input, returned as list of tuples (A -> [[1,"A"]])
V                  for every element N in this list
      +hN          add the head element of N (the number in the tuple)
         %hN2      to the head element of N mod 2
     *       eN    repeat the tail element of N that many times (the letter in the tuple)
    p              print repeated character without trailing newline

종종 그렇듯이, 나는 이것이 더 짧을 수 있다고 생각합니다. 여기에서 사용하는 것보다 목록에서 요소를 추출하는 더 좋은 방법이 있어야한다고 생각합니다.

PowerShell , 28 바이트

$args-replace'(.)\1?','$1$1'

온라인으로 사용해보십시오! (모든 테스트 케이스 포함)

망막의 포트 답변 입니다. 유일하게 주목할 점은 $args평소 대신$args[0] 합니다 (이후 -replace입력 배열의 각 항목을 반복 할 것이다, 우리는 인덱스 off 골프 수 있습니다), 그리고 '$1$1'그들이 정규 표현식으로 대체하고, 그래서 필요는 작은 따옴표를 할 수 PowerShell 변수로 취급되는 대신 변수 (큰 따옴표로 묶인 경우에 발생)

C, 67 바이트

i;f(char*s,char*d){i=*s++;*d++=i;*d++=i;*s?f(i-*s?s:++s,d):(*d=0);}

전화 :

int main()
{
    char *in="AAABBBCCCCDDDD";
    char out[128];
    f(in,out);
    puts(out);
}

brainfuck, 22 바이트

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

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

방금 두 번 인쇄 된 문자와 같지 않으면 현재 문자를 두 번 인쇄합니다.