24

दो तार "सीज़र समतुल्य" हैं यदि संबंधित वर्णों के बीच की दूरी (गिनती) समान है। हां, मैंने यह शब्द बनाया है। यहाँ एक उदाहरण है:

"एबीसी" और "सीडी" समान हैं

distance from a-c == 2
distance from b-d == 2
distance from c-e == 2

पूंजीकरण से कोई फर्क नहीं पड़ता।

"हैलो" और "वर्ल्ड" सीज़र के समकक्ष नहीं हैं क्योंकि

distance from h-w == 15
distance from e-o == 10
distance from l-r == 6
distance from l-l == 0
distance from o-d == 15

"Abcd" और "Yzab" सीज़र समतुल्य हैं क्योंकि

distance from a-y = 24
distance from b-z = 24
distance from c-a = 24 (it wraps around)
distance from d-b = 24

आपको एक पूरा कार्यक्रम लिखना होगा जो STDIN से दो तार लेता है, और यदि वे सीज़र के समकक्ष हैं, और यदि वे नहीं हैं तो एक मिथ्या मूल्य पर एक सत्य मान छापते हैं।

मान्य इनपुट

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

code-golf string

— DJMcMayhem
स्रोत

8

कमांड लाइन तर्क के रूप में इनपुट की अनुमति देना अच्छा होगा। मैं एक सी समाधान लिखने जा रहा था, लेकिन स्टड से पढ़ने के लिए काफी लंबा कोड चाहिए, खासकर यदि आपके पास समय से पहले अधिकतम लंबाई नहीं है।

— रेटो कोराडी

@RetoKoradi क्यों नहीं? यह शायद वैसे भी नहीं जीतेगा, क्योंकि सी बिल्कुल संक्षिप्त नहीं है।

— DJMcMayhem

सही, मुझे संदेह है कि सी के पास कभी भी एक पूर्ण जीत का मौका होगा। सर्वोत्तम रूप से, मैं उन समाधानों की तुलना करता हूं जो "वास्तविक";) प्रोग्रामिंग भाषाओं का उपयोग करते हैं। लेकिन वहां भी, अन्य भाषाएं अधिक कॉम्पैक्ट होती हैं, खासकर अगर इसमें स्ट्रिंग प्रसंस्करण शामिल है।

— रेटो कोराडी

4

जब भी मैं इसे प्रश्न सूची में देखता हूं, इसके उत्तर के रूप में कई उत्थान होते हैं।

— एलेक्स ए

1

@AlexA। जब तक आप इसे इंगित नहीं करते, मैं अनुपात का जवाब देने के लिए अप वोट पर कोई ध्यान नहीं दे रहा था। अब यह सब मुझे नोटिस है।

— DJMcMayhem

10

अजगर, 9 बाइट्स

}wm=.rzGG

लोअरकेस में दो तार होने की उम्मीद है, नई लाइन अलग हो गई है।

प्रदर्शन।

यह काम किस प्रकार करता है:

.rपायथ का रोटरी अनुवाद कार्य है। यह पहले तर्क में प्रत्येक तत्व को पहले तर्क में दूसरे तर्क में दूसरे तर्क में दूसरे प्रविष्टि में दर्ज करता है। इस मामले में, दूसरा तर्क G, लोअरकेस वर्णमाला है, इसलिए यह 1 के सीज़र शिफ्ट के बराबर है।

=फ़ंक्शन के सामने एक जगह रखने से यह जगह में आ जाता है। इस प्रकार, =.rzGसीज़र शिफ्ट को zएक से एक करने के लिए असाइन करता है z। ध्यान दें कि zपायथ में इनपुट की पहली पंक्ति के लिए इनिशियलाइज़ किया गया है।

इस अभिव्यक्ति का उपयोग मानचित्र के अंदर किया जाता है। m=.rzGGइस परिवर्तन को z26 बार लागू करता है , एक बार के प्रत्येक तत्व के लिए G, और एक सूची में परिणाम बचाता है। यह सभी संभावित सीज़र शिफ़्ट की सूची देता है z।

