27

इस चुनौती में, आपको दो शब्द दिए गए हैं: आपका काम यह निर्धारित करना है कि क्या वे आसन्न हैं ।

दो अक्षर समीप हैं यदि:

वे एक ही अक्षर हैं, या
वे शाब्दिक रूप से आसन्न हैं।

उदाहरण के लिए, J केवल I , J और K के निकट है । Z , A से सटा नहीं है

दो शब्द समीप हैं यदि:

वे एक ही लंबाई के हैं, और
प्रत्येक अक्षर दूसरे शब्द में एक अद्वितीय अक्षर के समीप है।

उदाहरण के लिए, कैट SAD के निकट है , C> D, A> A, T> S के रूप में । जीआरआरडी के पास
मुफ़्त नहीं है (प्रत्येक ई को जोड़ी के लिए एक पत्र की आवश्यकता है) ।

इनपुट आउटपुट

आपको दो तार दिए गए हैं, और यदि वे आसन्न हैं, तो आपको एक सत्य मान वापस करने की आवश्यकता है, अन्यथा एक मिथ्या मूल्य। नीचे दिए गए सभी परीक्षण मामलों के लिए आपको एक मिनट के भीतर वापस आ जाना चाहिए।

आप यह मान सकते हैं कि स्ट्रिंग्स में केवल अपरकेस, अल्फाबेटिक अक्षर होंगे।

दो तारों को एक सूची के रूप में पारित किया जा सकता है, या अवतरण किया जा सकता है, उद्धरण के साथ या बिना।

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

Truthy:

A A
A B
C B
DD CE
DE FC
ABCD BCDE
AACC DBBB
DJENSKE FDJCLMT
DEFGHIJKL HJLEHMCHE
IKLIJJLIJKKL LJLJLJLJLJHI
ACEGIKMOQSUWY BLNPRDFTVHXJZ
QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP
ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS

Falsy:

A C
A Z
B J
JK J
CC BA
CE D
DJENSKE GDJCLMT
DEFGHIJKL HJLHMCHE
IJKLIJKLKIJL LIJLLHJLJLLL 
AWSUKMEGICOQY RSHXBLJLNQDFZ
QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT
ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS

यह कोड-गोल्फ है , इसलिए सबसे कम वैध उत्तर जीतता है!

code-golf sequence decision-problem

— नाथन मेरिल
स्रोत

क्या इनपुट के आसपास उनके जैसे उद्धरण हो सकते हैं "A A"?

— तन्माथ

निश्चित परीक्षण के मामले। उद्धरण ठीक हैं।

— नाथन मेरिल

क्या इनपुट केवल अपरकेस होगा?

— तन्माथ

आप मान सकते हैं कि, हाँ।

— नाथन मेरिल

मुझे लगता है कि आपको चुनौती पाठ में उल्लेख करना चाहिए कि आप उद्धरण के साथ इनपुट स्ट्रिंग को परिभाषित करने की अनुमति देते हैं। क्या फॉर्म का एक भी सरणी {'string1' 'string2'}स्वीकार्य होगा?

— लुइस मेंडो

11

CJam, 14 13 12 बाइट्स

r$r$.-:)3,-!

इसे ऑनलाइन आज़माएं! या एक ही बार में सभी परीक्षण मामलों को सत्यापित करें ।

कलन विधि

बता दें कि s और t एक ही लंबाई के दो छांटे गए शब्द हैं। के लिए रों और टी कोषगत आसन्न होने के लिए (ला), यह आवश्यक और पर्याप्त है कि अपनी इसी पात्रों के सभी जोड़े भी ला रहे हैं।

हालत स्पष्ट रूप से सभी शब्दों के लिए पर्याप्त है, और लंबाई 1 के शब्दों के लिए आवश्यक है ।

अब, मान लें कि s और t की लंबाई n> 1 है , और a और b पहले अक्षर हैं, s और t का सम्मान करें ।

चूंकि रों और टी ला रहे हैं, वहाँ कुछ द्विभाजित मानचित्रण है φ के पात्रों के बीच रों और के पात्रों टी ऐसी है कि एक्स और φ (x) सभी के लिए ला रहे हैं एक्स में रों , जिसका अर्थ है कि | x - φ (एक्स) | ≤ 1 सभी के लिए एक्स में रों ।

आज्ञा देना c = φ (a) और d = φ ^-1 (b) । वजह से एक की और ख के minimality, एक ≤ घ (1) और ख ≤ सी (2) ।

