Hướng dẫn

Bài tập

Viết một phương thức lấy một mảng các chữ cái (tăng) liên tiếp làm đầu vào và trả về chữ cái còn thiếu trong mảng (liệt kê bằng một số ngôn ngữ).

Quy tắc

• Đây là mã golf nên câu trả lời ngắn nhất tính bằng byte sẽ thắng!
• Bạn sẽ luôn có được một mảng hợp lệ
• Sẽ luôn có chính xác một chữ cái bị thiếu
• Độ dài của mảng sẽ luôn luôn ít nhất là 2.
• Mảng sẽ luôn chứa các chữ cái chỉ trong một trường hợp (chữ hoa hoặc chữ thường)
• Bạn phải xuất trong cùng một trường hợp (chữ hoa hoặc chữ thường) mà đầu vào là
• Mảng sẽ luôn chỉ đi một chữ cái một lần (bỏ qua chữ cái còn thiếu)
• Độ dài mảng sẽ nằm trong khoảng từ 2 đến 25
• Phần tử đầu tiên hoặc cuối cùng của mảng sẽ không bao giờ bị thiếu

Ví dụ

['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'

Bình thường , 5 byte

-rhQe

Hãy thử trực tuyến!

C # (.NET Core) , 48 47 46 byte, nhập dưới dạng mảng char

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

Hãy thử trực tuyến!

Giải thích: phần tử đầu tiên trong mảng được tăng lên cũng như một con trỏ lặp lại các phần tử sau. Khi cả phần tử đầu tiên và phần tử hiện tại khác nhau, nó sẽ trả về phần tử đầu tiên.

C # (.NET Core) , 58 56 50 byte, nhập dưới dạng chuỗi

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

Hãy thử trực tuyến!

Giải pháp 58 byte trước đó (được tham chiếu trong bình luận đầu tiên):

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

Các thuật toán sử dụng System.Linq

Các thuật toán sau phải thêm using System.Linq;(18 byte) vào số byte và do đó dài hơn.

Tôi khá thích cái này (52 + 18 byte):

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

Và bạn cũng có một giải pháp tạm thời (45 + 18):

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

Và một giải pháp rất thông minh (37 + 18), lịch sự của Ed'ka:

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

Alice , 10 byte

/X.
\ior@/

Hãy thử trực tuyến!

Giải trình

Đây chỉ là một khung cho các chương trình tuyến tính hoạt động hoàn toàn trong chế độ Ordinal (xử lý chuỗi):

/...
\.../

Mã tuyến tính thực tế là:

i.rXo@

Mà không:

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.

Haskell , 33 30 byte

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

Hãy thử trực tuyến!

Ruby, 21 ký tự

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

Trả về một mảng phần tử duy nhất, theo nhận xét của chủ sở hữu câu hỏi .

Chạy mẫu:

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

Hãy thử trực tuyến!

Java 8, 70 57 56 48 46 byte

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

-14 (70 → 56) và -2 (48 → 46) byte nhờ @CarlosAlejo .
-8 (56 → 48) byte nhờ @Nevay .

Giải trình:

Hãy thử nó ở đây.

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 byte

Tất cả các tối ưu hóa nên được tắt và chỉ trên GCC 32 bit.

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

Lấy đầu vào dưới dạng một chuỗi.

Hãy thử trực tuyến!

Python 3 , 74 62 58 44 40 byte

-12 byte nhờ Erik the Outgolfer. -18 byte nhờ Leaky Nun. -4 byte nhờ nhạcman523.

Đưa đầu vào là một phụ.

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

Hãy thử trực tuyến!

Một giải pháp tuyệt vời khác:

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

Toán học, 46 byte

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

JavaScript (ES6), 70 byte

Nhập dưới dạng mảng ký tự

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

Ít chơi gôn

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

Kiểm tra

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 byte

Lấy đầu vào dưới dạng chuỗi

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

PHP Sandbox trực tuyến

Võng mạc , 33 25 byte

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

Hãy thử trực tuyến! Hoạt động với bất kỳ phạm vi ký tự ASCII nào. Chỉnh sửa: Đã lưu 8 byte nhờ @MartinEnder. Giải thích: Giai đoạn đầu tiên nhân đôi đầu vào. Thứ hai giảm tất cả các ký tự trong bản sao bằng 1 điểm mã. Giai đoạn thứ ba xóa tất cả các ký tự trong bản sao vẫn xuất hiện trong bản gốc. Điều này chỉ để lại đầu vào ban đầu, ký tự đứng trước ký tự đầu tiên của đầu vào ban đầu và ký tự bị thiếu. Giai đoạn cuối cùng sau đó chỉ phù hợp với nhân vật mất tích.

SWI Prolog, 124 byte

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).

Ví dụ:

?- 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.

Giải thích nhỏ:

Đây mlà thủ tục "chính", ntạo ra nhân vật được mong đợi tiếp theo trong danh sách. Việc cso sánh không - nếu kỳ vọng khớp với mục tiếp theo, hãy tiếp tục, nếu không thì in ra ký tự mong đợi và nhảy ra khỏi cửa sổ.