अंत में, }wजाँच करता है कि इनपुट की अगली पंक्ति उस सूची में है या नहीं।

— isaacg
स्रोत

14

CJam, 17 12 11 बाइट्स

1 बाइट डेनिस ने बचाया।

ll.m26f%)-!

इसका परीक्षण यहां करें।

पहला स्ट्रिंग लोअर केस और दूसरा अपर केस होने की उम्मीद करता है। 1सीज़र-समतुल्य तारों के लिए प्रिंट और 0अन्यथा।

व्याख्या

ll           e# Read two lines of input.
  .m         e# Take the differences of corresponding characters.
    26f%     e# Take the differences modulo 26.
        )-   e# Remove all copies of the last difference from the array. This will 
             e# yield an empty array if and only if all differences are the same.
          !  e# Logical NOT, which yields 1 for an empty array and 0 otherwise.

कारण हमें निचले मामले में पहले स्ट्रिंग की आवश्यकता है और ऊपरी मामले में दूसरा यह सुनिश्चित करना है कि अंतर हमेशा सकारात्मक है। अन्यथा मोड्यूलो लेना नकारात्मक कुछ लौट सकता है और जरूरी नहीं कि यह अद्वितीय भी हो, यहां तक कि सीज़र-समतुल्य तार भी।

— मार्टिन एंडर
स्रोत

1

यदि आपको पहले शब्द को लोअरकेस और दूसरे को अपरकेस बनाना है, तो आप 26f%एक बाइट को बचाने के लिए उपयोग कर सकते हैं ।

— डेनिस

आप पाइथ उत्तर के करीब लाने के लिए शेल कन्वेंशन ( stackoverflow.com/questions/2933843/… ) का उपयोग कर सकते हैं ।

— विसएच

1

@VicAche स्वीकृत सम्मलेन सत्य और मिथ्या की व्याख्या करने के लिए है जिस तरह से आपकी भाषा इसकी व्याख्या करती है। इसके अलावा, अगर मैंने हटा दिया तो !मेरे पास 0 या 1 नहीं होगा, बल्कि एक खाली या गैर-खाली सरणी होगी।

— मार्टिन एंडर

9

पायथन 2, 68 67 70 69 बाइट्स

print len({(ord(y)-ord(x))%26for x,y in zip(*raw_input().split())})<2

पायथन 3, 67 66 बाइट्स

print(len({(ord(y)-ord(x))%26for x,y in zip(*input().split())})<2)

यह थोड़ा मुश्किल है, ताकि टुकड़े को समझाया जा सके:

zip(*raw_input().split())इनपुट लेता है, इसे दो शब्दों की सूची में विभाजित करता है, यह मानते हुए कि शब्द व्हॉट्सएप द्वारा अलग किए जाते हैं। उसके बाद प्रत्येक शब्द ऑपरेटर के zipउपयोग द्वारा फ़ंक्शन के पैरामीटर के रूप में पारित किया जाता है *। zipसमारोह एक ही स्थिति में पत्र के लिए, पत्र-जोड़ों की सूची बनाएगा।
(ord(y)-ord(x))%26for x,y in ... यह सिर्फ उन अक्षरों के बीच की दूरी की एक जनरेटर अभिव्यक्ति के लिए 2 अक्षरों की सूची को बदल देता है।
{...} इस अभिव्यक्ति को एक सेट में कम कर देता है, अनिवार्य रूप से डुप्लिकेट को बाहर फेंक रहा है
len(...)<2 जाँच करता है कि क्या सेट में केवल एक आइटम बचा है (या खाली तारों के लिए 0), जिसका अनिवार्य रूप से मतलब है कि सभी अक्षरों में समान दूरी थी।
print मूल्य है कि आउटपुट

मुझे याद दिलाने के लिए xnor के लिए धन्यवाद के set(...)साथ प्रतिस्थापित किया जा सकता है {...}और पहले की जगह की forआवश्यकता नहीं है। इसके अलावा के लिए Josay करने के लिए धन्यवाद <=1करने के लिए <2अनुकूलन।

— KillianDS
स्रोत

