लापता पत्र का पता लगाएं

27

दिशा-निर्देश

कार्य

एक विधि लिखिए जो इनपुट के रूप में लगातार (बढ़ते) अक्षरों की एक सरणी लेती है और जो अनुपलब्ध अक्षर को सरणी में सूचीबद्ध करती है (कुछ भाषाओं में सूची)।

नियम

  • यह कोड गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है!
  • आपको हमेशा एक मान्य सरणी मिलेगी
  • हमेशा एक अक्षर गायब रहेगा
  • सरणी की लंबाई हमेशा कम से कम 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'

code-golf  array-manipulation  alphabet 
— Amorris
स्रोत
क्या मैं इसके बजाय एक स्ट्रिंग ले सकता हूं?
— लीक नून
@LeakyNun स्ट्रिंग्स वर्णों के सरणियाँ हैं, इसलिए हाँ।
— अमोरिस
1
क्या आउटपुट अनुपलब्ध वर्ण युक्त हो सकता है (उदाहरण: इनपुट ['a','b','c','d','f','g'], आउटपुट के लिए ['e'], यदि वह कोड को छोटा बनाता है?
— श्री Xcoder
1
@ Mr.Xcoder एक स्ट्रिंग पात्रों की एक सरणी है, इसलिए हां
— एमोरिस जूल
2
नियम चार बस नियम आठ का एक सबसेट है और इसे हटाया जा सकता है (कम से कम, यदि आप नियम आठ के अंत में "समावेशी" शब्द डालते हैं)।
— एनएच।

जवाबों:

11

सी # (.NET कोर) , 48 47 46 बाइट्स, चार सरणी के रूप में इनपुट

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण: सरणी में पहला तत्व बढ़ा हुआ है और साथ ही एक पॉइंटर निम्नलिखित तत्वों को पुनरावृत्त करता है। जब पहला तत्व और वर्तमान तत्व दोनों अलग-अलग होते हैं, तो यह पहला तत्व देता है।

सी # (.NET कोर) , 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);}

और आपके पास एक-लाइनर (45 + 18) -बाइट समाधान है:

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

और एक बहुत चालाक (37 + 18) -तत्कालीन समाधान, एडका के सौजन्य से:

s=>s.Select(e=>++e).Except(s).First()
— चार्ली
स्रोत
1
क्या यह सभी कोड रास्तों को वापस करने के साथ संकलित करने में विफल रहता है? लेकिन तुलना के लिए +1 s[i]-s[0], बहुत चालाक है!
— द लीथेलकोडर
@ TheLethalCoder यह विफल नहीं होगा क्योंकि forलूप की रोक स्थिति नहीं है, इसलिए जब तक ifस्थिति का मूल्यांकन नहीं किया जाता है , तब तक यह पुनरावृत्ति करता रहेगा true।
— चार्ली
1
आप इस तरह से 8 बाइट्स बचा सकते हैं: a=>{int i=0;for(;a[++i]-a[0]<=i;);return--a[i];}(जब आप इनपुट के रूप में लेते हैं char[])। मेरे btw के लिए धन्यवाद नहीं, मेरे जावा 8 उत्तर पर @ नवीन की टिप्पणी के लिए धन्यवाद ।
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन ने एक चार सरणी के रूप में इनपुट लेने वाले दो और बाइट्स को बचाने का एक तरीका पाया।
— चार्ली
1
शॉर्ट s=>s.Select(e=>++e).Except(s).First()
— लाइनक
8

ऐलिस , 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.
— मार्टिन एंडर
स्रोत
7

जावा 8, 70 57 56 48 46 बाइट्स

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

-14 (70 → 56) और -2 (48 → 46) बाइट्स @CarlosAlejo को धन्यवाद ।
-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
— केविन क्रूज़सेन
स्रोत
1
आप 8 बाइट्स को बचाने के लिए एक स्पष्ट डाली के बजाय एक निहित कलाकारों का उपयोग कर सकते हैं a->{int i=0;for(;a[++i]-a[0]<=i;);return--a[i];}।
— नेवले जूल
6

सी (जीसीसी) , ३३35 36 48 60 बाइट्स

सभी अनुकूलन को बंद कर दिया जाना चाहिए और केवल 32-बिट जीसीसी पर।

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

इनपुट को एक स्ट्रिंग के रूप में लें।

इसे ऑनलाइन आज़माएं!

— कीउ गण
स्रोत
2
"सभी अनुकूलन को बंद कर दिया जाना चाहिए और केवल 32-बिट जीसीसी पर।" यह कहने का एक बहुत ही गोल चक्कर वाला तरीका है (केवल यूबी के कारण काम करने के लिए प्रकट होता है)
— sehe
मैं कहता हूँ foo(char*a){return*a+1==a[1]?foo(a+1):++*a;}बहुत अच्छा है; अधिक प्राकृतिकfoo(char*a){while(*a+1==a[1])a++;return++*a;}
— sehe
पीपीसीजी पर @sehe निरंतर अपरिभाषित व्यवहार को स्वीकार्य माना जाता है
— गण
5

पायथन 3 , 74 62 58 44 40 बाइट्स

-12 बाइट्स एग्री टू द आउटकॉलफर। -18 बाइट्स लीक नन के लिए धन्यवाद। -4 बाइट्स Musicman523 के लिए धन्यवाद।

इनपुट को बाइटस्ट्रिंग के रूप में लेता है।

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

इसे ऑनलाइन आज़माएं!

एक और अच्छा समाधान:

lambda s:chr(*{*range(*s[::~-len(s)])}-{*s})
— totallyhuman
स्रोत
1
.difference({*s})->-{*s}
— आउटगोल्फ जूल
1
— लीकी नून
1
— लीकी नून
1
— संगीतज्ञ 523
1
आपका समाधान वह है जो मैं बाद में था, लेकिन बहुत अधिक सुरुचिपूर्ण तरीके से
— प्यूरफेरेट
4

मैथेमेटिका, 46 बाइट्स

Min@Complement[CharacterRange@@#[[{1,-1}]],#]&
— J42161217
स्रोत
मेरा मानना ​​है कि Min@Complement[CharacterRange@@#[[{1,-1}]],#]&इससे बाइट बच जाएगी।
— लीजनमोनियल 978
@ LegionMammal978 वास्तव में 2!
— J42161217
3

जावास्क्रिप्ट (ईएस 6), 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>
स्निपेट का विस्तार करें

— edc65
स्रोत
3

रेटिना , 33 25 बाइट्स

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

इसे ऑनलाइन आज़माएं! ASCII वर्णों की किसी भी सीमा के साथ काम करता है। संपादित करें: @MartinEnder के लिए 8 बाइट्स सहेजे गए। स्पष्टीकरण: पहला चरण इनपुट को डुप्लिकेट करता है। दूसरा कोड के सभी वर्णों को 1 कोड बिंदु से घटाता है। तीसरा चरण प्रतिलिपि के सभी पात्रों को हटा देता है जो अभी भी मूल में दिखाई देते हैं। यह सिर्फ मूल इनपुट को छोड़ता है, वह चरित्र जो मूल इनपुट के पहले चरित्र और छूटे हुए चरित्र से पहले है। अंतिम चरण तो बस गायब चरित्र से मेल खाता है।

— नील
स्रोत
यहाँ 25 है, एक ही मूल विचार का उपयोग कर: tio.run/##K0otycxL/P9fhevQNpV4rpCEgoT4ggQ9LRUulwQ9LsUEPZX///... (। मैं दूसरी पंक्ति decrementing रहा हूँ क्योंकि है कि एक बाइट की बचत होती है और उसके बाद मैं डिडुप्लीकेशन का उपयोग कर अद्वितीय चार खोजने हूँ)
— मार्टिन एंडर
@MartinEnder Deduplication बिल्कुल वही है जो मैं सबके साथ चाहता था, और मैं पहले ही भूल गया था कि यह रेटिना के पास है, ... (मुझे पता है कि पहली लाइन बढ़ाना दूसरी लाइन को घटाने से ज्यादा एक बाइट लेता है। इसने मैच रेगेक्स को छोटा कर दिया।)
— नील
3

एसडब्ल्यूआई प्रोलॉग, 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जारी है, और उम्मीद चरित्र प्रिंट आउट और खिड़की से बाहर कूद उम्मीद अगले आइटम से मेल खाती है, - तुलना करता है।

— जान ड्रोजेन
स्रोत
1
की तुलना में कम fail: 0=1।
— मैट
3

सी ++ 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;या इसी तरह ग्रहण किया जाएगा।

@ वीन के लिए धन्यवाद, प्रीप्रोसेसर की थोड़ी सी हैकिंग के साथ, आप इसे 82 बाइट्स (1 न्यूलाइन) तक ले जाते हैं

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

इसे देखें Live On Coliru

सी ++ 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[]उदाहरण के लिए

— sehe
स्रोत
आपको स्ट्राइक-आउट टेक्स्ट और अगले टेक्स्ट के बीच एक स्थान रखना होगा।
— सीजे डेनिस
@CJDennis पूरा किया। वैसे, आपका वर्तमान प्रतिनिधि (2469) एक सुंदर संख्या है (3 * 823 होने के साथ-साथ नेत्रहीन रूप से भी जोड़ा जाता है (24) (69) जो है (2 2 2 3) (3 23))
— sehe
2

चारकोल , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। एक स्ट्रिंग के रूप में इनपुट लेता है। ASCII वर्णों के लगभग किसी भी सन्निहित अनुक्रम के साथ काम करता है।

— नील
स्रोत
2

सी #, 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();
        }
    }
}
— TheLethalCoder
स्रोत
Ed'ka द्वारा एक बहुत ही चतुर Linq संस्करण :s=>s.Select(e=>++e).Except(s).First()
— चार्ली
@CarlosAlejo मैंने देखा कि आपने इसे अपने उत्तर में जोड़ दिया है, इसलिए मैं इसे अपडेट नहीं करूंगा, लेकिन हाँ यह बहुत चालाक है। यह करने के मेरे संस्करण की तुलना में बहुत कम है।
— TheLethalCoder
2

