Kuralları

Görev

Girdi olarak ardışık (artan) harfler dizisi alan ve dizideki eksik harfi döndüren bir yöntem yazın (bazı dillerde listeler).

kurallar

• Bu kod golf yani bayt cinsinden en kısa cevap kazanır!
• Her zaman geçerli bir dizi elde edersiniz
• Her zaman tam olarak bir harf eksik olacak
• Dizinin uzunluğu her zaman en az 2 olacaktır.
• Dizi her zaman yalnızca bir durumda (büyük veya küçük harf) harfler içerecektir
• Girdi ile aynı durumda (büyük veya küçük harf) çıktı vermelisiniz.
• Dizi her zaman yalnızca bir harfe gider (eksik harfi atlayarak)
• Dizi uzunluğu 2 ile 25 arasında olacak
• Dizinin ilk veya son elemanı asla kaybolmayacak

Örnekler

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

-rhQe

Çevrimiçi deneyin!

C # (.NET Core) , 48 47 46 bayt, karakter dizisi olarak giriş

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

Çevrimiçi deneyin!

Açıklama: Dizideki ilk öğe, aşağıdaki öğeleri yineleyen bir işaretçi ile artırılır. Hem ilk eleman hem de geçerli eleman farklı olduğunda, ilk elemanı geri döndürür.

C # (.NET Core) , 58 56 50 bayt, dize olarak giriş

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

Çevrimiçi deneyin!

Önceki 58 baytlık çözüm (ilk yoruma referans olarak verilmiştir):

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

System.Linq kullanarak algoritmalar

Aşağıdaki algoritmalar using System.Linq;, bayt sayımına (18 bayt) eklenmelidir ve bu nedenle daha uzundur.

Bunu çok beğendim (52 ​​+ 18 bayt):

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

Ve ayrıca bir tek gömlek (45 + 18) baytlık çözümünüz var:

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

Ve çok zekice (37 + 18) -byte çözümü, Ed'ka'nın izniyle:

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

Alice , 10 bayt

/X.
\ior@/

Çevrimiçi deneyin!

açıklama

Bu, tamamen Ordinal (string processing) modunda çalışan doğrusal programlar için sadece bir çerçevedir:

/...
\.../

Asıl doğrusal kod şudur:

i.rXo@

Hangisi yapar:

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 bayt

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

Çevrimiçi deneyin!

Yakut, 21 karakter

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

Soru sahibinin yorumuna göre tek bir öğe dizisi döndürür .

Örnek çalışma:

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

Çevrimiçi deneyin!

Java 8, 70 57 56 48 46 bayt

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

-CarlosAlejo sayesinde -14 (70 → 56) ve -2 (48 → 46) bayt . @Nevay
sayesinde -8 (56 → 48) bayt .

Açıklama:

Burada dene.

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 bayt

Tüm optimizasyonlar kapatılmalı ve sadece 32 bit GCC'de yapılmalıdır.

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

Bir dize olarak girişi alın.

Çevrimiçi deneyin!

Python 3 , 74 62 58 44 40 bayt

-Geçen Avcı Erik'e teşekkürler. Sızdıran Rahibe sayesinde -18 bayt. Müzisyen523 sayesinde -4 bayt.

Girdiyi bytestring olarak alır.

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

Çevrimiçi deneyin!

Başka bir serin çözüm:

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

Mathematica, 46 bayt

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

JavaScript (ES6), 70 bayt

Karakter dizisi olarak giriş

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

Daha az golf oynadı

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

Ölçek

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 bayt

Girdiyi dize olarak al

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

PHP Sandbox Çevrimiçi

Retina , 33 25 bayt

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

Çevrimiçi deneyin! Herhangi bir ASCII karakter aralığı ile çalışır. Düzenleme: @MartinEnder sayesinde 8 bayt kaydedildi. Açıklama: İlk aşama girişi kopyalar. İkincisi, kopyadaki tüm karakterleri 1 kod noktası kadar azaltır. Üçüncü aşama, kopyada hala orijinal belgede görünen tüm karakterleri siler. Bu sadece orijinal giriş, orijinal girişin ilk karakterinden önce gelen karakter ve eksik karakterden çıkar. Son aşama sadece kayıp karakterle eşleşir.