C ++ 14, thư viện chuẩn, loại vùng chứa chung ( 87 86 byte)

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

Loại container từ không gian tên ::stdđược giả sử (ví dụ std::string, std::listhoặc std::vector. Nếu không using namespace std;hoặc tương tự sẽ được giả định.

Nhờ @Ven, với một chút hack tiền xử lý, bạn có được nó xuống còn 82 byte (1 dòng mới)

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

Nhìn thấy nó Live On Coliru

C ++ 14 không có thư viện chuẩn (vẫn chung, 64 63 byte)

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

Một lần nữa, chỉ cần trợ giúp tra cứu tên nếu loại vùng chứa không phải từ không gian tên ::std(hoặc được liên kết với nó)

Live On Colirucho std::stringví dụ

Live On Colirucho char const[]ví dụ

Than , 18 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đưa đầu vào dưới dạng một chuỗi. Hoạt động với bất kỳ chuỗi ký tự ASCII gần như liền kề.

C #, 104 byte

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

Phiên bản đầy đủ / được định dạng:

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 byte

Lưu 1 byte nhờ @Luis

tdqf)Qc

Dùng thử tại MATL Online

Giải trình

      % 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

Excel, 110 + 2 = 112 byte

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

Phải được nhập dưới dạng công thức mảng ( Ctrl+ Shift+ Enter) để thêm dấu ngoặc nhọn { }ở mỗi đầu, thêm hai byte. Đầu vào là một chuỗi trong A1, đó là OK cho mỗi OP .

Đây không phải là câu trả lời ngắn nhất cho đến nay (Excel hiếm khi) nhưng tôi muốn xem liệu nó có thể được thực hiện hay không.

Rexx (Regina) , 56 byte

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

Hãy thử trực tuyến!

Cuối cùng, một cho phép REXX sử dụng thao tác chuỗi mạnh mẽ của nó.

CJam , 6 byte (chương trình đầy đủ) / 7 byte (khối mã)

q),^W=

Hãy thử trực tuyến!

Đây là một chương trình đầy đủ của CJam đọc chuỗi đầu vào từ đầu vào tiêu chuẩn và in chữ cái còn thiếu sang đầu ra tiêu chuẩn. CJam không thực sự có "phương thức", đó là điều mà thách thức yêu cầu, nhưng thứ gần nhất có lẽ sẽ là một khối mã thực thi, như thế này:

{),^W=}

Hãy thử trực tuyến!

Khối mã này, khi được đánh giá, lấy đầu vào dưới dạng một chuỗi (tức là một mảng các ký tự) trên ngăn xếp và trả về ký tự bị thiếu cũng trên ngăn xếp.

Giải thích: Trong chương trình đầy đủ, qđọc chuỗi đầu vào và đặt nó lên ngăn xếp. )sau đó bật ra ký tự cuối cùng của chuỗi đầu vào và toán tử phạm vi ,biến nó thành một mảng chứa tất cả các ký tự có các điểm mã bên dưới nó (bao gồm tất cả các chữ cái trước nó trong bảng chữ cái). Vì vậy, ví dụ, nếu đầu vào là cdfgh, thì sau ),ngăn xếp sẽ chứa các chuỗi cdfg(tức là đầu vào có chữ cái cuối cùng bị loại bỏ) và ...abcdefg, trong đó... viết tắt của một loạt các ký tự có mã ASCII bên dưới a(tức là tất cả các ký tự bên dưới đầu vào cuối bị loại bỏ lá thư).

^Sau đó, toán tử khác biệt tập đối xứng kết hợp các chuỗi này thành một chuỗi chứa chính xác các ký tự xuất hiện trong một trong các chuỗi, nhưng không phải trong cả hai chuỗi. Nó duy trì thứ tự xuất hiện các ký tự trong chuỗi, do đó, đối với đầu vào ví dụ cdfg, kết quả sau ),^sẽ là ...abe, trong đó ...một lần nữa là viết tắt của một loạt các ký tự có mã ASCII bên dưới a. Cuối cùng, W=chỉ trích xuất ký tự cuối cùng của chuỗi này, đó chính xác là ký tự bị thiếu emà chúng tôi muốn tìm (và loại bỏ phần còn lại). Khi chương trình kết thúc, trình thông dịch CJam sẽ in ra nội dung của ngăn xếp.

Phần thưởng: GolfScript , 6 byte (chương trình đầy đủ)

),^-1>

Hãy thử trực tuyến!

Nó chỉ ra rằng gần như cùng một mã cũng hoạt động trong GolfScript. Chúng tôi lưu một byte trong phiên bản chương trình đầy đủ do đầu vào ngầm của GolfScript, nhưng mất một byte bởi vì, không giống như của CJam W, GolfScript không có biến một chữ cái đơn giản được khởi tạo thành -1.

