지침

태스크

연속적인 (증가하는) 문자 배열을 입력으로 사용하고 배열에서 누락 된 문자를 반환하는 메소드를 작성하십시오 (일부 언어로 나열).

규칙

• 이것은 코드 골프이므로 바이트 단위의 최단 답변이 이깁니다!
• 당신은 항상 유효한 배열을 얻을 것입니다
• 항상 정확히 하나의 문자가 누락됩니다
• 배열의 길이는 항상 2 이상입니다.
• 배열은 항상 대소 문자 만 포함합니다 (대문자 또는 소문자)
• 입력과 같은 대소 문자 (대문자 또는 소문자)로 출력해야합니다.
• 배열은 항상 한 번에 한 문자 씩만 이동합니다 (누락 된 문자 생략)
• 배열 길이는 2에서 25 사이입니다.
• 배열의 첫 번째 또는 마지막 요소가 절대로 누락되지 않습니다

예

['a','b','c','d','f'] -> 'e'

['O','Q','R','S'] -> 'P'

['x','z'] -> 'y'

['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','w','x','y','z'] -> 'v'

Pyth , 5 바이트

-rhQe

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

C # (.NET Core) , 48 47 46 바이트, char 배열로 입력

s=>{for(int i=0;s[++i]==++s[0];);return s[0];}

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

설명 : 배열의 첫 번째 요소와 다음 요소를 반복하는 포인터가 증가합니다. 첫 번째 요소와 현재 요소가 모두 다르면 첫 번째 요소를 반환합니다.

C # (.NET Core) , 58 56 50 바이트, 문자열로 입력

s=>{var c=s[0];while(s.IndexOf(++c)>=0);return c;}

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

이전 58 바이트 솔루션 (첫 번째 주석에서 참조) :

s=>{for(int i=1;;i++)if(s[i]-s[0]>i)return(char)(s[i]-1);}

System.Linq를 사용하는 알고리즘

다음 알고리즘은 using System.Linq;바이트 수 에 (18 바이트)를 추가해야 하므로 더 길어집니다.

나는 이것을 좋아했습니다 (52 + 18 바이트).

s=>{int i=0;return(char)(s.First(c=>c-s[0]>i++)-1);}

또한 1 라이너 (45 + 18) 바이트 솔루션도 있습니다.

s=>(char)(s.Where((c,i)=>c-s[0]>i).First()-1)

Ed'ka가 제공 한 매우 영리한 (37 + 18) 바이트 솔루션 :

s=>s.Select(e=>++e).Except(s).First()

Alice , 10 바이트

/X.
\ior@/

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

설명

이것은 서수 (문자열 처리) 모드에서 완전히 작동하는 선형 프로그램의 프레임 워크 일뿐입니다.

/...
\.../

실제 선형 코드는 다음과 같습니다.

i.rXo@

어느 것이 :

i   Read all input.
.   Duplicate.
r   Range expansion. If adjacent letters don't have adjacent code points, the
    intermediate code points are filled in between them. E.g. "ae" would turn
    into "abcde". For the inputs in this challenge, this will simply insert
    the missing letter.
X   Symmetric set difference. Drops all the letters that appear in both strings,
    i.e. everything except the one that was inserted by the range expansion.
o   Output the result.
@   Terminate the program.

하스켈 , 33 30 바이트

f a=until(`notElem`a)succ$a!!0

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

루비, 21 자

->a{[*a[0]..a[-1]]-a}

질문 소유자의 comment 에 따라 단일 요소 배열을 반환합니다 .

샘플 실행 :

irb(main):001:0> ->a{[*a[0]..a[-1]]-a}[['a','b','c','d','f']]
=> ["e"]

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

자바 8, 70 57 56 48 46 바이트

a->{for(int i=0;++a[0]==a[++i];);return a[0];}

@CarlosAlejo 덕분에 -14 (70 → 56) 및 -2 (48 → 46) 바이트 . @Nevay
덕분에 -8 (56 → 48) 바이트 .

설명:

여기에서 시도하십시오.

a->{            // Method with char-array parameter and char return-type
  for(int i=0;  //  Start index-integer at 0 and loop as long as
    ++a[0]      //   the previous character + 1 (by modifying the character at index 0)
    ==a[++i];   //   equals the next character (by raising the index by 1 before checking)
  );            //  End of loop
  return a[0];  //  Return the now modified character at index 0 in the array
}               // End of method