इसके अलावा, बी और डी के बाद से , और ए और सी , और एलए, डी 1 बी + 1 (3) और सी (ए + 1 (4) ।

(1) और (3) , और (2) और (4) के संयोजन से , हमें यह पता चलता है कि ≤ d b b + 1 और b ≤ c 1 a + 1 है , जिसमें से हम घटाते हैं कि a - 1 ≤ b and a + 1 और इसलिए, कि ए और बी एलए हैं।

अब, (1) और (4) , और (2) और (3) को मिलाकर , हम उस c - 1 ≤ a ≤ d और d - 1 ≤ b , c प्राप्त करते हैं , जिससे हम उस c - 1 1 d को घटाते हैं। ≤ c + 1 और, इसलिए कि c और d LA हैं।

इस प्रकार, हम फिर से परिभाषित करता है, तो φ द्वारा φ (क) = ख और φ (घ) = सी , | x - φ (एक्स) | ≤ 1 अभी भी सभी x को s में और विशेष रूप से, सभी x के लिए s [1:] में रखेगा ।

इस तरह, s [0] = a और t [0] = b , और s [1:] और t [1:] , LA हैं।

चूँकि s [1:] की लंबाई n - 1 है , यह प्रेरण द्वारा आवश्यकता को सिद्ध करता है।

कोड

r               e# Read the first word from STDIN.
 $              e# Sort its characters.
  r             e# Read the second word from STDIN.
   $            e# Sort its characters.
    .-          e# Perform vectorized subtraction.
                e# This pushes either the difference of char codes of two
                e# corresponding characters or a character that has no does not
                e# correspond to a character in the other, shorter word.
      :)        e# Increment all results.
                e# In particular, this maps [-1 0 1] to [0 1 2].
        3,      e# Push the range [0 1 2].
          -     e# Perform set difference, i.e., remove all occurrences of 0, 1 and
                e# 2 from the array of incremented differences.
           !    e# Apply logical NOT. This gives 1 iff the array was empty iff
                e# all differences gave -1, 0 or 1.

— डेनिस
स्रोत

मुझे लगता है कि एक सरल तर्क है - केवल एक ही स्थान पर मिलान करने से क्रमबद्ध क्रम का उल्लंघन हो सकता है जब दो चीजें जैसे पार हो जाती हैं C->Y, D->X, और वे सिर्फ अनसोल्ड हो सकते हैं।

— xnor

@xnor मूल रूप से मैंने जो लिखा है। बस एक बहुत अधिक शब्दों के साथ। : पी

— डेनिस

4

MATL , 10 12 17 बाइट्स

c!S!odXl2<

यह डेनिस के दृष्टिकोण का उपयोग करता है : पहले क्रमबद्ध करें और मिलान स्थितियों में पात्रों की तुलना करें।

