Bu mücadelede, iki kelime geçtiniz: Göreviniz bitişik olup olmadıklarını belirlemek .

İki harf bitişikse:

1. Onlar aynı mektubu ya da
2. Sözcükbilimsel olarak bitişiktirler.

Örneğin, J sadece I , J ve K ile bitişiktir . Z , A'ya bitişik değildir

İki kelime bitişikse:

1. Onlar aynı uzunluktadır ve
2. Her harf, diğer bir deyişle benzersiz bir harf bitişiktir.

Örneğin, CAT , SAD'ın yanında , C> D, A> A, T> S olarak bitişiktir .
FREE , GRRD'ye bitişik değildir (her bir E'nin eşleşmesi için bir mektuba ihtiyacı vardır) .

Giriş çıkış

İki dizgiden geçersiniz ve bitişiklerse bir aldatma değeri, aksi takdirde sahte bir değer döndürmeniz gerekir. Aşağıdaki tüm test durumları için bir dakika içinde geri dönmelisiniz.

Dizelerin yalnızca büyük, alfabetik harfler içerdiğini varsayabilirsiniz.

İki dize bir liste olarak geçirilebilir veya tırnak işaretleri ile ya da tırnaklar olmadan birleştirilebilir.

Test Kılıfları

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

Bu kod golf , yani en kısa geçerli cevap kazanır!

CJam, 14 13 12 bayt

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

Çevrimiçi deneyin! veya tüm test durumlarını bir kerede doğrulayın .

Algoritma

Let s ve t , iki olması aynı uzunlukta kelime kriteri. İçin larındaki ve t (LA) sözlük sırasında bitişik olacak şekilde, karşılık gelen karakter her çifti de la olması gerekli ve yeterli olan.

Koşul tüm kelimeler için açıkça yeterli ve uzunluk 1 için kelimeler için gerekli .

Şimdi, s ve t'nin n> 1 uzunluğuna sahip olduğunu ve a ve b'nin s ve t'nin ilk karakterleri olmasını sağlayın . .

Yana ler ve t LA, bazıları bijective haritalama yoktur φ karakterler arasında s ve karakter t öyle ki x ve φ (x) tümü için LA edilir x in s yani | φ (x) - x | ≤ 1 için tüm x de s .

Let c = φ, (a) ve d = φ ^-1 (b) . Çünkü bir 'in ve B ' nin minimality, bir ≤ d (1) ve b ≤ C (2) .

Ayrıca, b ve d ve a ve c ve LA'dan dolayı d ≤ b + 1 (3) ve c ≤ a + 1 (4) .

Birleştirerek (1) ve (3) , ve (2) ve (4) , olsun bir ≤ d ≤ b + 1 ve b ≤ c ≤ a + 1 biz anlamak olan, bu bir 1 - ≤ b ≤ a + 1 ve bu nedenle, a ve b , LA'dır.

Şimdi, (1) ve (4) ve (2) ve (3) ' ü birleştirerek, bunu c - 1 ≤ d olarak hesapladığımız c - 1 ≤ a get d ve d - 1 ≤ b ≤ c'yi elde ederiz. ≤ c + 1 ve bu nedenle c ve d LA'dır.

Böylece φ ile φ (a) = b ve φ (d) = c , | x - φ (x) | ≤ 1 hala tüm x in s ve özellikle de tüm x in s için [1:] tutacaktır .

Bu şekilde, s [0] = a ve t [0] = b ve s [1:] ve t [1:] , LA'dır.

Yana s [1:] uzunluğu - n 1 , bu indüksiyon ile zorunluluğunu ortaya koymaktadır.

kod

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.

MATL , 10 12 17 bayt

c!S!odXl2<

Bu, Dennis'in yaklaşımını kullanır : önce sıralama ve karakterleri eşleşen konumlarda karşılaştırın.

Giriş, formatı olan bir dizge dizisidir {'CAT 'SAD'}.

Çıktı bir sıfırlar ve birler dizisidir. Sonuç, hepsini içeriyorsa gerçeği ifade etmektir (bu kararlaştırılmıştır) truthy olmak).

Bu zorluktan daha eski olan mevcut sürümü (10.2.1) kullanır .

EDIT: İşlev Xl, |dilin daha yeni sürümlerinde yeniden adlandırıldı (ve oartık gerekli değil). Aşağıdaki link bu değişiklikleri içermektedir.

