_{제목이 일부러 철자가 잘못되었습니다. 이유를 알아 보려면 자세한 내용을 읽으십시오.}

당신의 작업 : 문자를 포함하는 구분 된 문자열 또는 목록이 주어지면 A,B,C,D인접한 모든 동일한 문자의 색인을 출력하십시오. 여러 줄의 문자열 / 정수, 목록 / 배열 또는 구분 된 문자열이 출력 될 수 있습니다.

모든 출력은 목록이나 문자열 또는 여러 줄로 인쇄되어야합니다. 여러 줄이있는 경우 각 인쇄 된 줄에는 1 개의 문자열 또는 숫자 만 포함되어야합니다. 무엇이든 후행해도 괜찮습니다.

표준 입출력 방법. 표준 허점이 적용됩니다.

예를 들어, 입력 'ABCDDCBA'을 출력해야 3,4하거나 4,5, 해당 번호의 인덱스되어 있기 때문에, 1 행 인덱스 0- 여부에 따라 D그리고 D그 옆.

테스트 사례 :

테스트 케이스에는 단일 문자열로 입력이 제공되고-로 ,구분 된 문자열 로 출력됩니다 . 출력은 0- 인덱싱됩니다. 출력 된 모든 항목에 1을 추가하여 1- 인덱싱하십시오.

Input: 'ABCDCABCD'
Output: ''

Input: 'AABBCCDD'
Output: '0,1,2,3,4,5,6,7'

Input: 'ABCDDDCBA'
Output: '3,4,5'

Input: 'ABBCDD'
Output: '1,2,4,5'

이것은 code-golf 이므로 가장 짧은 코드가 승리합니다!

MATL , 8 7 바이트

d~ftQvu

출력은 1 기반입니다.

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

예를 들어 설명

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

d     % Implicitly input a string. Consecutive differences
      % STACK: [1  1  1  0  0 -1 -1 -1]
~     % Negate. Each character that equals the next gives true
      % STACK: [0 0 0 1 1 0 0 0]
f     % Find: (1-based) indices of true elements
      % STACK: [4 5]
tQ    % Duplicate, add 1 element-wise
      % STACK: [4 5], [5 6]
v     % Concatenate vertically
      % STACK: [4 5; 5 6]
u     % Unique (remove duplicates). This doesn't automatically sort, but the 
      % output will be sorted because the input, read in column-major order, is 
      % Implicitly display
      % STACK: [4; 5; 6]

망막 , 33 29 23 바이트

Martin Ender 덕분에 6 바이트 절약

T`L`:`(.)\1+
:
$.`¶
T`L

줄 바꿈으로 구분 된 인덱스 목록을 출력합니다.

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

설명

T`L`:`(.)\1+

동일한 문자의 런을 콜론으로 음역하여 중복 문자가있는 위치를 표시합니다.

:
$.`¶

그런 다음 각 콜론을 이전 텍스트 길이로 바꾸고 줄 바꿈을합니다.

T`L

마지막으로 나머지 문자를 삭제하십시오.

젤리 , 7 바이트

JṁŒgḊÐf

1 기반; OP에서 허용 하는 인덱스 실행 목록 목록을 반환합니다 .

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

방법?

JṁŒgḊÐf - Main link: char-list s       e.g. 'DCCABBBACCCD' (which is a python interpreted input of ['D','C','C','A','B','B','B','A','C','C','C','D'])
J       - range(length(s))                  [1,2,3,4,5,6,7,8,9,10,11,12]
  Œg    - group-runs(s)                     [['D'],['C','C'],['A'],['B','B','B'],['A'],['C','C','C'],['D']]
 ṁ      - mould left like right             [[1],[2,3],[4],[5,6,7],[8],[9,10,11],[12]]
     Ðf - filter keep items that would be truthy (empty is not truthy) after applying:
    Ḋ   -     dequeue (x[1:])               [    [2,3],    [5,6,7],    [9,10,11]     ]        

Brain-Flak , 57 46 바이트

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

에 +2 포함 -ar

0 기반 인덱싱을 사용합니다.

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

# While true
{

  # Subtract the second value on the stack from the first
  ({}[({})]

  # Push the height of this stack (the main stack) on the other stack
  <(([]<>)

  # Push the height of the main stack - 1
  [()])>

  # Push the difference that we calculated a second ago
  )

  # If they weren't the same character
  {

    # Pop the difference and the two stack heights
    (<{}{}{}>)

  # End if
  }

  # Pop the difference (or the 0 to get out of the if)
  {}

# Switch back to the main stack and end while
<>}