SWI Prolog, 124 bayt

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

Örnekler:

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

Küçük açıklama:

m"Ana" prosedürü vardır nlistedeki bir sonraki Beklenen bir karakter üretir. Karşılaştırma cyapar - beklenti sonraki öğeyle eşleşirse, devam et, aksi takdirde beklenen karakteri yazdır ve pencereden dışarı atla.

C ++ 14, standart kütüphane, genel kapsayıcı türü ( 87 86 bayt)

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

Ad alanından konteyner tipi ::stdvarsayılır (örneğin std::string, std::listveya std::vector. Aksi takdirde using namespace std;veya benzerleri varsayılır).

@Ven sayesinde, bir miktar önişlemci hacklemesi ile 82 bayta indiriliyor (1 newline)

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

Bak Live On Coliru

C ++ 14 standart kütüphane yok (hala genel 64 63 bayt)

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

Yine de, isim aramasına yalnızca konteyner tipi isim alanından değilse ::std(veya onunla ilişkilendirilmişse) yardım etmeniz gerekir.

Live On Coliru için std::stringörneğin

Live On Coliruiçin char const[]örneğin

Kömür , 18 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Bir dize olarak girdi alır. Herhangi bir bitişik ASCII karakter dizisi ile çalışır.

C #, 104 bayt

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

Tam / Biçimli sürüm:

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 bayt

@Luis sayesinde 1 bayt kurtarıldı

tdqf)Qc

MATL Online'da deneyin

açıklama

      % 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 bayt

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

İki bayt ekleyerek her iki uca da parantez ekleyen bir dizi formülü ( Ctrl+ Shift+ Enter) olarak girilmelidir { }. Giriş, OP başınaA1 Tamam olan bir dize gibidir .

Bu şu ana kadarki en kısa cevap değil (Excel nadiren öyle) ama yapılıp yapılmadığını görmek hoşuma gidiyor.

Rexx (Regina) , 56 bayt

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

Çevrimiçi deneyin!

Sonunda REXX'in güçlü string manipülasyonunu kullanmasını sağlayan bir tane var.

CJam , 6 bayt (tam program) / 7 bayt (kod bloğu)

q),^W=

Çevrimiçi deneyin!

Giriş dizesini standart girdiden okuyan ve eksik harfi standart çıktıya basan tam bir CJam programıdır. CJam aslında zorluğun istediği şey olan “yöntemlere” sahip değildir, ancak en yakın şey muhtemelen şöyle bir çalıştırılabilir kod bloğu olacaktır:

{),^W=}

Çevrimiçi deneyin!

Bu kod bloğu değerlendirildiğinde, girişi yığın üzerinde bir dize (yani bir karakter dizisi) olarak alır ve eksik karakteri de yığına geri döndürür.

Açıklama: Tam programda, qgiriş dizesini okur ve yığına yerleştirir. )daha sonra giriş dizesinin son karakterini gösterir ve range operatörü ,onu, altında kod noktaları olan tüm karakterleri içeren bir diziye dönüştürür (alfabedeki tüm harfler de dahil). Bu durumda, örneğin, giriş ise cdfgh, o zaman sonra ),yığın dizileri içerecektir cdfg(yani son harfi ile giriş çıkarıldı) ve ...abcdefgburada, ...ASCII kod altında olan karakter bir grup anlamına gelira kaldırılan geçen giriş altında (yani, tüm karakterlerin mektup).

Simetrik küme farkı işleci ^daha sonra bu dizeleri, dizelerin birinde görünen ve her ikisinde de olmayan karakterleri içeren tek bir dizgede birleştirir. O kadar örnek girişi için, karakterler dizelerinde görünme sırasını korur cdfg, sonuç sonra ),^olacak ...abenerede, ...yine aşağıda ASCII kodları ile karakterlerin bir demet açılımı a. Son olarak, W=bu dizgenin son karakterini çıkarır, bu da tam eolarak bulmak istediğimiz eksik karakterdir (ve gerisini atar). Program sona erdiğinde, CJam yorumlayıcısı yığının içeriğini dolaylı olarak yazdırır.

Bonus: GolfScript , 6 bayt (tam program)

),^-1>