मेरे समाधान के समान सुंदर एक ही मिनट में लगभग पोस्ट किया गया। आप इनपुट पर जाने के लिए मुझसे अधिक स्मार्ट हैं, लेकिन आप <=1'<2' में कम कर सकते हैं ।

— सिल्वेनैड

1

आप इसके {...}बजाय सीधे एक सेट समझ सकते हैं set((...))। आपके कोड को वास्तव में परिणाम प्रिंट करने की आवश्यकता है।

— xnor

@KillianDS डिफ़ॉल्ट नियमों को STDOUT या प्रिंटिंग (REPL मूल्यांकन नहीं) की आवश्यकता है, और यहाँ ओपी निर्दिष्ट मुद्रण है। अन्यथा, सामान्य लघु तरीका lambdaलेखन पर printया बचाने के लिए उपयोग करना है return।

— xnor

1

वैसे, आप पहले स्थान नहीं बनाते हैं for; पायथन लेक्सर सही ढंग से विभाजित होता है 26for।

— xnor

5

एपीएल (15)

1=≢∪26|-⌿⎕A⍳↑⍞⍞

इसके लिए अक्षरों को बड़ा करने की आवश्यकता है, और 1या तो प्रिंट करता है 0, जैसे:

      1=≢∪26|-⌿⎕A⍳↑⍞⍞
ABCD
YZAB
1

      1=≢∪26|-⌿⎕A⍳↑⍞⍞
HELLO
WORLD
0

स्पष्टीकरण:

↑⍞⍞: कीबोर्ड से दो पंक्तियों को पढ़ें, और N × 2 मैट्रिक्स में वर्णों को व्यवस्थित करें।
⎕A⍳: प्रत्येक चरित्र के लिए, यह किस स्थिति में पाया जाता है ⎕A(अपरकेस वर्णमाला)।
-⌿: प्रत्येक स्तंभ के लिए, पहले मान से दूसरा मान घटाएँ
26|: उन संख्याओं में से प्रत्येक का mod-26 लें।
यदि तार सीज़र-समतुल्य हैं, तो इस सूची में सभी संख्याएँ अब समान हैं, इसलिए:
≢∪: सूची में अद्वितीय मानों की संख्या ज्ञात कीजिए
1=: की तुलना करें 1।

— मारीनस
स्रोत

मैं APL :)

— orlp

@ एलेक्सा: मैं Dyalog APL 14 का उपयोग कर रहा हूं। अगर आपको रास्पबेरी पाई मिल गई है, तो यह मुफ़्त है; छात्रों के लिए यह मुफ़्त है; अन्यथा आप एक अपंजीकृत संस्करण डाउनलोड कर सकते हैं, जो कि नागवेयर है, लेकिन अन्यथा वास्तविक रूप से कार्यात्मक है। dyalog.com TryAPL इस पर आधारित है, वैसे।

— मारीनस

मैं Dyalog बनाम GNU APL, ngn / apl, और APLX पर आपके विचारों को सुनने के लिए इच्छुक हूं, हालांकि टिप्पणियाँ वास्तव में ऐसी चर्चा के लिए जगह नहीं हैं। ;)

— एलेक्स ए।

3

जे, 19 बाइट्स

