비어 있지 않은 소문자 ASCII 문자 a-z문자열이 제공되면 같은 문자의 연속 된 "실행"이 해당 문자의 사본 하나 이상으로 늘어난 문자열을 출력합니다.

예를 들어 dddogg( 3 d , 1 o , 2 g )가 ddddooggg( 4 d , 2 o , 3  )으로 바뀝니다 g.

이것은 코드 골프입니다 . 바이트 단위의 최단 답변이 승리합니다.

테스트 사례

aabbcccc-> aaabbbccccc
초인종-> ddooorrbbeelll
uuuuuuuuuz-> uuuuuuuuuuzz
q-> qq
xyxyxy-> xxyyxxyyxxyy
xxxyyy-> xxxxyyyy

05AB1E , 5 바이트

.¡€ĆJ

설명:

Example input: "dddogg"
.¡       Split into chunks of consecutive equal elements
         stack: [['ddd', 'o', 'gg']]
  €      For each...
   Ć       Enclose; append the first character to the end of the string
         stack: [['dddd', 'oo', 'ggg']]
    J    Join array elements into one string
         stack: ['ddddooggg']
Implicitly output top element in stack: "ddddooggg"

온라인 또는 테스트 스위트 로 사용해보십시오 .

동봉은 아주 새로운 내장입니다. 처음 사용한 거에요 매우 편리합니다.)

05AB1E , 4 바이트 (비경쟁)

γ€ĆJ

.¡γ최신 업데이트 로 대체되었습니다 .

파이썬 3 , 44 바이트

for c in input():print(c,end=c[id==c:]);id=c

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

레티 나 , 11 바이트

(.)\1*
$1$&

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

각 런 문자를 런 문자 중 하나와 그 뒤에 런 문자로 바꿉니다.

Pyth , 7 바이트

r9hMMr8

테스트 스위트 .

작동 원리

r9hMMr8  example input: "xxyx"
     r8  run-length encoding
         [[2, "x"], [1, "y"], [1, "x"]]
  hMM    apply h to each item
         this takes advantage of the overloading
         of h, which adds 1 to numbers and
         takes the first element of arrays;
         since string is array of characters in
         Python, h is invariant on them
         [[3, "x"], [2, "y"], [2, "x"]]
r9       run-length decoding
         xxxyyxx

MATL , 5 바이트

Y'QY"

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

설명

입력을 고려하십시오 'doorbell'.

Y'    % Implicit input. Run-length encoding
      % STACK: 'dorbel', [1 2 1 1 1 2]
Q     % Increase by 1, element-wise
      % STACK: 'dorbel', [2 3 2 2 2 3]
Y"    % Run-length decoding. Implicit display
      % STACK: 'ddooorrbbeelll'

Alice , 17 바이트

/kf.>o./
@i$QowD\

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

설명

/.../
@...\

이것은 서수 모드에서 완전히 작동하고 본질적으로 선형 인 프로그램의 프레임 워크입니다 (간단한 루프를 작성할 수 있고이 프로그램에서 하나를 사용할 수 있지만 여기서는 분기 제어 흐름을 사용하는 것이 더 까다 롭습니다). 명령 포인터는 코드를 통해 왼쪽에서 오른쪽으로 대각선으로 위아래로 튀어 오른 다음 끝에 두 개의 미러로 한 셀씩 이동하고 오른쪽에서 왼쪽으로 뒤로 이동하여 첫 번째 반복에서 건너 뛴 셀을 실행합니다. 그런 다음 선형화 된 형식 (거울 무시)은 기본적으로 다음과 같습니다.

ifQ>w.Doo.$k@

이것을 통해 봅시다 :

i     Read all input as a string and push it to the stack.
f     Split the string into runs of equal characters and push those
      onto the stack.
Q     Reverse the stack, so that the first run is on top.
>     Ensure that the horizontal component of the IP's movement is east.
      This doesn't do anything now, but we'll need it after each loop
      iteration.