Çevrimiçi deneyin!

Neredeyse aynı kodun aynı zamanda GolfScript'te de çalıştığı ortaya çıktı. GolfScript'in örtük girişi nedeniyle tam program sürümünde bir bayt tasarruf ediyoruz, ancak CJam'dan farklı olarak GolfScript'in W-1 olarak başlatılan kullanışlı bir tek harf değişkenine sahip olmadığından bir bayt kaybediyoruz .

Ayrıca, CJam ayrı bir tamsayı ve karakter türlerine (ve dizeleri sadece karakter içeren dizilerdir) sahipken, GolfScript sadece tek bir tamsayı tipine sahiptir (ve normal dizilerden biraz farklı şekilde davranan özel bir dize türüne sahiptir). Tüm bunların sonucu olarak, GolfScript yorumlayıcısının ASCII kod numarası yerine gerçek eksik mektubu yazdırmasını istiyorsak, karakterin yerine tek karakterli bir dize döndürmemiz gerekir. Neyse ki, bu değişikliği burada yapmak sadece indeksleme operatörünün =dizi / string sol kesme operatörüyle değiştirilmesini gerektirir >.

Elbette, GolfScript'in gizli I / O özelliği sayesinde, yukarıdaki kod yığından bir dize okuyan ve eksik harfi içeren tek karakterli bir dize döndüren pasaj olarak da kullanılabilir. Veya daha doğrusu, yığında tek bir dize argümanı olarak alan ve çıktısını yığında yazdırılabilir bir dize olarak döndüren herhangi bir parçacık da tam bir GolfScript programıdır.

Kabuğu , 6 bayt

→S-(ḣ→

Çevrimiçi deneyin!

Bu işlev bir dize (karakter listesi) girdi olarak alır ve çıktı olarak bir karakter döndürür.

açıklama

→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 bayt

Mevcut python 2 çözümünü kaybeder, ancak biraz farklı bir yaklaşım bu yüzden yine de gönderebilirim:

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

8 , 99 bayt

gerekçe

Harfler arasındaki mesafe ikiden büyükse, o zaman eksik bir harf vardır. Harf mesafesi, her harfin ASCII kodu arasındaki fark hesaplanarak elde edilir.

kod

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

Ungolfed versiyonu

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

Kullanım ve örnekler

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 bayt

Bir dize olarak girdi alır.

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

Nasıl?

• Initialization: We start with n = 0 and p = 0 and call the recursive function 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

• Step #1: We increment n until c = String.fromCharCode(n) is equal to the first character of the input string s[0].

• Step #2: Now that we're synchronized, we increment both n and p at the same time until c = String.fromCharCode(n) is not equal to s[p] anymore.

• Step #3: We return c: the expected character which was not found.

Test cases

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 bytes

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

• a.e. boolean mask for the input letters across ascii charset
• 1 0 1&E. new boolean mask indicating if the sequence 101 begins at that index, ie, find any place a "skip" sequence begins
• I. the index of that match, ie, the character before the skipped one
• >: increment by 1, ie, the index of the skipped char within ascii charset
• {&a. pick that index from the ascii charset, ie, return the skipped char

Try it online!

ES6, 125 bytes:

(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

The returned function needs to be called with an array

(["a","c"])

one could save another 9 bytes through removing .join("") and passing a string:

("ac")

ES6, 108 bytes:

(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

Common Lisp, 88 bytes

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

Try it online!

Python 2, 69 bytes

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

Try it online!

Some explanations As we know the first and the last elements of the list, we can easily compute the sum of the codes of all the chars in the list + the missed char (using summary formulas of arithmetic progression). The difference between this sum and the sum of the codes of all the chars in the list gives the code of the missed letter.

05AB1E, 9 7 bytes

ǤÝsKçθ

Try it online!

APL (Dyalog), 17 bytes

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

Try it online!

⎕AV∘∊ Boolean: each character in the Atomic Vector (character set) member of the argument?

(…) apply the following tacit function:

 ⊃ the first element of

 ⎕AV the Atomic Vector (the character set)

 /⍨ which

 ∨\ follows the initial (member of the argument)

 ∧ but

 ~ is not (a member of the argument)