1=[:#@~.26|-&(3&u:)

एक ही स्थिति पर पत्र में एक ही मामला होना चाहिए।

दोनों इनपुट स्ट्रिंग्स को उनके कोडपॉइंट प्रतिनिधित्व में परिवर्तित करने के बाद, &(3&u:)हम दो सरणियों के अंतर के मोडुलो 26 की 1लंबाई #की तुलना करते हैं। यदि सभी सीज़र-दूरी समान हैं, तो नब होगा ।~.26|-1

उपयोग:

   'abcd' (1=[:#@~.26|-&(3&u:)) 'yzab'
1

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

— randomra
स्रोत

3

जूलिया, 91 87 83 बाइट्स

a=readline()
b=readline()
show(length(Set([mod(a[i]-b[i],26)for i=1:length(a)]))<2)

असंगठित + स्पष्टीकरण:

# Read two strings from STDIN
a = readline()
b = readline()

# Get the absolute difference mod 26 of the character values in the strings
x = [mod(a[i] - b[i], 26) for i = 1:length(a)]

# Construct a set consisting of the elements of x. If the set has only a
# single element, the strings are Caesar equivalent. This will print a
# boolean value to STDOUT.
show(length(Set(x)) < 2)

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

— एलेक्स ए।
स्रोत

3

बग 101 92 बाइट्स के साथ C99, 92 बाइट्स

  r,i;main(z,a)char**a;{for(;z=a[2][++i];)r|=(a[1][i]-z+*a[2]-*a[1]+52)%26;putchar(49-!!r);}

बहुत सीधा; मान लें कि शब्द क्रमशः पहले और दूसरे तर्क के रूप में आते हैं। के साथ संकलित किया -std=c99।

— rr-
स्रोत

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

— रेटो कोराडी

आप सही कह रहे हैं, मैंने इसे याद किया। फिक्स्ड।

— आरआर-

3

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

उसी मामले में इनपुट की आवश्यकता होती है।

(p=prompt)(![z=(a[c='charCodeAt'](i)-b[c](i)+26)%26 for(i in b=p(a=p()))].some(x=>x^z))

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

— nderscore
स्रोत

2

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

{r(fm26f%}2*=

इसके लिए प्रत्येक शब्द में पहले वर्ण की आवश्यकता होती है ऊपरी मामले में, दूसरों को निचले मामले में।

इसे यहाँ आज़माएँ । ( यहाँ फ़ायरफ़ॉक्स ।)

बहुत खराब एपीएल वेरिएंट चरित्र अंकगणित का समर्थन नहीं करता है ...

व्याख्या

{
    r       e# Read a word.
    (f-     e# Return each character value minus the first character.
    26f%    e# Mod 26.
}2*         e# Repeat 2 times.
=           e# Check if they are equal.

— jimmy23013
स्रोत

2

पर्ल, 80

संपादित करें : एक असफल अनुकूलन गोल्फ कोड में फिसल गया था। अब यह अनलॉक्ड वर्जन से मेल खाता है। (बाइट की गिनती सही थी, हालांकि।)

@a=unpack"W*",<>;for(<>=~/./g){$n=ord()-shift@a;$p=!$c++||$p&&$n==$o;$o=$n}say$p

के लिए पर्ल संस्करण 5.10 ( perl -M5.10.0या perl -E …) के साथ चलाएँ say()। थोड़ा विस्तारित संस्करण:

@a=unpack"W*",<>;             # read first string, split and convert to numbers

for(<>=~/./g){                # reads the second string and splits it
   $n=ord()-shift@a;          # convert next character of second string and compare
   $p= !$c++ || $p && $n==$o; # compare differences (special case for first char)
   $o=$n
}

say $p

कोड आउटपुट 1(पर्ल में सत्य) अगर तार सीज़र के बराबर हैं, और खाली स्ट्रिंग (पर्ल में झूठी) तो वे नहीं हैं। यदि यह व्याख्या बहुत ढीली है, तो मुझे इसके लिए 2 बाइट्स जोड़ने की आवश्यकता हैsay$p+0 , जो प्रिंट 1या 0।

चरित्र का मामला इनपुट के बीच मेल खाना चाहिए।

— xebtl
स्रोत

ऊपर दिए गए प्रश्न पर टिप्पणियों के आधार पर, आप कमांड लाइन तर्क के रूप में भी इनपुट ले सकते हैं। आप -iदूसरी स्ट्रिंग में लेने के लिए उपयोग कर सकते हैं , जो इसे चर में संग्रहीत करेगा $^I। इसके अलावा, कमांड लाइन पर चलने के -Eबजाय उपयोग करने -eपर आपको sayमुफ्त में मिलेगा , इसलिए आप इसे बिना किसी बाइट को जोड़कर उपयोग कर सकते हैं। इसे चलाने का प्रयास करें: perl -iteststring -E'say$^I'आप इसे -iट्रिक के साथ छोटा कर सकते हैं ।

— hmatt1

धन्यवाद @chilemagic, -iचाल साफ है (और मुझे यह नहीं पता था!)। इस मामले में मुझे नहीं लगता कि इससे मदद मिलती है क्योंकि इससे $^Iकहीं ज्यादा लंबा समय है <>।

— xebtl

@chilemagic ओह, और इस चर्चा के अनुसार , मैंने -M5.10.0वैसे भी बाइट्स की गिनती नहीं की । (लेकिन मैंने -Eसंपादन में स्विच का उल्लेख किया है )

— xebtl

2

मैटलैब, 49 48 बाइट्स

यह वास्तव में एक त्वरित था। अफसोस की बात है कि स्टड से एक स्ट्रिंग प्राप्त करना काफी महंगा है।

x=@()input('','s');sum(diff(mod(x()-x(),26)))==0

ध्यान दें कि यह सबसे अधिक है, जैसे कि सभी जवाब नहीं, मामला संवेदनशील।

संपादित करें: एक अनाम फ़ंक्शन को परिभाषित करके एक बाइट का मुंडन!

— Oebele
स्रोत

2

प्रोलॉग, 56 बाइट्स

b([],[],_).
b([A|C],[B|D],N):-N is mod(A-B,26),b(C,D,N).

मामलों के सभी संयोजनों का समर्थन नहीं किया जाता है।

प्रयोग

b(`abcd`,`yzab`,_).

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

— Persitz
स्रोत

2

सी, 97 बाइट्स

#define D (*a[2]++-*a[1]+++26)%26
d,r;main(int c,char**a){for(d=D;*a[1];r|=d-D);puts(r?"N":"Y");}

— रेटो कोराडी
स्रोत

1

वाह! आपने शेष राशि बहाल कर दी है!

— DJMcMayhem

यदि आप पुन: उपयोग dकरते हैं तो 4 वर्णों को बचा सकते हैं और aइस प्रकार के मापदंडों को बाहर की तरह घोषित कर सकते हैं : d,r;main(int c,char**a){→r;main(d,a)char**a;{

— rr-

1

स्काला, 57 बाइट्स

(readLine zip readLine map(x=>x._1-x._2%26)toSet).size==1

दूसरों की तुलना में थोड़ा लंबा है, और अनिवार्य रूप से समकक्ष है, लेकिन यह भाषा की एक अलग शैली में है!

मेरा भी यह संस्करण है (56 बाइट्स):

(readLine zip readLine map(_._1-x$1._2%26)toSet).size==1

लेकिन मुझे पता नहीं है कि अगर x $ 1 काम करना संयोग है या डिज़ाइन द्वारा ...

— अन्य लोग
स्रोत

1

यह वास्तव में अजीब है, x$1बिना xपरिभाषित किए काम कैसे होता है?

— दान गेट्ज़

@DanGetz मुझे पूरा यकीन है कि यह एक संकलक अस्थायी है। मैं इसके बारे में ढेर अतिप्रवाह पर एक प्रश्न पूछ सकता हूं: डी

— अन्य

1

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

एक अंतरिक्ष द्वारा अलग किए गए स्टड से 2 समान आवरण वाले तार लेता है:

s,t=raw_input().split();print len(set((ord(c)-ord(d))%26 for c,d in zip(s,t)))<2

निम्नलिखित परीक्षण मामलों पर परीक्षण किया गया:

tests = [
    ("abc", "abc", True),
    ("abcd", "abc", False),
    ("abc", "cde", True),
    ("Abc", "Cde", True),
    ("abc", "deg", False),
    ("Hello", "World", False),
    ("Abcd", "Yzab", True),
    ("", "", True)
]

for s, t, v in tests:
    if len(s) == len(t): # I didn't read that at first
        assert v == (len(set((ord(c) - ord(d)) % 26 for c, d in zip(s, t))) < 2)

— SylvainD
स्रोत

1

पायथन 2 - 241 237 188 147 बाइट्स

उद्धरण में संलग्न लोअरकेस स्ट्रिंग के रूप में इनपुट लेता है, अंतरिक्ष अलग। कोई बेहतर तरीका ज़रूर होगा..

s=[[ord(x)for x in y]for y in input().split()];v=[];v=[v+[(s[1][i]-s[0][i])%26]for i in xrange(0,len(s[0]))];v=sum(v,[]);print sum(v)//v[0]==len(v)

अघोषित (260-विषम बाइट्स)

strs = [[ord(x) for x in y] for y in raw_input().split()]
vals = []
for i in xrange(0, len(strs[0])):
if strs[0][i]<strs[1][i]:
    vals += [strs[1][i]-strs[0][i]]
else:
    vals += [26-(strs[0][i]-strs[1][i])]
return sum(vals)//vals[0] == len(vals)

— Kade
स्रोत

मुझे यकीन है कि आप सभी चर 1 वर्ण लंबे और बाइट्स का एक गुच्छा बचा सकते हैं। आपको अपने स्कोर में 4 भी जोड़ना होगा, जैसा कि आप "अपने इनपुट में 4 s अतिरिक्त की अपेक्षा करते हैं।

@ विविधता मैं विश्वास नहीं कर सकता कि मैंने चर को छोटा नहीं किया .. शौकिया चाल। मैंने बाइट की गिनती में 2 जोड़ा, जैसा कि मैंने ठीक से नहीं बताया; इनपुट "abc cde" की तरह काम करता है।

— काडे

1

आर, 83 84

अन्य समाधानों के समान ही बहुत कुछ। स्ट्रिंग्स को पूर्णांक के वेक्टर में परिवर्तित करें। वैक्टर के अंतर को 26 से कम करें। सूची की लंबाई के अनुसार एक अनूठा करें। 1. यह अपेक्षा करता है कि प्रत्येक स्ट्रिंग में इसी वर्ण के मामले समान हो।

length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2

यह दो तारों के प्रवेश की प्रतीक्षा करता है

> length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2
abcdefghijklmnopqrstuvwxyz
opqrstuvwxyzabcdefghijklmn
[1] TRUE
> length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2
Hello
World
[1] FALSE
> length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2
Bob
Nan
[1] TRUE
>

— MickyT
स्रोत

आप इसके <2बजाय का उपयोग करके एक बाइट बचा सकता है ==1।

— एलेक्स ए।

आप 3 बाइट्स को केवल आउटपुट करके 1या0

@AlexA। धन्यवाद एलेक्स मैंने उस एक को याद किया ... और अब मुझे वह याद आती है :)

— मिकी

@ विविधता: कैसे?

— एलेक्स ए।

@Reticality दुर्भाग्य से यह 1 या एक से अधिक होगा।

— मिकी

1

मतलाब / ऑक्टेव, ५३ ५२

x=@()input('','s');isscalar(unique(mod(x()-x(),26)))

इनपुट सभी एक ही मामले का होना चाहिए।

अफसोस की बात है कि मतलब उपयोगकर्ता इनपुट के साथ बहुत अच्छा नहीं है। अनाम हैंडल के रूप में, यह केवल 35 बाइट्स हो सकता है:

@(a,b)isscalar(unique(mod(a-b,26)))

मतलाब एक स्ट्रिंग के पात्रों को संख्याओं के वेक्टर के रूप में मानता है। घटाव करने से हमें उनका अंतर पता uniqueचलता है , और उस वेक्टर को केवल विशिष्ट मान वाले वेक्टर में परिवर्तित कर देता है। यदि केवल एक ही संख्या है, तो शब्द caeser समतुल्य हैं और isscalar रिटर्न 1 है, अन्यथा यह 0 वापस आएगा।

— FryAmTheEggman
स्रोत

ओह! एक और मतलब की एंट्री! खुद को जवाब देने के बाद ही जवाब दिया।

— ओबेले

बस पता चला कि आप x = @ () इनपुट ('', 's') को परिभाषित करके एक बाइट बचा सकते हैं;

— ओबेले

@ ओबेले धन्यवाद! मुझे लगता है कि मैं मतलाब में और अधिक गोल्फ समस्याओं की कोशिश शुरू करने जा रहा हूं, मैंने इसे वास्तव में मजेदार पाया है।

— FryAmTheEggman

हाँ, यह है। कई समस्याओं के लिए यह अपने मैट्रिक्स-आधारित सामान के साथ बहुत संक्षिप्त हो सकता है। ऑक्टेव में थोड़ा और अधिक मुक्त वाक्यविन्यास है, जो कभी-कभी कुछ और बाइट्स को भी बचा सकता है, जैसे कि इनलाइन चर परिभाषा।

— ओबेले

1

बैश, 71 48

"मानक" यूनिक्स कार्यक्रम का उपयोग करना caesar(6) ।

नया संस्करण (@DigitalTrauma से बहुत मदद के साथ):

read a b;seq -f"caesar %g <<<$a" 26|bash|grep $b

इनपुट्स को एक ही लाइन पर होना चाहिए, स्पेस से अलग किया जाएगा
चरित्र का मामला इनपुट के बीच मेल खाना चाहिए।
1सच के लिए प्रिंट या झूठ के लिए कुछ भी नहीं।

यदि कमांड लाइन तर्कों के माध्यम से इनपुट की अनुमति है, तो इसे 39 बाइट्स तक छोटा किया जा सकता है :

 seq -f"caesar %g <<<$1" 26|bash|grep $2

रिकॉर्ड के लिए पुराना संस्करण:

 read a b;for i in `seq 26`;do [ `echo $a|caesar $i` = $b ]&&echo 1;done

— xebtl
स्रोत

48 बाइट्स, मेरी गिनती से: read a b;seq -f"caesar %g <<<$a" 26|bash|grep $bपरिणाम $?बिलिन चर में होता है, जहां 0 == FALSE और 1 == TRUE, मानक शेल शब्दार्थ के अनुसार।

— डिजिटल ट्रामा

@DigitalTrauma कुछ निफ्टी विचार हैं! मुझे विशेष रूप से seq -f | bashबिट पसंद है । परिणाम $?चुनौती के मेरे पढ़ने से मान्य नहीं है, लेकिन सिर्फ मेरे कोड की तरह, तुम्हारा कुछ भी गलत के लिए और कुछ के लिए सच नहीं है (दो खाली इनपुट तार के सीमावर्ती मामले को छोड़कर)। वैसे भी, यह मेरे जवाब में इस सब का उपयोग करने के लिए धोखा देने जैसा महसूस होगा, शायद आपको अपना खुद का प्रस्तुत करना चाहिए।

— xebtl

चिंता न करें - मैं आपको उपयोग करने के लिए गोल्फ सुझाव दे रहा हूं। अगर मैं उनका उपयोग करना चाहता, तो मैं पहले से ही ऐसा कर चुका होता :)। सत्य / असत्य बात के लिए के रूप में, मैं यह व्याख्या करने के लिए करते हैं कि आपकी दी गई भाषा में क्या सच और गलत है - कोशिश करें [ 0 == 0 ] ; echo $?और[ 0 == 1 ] ; echo $?

— डिजिटल आघात

1

> <> (मछली) , 50 बाइट्स

i:3b*(?v88+0.;n1<
0)?vc1.>~ri-&l?!^i-&:&-2d*%
;n0<

एक ही स्थिति में समान मामले के लिए पत्रों की अपेक्षा करता है।

व्याख्या

i:3b*(?v88+0.लूपिंग जंप प्रदान करने के साथ स्टैक में पहला शब्द पढ़ता है
~ri-&~स्टैक से अलग करने वाले स्थान को हटाता है, स्टैक को उलट देता है r(पहला अक्षर शीर्ष पर होगा), दूसरे शब्द के पहले अक्षर में पढ़ता है i, पहले शब्द के पहले अक्षर से ऑफसेट की गणना करता है -और इसे रजिस्टर में संग्रहीत करता है &।
l?!^i-&:&-2d*%0)?vदूसरे शब्द के हर अगले अक्षर को पहले शब्द के संगत अक्षर से हटाता है, जो स्टैक के शीर्ष पर &:&-होता है, रजिस्टर में संग्रहीत ऑफसेट को हटाता है और जाँचता है कि क्या परिणाम 0 mod 26 है 2d*%। यदि 0 प्रिंट नहीं करता है और समाप्त होता है 0n;।c1.लूपिंग कूद प्रदान करता है।
अगर दूसरे शब्द के अंत तक पहुँच जाता है तो प्रोग्राम 1 प्रिंट करता है और समाप्त हो जाता है 1n;।

— randomra
स्रोत

0

केडीबी (क्यू), 35 बाइट्स

{0=sum(1_-':)mod[;26](-)."i"$(x;y)}

व्याख्या

                         "i"$(x;y)      / convert to ascii decimal
                     (-).               / get differences
             mod[;26]                   / mod 26
      (1_-':)                           / difference between the differences
 0=sum                                  / sum should be 0 if equivalent
{                                 }     / lambda

परीक्षा

q){0=sum(1_-':)mod[;26](-)."i"$(x;y)}["abcd";"yzab"]
1b

— वूइकेंट ली
स्रोत

0

जावा 281

import java.util.*;enum C{E;Scanner s=new Scanner(System.in);public static void main(String[]z){char[]u=E.n(),v=E.n();int i=0,d=(u[0]-v[0]+26)%26;boolean e=true;for(;++i<u.length;)e&=d==(u[i]-v[i]+26)%26;System.out.print(e);}char[]n(){return s.next().toUpperCase().toCharArray();}}

विस्तार:

import java.util.*;
enum Caesar{
    Equivalence;
    Scanner input=new Scanner(System.in);
    public static void main(String[]z){
        char[]firstString=Equivalence.nextInput(),secondString=Equivalence.nextInput();
        int index=0,difference=(firstString[0]-secondString[0]+26)%26;
        boolean isEqual=true;
        for(;++index<firstString.length;)
            isEqual&=difference==(firstString[index]-secondString[index]+26)%26;
        System.out.print(isEqual);
    }
    char[]nextInput(){
        return input.next().toUpperCase().toCharArray();
    }
}

मैं 14 बाइट्स बचा सकता था अगर मुझे सब कुछ अपरकेस में बदलने से छुटकारा मिल गया था, लेकिन मुझे ऐसा लगता है कि इसे छोड़ने के लिए यह अधिक पूर्ण है।

— जैक अम्मो
स्रोत

0

जेली , 5 बाइट्स

Oạ/ċ2

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

समकक्ष के लिए एक सकारात्मक पूर्णांक आउटपुट, 0 अन्यथा

यह काम किस प्रकार करता है

Oạ/ċ2 - Main link. Argument A (a list of strings)  e.g. ["abc", "cde"]

O     - Ordinal. Cast to code point                     [[97, 98, 99], [99, 100, 101]]
  /   - Reduce the list by...
 ạ    -   absolute difference                           [2, 2, 2]
   ċ2 - Count the number of 2s in the list              3

— केर्ड सिक्काहिरिंग
स्रोत

सीजर तुल्यता

मान्य इनपुट

अजगर, 9 बाइट्स

CJam, 17 12 11 बाइट्स

व्याख्या

पायथन 2, 68 67 70 69 बाइट्स

पायथन 3, 67 66 बाइट्स

एपीएल (15)

जे, 19 बाइट्स

जूलिया, 91 87 83 बाइट्स

बग 101 92 बाइट्स के साथ C99, 92 बाइट्स

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

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

व्याख्या

पर्ल, 80

मैटलैब, 49 48 बाइट्स

प्रोलॉग, 56 बाइट्स

सी, 97 बाइट्स

स्काला, 57 बाइट्स

पायथन 2 - 241 237 188 147 बाइट्स

आर, 83 84

मतलाब / ऑक्टेव, ५३ ५२

बैश, 71 48

> <> (मछली) , 50 बाइट्स

केडीबी (क्यू), 35 बाइट्स

व्याख्या

परीक्षा

जावा 281

जेली , 5 बाइट्स

यह काम किस प्रकार करता है