MATL, 8 7 बाइट्स

1 बाईट ने @Luis को धन्यवाद दिया

tdqf)Qc

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

      % 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
— Suever
स्रोत
@LuisMendo बहुत बढ़िया, धन्यवाद!
— स्वेवर
2

एक्सेल, 110 + 2 = 112 बाइट्स

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

एक सरणी सूत्र ( Ctrl+ Shift+ Enter) के रूप में दर्ज किया जाना चाहिए जो { }दो बाइट्स जोड़कर प्रत्येक छोर पर घुंघराले कोष्ठक जोड़ता है । इनपुट एक स्ट्रिंग के रूप में है A1, जो ओपी प्रति ओके है ।

यह अब तक का सबसे छोटा जवाब नहीं है (एक्सेल शायद ही कभी हो) लेकिन मुझे यह देखना पसंद है कि क्या यह किया जा सकता है।

— इंजीनियर टोस्ट
स्रोत
2

CJam , 6 बाइट्स (पूरा कार्यक्रम) / 7 बाइट्स (कोड ब्लॉक)

q),^W=

इसे ऑनलाइन आज़माएं!

यह एक पूर्ण सीजेएम प्रोग्राम है जो मानक इनपुट से इनपुट स्ट्रिंग को पढ़ता है और लापता पत्र को मानक आउटपुट पर प्रिंट करता है। CJam के पास वास्तव में "विधियाँ" नहीं हैं, जो कि चुनौती के लिए पूछती है, लेकिन निकटतम चीज़ संभवतः एक निष्पादन योग्य कोड ब्लॉक होगी, जैसे:

{),^W=}

इसे ऑनलाइन आज़माएं!

यह कोड ब्लॉक, जब मूल्यांकन किया जाता है, तो इनपुट को स्टैक पर स्ट्रिंग (यानी वर्णों की एक सरणी) के रूप में लिया जाता है, और लापता चरित्र को भी स्टैक पर लौटाता है।

स्पष्टीकरण: पूर्ण कार्यक्रम में, qइनपुट स्ट्रिंग को पढ़ता है और इसे स्टैक पर रखता है। )फिर इनपुट स्ट्रिंग के अंतिम वर्ण को पॉप करता है, और रेंज ऑपरेटर ,इसे एक सरणी में बदल देता है जिसमें सभी वर्ण होते हैं जिनके नीचे कोड बिंदु होते हैं (वर्णमाला में इसके पहले के सभी अक्षर सहित)। इस प्रकार, उदाहरण के लिए, यदि इनपुट था cdfgh, तो ),स्टैक के बाद स्ट्रिंग्स शामिल होंगे cdfg(यानी हटाए गए अंतिम अक्षर के साथ इनपुट) और ...abcdefg, जहां ...नीचे ASCII कोड वाले वर्णों का एक समूह है a(यानी हटाए गए अंतिम इनपुट के नीचे सभी वर्ण) पत्र)।