C (gcc) , 3335 36 48 60 바이트

모든 최적화는 꺼져 있어야하며 32 비트 GCC에서만 사용해야합니다.

f(char*v){v=*v+++1-*v?*v-1:f(v);}

문자열로 입력하십시오.

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

파이썬 3 , 74 62 58 44 40 바이트

Outgolfer Erik 덕분에 -12 바이트. Leaky Nun 덕분에 -18 바이트 musicman523 덕분에 -4 바이트.

입력을 바이트 스트링으로 취합니다.

lambda s:chr(*{*range(s[0],s[-1])}-{*s})

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

또 다른 멋진 솔루션 :

lambda s:chr(*{*range(*s[::~-len(s)])}-{*s})

매스 매 티카, 46 바이트

Min@Complement[CharacterRange@@#[[{1,-1}]],#]&

자바 스크립트 (ES6), 70 바이트

문자형 배열로 입력

(a,p)=>a.some(c=>(q=p+1,p=c.charCodeAt(),p>q))&&String.fromCharCode(q)

덜 골프

a=>{
  p = undefined;
  for(i = 0; c = a[i]; i++)
  {
    q = p+1
    p = c.charCodeAt()
    if (p>q)
      return String.fromCharCode(q)
  }
}

테스트

F=(a,p)=>a.some(c=>(q=p+1,p=c.charCodeAt(),p>q))&&String.fromCharCode(q)

function update() {
  var a0=A0.value.charCodeAt()
  var a1=A1.value.charCodeAt()
  if (a1>a0) {
    var r = [...Array(a1-a0+1)]
      .map((x,i)=>String.fromCharCode(a0+i))
      .filter(x => x != AX.value)
    I.textContent = r.join('') + " => " + F(r)
  }
  else {
    I.textContent=''
  }
}

update()

input { width: 1em }

Range from <input id=A0 value='O' pattern='[a-zA-Z]' length=1 oninput='update()'>
to <input id=A1 value='T' pattern='[a-zA-Z]' length=1 oninput='update()'>
excluding <input id=AX value='Q' pattern='[a-zA-Z]' length=1 oninput='update()'>
<pre id=I></pre>

PHP> = 7.1, 46 바이트

문자열로 입력 받아

<?=trim(join(range(($a=$argn)[0],$a[-1])),$a);

PHP 샌드 박스 온라인

망막 , 33 25 바이트

$
¶$_
T`p`_p`.*$
D`.
!`.$

온라인으로 사용해보십시오! 모든 ASCII 문자 범위에서 작동합니다. 편집 : @MartinEnder 덕분에 8 바이트가 절약되었습니다. 설명 : 첫 번째 단계는 입력을 복제합니다. 두 번째는 사본의 모든 문자를 1 코드 포인트 씩 줄입니다. 세 번째 단계는 사본에서 원본에 여전히 나타나는 모든 문자를 삭제합니다. 이것은 원래 입력, 원래 입력의 첫 문자 앞에 오는 문자 및 누락 된 문자를 그대로 둡니다. 마지막 단계는 잃어버린 캐릭터와 일치합니다.

SWI 프롤로그, 124 바이트

m([H|T]):-n(H,N),c(T,N),!,m(T).
n(I,N):-o(I,C),D is C+1,o(N,D).
c([N|_],N).
c(_,N):-print(N),!,fail.
o(C,O):-char_code(C,O).

예 :

?- m(['a','b','c','d','f']).
e
false.

?- m(['O','Q','R','S']).
'P'
false.

?- m(['x','z']).
y
false.

?- m(['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','w','x','y','z']).
v
false.

작은 설명 :

는 m"메인"절차는이 n목록에서 다음 예상 문자를 생성합니다. 는 c비교를 수행 - 기대는 다음 항목과 일치하는 경우, 다른 예상 문자를 인쇄하고 창 밖으로 뛰어 계속.

C ++ 14, 표준 라이브러리, 일반 컨테이너 유형 ( 87 86 바이트)

[](auto a){return++*adjacent_find(begin(a),end(a),[](auto a,auto b){return a+1!=b;});}

네임 스페이스의 컨테이너 유형 ::std(예를 가정 std::string, std::list또는 std::vector. 그렇지 않으면 using namespace std;또는 이와 유사한 가정 할 것이다.

약간의 전 처리기 해킹이있는 @Ven 덕분에 82 바이트 (1 줄 바꿈) 로 줄일 수 있습니다.

#define x [](auto a,int b=0){return++
x *adjacent_find(begin(a),end(a),x a!=b;});}

그것을보십시오 Live On Coliru

C ++ 14 표준 라이브러리 없음 (여전히 일반, 64 63 바이트)

[](auto& a){auto p=*begin(a);for(auto c:a)if(c!=p++)return--p;}

다시 한 번, 네임 스페이스가 아닌 컨테이너 유형이 아닌 컨테이너 유형 인 경우에만 이름 조회를 도와야 ::std합니다.

Live On Colirustd::string예 를 들어

Live On Coliruchar const[]예 를 들어

숯 , 18 바이트

Ｆγ¿¬∨∨‹ι⌊θ›ι⌈θ№θιι

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 입력을 문자열로받습니다. 거의 연속 된 ASCII 문자 시퀀스와 함께 작동합니다.

C #, 104 바이트

using System.Linq;a=>(char)Enumerable.Range(a.Min(),a.Max()-a.Min()).Except(a.Select(c=>(int)c)).First()

풀 / 포맷 버전 :

using System.Linq;

namespace System
{
    class P
    {
        static void Main()
        {
            Func<char[], char> f = a =>
                (char)Enumerable.Range(a.Min(), a.Max() - a.Min())
                                .Except(a.Select(c=>(int)c))
                                .First();

            Console.WriteLine(f(new[] { 'a', 'b', 'c', 'd', 'f' }));

            Console.ReadLine();
        }
    }
}

MATL, 8 7 바이트

@Luis 덕분에 1 바이트 절약

tdqf)Qc

MATL Online 에서 사용해보십시오

설명

      % Implicitly grab the input as a string
t     % Duplicate the string
d     % Compute the differences between successive characters
q     % Subtract 1 from each element
f     % Get the locations of all non-zero characters (1-based index)
)     % Extract that character from the string
Q     % Add one to get the next character (the missing one)
c     % Convert to character and display

엑셀, 110 + 2 = 112 바이트

=CHAR(CODE(LEFT(A1))-1+MATCH(0,IFERROR(FIND(CHAR(ROW(INDIRECT(CODE(LEFT(A1))&":"&CODE(RIGHT(A1))))),A1),0),0))

각 끝에 중괄호를 추가 하고 2 바이트 를 추가 하는 배열 수식 ( Ctrl+ Shift+ Enter) 으로 입력해야합니다 { }. 입력은의 문자열로 A1, OP 당 OK 입니다 .

이것은 가장 짧은 대답은 아니지만 (Excel은 거의 없습니다), 나는 그것이 가능한지 보는 것을 좋아합니다.

렉스 (레지나) , 56 바이트

a=arg(1)
say translate(xrange(left(a,1),right(a,1)),'',a)

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

마지막으로 REXX는 강력한 문자열 조작을 사용할 수 있습니다.

CJam , 6 바이트 (풀 프로그램) / 7 바이트 (코드 블록)

q),^W=

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

표준 입력에서 입력 문자열을 읽고 누락 된 문자를 표준 출력으로 인쇄하는 완전한 CJam 프로그램입니다. CJam은 실제로 "방법"을 가지고 있지 않습니다. 이는 도전이 요구하는 것이지만 가장 가까운 것은 아마도 다음과 같은 실행 가능한 코드 블록 일 것입니다.

{),^W=}

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

이 코드 블록은 평가 될 때 스택에서 입력을 문자열 (예 : 문자 배열)로 취하고 스택에서도 누락 된 문자를 반환합니다.

설명 : 전체 프로그램 q에서 입력 문자열을 읽고 스택에 배치하십시오. )그런 다음 입력 문자열의 마지막 문자를 튀기고 범위 연산자 ,는 아래에 코드 포인트가있는 모든 문자가 포함 된 배열 (알파벳 앞의 모든 문자 포함)로 변환합니다. 따라서 예를 들어 입력이 cdfgh이면 ),스택 뒤에 문자열 cdfg(예 : 마지막 문자가 제거 된 입력)이 포함되고 ...abcdefg여기에서 ...ASCII 코드가 아래에있는 여러 문자 a(즉, 마지막으로 제거 된 입력 아래에있는 모든 문자)가 나타납니다. 편지).

대칭 집합 차이 연산자 ^는 이러한 문자열을 문자열 중 하나에는 나타나지만 두 문자열에는 나타나지 않는 문자를 포함하는 단일 문자열로 결합합니다. 이 때문에 예를 들어, 입력, 문자가 문자열에 표시되는 순서를 보존 cdfg, 결과는 이후에 ),^있을 것입니다 ...abe경우, ...다시 아래 ASCII 코드 문자로 무리를 의미합니다 a. 마지막 W=으로이 문자열의 마지막 문자를 추출합니다.이 문자 e는 우리가 찾고자 하지 않은 문자 이며 나머지는 버립니다. 프로그램이 끝나면 CJam 인터프리터는 스택의 내용을 암시 적으로 인쇄합니다.

보너스 : GolfScript , 6 바이트 (전체 프로그램)

),^-1>

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

거의 동일한 코드가 GolfScript에서도 작동한다는 것이 밝혀졌습니다. GolfScript의 암시 적 입력으로 인해 전체 프로그램 버전에서 1 바이트를 저장하지만 CJam과 달리 GolfScript W에는 -1로 초기화 된 편리한 단일 문자 변수가 없기 때문에 1 바이트가 손실됩니다 .

또한 CJam에는 별도의 정수 및 문자 유형이 있으며 (문자열은 문자를 포함하는 배열 일뿐), GolfScript는 단일 정수 유형 만 있으며 (일반 배열과는 약간 다른 특수 문자열 유형을 가짐). 이 모든 결과는 GolfScript 인터프리터가 ASCII 코드 번호 대신 실제 누락 된 문자를 인쇄하려면 문자 자체 대신 단일 문자 문자열을 반환해야한다는 것입니다. 다행히도 여기서 변경하려면 인덱싱 연산자 =를 배열 / 문자열 왼쪽 잘림 연산자로 바꾸면 >됩니다.

물론 GolfScript의 암시 적 I / O 덕분에 위의 코드는 스택에서 문자열을 읽고 누락 된 문자가 포함 된 단일 문자 문자열을 반환하는 스 니펫으로 사용할 수도 있습니다. 또는 스택에서 단일 문자열을 인수로 사용하고 스택에서 출력 가능한 문자열로 출력을 리턴하는 스 니펫도 완전한 GolfScript 프로그램입니다.

껍질 , 6 바이트

→S-(ḣ→

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

이 함수는 문자열 (문자 목록)을 입력으로 받아서 문자를 출력으로 반환합니다.

설명

→S-(ḣ→
    ḣ→    Get the list of all characters from the null byte to the last character of the input
 S-       Subtract the input from this list
→         Get the last element of the result

파이썬 2-76 바이트

기존 Python 2 솔루션을 잃어 버렸지 만 약간 다른 접근 방식이므로 어쨌든 게시 할 것이라고 생각했습니다.

lambda c:[chr(x)for x in range(ord(c[0]),ord(c[0]+26)if chr(x)not in c][0]

8 번째 , 99 바이트

이론적 해석

문자 사이의 거리가 2보다 큰 경우 누락 된 문자가 있습니다. 문자 거리는 각 문자의 ASCII 코드 간 차이를 계산하여 얻습니다.

암호

: f ' nip s:each repeat over n:- 2 n:= if n:1+ "" swap s:+ . reset 1 then depth n:1- while! reset ;

언 골프 버전

: f \ s -- c 
  ' nip s:each    \ convert each letter into its ASCII code and put them on stack
  repeat
    over
    n:- 2 n:=     \ check if there is a missing letter 
    if            
      n:1+        \ compute the ASCII code of missing letter
      "" swap s:+ \ convert ASCII code into printable character
      .           \ print out the missing letter
      reset 1     \ set condition to exit from while!
    then
    depth n:1-    \ verify if there are letters to check
  while!          
  reset           \ clean stack
;

사용법 및 예

ok> "abcdf" f
e
ok> "OQRS" f
P
ok> "xz" f
y
ok> "abcdefghijklmnopqrstuwxyz" f
v
ok> "ab" f

ok> "def" f

ok>

자바 스크립트 (ES6), 64 바이트

입력을 문자열로받습니다.

s=>(g=p=>(c=String.fromCharCode(n++))<s[p]?p?c:g(p):g(p+1))(n=0)

방법?

• 초기화 : 우리는 n = 0 과 p = 0으로 시작 하고 재귀 함수 g ()를 호출합니다 .

  g = p =>                                   // given p
    (c = String.fromCharCode(n++)) < s[p] ?  // if the next char. c is not equal to s[p]:
      p ?                                    //   if p is not equal to zero:
        c                                    //     step #3
      :                                      //   else:
        g(p)                                 //     step #1
    :                                        // else:
      g(p + 1)                               //   step #2

• 단계 # 1 : 입력 문자열 s [0] 의 첫 문자가 될 때까지 n을 증가시킵니다 .c = String.fromCharCode(n)

• 2 단계 : 이제 동기화 되었으므로 더 이상 s [p]와 같지 않을 때까지 n 과 p 를 동시에 증가시킵니다 .c = String.fromCharCode(n)

• 3 단계 : c : 찾지 못한 예상 문자 c를 반환 합니다.

테스트 사례

let f =

s=>(g=p=>(c=String.fromCharCode(n++))<s[p]?p?c:g(p):g(p+1))(n=0)

console.log(f('abcdf'))                     // -> 'e'
console.log(f('OQRS'))                      // -> 'P'
console.log(f('xz'))                        // -> 'y'
console.log(f('abcdefghijklmnopqrstuwxyz')) // -> 'v'

J, 20 바이트

{&a.>:I.1 0 1&E.a.e.

• a.e. ASCII 문자셋의 입력 문자에 대한 부울 마스크
• 1 0 1&E.시퀀스 101가 해당 인덱스에서 시작 하는지 여부를 나타내는 새 부울 마스크 ( 예 : "건너 뛰기"시퀀스가 시작되는 위치를 찾습니다)
• I. 일치하는 인덱스, 즉, 스킵 된 것 전의 문자
• >: 1 씩 증가, 즉 ASCII 문자셋 내에서 건너 뛴 문자의 색인
• {&a. ASCII 문자 집합에서 해당 색인을 선택하십시오. 즉, 건너 뛴 문자를 반환하십시오.

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

ES6, 125 바이트 :

(a=>((s,f)=>(r=(i,b)=>a[i]?r(i+1,b||(s[f](i)-s[f](i-1)-1&&String.fromCharCode(s[f](i-1)+1))):b)(1,0))(a.join(""),"charCodeAt"))

http://jsbin.com/vasoqidawe/edit?console

반환 된 함수는 배열로 호출해야합니다.

(["a","c"])

.join ( "") 을 제거 하고 문자열을 전달하여 다른 9 바이트를 절약 할 수 있습니다 .

("ac")

ES6, 108 바이트 :

(a=>((s,f,o)=>(a.find((_,i)=>(o?++o:o=s[f](i))!==s[f](i)),String.fromCharCode(o)))(a.join(""),'charCodeAt'),0))

http://jsbin.com/tudiribiye/edit?console

공통 리스프, 88 바이트

(lambda(s)(loop as(x y)on s if(>(#1=char-code y)(1+(#1#x)))return(code-char(1+(#1#x)))))

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

파이썬 2 , 69 바이트

lambda a:chr((ord(a[0])+ord(a[-1]))*-~len(a)/2-sum(ord(x)for x in a))

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

몇 가지 설명 목록의 첫 번째 요소와 마지막 요소를 알고 있으므로 list + the missed char( 산술 진행의 요약 수식 사용) 에있는 모든 문자의 코드 합계를 쉽게 계산할 수 있습니다 . 이 합계와의 모든 문자 코드의 합계의 차이 는 누락 된 문자의 코드를 제공합니다. list

05AB1E , 9 7 바이트

ǤÝsKçθ

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

APL (Dyalog) , 17 바이트

(⊃⎕AV/⍨∨\∧~)⎕AV∘∊

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

⎕AV∘∊ 부울 :의 각 문자 A 토믹 V 인수 ector (문자 세트) 멤버의 ?

(…)  다음 암묵적 기능을 적용하십시오.

 ⊃ 의 첫 번째 요소

 ⎕AV토믹 V 엑터 (문자 세트)

 /⍨ 어느

 ∨\ 처음 (논쟁의 구성원)을 따릅니다.

 ∧ 그러나

 ~ 아니다 (논쟁의 일원)