Çevrimiçi deneyin!

Açıklama :

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

Dizeleri ayrı girdiler olarak kabul eden eski yaklaşım: 12 bayt :

SiSXhcodXl2<

DÜZENLEME : Bağlantıdaki kod değiştirilerek dilde değişiklik yapıldı Yukarıdaki yoruma bakınız.

Çevrimiçi deneyin !

Açıklama :

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

C, 233 bayt

#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;}

Bunu kaydederek adj.hve sonra bu adj.cdosyayı kullanarak test edebilirsiniz :

#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;
}

Sonra kullanarak derleyin gcc adj.c -o adj. Çıktı:

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

Python 2,90 bayt

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

Basit anonim işlev, zipsadece kontamine olacak çünkü uzunluğu için ayrı bir kontrol olması gerekir. itertools( zip_longest) 'De benzer bir işleve sahip olan ve boş dizeleri tıklatacak, ancak bu oldukça maliyetli olacaktır.

İle test

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

üretir:

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

JavaScript (ES6), 86 90 94

Düzenleme 4 bayt thx @Neil kaydet
Düzenleme 2 4 bayt thx @ Mwr247 kaydet

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

Not: Bir çift harfe bitişiklik kontrolü yapın. Harfler eşitse, çifti bir baz 36 sayı n olarak alın n = a*36+a = a*37. 1 farkı varsa o zaman n = a*36+a+1 = a*37+1veya n = a*36+a-1 = a*37-1. Öyleyse n % 370, 1 veya 36 olmalı.n%37%36 olmalı. 0 veya 1 olmalıdır.

Not 2: eklenen '0', a ve b'nin aynı uzunlukta olmasını sağlamak için kullanılır. O zaman daha kısaa.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>

JavaScript ES6, 117 bayt 116 bayt 111 bayt 109 bayt

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

Test Kılıfları

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>

Kredi

• @ rink.attendant.6 5 byte tıraş edildi
• @ user81655 2 byte tıraş etti

Pyth, 37 31 bayt

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

Tüm test durumlarında çevrimiçi olarak deneyin!

Kısaltılmış azaltma gösterimini kullanarak ( -Fyerine .U-bZ) 6 bayt kapalı

Çözüm esinlenerek Dennis

Codegolf'a ilk başvuru!

açıklama

İfadeyi &, sonucun çıktısına göre iki bölüme ayırabiliriz . Biraz sözde Python yazarak açıklamaya çalışacağım.

İlk önce, iki kelimenin uzunluğunun aynı olduğunu kontrol ederiz.

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

Ardından, Dennis'in yöntemini uyguluyoruz:

       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] 

Ardından -, bu listenin [Z1( [0, 1]) içinde bulunmayan tüm öğelerini filtrelemek için işleci kullanırız ve sonucun boş bir liste olup olmadığını kontrol ederiz.qY

JavaScript (ES6), 87 bayt

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

Maksimum değere bölerek, ardından bit yönünde "veya" ( |) ile keserek sıfır merkezli bir simetrik aralık kontrolü kullanır . İki veya daha fazla çek yapmak zorunda kalmadan daha kısa Math.abs().

Haskell, 67 63 bayt

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

Kullanım örneği: f "FREE" "GRRD"-> False.

Nasıl çalışır (not: fkısmen nokta içermez ve ikinci parametre btanımında görünmez):

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

Düzenleme: @xnor kaydetmek için 4 bayt bulundu. Teşekkürler!

C, 172 bayt

#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);}

Test Kılıfları

$ 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++

PowerShell, 140 bayt

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)

Bu kısaltmak mümkün olabilir. Şu anda Python veya JavaScript ile rekabet etmiyor, ancak biraz farklı bir yaklaşım kullanıyor, bu yüzden göndereceğimi düşündüm.

açıklama

Bu kod gerçekten PowerShell'de akıcı olmayan biri için kafa karıştırıcıdır, bu yüzden İngilizceyi elimden geldiğince kırmaya çalışacağım ...

param($a,$b)Normal olarak girdi almakla başlarız .

Kodun geri kalanının tamamı aslında bir ifadedir ve (...)-and(...)iki Boole deyimini -andoperatörle test etmek için kullanılamaz .