सममित सेट अंतर ऑपरेटर ^तब इन तारों को एक ही तार में जोड़ता है जिसमें बिल्कुल वही अक्षर होते हैं जो एक तार में दिखाई देते हैं, लेकिन दोनों में नहीं। यह उस क्रम को संरक्षित करता है जिसमें अक्षर तार में दिखाई देते हैं, इसलिए उदाहरण इनपुट के लिए cdfg, परिणाम के बाद ),^होगा ...abe, जहां ...फिर से नीचे ASCII कोड के साथ वर्णों का एक गुच्छा होता है a। अंत में, W=बस इस स्ट्रिंग के अंतिम चरित्र को निकालता है, जो वास्तव में गायब चरित्र है eजिसे हम ढूंढना चाहते थे (और बाकी को छोड़ देता है)। जब कार्यक्रम समाप्त होता है, सीजेएम दुभाषिया स्पष्ट रूप से स्टैक की सामग्री को प्रिंट करता है।

बोनस: GolfScript , 6 बाइट्स (पूरा कार्यक्रम)

),^-1>

इसे ऑनलाइन आज़माएं!

यह पता चला है कि लगभग समान कोड भी गोल्फस्क्रिप्ट में काम करता है। हम गोल्फस्क्रिप्ट के निहित इनपुट के कारण पूर्ण प्रोग्राम संस्करण में एक बाइट बचाते हैं, लेकिन एक बाइट खो देते हैं, क्योंकि सीजैम के विपरीत W, गोल्फस्क्रिप्ट में -1 के लिए एक एकल एकल अक्षर चर नहीं है।

इसके अलावा, CJam में अलग-अलग पूर्णांक और चरित्र प्रकार हैं (और तार केवल वर्ण युक्त सरणियाँ हैं), जबकि गोल्फस्क्रिप्ट में केवल एक पूर्णांक प्रकार है (और एक विशेष स्ट्रिंग प्रकार है जो सामान्य सरणियों से कुछ अलग व्यवहार करता है)। इन सबका परिणाम यह है कि, अगर हम चाहते हैं कि गोल्फस्क्रिप्ट दुभाषिया अपने ASCII कोड संख्या के बजाय वास्तविक लापता पत्र का प्रिंट आउट ले, तो हमें केवल चरित्र के बजाय एकल-वर्ण स्ट्रिंग को वापस करने की आवश्यकता है। सौभाग्य से, यहाँ उस बदलाव को बनाने के लिए बस अनुक्रमणिका ऑपरेटर =को सरणी / स्ट्रिंग बायीं ट्रंकेशन ऑपरेटर के साथ बदलने की आवश्यकता है >।