इनपुट स्ट्रिंग्स की एक सरणी है, प्रारूप के साथ {'CAT 'SAD'}।

आउटपुट शून्य और लोगों की एक सरणी है। एक परिणाम सत्य है यदि इसमें सभी शामिल हैं (यह सत्य होने के लिए सहमत है)।

वर्तमान रिलीज़ (10.2.1) का उपयोग करता है , जो इस चुनौती से पहले है।

संपादित करें: भाषा के नए संस्करणों में फ़ंक्शन Xlका नाम बदल दिया गया है |(और oअब आवश्यक नहीं है)। नीचे दिए गए लिंक में वे संशोधन शामिल हैं।

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

स्पष्टीकरण :

c         % implicitly cell array of strings and convert to 2D char array. 
          % This pads with spaces if needed
!S!       % sort each row
o         % convert array from char to double
d         % difference between elements in the same column
Xl        % absolute value of each entry
2         % number literal
<         % each entry becomes 1 if smaller than 2 (adjacent letters), and 0 otherwise

पुराना दृष्टिकोण, जो स्ट्रिंग्स को अलग इनपुट के रूप में स्वीकार करता है: 12 बाइट्स :

SiSXhcodXl2<

संपादित करें : लिंक के कोड को भाषा में परिवर्तनों को दर्ज करते हुए संशोधित किया गया है; ऊपर टिप्पणी देखें।

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

स्पष्टीकरण :

S         % implicitly input first string and sort
iS        % input second string and sort
Xh        % build cell array with these two strings
c         % convert to 2D char array. This pads with spaces if needed
o         % convert array from char to double
d         % difference between elements in the same column
Xl        % absolute value of each entry
2         % number literal
<         % each entry becomes 1 if smaller than 2 (adjacent letters), and 0 otherwise

— लुइस मेंडो
स्रोत

1

इसलिए [1 0 1]MATL में सरणी गलत है। यह उपयोगी है।

— डेनिस

@ डेनिस अन्य भाषाओं में भी गलत नहीं है? मतलाब / ऑक्टेव में यह इस तरह से काम करता है: सभी तत्वों को

— नॉनजरो

1

नहीं, वास्तव में, मैं इस तरह से व्यवहार करने वाली दूसरी भाषा नहीं जानता। पायथन और CJam में, उदाहरण के लिए, सरणियाँ सत्य हैं यदि वे गैर-खाली हैं। जावास्क्रिप्ट और रूबी में, उदाहरण के लिए, सभी सरणियाँ सत्य हैं।

— डेनिस

@ डेनिस मेरे सोचने के तरीके से अजीब है। तो अजगर में एक सरणी [0 0]सत्य है?

— लुइस मेंडो

1

हां, क्योंकि इसकी सकारात्मक लंबाई है। यह आमतौर पर कष्टप्रद है जब गोल्फ।

— डेनिस

2

सी, 233 बाइट्स

#include <stdlib.h>
#include <string.h>
#define h char
#define r return
int c(void*a,void*b){r*(h*)a-*(h*)b;}int a(h*s,h*t){int l=strlen(s),m=strlen(t);if(l!=m)r 0;qsort(s,l,1,c);qsort(t,m,1,c);while(l--)if(abs(s[l]-t[l])>1)r 0;r 1;}

आप इसे adj.hइस adj.cफ़ाइल का उपयोग करके सहेज सकते हैं और फिर इसका परीक्षण कर सकते हैं :

#include <stdio.h>
#include "adj.h"

int main() {
  char aa[] = "A", A[] = "A";
  char b[] = "A", B[] = "B";
  char cc[] = "C", C[] = "B";
  char d[] = "DD", D[] = "CE";
  char e[] = "DE", E[] = "FC";
  char f[] = "ABCD", F[] = "BCDE";
  char g[] = "AACC", G[] = "DBBB";
  char hh[] = "DJENSKE", H[] = "FDJCLMT";
  char i[] = "DEFGHIJKL", I[] = "HJLEHMCHE";
  char j[] = "IKLIJJLIJKKL", J[] = "LJLJLJLJLJHI";
  char k[] = "ACEGIKMOQSUWY", K[] = "BLNPRDFTVHXJZ";
  char l[] = "QQSQQRRQSTTUQQRRRS", L[] = "PQTTPPTTQTPQPPQRTP";
  char m[] = "ELKNSDUUUELSKJFESD", M[] = "DKJELKNSUELSDUFEUS";
  char n[] = "A", N[] = "C";
  char o[] = "A", O[] = "Z";
  char p[] = "B", P[] = "J";
  char q[] = "JK", Q[] = "J";
  char rr[] = "CC", R[] = "BA";
  char s[] = "CE", S[] = "D";
  char t[] = "DJENSKE", T[] = "GDJCLMT";
  char u[] = "DEFGHIJKL", U[] = "HJLHMCHE";
  char v[] = "IJKLIJKLKIJL", V[] = "LIJLLHJLJLLL";
  char w[] = "AWSUKMEGICOQY", W[] = "RSHXBLJLNQDFZ";
  char x[] = "QQSQQRRQSTTUQQQRRS", X[] = "PQTTPPTTQTPQPPQRTT";
  char y[] = "ELKNSDUVWELSKJFESD", Y[] = "DKJELKNSUELSDUFEUS";
  char *z[] = {aa,b,cc,d,e,f,g,hh,i,j,k,l,m,n,o,p,q,rr,s,t,u,v,w,x,y};
  char *Z[] = {A ,B,C ,D,E,F,G,H ,I,J,K,L,M,N,O,P,Q,R ,S,T,U,V,W,X,Y};

  for(int _=0;_<25;_++) {
    printf("%s %s: %s\r\n", z[_], Z[_], a(z[_], Z[_]) ? "true" : "false");
  }

  return 0;
}

फिर संकलन का उपयोग करें gcc adj.c -o adj। आउटपुट है:

A A: true
A B: true
C B: true
DD CE: true
DE CF: true
ABCD BCDE: true
AACC BBBD: true
DEEJKNS CDFJLMT: true
DEFGHIJKL CEEHHHJLM: true
IIIJJJKKKLLL HIJJJJJLLLLL: true
ACEGIKMOQSUWY BDFHJLNPRTVXZ: true
QQQQQQQRRRRRSSSTTU PPPPPPPQQQQRTTTTTT: true
DDEEEFJKKLLNSSSUUU DDEEEFJKKLLNSSSUUU: true
A C: false
A Z: false
B J: false
JK J: false
CC AB: false
CE D: false
DEEJKNS CDGJLMT: false
DEFGHIJKL HJLHMCHE: false
IIIJJJKKKLLL HIJJJLLLLLLL: false
ACEGIKMOQSUWY BDFHJLLNQRSXZ: false
QQQQQQQQRRRRSSSTTU PPPPPPQQQQRTTTTTTT: false
DDEEEFJKKLLNSSSUVW DDEEEFJKKLLNSSSUUU: false

— पैट्रिक रॉबर्ट्स
स्रोत

2

पायथन 2, 90 बाइट्स

lambda A,B:all(ord(b)-2<ord(a)<ord(b)+2for a,b in zip(sorted(A),sorted(B)))*len(A)==len(B)

साधारण अनाम फ़ंक्शन, मुझे लंबाई के लिए एक अलग जांच zipकरनी होगी क्योंकि सिर्फ आकस्मिक होगा। इसमें एक समान कार्य होता है itertools( zip_longest) जो खाली तारों को खींच देगा, लेकिन यह काफी महंगा होगा।

के साथ परीक्षण

f=lambda A,B:all(ord(b)-2<ord(a)<ord(b)+2for a,b in zip(sorted(A),sorted(B)))*len(A)==len(B)

for case in testCases.split('\n'):
    print case, f(*case.split())

पैदा करता है:

A A True
A B True
C B True
DD CE True
DE FC True
ABCD BCDE True
AACC DBBB True
DJENSKE FDJCLMT True
DEFGHIJKL HJLEHMCHE True
IKLIJJLIJKKL LJLJLJLJLJHI True
ACEGIKMOQSUWY BLNPRDFTVHXJZ True
QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP True
ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS True
A C False
A Z False
B J False
JK J False
CC BA False
CE D False
DJENSKE GDJCLMT False
DEFGHIJKL HJLHMCHE False
IJKLIJKLKIJL LIJLLHJLJLLL  False
AWSUKMEGICOQY RSHXBLJLNQDFZ False
QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT False
ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS False

— wnnmaw
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 86 90 94

4 बाइट्स संपादित करें thx @Neil को सहेजें
2 संपादित करें 4 बाइट्स सहेजें thx @ Mwr247

(a,b)=>[...[...a].sort(),0].every((x,i)=>parseInt(x+([...b].sort()[i]||0),36)%37%36<2)

नोट: पत्रों की एक जोड़ी पर आसन्न जाँच। जोड़े को आधार 36 नंबर n के रूप में लें , यदि अक्षर समान हैं, तो n = a*36+a = a*37। अगर 1 का अंतर है तो n = a*36+a+1 = a*37+1या n = a*36+a-1 = a*37-1। तो n % 370, 1 या 36 n%37%36होना चाहिए । और 0 या 1 होना चाहिए।

नोट 2: जोड़ा गया '0' का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि ए और बी एक ही लंबाई के हैं। यह तब छोटा होता हैa.length==b.length

F=(a,b)=>[...[...a].sort(),0].every((x,i)=>parseInt(x+([...b].sort()[i]||0),36)%37%36<2)

console.log=x=>O.textContent+=x+'\n';

testOK=[['A','A'],['A','B'],['C','B'],['DD','CE'],['DE','FC'],
['ABCD','BCDE'],['AACC','DBBB'],['DJENSKE','FDJCLMT'],
['DEFGHIJKL','HJLEHMCHE'],['IKLIJJLIJKKL','LJLJLJLJLJHI'],
['ACEGIKMOQSUWY','BLNPRDFTVHXJZ'],
['QQSQQRRQSTTUQQRRRS','PQTTPPTTQTPQPPQRTP'],
['ELKNSDUUUELSKJFESD','DKJELKNSUELSDUFEUS']];
testFail=[['A','C'],['A','Z'],['B','J'],['JK','J'],['CC','BA'],['CE','D'],
['DJENSKE','GDJCLMT'],['DEFGHIJKL','HJLHMCHE'],
['IJKLIJKLKIJL','LIJLLHJLJLLL',''],
['AWSUKMEGICOQY','RSHXBLJLNQDFZ'],
['QQSQQRRQSTTUQQQRRS','PQTTPPTTQTPQPPQRTT'],
['ELKNSDUVWELSKJFESD','DKJELKNSUELSDUFEUS']];

console.log('TRUE')
testOK.forEach(t=>{
  var a=t[0],b=t[1],r=F(a,b)
  console.log(r+' '+a+' '+b)
})  
console.log('FALSE')
testFail.forEach(t=>{
  var a=t[0],b=t[1],r=F(a,b)
  console.log(r+' '+a+' '+b)
})

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

मुझे लगता है कि आप ''पहले के स्थान पर उपयोग कर सकते हैं '0'क्योंकि यह पार्स के मूल्य को नहीं बदलता है।

— नील

@ सही, और फिर से सोच यह और भी अच्छा है। मैं संख्यात्मक 0 और 0. का उपयोग कर सकता हूं। जब स्ट्रिंग को जोड़ते हैं तो वैसे भी यह एक स्ट्रिंग बन जाता है, और संख्यात्मक 0 + 0 अभी भी 0 मॉड है जो भी हो

— edc65

मेरा मानना है कि आप bचरित्र संदर्भ के साथ अपनी तरह का पतन कर सकते हैं : (a,b)=>[...[...a].sort(),0].every((x,i)=>parseInt(x+([...b].sort()[i]||0),36)%37%36<2)= 86 बाइट्स

— Mwr247

@ Mwr247 चतुर। धन्यवाद

— edc65

1

जावास्क्रिप्ट ईएस 6, 117 बाइट्स 116 बाइट्स 111 बाइट्स 109 बाइट्स

(j,k)=>j.length==k.length&&(f=s=>[...s].sort())(j).every((c,i)=>Math.abs(c[h='charCodeAt']()-f(k)[i][h]())<2)

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

a=(j,k)=>j.length==k.length&&(f=s=>[...s].sort())(j).every((c,i)=>Math.abs(c[h='charCodeAt']()-f(k)[i][h]())<2);
// true
console.log('A A:', a('A', 'A'));
console.log('A B:', a('A', 'B'));
console.log('C B:', a('C', 'B'));
console.log('DD CE:', a('DD', 'CE'));
console.log('DE FC:', a('DE', 'FC'));
console.log('ABCD BCDE:', a('ABCD', 'BCDE'));
console.log('AACC DBBB:', a('AACC', 'DBBB'));
console.log('DJENSKE FDJCLMT:', a('DJENSKE', 'FDJCLMT'));
console.log('DEFGHIJKL HJLEHMCHE:', a('DEFGHIJKL', 'HJLEHMCHE'));
console.log('IKLIJJLIJKKL LJLJLJLJLJHI:', a('IKLIJJLIJKKL', 'LJLJLJLJLJHI'));
console.log('ACEGIKMOQSUWY BLNPRDFTVHXJZ:', a('ACEGIKMOQSUWY', 'BLNPRDFTVHXJZ'));
console.log('QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP:', a('QQSQQRRQSTTUQQRRRS', 'PQTTPPTTQTPQPPQRTP'));
console.log('ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS:', a('ELKNSDUUUELSKJFESD', 'DKJELKNSUELSDUFEUS'));

// false
console.log('A C:', a('A', 'C'));
console.log('A Z:', a('A', 'Z'));
console.log('B J:', a('B', 'J'));
console.log('JK J:', a('JK', 'J'));
console.log('CC BA:', a('CC', 'BA'));
console.log('CE D:', a('CE', 'D'));
console.log('DJENSKE GDJCLMT:', a('DJENSKE', 'GDJCLMT'));
console.log('DEFGHIJKL HJLHMCHE:', a('DEFGHIJKL', 'HJLHMCHE'));
console.log('IJKLIJKLKIJL LIJLLHJLJLLL:', a('IJKLIJKLKIJL', 'LIJLLHJLJLLL'));
console.log('AWSUKMEGICOQY RSHXBLJLNQDFZ:', a('AWSUKMEGICOQY', 'RSHXBLJLNQDFZ'));
console.log('QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT:', a('QQSQQRRQSTTUQQQRRS', 'PQTTPPTTQTPQPPQRTT'));
console.log('ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS:', a('ELKNSDUVWELSKJFESD', 'DKJELKNSUELSDUFEUS'));

<!-- results pane console output; see http://meta.stackexchange.com/a/242491 -->
<script src="http://gh-canon.github.io/stack-snippet-console/console.min.js"></script>

स्निपेट का विस्तार करें

श्रेय

@ rink.attenders.6 5 बाइट्स से मुंडा
@ user81655 2 बाइट्स मुंडा

— पैट्रिक रॉबर्ट्स
स्रोत

के [...s]बजाय आप का उपयोग कर सकते हैं s.split('')?

— रिंक.टेंटडेंट .6

@ rink.attenders.6, हाँ, धन्यवाद। अभी भी ES6 की आदत हो रही है और मुझे याद रखने की जरूरत है कि एक शॉर्टकट है!

— पैट्रिक रॉबर्ट्स

1

पायथ, 37 31 बाइट्स

&qZ-FmldK.zqY-m.a-FdCmmCkSdK[Z1

सभी परीक्षण मामलों के साथ इसे ऑनलाइन आज़माएं!

छोटा बाइट नोटेशन ( -Fइसके बजाय .U-bZ) का उपयोग करके 6 बाइट्स को शेव किया

समाधान डेनिस से प्रेरित है

कोडगुल्फ़ के लिए पहला सबमिशन!

व्याख्या

हम अभिव्यक्ति को दो भागों में विभाजित कर सकते हैं, जिनकी तुलना &परिणाम के उत्पादन के साथ की जाती है। मैं कुछ छद्म पायथन लिखकर समझाने की कोशिश करूंगा

पहले हम जांचते हैं कि दो शब्दों की लंबाई समान है

mldK.z         lengths = map(lambda d: len(d), K=all_input())
.U-bZmldK.z    diff = reduce(lambda b, Z: b - Z, lengths)
qZ.U-bZmldK.z  diff == 0

फिर, हम डेनिस विधि लागू करते हैं:

       K                                                      # ['CAT', 'SAD']
 m   SdK           sort = map(lambda d: sorted(d), K)         # ['ACT', 'ADS']
 mmCkSdK           ascii = map(lambda d: sorted(d), map(lambda k: ord(k), K))
                                                              # [[65, 67, 84], [65, 68, 83]]
CmmCkSdK           zipped = zip(*ascii)                       # [[65, 65], [67, 68], [84, 83]]
m.U-bZd CmmCkSdK   map(lambda d: d[0] - d[1], zipped)         # [0, -1, 1]
m.a.U-bZd CmmCkSdK map(lambda d: abs(d[0] - d[1]), zipped)    # [0, 1, 1]

फिर हम -उस सूची के सभी तत्वों को फ़िल्टर करने के लिए ऑपरेटर का उपयोग करते हैं जो [Z1( [0, 1]) में नहीं हैं , और जांचें कि परिणाम एक खाली सूची हैqY

— Tenchi2xh
स्रोत

1

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

(a,b)=>![...a].sort().some((d,i)=>(d[c='charCodeAt']()-([...b].sort()[i]||c)[c]())/2|0)

अधिकतम मान से विभाजित करके एक शून्य-केंद्रित सममित सीमा जांच का उपयोग करता है, फिर बिटवाइज़ "या" ( |) के साथ ट्रंकटिंग करता है । दो चेक या एक के साथ करने की तुलना में कम है Math.abs()।

— Mwr247
स्रोत

1

हास्केल, 67 63 बाइट्स

import Data.List
f a=any(null.(a\\)).mapM(\x->[pred x..succ x])

प्रयोग उदाहरण: f "FREE" "GRRD"-> False।

यह कैसे काम करता है (ध्यान दें: fआंशिक रूप से बिंदु मुक्त है और bपरिभाषा में दूसरा पैरामीटर नहीं दिखता है):

mapM(\x->[pred x..succ x])      -- for each letter of b make a list of the
                                -- predecessor, the letter itself and the successor.
                                -- Make a list of every possible combination
                                -- thereof, e.g "dr" ->
                                -- ["cq","cr","cs","dq","dr","ds","eq","er","es"] 
any(null.(a\\))                 -- see if the difference between any of the
                                -- combinations and the other parameter a is
                                -- empty, i.e. they have the same elements

संपादित करें: @xnor को बचाने के लिए 4 बाइट्स मिले। धन्यवाद!

— nimi
स्रोत

है id xबस नहीं x? या कैसे [pred x..succ x]?

— xnor

@xnor: मैंने शुरुआत \x->map($x)[pred,id,succ]की idथी , इसलिए सिर्फ एक बचा था। बेशक ..यह सब धड़कता है। धन्यवाद!

— निम्मी ०

0

सी, 172 बाइट्स

#define q(x)qsort(x,strlen(x),1,c)
c(x,y)char*x,*y;{return*x-*y;}main(a,v,w)char**v,*w,*a;{for(q(w=v[1]),q(a=v[2]);*w&&*a&&abs(*w-*a)<2;w++,a++);printf("%d",abs(*w-*a)<2);}

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

$ bash -x test.sh
+ bash -x test.sh
+ ./a.out A A
1+ ./a.out A B
1+ ./a.out C B
1+ ./a.out DD CE
1+ ./a.out DE FC
1+ ./a.out ABCD BCDE
1+ ./a.out AACC DBBB
1+ ./a.out DJENSKE FDJCLMT
1+ ./a.out DEFGHIJKL HJLEHMCHE
1+ ./a.out IKLIJJLIJKKL LJLJLJLJLJHI
1+ ./a.out ACEGIKMOQSUWY BLNPRDFTVHXJZ
1+ ./a.out QQSQQRRQSTTUQQRRRS PQTTPPTTQTPQPPQRTP
1+ ./a.out ELKNSDUUUELSKJFESD DKJELKNSUELSDUFEUS
1+ ./a.out A C
0+ ./a.out A Z
0+ ./a.out B J
0+ ./a.out JK J
0+ ./a.out CC BA
0+ ./a.out CE D
0+ ./a.out DJENSKE GDJCLMT
0+ ./a.out DEFGHIJKL HJLHMCHE
0+ ./a.out IJKLIJKLKIJL LIJLLHJLJLLL
0+ ./a.out AWSUKMEGICOQY RSHXBLJLNQDFZ
0+ ./a.out QQSQQRRQSTTUQQQRRS PQTTPPTTQTPQPPQRTT
0+ ./a.out ELKNSDUVWELSKJFESD DKJELKNSUELSDUFEUS
0++

— कोल कैमरून
स्रोत

0

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

param($a,$b)(($a=[char[]]$a|sort).Count-eq($b=[char[]]$b|sort).Count)-and(($c=0..($a.Count-1)|%{+$a[$_]-$b[$_]}|sort)[0]-ge-1-and$c[-1]-le1)

यह कम हो सकता है। यह वर्तमान में पायथन या जावास्क्रिप्ट के साथ प्रतिस्पर्धी नहीं है, लेकिन यह थोड़ा अलग दृष्टिकोण का उपयोग करता है, इसलिए मुझे लगा कि मैं इसे पोस्ट करूंगा।

व्याख्या

यह कोड वास्तव में किसी के लिए पॉवरशेल में धाराप्रवाह नहीं होने के लिए भ्रामक है, इसलिए मैं इसे अंग्रेजी में सबसे अच्छा मैं करने की कोशिश कर सकता हूं ...

हम इनपुट param($a,$b)को सामान्य रूप से लेना शुरू करते हैं ।

कोड के पूरे बाकी वास्तव में एक बयान है, और ऑपरेटर के (...)-and(...)साथ दो बूलियन बयानों का परीक्षण करने के लिए तोड़ा जा सकता है -and।

बाएं हाथ के परनों (... -eq ...)को दो वस्तुओं की समानता का परीक्षण करने के लिए तोड़ा जा सकता है। इस उदाहरण में, ऑब्जेक्ट .Countदो नए चार-सरणियों के एस (यानी, लंबाई) हैं। प्रत्येक आंतरिक परिन ($a=[char[]]$a|sort)मूल इनपुट शब्द लेता है, इसे चार-सरणी के रूप में फिर से कास्ट करता है, फिर इसे सॉर्ट करता है और उसी चर में वापस बचाता है। हम ऐसा करते हैं $aऔर दोनों के लिए $b। बाएं हाथ की ओर इस प्रकार पुष्टि करता है कि इनपुट शब्द समान लंबाई हैं। यदि वे समान लंबाई नहीं हैं, तो बाहरी बूलियन कथन का यह आधा भाग विफल Falseहो जाएगा और आउटपुट हो जाएगा।

दाईं ओर बढ़ते हुए, हम फिर से दो बूलियन कथनों का परीक्षण कर रहे हैं (... -and ...)। बाएं हाथ की ओर का परीक्षण करता है कि क्या कुछ अधिक-से-या-बराबर-से-नकारात्मक 1 के साथ है -ge-1। कुछ एक का निर्माण किया सरणी के zeroth-तत्व है $c, जो द्वारा बनाई गई है:

अनुमत सूचकांकों की एक सीमा लेना 0..($a.count-1)
एक पाश में बांधा |%{...}
लूप के प्रत्येक पुनरावृत्ति, हम अनुक्रमित वर्ण के ASCII मानों को लेते हैं और अनुक्रमणिका वर्ण $aके ASCII मान को घटाते हैं$b
जो फिर |sortसंख्यात्मक मान द्वारा संपादित किया जाता है

कथन का दूसरा पक्ष $c[-1]सरणी का अधिकतम मान लेता है और यह सुनिश्चित करता है कि यह 1 से कम-या-बराबर है -le1।

इस प्रकार, यदि दो इनपुट स्ट्रिंग्स वास्तव में आसन्न हैं, तो $cसरणी कुछ इस तरह होगी @(-1,-1,-1...0,0,0...1,1,1)। तो पहला तत्व होगा -1और आखिरी तत्व होगा 1। यदि वे आसन्न नहीं हैं, तो किसी विशेष जोड़ी के लिए एएससीआईआई मानों में अंतर < -1या तो होगा > 1, इसलिए बाहरी बूलियन परीक्षण का यह आधा विफल हो जाएगा, और Falseआउटपुट होगा।

केवल तभी जब दोनों पक्ष Trueआउटपुट होंगे, और तार इसलिए लाए जाएंगे ।

— AdmBorkBork
स्रोत

0

जंग, ~~269~~ 264 बाइट्स

fn a(w:&str,x:&str)->bool{if w.len()==x.len(){return{let mut c:Vec<char>=w.chars().collect();let mut d:Vec<char>=x.chars().collect();c.sort();d.sort();for(e,f)in c.iter().zip(d.iter()){if(((*e as u8)as f64)-((*f as u8)as f64)).abs()>1f64{return false}}true}}false}

विस्तारित:

fn are_adjacent(w: &str, x: &str)->bool{

    if w.len() == x.len(){

        return {

            let mut c : Vec<char> = w.chars().collect();
            let mut d : Vec<char> = x.chars().collect();

            c.sort();
            d.sort();

            for (e,f) in c.iter().zip(d.iter()){
                if (((*e as u8) as f64) - ((*f as u8) as f64)).abs() > 1f64{
                    return false
                } 
            }

            true
        }
    }

    false
}

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

fn main(){
    assert_eq!(true,are_adjacent("A","B"));
    assert_eq!(true,are_adjacent("A","B"));
    assert_eq!(true,are_adjacent("C","B"));
    assert_eq!(true,are_adjacent("DD","CE"));
    assert_eq!(true,are_adjacent("DE","FC"));
    assert_eq!(true,are_adjacent("ABCD","BCDE"));
    assert_eq!(true,are_adjacent("AACC","DBBB"));
    assert_eq!(true,are_adjacent("DJENSKE","FDJCLMT"));
    assert_eq!(true,are_adjacent("DEFGHIJKL","HJLEHMCHE"));
    assert_eq!(true,are_adjacent("IKLIJJLIJKKL","LJLJLJLJLJHI"));
    assert_eq!(true,are_adjacent("ACEGIKMOQSUWY","BLNPRDFTVHXJZ"));
    assert_eq!(true,are_adjacent("QQSQQRRQSTTUQQRRRS","PQTTPPTTQTPQPPQRTP"));
    assert_eq!(true,are_adjacent("ELKNSDUUUELSKJFESD","DKJELKNSUELSDUFEUS"));

    assert_eq!(false,are_adjacent("A","C"));
    assert_eq!(false,are_adjacent("A","Z"));
    assert_eq!(false,are_adjacent("B","J"));
    assert_eq!(false,are_adjacent("JK","J"));
    assert_eq!(false,are_adjacent("CC","BA"));
    assert_eq!(false,are_adjacent("CE","D"));
    assert_eq!(false,are_adjacent("DJENSKE","GDJCLMT"));
    assert_eq!(false,are_adjacent("DEFGHIJKL","HJLHMCHE"));
    assert_eq!(false,are_adjacent("IJKLIJKLKIJL","LIJLLHJLJLLL"));
    assert_eq!(false,are_adjacent("AWSUKMEGICOQY","RSHXBLJLNQDFZ"));
    assert_eq!(false,are_adjacent("QQSQQRRQSTTUQQQRRS","PQTTPPTTQTPQPPQRTT"));
    assert_eq!(false,are_adjacent("QQSQQRRQSTTUQQQRRS","PQTTPPTTQTPQPPQRTT"));
    assert_eq!(false,are_adjacent("ELKNSDUVWELSKJFESD","DKJELKNSUELSDUFEUS"));
}

— WKS
स्रोत

0

एपीएल, 59 बाइट्स (अक्षर)

(६१ अगर हमें {if और ६३ की आपूर्ति करनी है, तो ← के साथ ६३)

मैं सबसे महान एपीएलर नहीं हूं, लेकिन यह बहुत मजेदार है।

(0=+/2≤|¨∊-/{⎕av⍳⍵}¨(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵])∧=/⍴¨∊¨⍺⍵

=/⍴¨∊¨⍺⍵ इनपुट समान रूप से लंबे हैं?

∧ और नीचे के सभी

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] दोनों इनपुटों को क्रमबद्ध करें और उन्हें दो के रूप में लंबे समय तक होने के लिए आकार दें (वे चारों ओर लपेटते हैं यदि आप उन्हें लंबे समय तक बनाते हैं तो वे हैं)

|¨∊-/{⎕av⍳⍵} दोनों चार वैक्टर को अपने एससीआई मूल्यों के वैक्टर में परिवर्तित करें, एक वेक्टर घटाव और सभी मूल्यों को पूर्ण करें

0=+/2≤ मानों को दो से अधिक या उसके बराबर मान दें और जांचें कि क्या परिणाम 0 के बराबर है

— Koneke
स्रोत

0

के (ओके) , 27 बाइट्स

समाधान:

2>|/x*x:-/(|/#:'x)$x@'<:'x:

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

उदाहरण:

2>|/x*x:-/(|/#:'x)$x@'<:'x:("QQSQQRRQSTTUQQRRRS";"PQTTPPTTQTPQPPQRTP")
1
2>|/x*x:-/(|/#:'x)$x@'<:'x:("DEFGHIJKL";"HJLHMCHE")
0
2>|/x*x:-/(|/#:'x)$x@'<:'x:("AAA";"AAA")
1
2>|/x*x:-/(|/#:'x)$x@'<:'x:("AAA";"AA")
0

स्पष्टीकरण:

पहले प्रत्येक स्ट्रिंग को क्रमबद्ध करें, फिर उसी लंबाई में पैड करें, फिर दूसरे से एक (ASCII मानों के वर्ण) लें, वर्ग परिणाम क्योंकि कोई अंतर्निहित नहीं है abs, अधिकतम अंतर लें और जांचें कि क्या 2 से कम है।

2>|/x*x:-/(|/#:'x)$x@'<:'x: / the solution
                         x: / save input to variable x
                      <:'   / ascending sorted indices (<:) for each (') list
                   x@'      / apply (@) each (') of these indices to the input (x)                             
          (      )$         / pad
             #:'x           / count (#:) each (') list (x)
           |/               / max (|) over (/) to get maximum
        -/                  / subtract (-) over (/) to take 2nd list from 1st
      x:                    / save in variable x
    x*                      / multiply by x (so square)
  |/                        / max over to get maximum distance
2>                          / is 2 greater than (>) to this maximum? returns 1 (true) or 0 (false)

— streetster
स्रोत

0

जे, 27 बाइट्स

[:*/@(2>|)[:-/,:&(3&u:@/:~)

ungolfed

[: */@(2 > |) [: -/ ,:&(3&u:@/:~)

व्याख्या की

&(3&u:@/:~) दोनों तर्कों को क्रमबद्ध करें, और उन्हें एससीआई संख्या में परिवर्तित करें
,: एक 2 xn मैट्रिक्स बनाता है, जहाँ n args के वर्णों की संख्या है
-/ इसी पंक्ति की दूरी का प्रतिनिधित्व करते हुए लंबाई n की सूची देते हुए, एक पंक्ति को दूसरे से घटाएं
(2>|) 1 रिटर्न अगर दूरी का पूर्ण मान 2 से कम है, तो अन्यथा
*/पलता उन सभी 0रों और 1एक साथ है: इसलिए, अंतिम परिणाम 1 इसी वर्ण के सभी जोड़े iff आसन्न हो रहा है।

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

— जोनाह
स्रोत

आसन्न शब्दों का मिलान

इनपुट आउटपुट

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

CJam, 14 13 12 बाइट्स

कलन विधि

कोड

MATL , 10 12 17 बाइट्स

सी, 233 बाइट्स

पायथन 2, 90 बाइट्स

जावास्क्रिप्ट (ईएस 6), 86 90 94

जावास्क्रिप्ट ईएस 6, 117 बाइट्स 116 बाइट्स 111 बाइट्स 109 बाइट्स

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

श्रेय

पायथ, 37 31 बाइट्स

व्याख्या

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

हास्केल, 67 63 बाइट्स

सी, 172 बाइट्स

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

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

व्याख्या

एपीएल, 59 बाइट्स (अक्षर)

के (ओके) , 27 बाइट्स

जे, 27 बाइट्स

ungolfed

व्याख्या की