Soldaki parens (... -eq ...), iki nesnenin eşitliğini test etmek için kırılabilir . Bu durumda, nesneler.Count iki yeni karakter dizisinin s'sidir (yani uzunluğu). Her bir iç parne ($a=[char[]]$a|sort)orijinal giriş sözcüğünü alır, onu bir karakter dizisi olarak yeniden yazar, sonra sıralar ve tekrar aynı değişkene kaydeder. Biz her ikisi için bunu $ave $b. Böylece sol taraf, giriş kelimelerinin aynı uzunlukta olduğunu doğrular. Aynı uzunlukta değillerse, dış Boole ifadesinin bu yarısı başarısız olur ve çıkar False.

Sağ tarafa geçerek, iki Boole ifadesini tekrar test ediyoruz (... -and ...). Sol taraftaki bir şey ile negatif 1'den eşit veya daha büyük bir şey olup olmadığını test eder -ge-1. Şey oluşturulmuş bir dizi sıfırıncı-elemanıdır $coluşturulur:

• izin verilen endekslerin bir dizi alarak 0..($a.count-1)
• bir döngü içine borulu |%{...}
• Döngünün her yinelemesinde, dizinlenmiş karakterin ASCII değerlerini alırız. $a ASCII değerini çıkarırız.$b
• hangisi o zaman |sort sayısal değere göre

İfadenin diğer tarafı maksimum değeri alır $c[-1] dizinin 1 ile eşit veya daha küçük olmasını sağlar -le1.

Bu nedenle, eğer iki giriş dizisi gerçekten bitişikse, $cdizi gibi bir şey olacaktır @(-1,-1,-1...0,0,0...1,1,1). Böylece ilk eleman olacak -1ve son eleman olacak 1. Eğer bitişik değilse, belirli bir çift için ASCII değerlerindeki fark < -1ya> 1 , dış Boole testin bu devre, başarısız olacak şekilde ve Falseçıkış olacaktır.

Sadece iki tarafın da geçmesi Truedurumunda çıktı alınacak ve bu nedenle dizgiler LA olacaktır.

Rust, 269 264 bayt

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}

Expanded:

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
}

Test Durumları:

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"));
}

APL, 59 bayt (karakter)

(61'e {ve}, 63'e f ← vermemiz gerekiyorsa)

Ben en iyi APLer değilim, ama bu sadece çok eğlenceli.

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

=/⍴¨∊¨⍺⍵ girişler eşit uzunlukta mı?

∧ ve aşağıdakilerin tümü

(⍺{⌈/⍴¨⍺⍵}⍵)⍴¨⍺[⍋⍺]⍵[⍋⍵] Her iki girişi de sıralayın ve ikisini en uzun sürecek şekilde biçimlendirin (daha uzun olursanız sarın)

|¨∊-/{⎕av⍳⍵} her iki char vektörünü ascii değerlerinin int vektörlerine dönüştürmek, vektör çıkarma yapmak ve tüm değerleri mutlak hale getirmek

0=+/2≤ ikiden büyük veya eşit olan değerleri toplayın ve sonucun 0'a eşit olup olmadığını kontrol edin

K (OK) , 27 bayt

Çözüm:

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

Çevrimiçi deneyin!

Örnekler:

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

Açıklama:

Öncelikle her dizeyi sıralayın, daha sonra aynı uzunlukta ped yapın, sonra diğerinden (karakterlerin ASCII değerleri) bir tane alın, yerleşik olmadığından kare sonuç absalın, maksimum farkı alın ve 2'den az olup olmadığını kontrol edin.

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)

J, 27 bayt

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

ungolfed

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

açıkladı

• &(3&u:@/:~) her iki argümanı sıralar ve onlara ascii sayılarına dönüştürür
• ,: 2 xn matris oluşturur, burada n, argların karakter sayısıdır.
• -/ bir satır diğerinden çıkarılarak karşılık gelen karakterlerin mesafesini temsil eden n uzunluğu belirlenir.
• (2>|) mesafenin mutlak değeri 2, 0'dan küçükse 1 değerini döndürür
• */tüm bunları 0ve sonuçları bir 1araya getirir: bu nedenle, sonuç, karşılık gelen karakterlerin tüm çiftleri bitişik olduğunda 1 olur.

Çevrimiçi deneyin!