दो अक्षरों के बीच का अक्षर

Question

एक प्रोग्राम लिखें जो एकल लोअरकेस शब्द को इनपुट के रूप में स्वीकार करता है और उन अक्षरों के जोड़े की संख्या को आउटपुट करता है, जिनके बीच वर्णमाला के समान अक्षरों की संख्या होती है।

उदाहरण के लिए, 'प्रकृति' शब्द में, हमारे पास 4 जोड़े हैं:

• nr: चूंकि शब्द के अंदर उनके बीच तीन अक्षर हैं (a, t, u) और उनके बीच तीन अक्षर (o, p, q)
• ae: चूंकि शब्द के अंदर उनके बीच तीन अक्षर हैं (t, u, r) और उनके बीच के तीन अक्षर (b, c, d)
• tu: चूंकि शब्द के अंदर उनके बीच कोई अक्षर नहीं हैं और वर्णमाला में उनके बीच कोई अक्षर नहीं है
• tr: चूंकि शब्द (यू) के अंदर उनके बीच एक अक्षर है और वर्णमाला (ओं) में उनके बीच एक अक्षर है

चूंकि चार जोड़े हैं, इसलिए इस मामले में आउटपुट 4 होना चाहिए।

Comments

शब्दांकन को थोड़ा और स्पष्ट किया जा सकता है।

— ऑप्टिमाइज़र

मुझे सवाल नहीं आता। अक्षर a , t , u , nr के अंदर कैसे होंगे? और सभी निम्नलिखित उदाहरण ... (cc @flodel)

— nicael

यदि आप प्रकृति को देखते हैं, तो n और r पहले और 5 वें स्थान पर हैं। इसलिए उनके बीच तीन अक्षर हैं। वे 2, 3 और 4 वें स्थान पर ए, टी और यू हैं। यही शब्द के अंदर n और r के बीच तीन अक्षर होते हैं ।

— फ्लोडेल

@flodel आप संपादन में सही हैं; मुझे चौथी जोड़ी याद आ गई।

— भूत_न_थे_कोड

अगर शब्द होते तो क्या होता rjjjnfffr? क्या वह एक जोड़ी ( nr) या दो जोड़ी ( nrऔर rn) होगी? और किस बारे में abzab? वह दो जोड़ी है abया एक?

— नहीं कि

Answer 1

पायथ, 19 बाइट्स

lfqF-MSMCT.cCUBCMz2

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

lfqF-MSMCT.cCUBCMz2
                 z   read a string from input
               CM    convert into list of ascii-values
            CUB      create a list of pairs (ascii-value, index in string)
          .c      2  all combinations of length 2
 f                   filter for combinations T, which satisfy:
        CT              transpose T ((ascii1, ascii2), (index1, index2)
      SM                sort each list
    -M                  create the the difference for each
  qF                    check if they are equal
l                    print the number of remaining combinations

Answer 2

आर, 110 बाइट्स

function(s){w=strsplit(s,"")[[1]]
O=outer
n=nchar(s)
sum(abs(O(r<-match(w,letters),r,"-"))==O(1:n,1:n,"-"))-n}

Degolfed:

F = function(s){
   chars = strsplit(s,"")[[1]]
   num_chars = nchar(s)
   letter_rank = match(chars, letters)
   rank_dist = abs(outer(letter_rank, letter_rank, "-"))
   position_dist = outer(1:num_chars, 1:num_chars, "-")
   return(sum(rank_dist == position_dist) - num_chars)
}

F("nature")
# [1] 4
F("supercalifragilisticexpialidocious")
# [1] 25

Answer 3

ऑक्टेव, 41 बाइट्स

@(s)nnz(abs(s-s')==(t=1:(u=nnz(s)))-t')-u

Answer 4

CJam, 36 बाइट्स

r:A,{)Aew}%1>{{:B,B0=BW=-z)=}%}%e_:+

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

Answer 5

जे, 27 बाइट्स

#-:@-~#\+/@,@:=&(|@-/~)3&u:

उपयोग:

   (#-:@-~#\+/@,@:=&(|@-/~)3&u:) 'nature'
4

स्पष्टीकरण:

#-:@-~#\+/@,@:=&(|@-/~)3&u:
      #\                    lengths of input prefixes (1,2,...,length)
                       3&u: codepoints of input
               &(     )     with the last two do parallel:
                 |@-/~      create difference table with itself and take absolute values
              =             compare the elements of the two difference tables
        +/@,@:              sum the table              
#   -~                      subtract the length of the input (self-similar letters)
 -:@                        half the result (each pair was accounted twice)

इसे यहाँ ऑनलाइन आज़माएँ।

Answer 6

सीजेएम, 25 बाइट्स

l:T,_2m*{_:-\Tf=:-z=},,\-

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

स्पष्टीकरण:

l     Get input.
:T    Store in variable T for later use.
,     Calculate length.
_     Copy for use at the very end.
2m*   Use Cartesian power to calculate all possible position pairs.
{     Start filter.
  _     Create copy of index pair.
  :-    Calculate difference between indices.
  \     Swap copy of index pair to top.
  T     Get input string stored in variable T.
  f=    Extract the letters for the index pair.
  :-    Calculate difference of the two letters.
  z     Take the absolute value.
  =     Compare index difference and letter difference.
},    End filter.
,\
-     Pairs of identical indices passed the filter. Eliminate them from the
      count by subtracting the length of the input.

Answer 7

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

f=w=>(p=0,q="charCodeAt",[...w].map((c,a)=>{for(b=a;w[++b];)p+=Math.abs(w[q](a)-w[q](b))==b-a}),p)

प्रयोग

f("nature")
=> 4

व्याख्या

f=w=>(
  p=0,                                 // p = number of pairs
  q="charCodeAt",
  [...w].map((c,a)=>{                  // iterate through each character of input
                                       // a = character A index
    for(b=a;w[++b];)                   // iterate through the remaining input characters
                                       // b = character B index
      p+=                              // add 1 to p if true or 0 if false
        Math.abs(w[q](a)-w[q](b))==b-a // compare absolute difference of character codes
                                       //     to difference of indices
  }),
  p                                    // return p
)

Answer 8

पायथन 2, 91 वर्ण

lambda i:sum(y-x==abs(ord(i[y])-ord(i[x]))for x in range(len(i))for y in range(x+1,len(i)))

Answer 9

MATLAB, 84 बाइट्स

s=input('');disp(sum(diff(nchoosek(find(s),2),[],2)==abs(diff(nchoosek(s,2),[],2))))

यह लाइन इनपुट के रूप में स्ट्रिंग मांगती है। यह तब सभी संभावित अक्षरों को बनाता है और उनके संबंधित सूचकांकों के लिए भी यही करता है। फिर हम यह निर्धारित करते हैं कि मूल्यों का अंतर (पूर्ण) अंतर उन सभी मामलों को समेटने के लिए है जहां यह होता है। परिणाम कमांड विंडो में प्रदर्शित होता है।

Answer 10

जावास्क्रिप्ट ES7, 93

सरणी समझ का उपयोग करना । ES6 के साथ .map.map.map2 बाइट्स लंबा है।

फ़ायरफ़ॉक्स के साथ नीचे स्निपेट का परीक्षण करें

f=s=>[for(x of s)x.charCodeAt()].map((a,i,s)=>s.map((b,j)=>t+=j>i&(b>a?b-a:a-b)==j-i),t=0)&&t

document.write('nature'+'\n'+f('nature'))

Answer 11

पॉवरशेल, 114 100 बाइट्स

param($a)$b=$a.length;0..($b-1)|%{$i=$_;($_+1)..$b|%{$o+=[math]::Abs(+$a[$_]-$a[$i])-eq($_-$i)}};+$o

बहुत सीधे-सीधे, लेकिन एक जोड़े की चाल का उपयोग करता है।

• param(..)हमारा इनपुट लेता है, उसे सहेजता है $a।
• हम एक अस्थायी चर सेट $bहोने के लिए .lengthहमारे इनपुट के। यह बाद में बाइट बचाता है।
• 0..($b-1)|%{..}एक for($i=0;$i-le($b-1);$i++){..}लूप के बराबर है , लेकिन काफी छोटा है।
• हालाँकि, हमें वेरिएबल सेट करने की आवश्यकता है $iताकि इसे चालू रखा जा सके ...
• ($_+1)..$b|%{..}अगले forलूप के बाद $_से केवल आंतरिक लूप के लिए स्थिति है।
• हम जाँच करने के लिए एक लंबी .NET .NET कॉल का उपयोग करते हैं कि क्या हमारे दो पात्रों के बीच निरपेक्ष मूल्य (यहाँ हम +बाइट्स के एक गुच्छा को बचाने के लिए prepending के साथ अंतर्निहित कास्टिंग का उपयोग करते हैं ) -eqसरणी में स्थितीय अंतर के लिए ual है। चूंकि हमें स्पष्ट रूप से लोअरकेस इनपुट दिया गया है, इसलिए हमें केस रूपांतरण करने की आवश्यकता नहीं है। यह बयान या तो वापस आ जाएगी Trueया False।
• हम उस परिणाम को जमा करने के लिए फिर से अंतर्निहित कास्टिंग का दुरुपयोग करते हैं $o, इसलिए True1 जोड़ देंगे, जबकि False0 जोड़ देगा।
• एक बार छोरों के समाप्त होने के बाद, हम आउटपुट करते हैं $o। ध्यान दें कि अगर मैच नहीं होते थे तो हमें +प्रिंटिंग से बचने के लिए एक ही ट्रिक-कास्ट-टू-इंट करने की जरूरत थी False।

Answer 12

रूबी, 74

 ->s{[*0...s.size].permutation(2).count{|i,j|(s[i].ord-s[j].ord).abs==j-i}}

यहां कुछ भी दिलचस्प नहीं है। मैं उपयोग करने के लिए प्यार होता eval("s[i].#{["succ"]*(j-i)*?.}")... लेकिन बहुत लंबा लग रहा था।

Answer 13

मैटलैब(94)(80)

संपादित करें: मैंने 'प्रकृति' में (t, r) के रूप में, वर्णनात्मक क्रम के उलट होने की स्थिति में, इसलिए अधिक वजन के लिए अधिक बाइट्स :(

@(a)sum(arrayfun(@(x)sum(1:nnz(find(a==fix(x/2)+(-1)^x*(1:1:nnz(a))))-1),2:244))

---

• द्विपदीय कार्य एक मूर्ख अपवाद को फेंक देता है जब k n से बड़ा होता है और मैं arraycellकार्य के अंदर अपवादों को पकड़ नहीं पाता, अन्यथा मैं इसे और अधिक फुला सकता था। कौन एक समारोह में निर्मित की जरूरत है ??

  अब मैं इसे केवल हाथ से कर सकता था, द्विपद (n, 2) = n / (2 (n-2)!) = N (n-1) / 2 को सरल बनाता था। टिप्पणी करते हैं कि यह अंतिम मान 1 से n-1 तक पूर्णांकों का योग है, यह गणित गणित के किसी भी अपवाद को नहीं छोड़ता है, भगवान आशीर्वाद गणित।

• पीएस: इस विधि slvrbld की तुलना में अलग है

क्रियान्वयन

  >> ans('abef')

  ans =

       2

  >> ans('abcd')

  ans =

       6

  >> ans('nature')

  ans =

       4

Comments

मुझे लगता है कि इसे हटाने के लिए सुरक्षित है , 'एस' इनपुट से () का तर्क। आपको 4 बाइट बचाता है। इसके अलावा, यह लंबे समय तक तार (जैसे 'सुपरकैलिफ्रैग्लिसिटिसपियालिडोसियस' पर फेल होता है जो कि टेस्ट केस के रूप में इस्तेमाल किया जाता है) हार्डकोड के लिए लूप रेंज के कारण होता है ... आप इसे ठीक करना चाह सकते हैं।

— slvrbld

@slvrbld मुझे नहीं लगता कि मुझे इसकी आवश्यकता है, नवीनतम संपादन देखें

— Abr001am