बेशक, GolfScript के निहित I / O के लिए धन्यवाद, ऊपर दिए गए कोड को एक स्निपेट के रूप में भी इस्तेमाल किया जा सकता है जो स्टैक से एक स्ट्रिंग पढ़ता है और एक एकल-वर्ण स्ट्रिंग देता है जिसमें लापता अक्षर होता है। या, बल्कि, कोई भी स्निपेट जो एक तर्क के रूप में स्टैक पर एक एकल स्ट्रिंग लेता है, और स्टैक पर एक प्रिंट करने योग्य स्ट्रिंग के रूप में अपना आउटपुट देता है, एक पूर्ण गोल्फस्क्रिप्ट प्रोग्राम भी है।

— इल्मरी करोनें
स्रोत
6
कोड स्निपेट को डिफ़ॉल्ट रूप से अनुमति नहीं है ; केवल कार्य और पूर्ण कार्यक्रम हैं। तो आपको शायद q(प्रोग्राम), या {...}(ब्लॉक) की आवश्यकता है। हालांकि दृष्टिकोण के लिए +1
— लुइस मेंडो
यह बहुत चालाक है!
— फलों के जूल
2

भूसी , 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

पायथन 2 - 76 बाइट्स

मौजूदा अजगर 2 समाधान के लिए खो देता है, लेकिन यह थोड़ा अलग दृष्टिकोण है तो मैंने सोचा कि मैं इसे वैसे भी पोस्ट करूंगा:

lambda c:[chr(x)for x in range(ord(c[0]),ord(c[0]+26)if chr(x)not in c][0]
— LangeHaare
स्रोत
2

8 वें , 99 बाइट्स

दलील

यदि अक्षरों के बीच की दूरी दो से अधिक है, तो एक लापता पत्र है। प्रत्येक पत्र के 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>
— अराजकता मनोर
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 64 बाइट्स

एक स्ट्रिंग के रूप में इनपुट लेता है।

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

कैसे?

  • प्रारंभ: हम n = 0 और p = 0 से शुरू करते हैं और पुनरावर्ती फ़ंक्शन को जी () कहते हैं ।

    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: हम तब तक एन वेतन वृद्धि करते हैं जब तक c = String.fromCharCode(n)इनपुट स्ट्रिंग s [0] के पहले चरित्र के बराबर न हो ।

  • चरण # 2: अब जब हम सिंक्रनाइज़ हो गए हैं, हम एन और पी दोनों को एक ही समय में बढ़ाते हैं, जब तक c = String.fromCharCode(n)कि एस [पी] के बराबर नहीं हो।

  • चरण # 3: हम वापसी सी : अपेक्षित चरित्र जो नहीं मिला था।

परीक्षण के मामलों

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
1

जे, 20 बाइट्स

{&a.>:I.1 0 1&E.a.e.
  • a.e. आसिकी चारसेट के इनपुट पत्रों के लिए बूलियन मास्क
  • 1 0 1&E.नए बूलियन मास्क से संकेत मिलता है कि यदि अनुक्रम 101उस सूचकांक पर शुरू होता है, अर्थात, किसी भी स्थान को "छोड़ें" अनुक्रम शुरू होता है
  • I. उस मैच का इंडेक्स, यानी कि पहले वाला पात्र
  • >: 1 से वृद्धि, यानी, एससीआई चारसेट के भीतर स्किप किए गए चार का सूचकांक
  • {&a. एससीआई चारसेट से उस इंडेक्स को चुनें, यानी स्किप किए गए चार को वापस करें

इसे ऑनलाइन आज़माएं!

— जोनाह
स्रोत
वह मुझे एक स्निपेट की तरह लगता है।
— आदम जूल
@ Adám यह एक tacit (बिंदु-मुक्त) शैली में लिखा गया है, जो मेरा मानना ​​है कि स्निपेट के विपरीत "फ़ंक्शन-जैसे" के रूप में गिना जाता है। जैसा कि सबसे अच्छा मैं बता सकता हूं, यह आपके एपीएल समाधान की तुलना में स्निपेट से अधिक नहीं है (लेकिन मुझे डायलाग नहीं पता है, इसलिए जो मैं नमक के दाने के साथ कहता हूं वह ले लो)।
— ज़गरेप
@ हाँ, यह इस अर्थ में है कि यह एक चर को नहीं सौंपा जा सकता है, लेकिन इसके दाईं ओर इनपुट मानता है। क्या यह कानूनी नहीं है? मैंने इसके बारे में कहीं पूछा था और कहा गया था कि यह ठीक है
— योना
एपीएल / जे / के के लिए मेरी समझ यह है कि कोड को एक नाम में रहने में सक्षम होना चाहिए, चाहे असाइनमेंट द्वारा या शरीर के रूप में एक स्पष्ट क्रिया / कार्य (हालांकि, स्पष्ट रूप में तब स्पष्ट इनपुट भी होना चाहिए)। स्निपेट वह कोड होता है जो वैरिएबल और / या लाइन में चिपकाने के लिए मान लेता है, लेकिन अपने दम पर खड़ा नहीं हो सकता।
— 15
@zgrep नहीं, यह कोड स्पष्ट (गैर-टैसिट) है, लेकिन इसके दाईं ओर के तर्क के संदर्भ को याद कर रहा है। मेरा एपीएल फ़ंक्शन एक पूर्ण टासिट फ़ंक्शन है जिसे एक कोष्ठक में रखा या रखा जा सकता है।
— एडम जूल
1

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"])

एक और 9 बाइट्स को हटाने के माध्यम से बचा सकता है .join ("") और एक स्ट्रिंग पास कर रहा है:

("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

— जोनास विल्म्स
स्रोत
1
बाँध ??? गोल्फ में?
— edc65
@ edc65 इसमें क्या गलत है? (क्षमा करें यदि यह n00b है, लेकिन यह मेरा पहला गोल्फ है :))
— जोनास विलम्स
@ edc65 लेकिन आप शायद सही हैं, इसे हटाकर 4 बाइट्स बचाए गए ...
— जोनास विल्म्स
a.join("")हो सकता हैa.join``
— user2428118
1

पायथन 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

— mdahmoune
स्रोत
1

05AB1E , 9 7 बाइट्स

ǤÝsKçθ

इसे ऑनलाइन आज़माएं!

— आउटग्रॉफर को एरिक करें
स्रोत
मुझे लगता है 2कि हम एक ही एल्गोरिथ्म का उपयोग कर रहे हैं, भले ही मैं 05AB1E को शायद ही जानता हूँ:
— लीक नून
@ LeakyNun अच्छा है, मैंने एल्गोरिथ्म के बारे में भी सोचा है ...
— एरिक आउटगॉल्फ
मैंने अभी-अभी अपना एल्गोरिथ्म बदला है।
— लीक नून
@LeakyNun यह 05AB1E किसी भी रास्ते में लंबा होगा।
— एरिक आउटगॉल्फ जूल
मैंने सिर्फ एक और एल्गोरिथ्म के बारे में सोचा , जिसमें 2 शामिल हैं , आपका हो सकता है ...
— लीक
1

एपीएल (डायलॉग) , 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

⎕AV∘∊ बुलियन: ए टोमिक वी एक्टर (कैरेक्टर सेट) में प्रत्येक चरित्र तर्क का सदस्य?

(… ) निम्नलिखित टैसिट फ़ंक्शन लागू करें:

 ⊃ का पहला तत्व

 ⎕AVएक टॉमिक वी Ector (वर्ण सेट)

 /⍨ कौन कौन से

 ∨\ प्रारंभिक (तर्क का सदस्य)

 ∧ परंतु

 ~ है (तर्क का सदस्य)

— एडम
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.