Ngoài ra, CJam có các loại số nguyên và ký tự riêng biệt (và các chuỗi chỉ là các mảng chứa các ký tự), trong khi GolfScript chỉ có một loại số nguyên duy nhất (và có một loại chuỗi đặc biệt hoạt động hơi khác so với các mảng thông thường). Kết quả của tất cả những điều này là, nếu chúng ta muốn trình thông dịch GolfScript in ra chữ cái bị thiếu thực tế thay vì số mã ASCII của nó, chúng ta cần trả về một chuỗi ký tự đơn thay vì chỉ chính ký tự đó. May mắn thay, thực hiện thay đổi đó ở đây chỉ cần thay thế toán tử lập chỉ mục =bằng toán tử cắt ngắn mảng / chuỗi trái> .

Tất nhiên, nhờ vào I / O ẩn của GolfScript, mã ở trên cũng có thể được sử dụng như một đoạn mã đọc một chuỗi từ ngăn xếp và trả về một chuỗi ký tự đơn có chứa ký tự bị thiếu. Hoặc, đúng hơn, bất kỳ đoạn mã nào lấy một chuỗi trên ngăn xếp làm đối số và trả về đầu ra của nó dưới dạng một chuỗi có thể in trên ngăn xếp, cũng là một chương trình GolfScript đầy đủ.

Husk , 6 byte

→S-(ḣ→

Hãy thử trực tuyến!

Hàm này lấy một chuỗi (danh sách các ký tự) làm đầu vào và trả về một ký tự làm đầu ra.

Giải trình

→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

Python 2 - 76 byte

Mất giải pháp python 2 hiện có nhưng đó là một cách tiếp cận hơi khác nên tôi nghĩ dù sao tôi cũng sẽ đăng nó:

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

8 , 99 byte

Cơ sở lý luận

Nếu khoảng cách giữa các chữ cái lớn hơn hai, thì có một chữ cái bị thiếu. Khoảng cách chữ có được bằng cách tính toán sự khác biệt giữa mã ASCII của mỗi chữ cái.

Mã

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

Phiên bản ung dung

: 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
;

Cách sử dụng và ví dụ

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

ok> "def" f

ok>

JavaScript (ES6), 64 byte

Đưa đầu vào dưới dạng một chuỗi.

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

Làm sao?

• Khởi tạo: Chúng tôi bắt đầu với n = 0 và p = 0 và gọi hàm đệ quy 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

• Bước # 1: Chúng tôi tăng n cho đến khic = String.fromCharCode(n)bằng ký tự đầu tiên của chuỗi đầu vào s [0] .

• Bước # 2: Bây giờ chúng tôi đã đồng bộ hóa, chúng tôi tăng cả n và p cùng một lúc cho đến khic = String.fromCharCode(n)không còn bằng s [p] nữa.

• Bước # 3: Chúng tôi trả về c : ký tự dự kiến ​​không tìm thấy.

Các trường hợp thử nghiệm

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 byte

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

• a.e. mặt nạ boolean cho các chữ cái đầu vào trên bảng mã ascii
• 1 0 1&E. mặt nạ boolean mới chỉ ra nếu trình tự 101 bắt đầu tại chỉ mục đó, nghĩa là tìm bất kỳ nơi nào một chuỗi "bỏ qua" bắt đầu
• I. chỉ số của trận đấu đó, tức là ký tự trước khi bỏ qua
• >: tăng thêm 1, tức là chỉ số của char bị bỏ qua trong bộ ký tự ascii
• {&a. chọn chỉ mục đó từ bộ ký tự ascii, nghĩa là trả về char bị bỏ qua

Hãy thử trực tuyến!

ES6, 125 byte:

(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

Hàm trả về cần được gọi với một mảng

(["a","c"])

người ta có thể lưu thêm 9 byte thông qua việc loại bỏ .join ("") và truyền chuỗi:

("ac")

ES6, 108 byte:

(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

Lisp thông thường, 88 byte

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

Hãy thử trực tuyến!

Python 2 , 69 byte

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

Hãy thử trực tuyến!

Một số giải thích Khi chúng ta biết các yếu tố đầu tiên và cuối cùng của danh sách, chúng ta có thể dễ dàng tính tổng các mã của tất cả các ký tự trong list + the missed char(sử dụng các công thức tóm tắt của tiến trình số học ). Sự khác biệt giữa tổng này và tổng mã của tất cả các ký tự trong listmã đưa ra mã của chữ cái bị bỏ lỡ.

05AB1E , 9 7 byte

ǤÝsKçθ

Hãy thử trực tuyến!

APL (Dyalog) , 17 byte

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

Hãy thử trực tuyến!

⎕AV∘∊ Boolean: mỗi ký tự trong thành viên A tomic V ector (bộ ký tự) của đối số?

(... ) áp dụng các chức năng ngầm như sau:

 ⊃ yếu tố đầu tiên của

 ⎕AV các Một Tomic V ector (bộ ký tự)

 /⍨ mà

 ∨\ theo sau (thành viên của đối số)

 ∧ nhưng

 ~ không phải là (một thành viên của cuộc tranh luận)