w     Push the current IP address to the return address stack. This marks
      the beginning of the main loop.

  .     Duplicate the current run.
  D     Deduplicate the characters in that run so we just get the character
        the run is made up of.
  o     Output the character.
  o     Output the run.
  .     Duplicate the next run. When we've processed all runs, this will
        duplicate an implicit empty string at the bottom of the stack instead.
  $     If the string is non-empty (i.e. there's another run to process),
        execute the next command otherwise skip it.

k     Pop an address from the return address stack and jump there. Note that
      the return address stack stores no information about the IP's direction,
      so after this, the IP will move northwest from the w. That's the wrong
      direction though, but the > sets the horizontal component of the IP's
      direction to east now, so that the IP passes over the w again and can
      now execute the next iteration in the correct direction.
@     Terminate the program.

젤리 , 6 바이트

Œg;Q$€

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

전체 프로그램으로 만 작동합니다 (예 : 문자열 화 된 출력).

Brachylog , 8 바이트

ḅ{t,?}ᵐc

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

설명

             Example input: "doorbell"
ḅ            Blocks: ["d","oo","r","b","e","ll"]
 {   }ᵐ      Map: ["dd","ooo","rr","bb","ee","lll"]
  t            Tail: "d" | "o" | "r" | "b" | "e" | "l"
   ,?          Prepend to input: "dd" | "ooo" | "rr" | "bb" | "ee" | "lll"
       c     Concatenate: "ddooorrbbeelll"

C, 49 바이트

i;f(char*s){for(;putchar(*s);)i=s[i]^s[1]||!s++;}

온라인에서 작동 하는지 확인하십시오 .

파이썬 2 , 47 바이트

f=lambda s:s and-~(s[0]*2!=s[:2])*s[0]+f(s[1:])

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

C, 53 바이트

i;f(char*s){for(;i=*s++;)putchar(i^*s?putchar(i):i);}

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

PHP, 40 바이트

<?=preg_filter('#(.)\1*#',"$1$0",$argn);

온라인 버전

PHP <7.1, 44 바이트

정규식없는 버전

for(;a&$c=$argn[$i++];)echo$c[$c==$l].$l=$c;

온라인 버전

Japt , 8 바이트

7 바이트 코드, -P플래그는 +1

ó¥ ®+Zg

온라인으로 테스트하십시오!

설명

이것은 ó어제 방금 추가 한 (가짜 파티션) 내장을 사용합니다 .

ó¥  ®   +Zg
ó== mZ{Z+Zg}

ó==           // Split the input into runs of equal chars.
    mZ{    }  // Replace each item Z in this array with
       Z+Zg   //   Z, concatenated with the first char of Z.
-P            // Join the resulting array back into a string.
              // Implicit: output result of last expression

헥사 고니 , 33 바이트

\~..,}/',\<.-/.<@;$>.${;/${/"$.>$

넓히는:

   \ ~ . .
  , } / ' ,
 \ < . - / .