# Switch to the stack with the indexes and implicitly print
<>

수학, 32 바이트

Union@@StringPosition[#,x_~~x_]&

동일한 문자에 인접한 문자의 1- 인덱스 위치를 반환하는 순수 함수.

설명:

StringPosition["string","sub"]"sub"의 하위 문자열로 표시 되는 시작 및 끝 문자 위치 목록을 제공합니다 "string". x_~~x_는 StringExpression인접한 두 개의 동일한 문자와 일치합니다. 예를 들어, StringPosition["ABCDDDCBA",x_~~x_]gives {{4, 5}, {5, 6}}. 적용 Union하면 목록을 조인하고 중복을 정렬 및 삭제합니다.

Brain-Flak , 69, 59 , 56 바이트

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

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

-arASCII 입력을 활성화하고 스택을 반전시키는 플래그에 +2 바이트 .

0 기반 인덱싱을 사용합니다. 푸시 팝 중복 을 줄여 10 바이트를 절약했습니다 . 1에서 0 기반 색인으로 전환하여 다른 4 바이트를 절약했습니다.

이것은 brain-flak가 잘하는 유일한 문자열 기반 도전입니다. 그것은 일반적으로 문자열 처리가 끔찍하지만 brain-flak가 연속 문자를 비교하는 데 뛰어 나기 때문입니다. 다음은 작동 방식을 설명하는 주석이 포함 된 읽을 수있는 코드 버전입니다.

#While True
{

    #Determine if top two are equal
    ({}[({})]<(())>){((<{}{}>))}{}

    #If so
    {

        #Pop the one, and negate it's value (giving us -1)
        ([{}]

        #Push stack height over
        ([]<>)

        #Then push stack height plus the negated pop (-1)
        ) 

        #Push a zero back onto the main stack
        (<>)

    #Endwhile
    }

    #Pop the zero
    {}

#Endwhile
}

#Toggle back, implicitly display
<>

Brachylog , 19 바이트

l⟦k:?z{sĊtᵐ=∧Ċ∋h}ᶠd

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

설명

Brachylog는 일반적으로 색인으로 끔찍하며 여기에 다시 표시됩니다.

경우 false.에는 인접한 문자가없는 경우에 허용되는 출력, 이것은 대체하여 1 바이트 적은 것 ᶠd가 ᵘ.

l⟦k                      The list [0, …, length(Input) - 1]
   :?z                   Zip the Input with this list
      {         }ᶠd      Find with no duplicates:
            ∧Ċ∋h           The heads of each element of Ċ = [A, B] (i.e. the indexes)…
        Ċtᵐ=               …where the tails of both A and B are equal (i.e. the letters)…
       sĊ                  …and where Ċ = [A, B] is a substring of the Input

옥타브 , 35 바이트

@(s)unique([x=find(~diff(+s)),x+1])

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

내 MATL 답변과 비슷합니다 . 여기에 unique자동으로 정렬됩니다. 입력 diff은로 변환되어야하며 double, 단항에 의해 수행됩니다 +.

Cubix, 37 32 31 29 28 바이트

3 바이트 절약 방향으로 나를 가리켜 준 ETHProductions에게 감사합니다

$uO@(;Usoi?-!w>;.....S_o\;#O

여기에서 보십시오 ! 출력 인덱스는 1부터 시작하며 오름차순이 아닙니다.

넓히는:

      $ u O
      @ ) ;
      U s o
i ? - ! w > ; . . . . .
S _ o \ ; # O . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

설명

입력 문자를 문자별로 읽어서 작동합니다. 두 문자를 비교하기 위해 단순히 문자 코드를 빼고 결과가 0이면 스택의 현재 길이, 공백, 스택의 현재 길이-1 및 다른 공백을 인쇄합니다. 그런 다음 스택을 약간 정리하고 읽기 루프로 다시 시작합니다. 입력 문자열의 끝에 도달하면 프로그램이 중지됩니다.

C, 75 바이트

i;f(char*s){for(i=0;*s;++s,++i)if(s[1]==*s|(i&&s[-1]==*s))printf("%d ",i);}

공백을 구분 기호로 사용합니다. (마지막 쉼표는보기에 좋지 않습니다.)

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

C # , 115 바이트

골프

i=>{var o="";for(int x=1,l=i.Length;x<=l;x++)o+=(x<l&&i[x]==i[x-1])||(x>1&&i[x-1]==i[x-2])?(x-1)+" ":"";return o;};

언 골프

i => {
   var o = "";

   for( int x = 1, l = i.Length; x <= l; x++ )
      o += ( x < l && i[ x ] == i[ x - 1 ] ) || ( x > 1 && i[ x - 1 ] == i[ x - 2 ] )
         ? ( x - 1 ) + " "
         : "";

   return o;
};

언 골프 가능

i => {
   // List of positions
   var o = "";

   // Cycle through the string
   for( int x = 1, l = i.Length; x <= l; x++ )
      // Check if 'x' is below the string length
      //    and if the current and previous char are the same...
      //    ... or if 'x' is beyong the string length
      //    and the 2 previous chars are the same.
      o += ( x < l && i[ x ] == i[ x - 1 ] ) || ( x > 1 && i[ x - 1 ] == i[ x - 2 ] )

         // If true, add the index to the list of positions...
         ? ( x - 1 ) + " "

         // ...otherwise add nothing
         : "";

   // Return the list of positions.
   return o;
};

전체 코드

using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, String> f = i => {
            // List of positions
            var o = "";

            // Cycle through the string
            for( int x = 1, l = i.Length; x <= l; x++ )
               // Check if 'x' is below the string length
               //    and if the current and previous char are the same...
               //    ... or if 'x' is beyong the string length
               //    and the 2 previous chars are the same.
               o += ( x < l && i[ x ] == i[ x - 1 ] ) || ( x > 1 && i[ x - 1 ] == i[ x - 2 ] )

                  // If true, add the index to the list of positions...
                  ? ( x - 1 ) + " "

                  // ...otherwise add nothing
                  : "";

            // Return the list of positions.
            return o;
         };

         List<String>
            testCases = new List<String>() {
               "ABCDCABCD",
               "AABBCCDD",
               "ABCDDDCBA",
               "",
               "A",
               "AA",
               "AAA",
         };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $"{testCase}\n{f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

자료

• V1.0 - 115 bytes- 초기 솔루션입니다.

노트

추가 할 사항이 없습니다

젤리 , 8 바이트

=2\T’œ|$

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

k, 18 바이트

{?,/-1 0+/:&:=':x}

예 :

k){?,/-1 0+/:&:=':x}"AABCDDDCBAA"
0 1 4 5 6 9 10
k){?,/-1 0+/:&:=':x}"ABCDCBA"
()

로의 번역 q은 이해하기 쉽습니다.

{distinct raze -1 0+/:where not differ x}

자바 스크립트, 52 바이트

1 바이트를 골프로 해주셔서 감사합니다 @Neil

x=>x.map((a,i)=>a==x[++i-2]|a==x[i]&&i).filter(a=>a)

0 인덱스 문자 배열로 입력을받습니다
. 1 인덱스 배열로 출력을 돌려줍니다.

설명

x.map()

문자열의 각 문자에 대해

(a,i)=>(a==x[++i-2]|a==x[i])*i

이전 문자 또는 다음 문자와 같으면 index + 1을 리턴하고 그렇지 않으면 리턴하지 않습니다 (배열에 정의되지 않은 상태로 남음)

.filter(a=>a)

결과 배열에서 정의되지 않은 모든 요소 제거

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

파이썬 2, 55 54 바이트

m=j=0
for i in input():
 if m==i:print~-j,j,
 j+=1;m=i

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

공백으로 구분 된 색인을 출력합니다 (OP에서 허용하는대로 일부 색인을 두 번 표시 함).

펄 5 , 37 바이트

35 바이트의 코드 + pl플래그

s/(?<=(.))\1|(.)(?=\2)/print pos/ge

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

(?<=(.))\1|(.)(?=\2)두 개의 (?<=(.))\1반복 된 문자 ( ) 또는 반복되는 문자 ( ) 앞에 일치합니다 (.)(?=\2).
그런 다음 print pos일치 위치를 인쇄합니다. ( 수정자가 pos있는 정규식에서 사용될 때 현재 일치하는 색인을 포함합니다 /g).

펄 6 ,  66  57 바이트

*.comb.rotor(2=>-1).kv.flatmap({($^a,$a+1)xx[eq] $^b[0,1]}).squish

시도 해봐

{m:ex/[(.)<($0|(.))>$0]{make $/.from}/».ast.sort.squish}

시도 해봐

PHP, 100 바이트

for(;$i<strlen($s=$argn);$i++)$s[$i]==$s[$i+1]||$s[$i]==$s[$i-1]&&$i?$r[$i]=+$i:0;echo join(",",$r);

루비 , 51 + 1 = 52 바이트

-n플래그를 사용합니다 .

i=0;d=[];gsub(/./){$&==$_[i+=1]?d+=[i-1,i]:0};p d&d

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

배치, 139 바이트

@set/ps=
@set/ai=c=0
:l
@if %s:~,1%==%s:~1,1% set c=2
@if %c% gtr 0 echo %i%
@set/ai+=1,c-=1
@if not "%s:~1%"=="" set s=%s:~1%&goto l

STDIN에서 입력을받습니다. c변수 에 인쇄 할 숫자의 수를 추적하여 작동 하며 쌍이 감지되면 2로 재설정됩니다. 참고 : 6 바이트의 비용으로,뿐만 아니라 대부분의 ASCII 문자로 작동하도록 강화할 수 있습니다 ABCD.

C #, 89 바이트

using System.Linq;s=>string.Join("",s.Skip(1).Select((a,i)=>a==s[i]?i+" "+(i+1)+" ":""));

행에 3 개 이상의 문자가 있으면 인덱스가 반복됩니다. 의견에 허용 된 @Comrade SparklePony

Ungolfed 전체 프로그램 :

using System;
using System.Collections.Generic;
using System.Linq;

namespace Namespace
{
    class Class1
    {
        static void Main(string[] args)
        {
            Func<string, string> f2 =
                s => string.Join("" ,         //Combine the results into one string
                s.Skip(1)                     //Start with the second element
                .Select(
                    (a, i) =>                 // 'a' is the current element, 'i' is the index of the element in the result of 'Skip'
                    a == s[i] ?               // therefore 's[i]' is the previous element; compare it with the current one
                    i + " " + (i + 1) + " " : //If true, return the indexes
                    ""                        //Otherwise an empty string
                ));

            var tests = new string [] {
               "ABCDCABCD",
               "AABBCCDD",
               "ABCDDDCBA",
               "ABBCDD"
            };

            foreach (var test in tests)
            {
                Console.WriteLine(test);
                Console.WriteLine(string.Join("", f2(test)));
                Console.WriteLine();
            }

            Console.ReadLine();
        }
    }
}

QBIC , 42 바이트

;[2,_lA||~mid$(A,a-1,1)=mid$(A,a,1)|?a-1,a

샘플 출력 :

Command line: AADCDBBD
 1             2 
 6             7 

설명:

;               Get A$ from the cmd line
[2,    |        FOR a% = 2 TO
   _lA|              the length of A$
~mid$(A,a-1,1)  IF the character at index a%
=mid$(A,a,1)    equals the char at index a%-1
|               THEN
?a-1,a          PRINT both indexes, tab-separated
                Any further doubles are printed on a separate line
                The IF and FOR are closed implicitly

편집 : QBIC에는 이제 하위 문자열이 있습니다! 이 문제는 이제 32 바이트로 해결할 수 있습니다.

;[2,_lA||~_sA,a-1|=_sA,a||?a-1,a

어디에:

_s      This is the substring function; it takes 1, 2 or 3 arguments. 
        Arguments are comma-seperated, the list is delimited with |
        In this answer we see Substring take 2 arguments:
  A,    The string to take from
    a|  Starting position (note:uppercase represents strings, lowercase is for nums)
        Any omitted argument (in this case 'length to take') is set to 1.

k, 14 바이트

이것은 함수이며, 문자열을 받아 인덱스 목록을 반환합니다.

&{x|1_x,0}@=':

설명:

           =': /compare each letter to the previous, return binary list
 {       }@    
    1_x,0      /shift left
  x|           /combine shifted and unshifted with binary or
&              /get indices of 1s

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

사용하는 방법:

&{x|1_x,0}@=':"STRINGGOESHERE"

PHP, 70 바이트

for(;a&$c=$argn[$i];)$i++&&$argn[$i-2]==$c||$argn[$i]==$c?print$i._:0;

STDIN에서 입력을받습니다. 로 실행하십시오 -R.