< @ ; $ > . $
 { ; / $ { /
  " $ . > $
   . . . .

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

의사 코드는 다소 있습니다.

char = readchar()
while (char > 0)
    print(char)
    run_char = char
    do
        print(char)
        char = readchar()
    while (run_char == char)

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

s=>s.replace(/(.)\1*/g,"$1$&")

시도 해봐

f=
s=>s.replace(/(.)\1*/g,"$1$&")
i.addEventListener("input",_=>o.innerText=f(i.value))
console.log(f("aabbcccc")) // aaabbbccccc
console.log(f("doorbell")) // ddooorrbbeelll
console.log(f("uuuuuuuuuz")) // uuuuuuuuuuzz
console.log(f("q")) // qq
console.log(f("xyxyxy")) // xxyyxxyyxxyy
console.log(f("xxxyyy")) // xxxxyyyy

<input id=i><pre id=o>

brainfuck , 23 바이트

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

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

설명

,            read the first input character
 [           main loop to be run for each input character
 .           output the character once
 [->->+<<]   subtract from previous character (initially 0), and create a copy of this character
 >[          if different from previous character:
   [-]       zero out cell used for difference (so this doesn't loop)
   >.<       output character again from copy
 ]
 ,           read another input character
]

펄 6 , 18 바이트

{S:g/)>(.)$0*/$0/}

시도 해봐

넓히는:

{   # bare block lambda with implicit parameter ｢$_｣

  S        # replace and return
  :global  # all occurrences
  /

    )>     # don't actually remove anything after this

    (.)    # match a character

    $0*    # followed by any number of the same character

  /$0/     # replace with the character (before the match)
}

05AB1E , 8 바이트

.¡DÔ‚ø˜J

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

설명:

.¡DÔ‚ø˜J
.¡       Split equal runs of input
  D      Duplicate
   Ô     Take connected-uniquified
    ‚    Pair connected-uniquified equal runs with original equal runs
     ø   Zip
      ˜  Deep-flatten (i.e. normal flattening)
       J Join elements together

하스켈, 36 바이트

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

사용 예 : f "aab"-> "aaabb". 온라인으로 사용해보십시오!

문자열에 두 개 이상의 문자가 있으면 a첫 번째 문자, 두 번째 문자 b및 c나머지 문자열에 바인딩 됩니다 . 출력은되는 a다음 a경우 a동일하지 b와 재귀 호출 하였다 b:c. 문자가 하나만 있으면 결과는이 문자의 두 배입니다.

CJam, 10 바이트

le`1af.+e~

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

설명:

e# Input: doorbell
l   e# Read line:              | "doorbell"
e`  e# Run-length encode:      | [[1 'd] [2 'o] [1 'r] [1 'b] [1 'e] [2 'l]]
1a  e# Push [1]:               | [[1 'd] [2 'o] [1 'r] [1 'b] [1 'e] [2 'l]] [1]
f.+ e# Vectorized add to each: | [[2 'd] [3 'o] [2 'r] [2 'b] [2 'e] [3 'l]]
e~  e# Run-length decode:      | "ddooorrbbeelll"
e# Implicit output: ddooorrbbeelll

루비, 30 바이트

->s{s.gsub(/((.)\2*)/){$1+$2}}

젤리 , 5 바이트

n2\׿

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

작동 원리

n2\׿  Main link. Argument: s (string)

n2\    Reduce all overlapping slices of length two by non-equal.
       For input "doorbell", this returns [1, 0, 1, 1, 1, 1, 0].
   ×   Multiply the characters of s by the Booleans in the resulting array. This is
       essentially a bug, but integer-by-string multiplication works as in Python.
       For input "doorbell", this returns ['d', '', 'o', 'r', 'b', 'e', '', 'l'].
       Note that the last character is always left unchanged, as the Boolean array
       has one fewer element than s.
    ż  Zip the result with s, yielding an array of pairs.
       For input "doorbell", this returns [['d', 'd'], [[], 'o'], ['o', 'o'],
           ['r', 'r'], ['b', 'b'], ['e', 'e'], [[], 'l'], ['l', 'l']].
       (implicit) Print the flattened result.

배치, 140 바이트

@set/ps=
@set r=
:g
@if not "%s:~,1%"=="%s:~1,1%" set r=%r%%s:~,1%
@set r=%r%%s:~,1%
@set s=%s:~1%
@if not "%s%"=="" goto g
@echo %r%

STDIN에서 입력을받습니다.

sed, 18 15 바이트 (-r의 경우 +1)

s/(.)\1*/\1&/g

독창적 인 솔루션

s/((.)\2*)/\1\2/g

R, 36 바이트

gsub("((.)\\1*)","\\2\\1",scan(,""))

PowerShell, 50 바이트

{-join([char[]]$_|%{if($_-ne$p){($p=$_)}$_});rv p}

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

매스 매 티카, 34 21 바이트

Mathematica에서 13 바이트를 절약 할 수 있는 올바른 방법을 찾은 Martin Ender에게 감사 합니다!

##&[#,##]&@@@Split@#&

문자 배열을 입력 및 출력 형식으로 사용하는 순수한 기능. Split목록을 동일한 문자로 구성합니다. ##&[#,##]&는 일련의 인수를 반환하는 함수입니다. 첫 번째 인수, 그 다음에 모든 인수 (특히 첫 번째 인수를 반복); 이것은 목록의 @@@모든 하위 Split목록에 적용됩니다 ( ) .

자바, 151 (146) 60 바이트

String f(String s){return s.replaceAll("((.)\\2*)","$1$2");}

• @FryAmTheEggman 덕분에 -5 바이트
• @KevinCruijssen 덕분에 -86 바이트

정규식

(         )     group

 (.)            a character

     \\2*       optional repetition

상세한

import java.util.*;
import java.lang.*;
import java.io.*;

class H
{
    public static String f(String s)
    {
        return s.replaceAll("((.)\\2*)","$1$2");
    }

    public static void main(String[] args)
    {
        f("dddogg");
    }
}

brainfuck , 38 바이트

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

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

,.               print the "doubling" of the first char of input
[                this main loop runs on every char
  .              print it "normally" (the not-doubling)
  >,             read the next char
  [              judiciously placed "loop" to prevent printing NULs
    [->+>+<<]    copy new char at position p to p+1 and p+2
    <[->>-<<]>>  subtract old char from p+1 - zero if same, nonzero otherwise
    [            if it *is* different (nonzero)...
      [-]        clear it
      >.<        print the char (at p+2 now) again
    ]
  ]
  >              the new char is now the old char
]

Alice , 12 바이트

이 답변이 게시되기 전에도 Martin Ender 덕분에 2 바이트가 골퍼되었습니다. 그는 당신이 상상했던 것보다 더 강력합니다.

I4&.h%?-$OO!

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

설명

I                 Input a character and push its unicode value
 4&.              Push 4 more copies of this value to the stack
                  (they will be needed for the following operations)
    h%            Try to compute n%(n+1), exits with an error if n==-1
                  which happens on EOF
      ?           Push a copy of what's currently on the tape.
                  In the first iteration this will push -1, in following
                  iterations it will push the previous character.
       -$O        If the two topmost values on the stack are different
                  output the third one. This will output one more copy of
                  any new character encountered.
          O       Output this character.
           !      Store this character on the tape.

                  Execution loops back to the beginning of the line.