2 स्ट्रिंग्स का सबसे लंबा आम उपसर्ग

Question

एक प्रोग्राम लिखें जो इनपुट के रूप में 2 स्ट्रिंग्स लेता है, और सबसे लंबे समय तक सामान्य उपसर्ग देता है। यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ जवाब।

Test Case 1:

"global" , "glossary"
"glo"


Test Case 2:

"department" , "depart"
"depart"

Test Case 3:

"glove", "dove"
""

Comments

एक और अच्छा परीक्षण का मामला है "aca", "aba"।

— मॉर्गन थ्रैप

क्या आप एक पूर्ण प्रोग्राम चाहते हैं जो STDIN से इनपुट करता है और STDOUT पर प्रिंट करता है, या फ़ंक्शन ठीक हैं?

— xnor

क्या हम मान सकते हैं कि इनपुट में नई लिंक नहीं होंगी? इनपुट में कौन से वर्ण होंगे?

— 23

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

— रैंडम 832

दिए गए सभी उदाहरण लोअरकेस में हैं, लेकिन क्या हमें मामले की संवेदनशीलता के बारे में चिंता करने की ज़रूरत है? उदाहरण के लिए, चाहिए globalऔर GLOSSARYवापसी gloया ''?

— AdmBorkBork 16

Answer 1

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

इस कार्य के लिए एक अंतर्निहित कार्य करने के लिए धन्यवाद पायथन! : डी

import os;print(os.path.commonprefix(input().split()))

इनपुट को दो शब्दों के रूप में लेता है जैसे कि एक स्थान द्वारा अलग किया गया glossary global।

Answer 2

हास्केल, 29 बाइट्स

(c:x)%(d:y)|c==d=c:x%y;_%_=""

उपयोग:

>> "global"%"glossary"
"glo"

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

Answer 3

पायथ, 8 7 बाइट्स

e@F._MQ

धन्यवाद @ बसा 1 बाइट के लिए

उद्धृत इनपुट और अल्पविराम अलग हो जाता है, जैसे "abc", "acc"। यह एक त्रुटि पर बाहर निकलता है (लेकिन रिक्ति को खाली छोड़ देता है) जब परिणाम खाली स्ट्रिंग होता है। यदि यह अस्वीकार्य है, तो इसके लिए 2 बाइट्स जोड़ें#e@F._MQq

परीक्षण सूट

व्याख्या

e@F._MQ        : implicit Q = eval(input)
   ._MQ        : Map the prefix operator onto both inputs
 @F            : Fold the setwise intersection operator over those lists
e              : Take the last such element, the prefixes are always made from shortest
               : to longest, so this always gives the longest matching prefix

Comments

परिणाम बिना त्रुटि के रिक्त स्ट्रिंग बनाने के लिए e|@F._M.z]k:।

— kirbyfan64sos

@ kirbyfan64sos मुझे विश्वास है कि जिस चीज के बारे में मैंने इसे आसपास रखा है, वह इससे #...qएक बाइट कम है, मैं इसे पूर्ण कोड में संपादित करूंगा, मुझे लगता है कि भ्रामक है

— FryAmTheEggman

फॉर्म में इनपुट लें "abc", "def"और आप Qइसके बजाय.z

— isaacg

Answer 4

सी ++, 101 100 99 बाइट्स

#include<iostream>
int i;main(){std::string s,t;std::cin>>s>>t;for(;s[i]==t[i];std::cout<<s[i++]);}

से दो तारों को पढ़ता है stdin, एक तार से वर्तमान स्थिति में चरित्र को प्रिंट करता है जबकि वर्तमान स्थिति पर चरित्र दूसरे स्ट्रिंग में उसी स्थिति के चरित्र के बराबर है।

एक बाइट को बचाने के लिए ज़ेरेगेस को धन्यवाद ।

Comments

यह forकथन का एक सुंदर और भयानक उपयोग है ...

— जोशपब्रॉन

यदि तार बराबर थे, तो लूप समाप्त करने में विफल होगा।

— जॉन ट्रंटवेविन 23

व्हॉट्सएप वाले स्ट्रिंग्स के लिए काम नहीं करेंगे। int iवैश्विक अंतरिक्ष में बनाकर आप एक बाइट को बचा सकते हैं (ताकि यह 0 प्रारंभिक हो जाएगा)

— ज़ेरेगेस

@JonTrauntvein मुझे लगता है कि मामला UB (?) है। हालांकि यह मेरे लिए ™ काम करता है। (gcc-5.1)

— स्वेरापॉटो

Answer 5

हास्केल, 38 बाइट्स

((map fst.fst.span(uncurry(==))).).zip

प्रयोग उदाहरण: ( ((map fst.fst.span(uncurry(==))).).zip ) "global" "glossary"-> "glo"।

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

Answer 6

CJam, 12 11 9 बाइट्स

l_q.-{}#<

यह दो अलग-अलग लाइनों पर स्ट्रिंग को यूनिक्स-शैली की रेखा के साथ समाप्त होता है, अर्थात, पढ़ता है <string>\n<string>\n।

-1 बाइट के लिए @ मार्टिनबटनर और -2 बाइट्स के लिए @ jimmy23013 को धन्यवाद!

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

l_         e# Read a line (w/o trailing LF) from STDIN and push a copy.
  q        e# Read another line from STDIN (with trailing LF).
           e# The trailing linefeed makes sure that the lines are not equal.
   .-      e# Perform vectorized character subtraction. This yields 0 for equal
           e# characters, a non-zero value for two different characters, and the
           e# characters themselves (truthy) for the tail of the longer string.
     {}#   e# Find the index of the first truthy element.
        <  e# Keep that many characters from the first string.

Comments

डार, मुझे विश्वास नहीं हो सकता है कि मेरा पहला उत्तर इतना करीब था!

— जिओवेल

आप एक अनुगामी न्यूलाइन और उपयोग मानकर थोड़ा धोखा दे सकते हैं l_q.-।

— jimmy23013

@ jimmy23013 यह यूनिक्स की तरह ओएस पर इनपुट के लिए मानक है, तो क्यों नहीं? धन्यवाद!

— डेनिस

Answer 7

एपीएल, १३

{⊃↓K/⍨=⌿K←↑⍵}

यह एक ऐसा फ़ंक्शन है जो दो स्ट्रिंग्स की एक सरणी लेता है, और उपसर्ग लौटाता है:

      {⊃↓K/⍨=⌿K←↑⍵}'glossary' 'global'
glo
      {⊃↓K/⍨=⌿K←↑⍵}'department' 'depart'
depart

Comments

क्या यह कहना उचित है कि एपीएल वर्णमाला बाइट के आकार के वर्णों की वर्णमाला है? या वह मानक अभ्यास यहाँ के आसपास है?

— फिलिप्पा

@Filipq उत्तर यहाँ भाषा के लिए सबसे अधिक प्राकृतिक कूटबन्धन का उपयोग करता है। APL का अपना कोड पेज होता है, जिस पर प्रत्येक वर्ण एक सिंगल बाइट होता है।

— एलेक्स ए।

Answer 8

AppleScript, 215 बाइट्स

और मैंने बहुत कोशिश की ...;

x को सेट करें (संवाद "" डिफ़ॉल्ट उत्तर "") का पाठ वापस आ गया
एक सेट (प्रदर्शन संवाद "" डिफ़ॉल्ट उत्तर "") का पाठ वापस आ गया
1 से n सेट करें
"ओ" पर सेट करें
x के आइटम n = एक आइटम n के दौरान दोहराएं
सेट ओ से ओ एंड एक्स के आइटम एन
n से n + 1 पर सेट करें
समाप्त
ओ

मैं देखना चाहता था कि AppleScript इसे कितनी अच्छी तरह से खींच सकता है, और आदमी इसे स्ट्रिंग तुलना के लिए नहीं बनाया गया है।

Comments

AppleScript किसी भी चीज़ के लिए नहीं बनाया गया था ।

— kirbyfan64sos

केवल एक चीज जो मैं इसके अलावा भयानक गोल्फ के लिए उपयोग करता हूं tell app "System Events" to <something>। यह है कि यह कैसे सामान इस तरह का साथ सौदों को देखने के लिए, हालांकि दिलचस्प। @ kirbyfan64sos

— Addison Crump

Answer 9

आरएस , 14 बाइट्स

(.*).* \1.*/\1

लाइव डेमो और परीक्षण के मामले।

यह बहुत आसान है। यह सिर्फ मेल खाता है ... सबसे लंबा सामान्य उपसर्ग है और बाकी स्ट्रिंग को हटा देता है। यदि कोई सबसे लंबा सामान्य उपसर्ग नहीं है, तो यह सब कुछ साफ करता है।

Answer 10

सेड, १ 18

मेरे मन में कुछ अधिक लंबा और अधिक जटिल था, इसलिए इस विचार का श्रेय @ kirbyfan64sos को जाता है ।

s/(.*).* \1.*/\1/

इसमें -rsed के विकल्प के लिए +1 शामिल है ।

Comments

आपका मूल विचार क्या था?

— kirbyfan64sos

@ kirbyfan64sos इसमें मूल रूप से एक के बाद एक पात्रों के माध्यम से लूपिंग करना और एक बेमेल पर रोक शामिल है। यह सिर्फ एक विचार था - इसके पीछे कोई कोड नहीं।

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

Answer 11

सीजाम, 12 8 26

r:AAr:B.=0#_W={;;ABe<}{<}?

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

(उपयोग करने के लिए विचार मिला। = डेनिस के जवाब को देखने के बाद।

सभी किनारे के मामलों के साथ, मेरे जैसे CJam के लिए इसे छोटा रखना कठिन हो गया। उम्मीद है, यह कम से कम सभी मामलों के लिए काम करता है।

Answer 12

सी #, 201 147 बाइट्स

using System.Linq;class a{static void Main(string[]a){a[0].Take(a[1].Length).TakeWhile((t,i)=>a[1][i]==t).ToList().ForEach(System.Console.Write);}}

मुझे पता है कि यह बहुत प्रतिस्पर्धी नहीं है। मैं बस यह देखना चाहता था कि यह कैसा दिखेगा।

EDIT: थैंक्स ऐश बर्लक्ज़ेंको, बेरेन्ड, और डेनिस_ई

Comments

बस 250 बाइट्स के तहत C # उत्तर प्राप्त करना प्रतिस्पर्धी है। इसके अलावा, आप बस नहीं कर सकते using System.*?

— ताली

.ForEach(x=>Console.Write(x))को छोटा किया जा सकता है.ForEach(Console.Write)

— एश बर्लज़ेंको

using System.Collections.Generic;अनावश्यक है। अंतरिक्ष को हटाकर एक और बाइट को शेव करें string[] a।

— बेरेंड

1- Containsअनावश्यक है। 2-आप कुछ बाइट्स को हटाकर using System;और कहकर बचा सकते हैं System.Console.Write;3-यह कोड गलत परिणाम ("ए") इनपुट "एएबी", "आब" के कारण देता है IndexOf। सबसे छोटा फिक्स जो मैं सोच सकता था कि a[0].Take(a[1].Length)यह 147 बाइट्स लंबा है: "System.Linq का उपयोग करके; क्लास ए {स्टेटिक शून्य मेन (स्ट्रिंग [] a] {a [0] .Take ([[1] .Length) .ThWhile ((c, i) => a [1] [i] == c) .TLList ()। ForEach (System.Console.Write);}}}

— Dennis_E

टिप्पणियों के लिए धन्यवाद जब मुझे अवकाश मिलता है तो मैं उन सभी पर विशेष रूप से डेनिस_ई की टिप्पणी पर एक अच्छी नज़र डालूंगा।

— जकोथशेड्स

Answer 13

आम लिस्प, 39

(lambda(a b)(subseq a 0(mismatch a b)))

दो स्ट्रिंग तर्क लेता है, सूचकांक को निर्धारित करता है कि मैं कहां भिन्न हूं , और 0 से i तक एक विकल्प देता है ।

Answer 14

पर्ल 5, 20 19 18 बाइट्स

19 बाइट्स, इसके अलावा -Eध्वज के लिए 1 -e:

say<>=~/^(.*).* \1/

यह बेशर्मी से डिजिटल ट्रॉमा के sed उत्तर से कॉपी किया गया है । यह मानता है कि इनपुट उन स्थानों के बिना (या पहले) और उनके बीच एक स्थान के बिना शब्दों का एक जोड़ा है।

---

अद्यतन करें:

ThisSuitIsBlackNot ने -peबाइट को बचाने के लिए इस प्रकार उपयोग करने का सुझाव दिया (धन्यवाद!)।

($_)=/^(.*).* \1/

और फिर लुक स्टॉर्म ने -nEएक और बाइट बचाने के लिए इस प्रकार उपयोग करने का सुझाव दिया (धन्यवाद!):

say/^(.*).* \1/

(मैं -Eमानक के बजाय एक बाइट के रूप में गिन रहा हूं -e, लेकिन -nया -pदो के रूप में। मेरी धारणा यह है कि यहां चारों ओर एसओपी है।)

Comments

" -M5.010, जब जरूरत होती है, स्वतंत्र है" । एक ही मेटा पोस्ट के अनुसार, -peया -ne1 अतिरिक्त बाइट होगा, न कि 2. तो perl -nE 'say/^(.*).* \1/'स्कोर 16 बाइट्स होगा।

— ThisSuitIsBlackNot 21

Answer 15

अजगर 3, 72

31 बाइट्स ने FryAmTheEggman को धन्यवाद दिया। 8 डीएसएम के लिए धन्यवाद बचाया।

r=''
for x,y in zip(input(),input()):
 if x==y:r+=x
 else:break
print(r)

Comments

अजगर प्रोग्रामर के बिना क्या करेंगे zip? : डी

— बीटा डिके

@BetaDecay हमारी उड़ान हर समय खुली रहेगी।

— मॉर्गन थ्रैप

आप input()s को अंदर रख सकते हैं zipऔर सहेज सकते हैं aऔर bबांध सकते हैं।

— DSM

@DSM Ooo, अच्छी बात है। धन्यवाद!

— मॉर्गन थ्रैप 22

Answer 16

पायथन 3, 47

def f(w):[print(end=c[c!=d])for c,d in zip(*w)]

एक फ़ंक्शन जो wदो शब्दों की एक सूची लेता है , और एक त्रुटि के साथ समाप्त करने से पहले सामान्य उपसर्ग प्रिंट करता है।

पायथन 3 के printफंक्शन से आप print(end=c)स्ट्रेट्स को एक दूसरे के खिलाफ फ्लश कर सकते हैं (इस छोटे सिंटैक्स के साथ 3 बाइट बचाने के लिए Sp3000 के लिए धन्यवाद)। यह बार-बार शब्दों से दो अक्षर लेता है, और पहले अक्षरों को प्रिंट करता है। अनुक्रमण c[c!=d]एक आउट-ऑफ-बाउंड त्रुटि देता है c!=d, जहां दो असमान पत्रों का सामना होने पर निष्पादन को समाप्त कर देता है।

लूप के लिए एक स्पष्ट सूची समझ से अधिक लंबा है:

def f(w):
 for c,d in zip(*w):print(end=c[c!=d])

Comments

वाह! मैं भी एक समारोह का उपयोग करने के बारे में नहीं सोचा था! अच्छा है। +1

— ज़ैच गेट्स

केवल अब यह देखा, लेकिन कैसे के बारे में print(end=c[c!=d])?

— Sp3000

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

— xnor

Answer 17

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

f=(a,b)=>[...a].filter((e,i)=>e==b[i]?1:b='').join``

उपयोग:

>> f("global","glossary")
"glo"

Comments

साथ काम नहीं करता ada,aca...

— 22

वूप्स, फिक्स्ड। स्ट्रिंग्स के बाद फ़िल्टरिंग को मारना न भूलें।

— डेंड्रोबियम

तो आप छोड़ सकते हैं आप, समारोह के नाम की जरूरत नहीं हैf=

— Ypnypn

आप इसे मानचित्र के साथ छोटा कर सकते हैं(a,b)=>[...a].map((e,i)=>e==b[i]?e:b='').join``

— शॉन एच

Answer 18

रेटिना , 14 बाइट्स

Kirbyfan64sos के समान विचार का उपयोग करता है । दुर्भाग्य से, मार्टिन के दावे के बावजूद कि अंततः मैच मोड में कैप्चरिंग समूहों को प्रिंट करने का एक तरीका होगा, इसे अभी तक लागू नहीं किया गया है। अन्यथा,(.*).* \1 2 बाइट्स के साथ या कुछ-अभी-मौजूदा कॉन्फ़िगरेशन स्ट्रिंग विकल्प के लिए उपयोग किया जा सकता है।

(.*).* \1.*
$1

प्रत्येक लाइन अपनी फ़ाइल में जाएगी, जिसमें 1 बाइट अतिरिक्त फ़ाइल प्रति जोड़ी जाएगी। वैकल्पिक रूप से, -sध्वज के साथ एक फ़ाइल में चलाएं ।

Comments

लालच के कारण समतुल्य रेगीक्स मेल करने में विफल रहता है (और एक गैर-लालची रेगेक्स सबसे छोटे विकल्प , यानी रिक्त) से मेल खाएगा , क्या आप सुनिश्चित हैं कि यह काम करता है?

— 16

@ Random832 इस रेगेक्स रिप्लेस टेस्टर का उपयोग करके देखें । ऑपरेशन को "बदलें" पर सेट करें, और पैटर्न को सही बक्से में रखें। यदि एक होना चाहिए तो यह मेल नहीं खाता। लालच के कारण यह कैसे संभव हो सकता है ? यही कारण है कि यह काम करता है। \1सुनिश्चित करता है कि दोनों शब्द एक ही उपसर्ग से शुरू होते हैं। तो लालच कैसा (.*)भी हो, \1एक ही है।

— mbomb007

Vim में यह बिल्कुल भी मिलान करने से इंकार करता है - मुझे लगता है कि यह पहली (। *) के लिए एक लंबी स्ट्रिंग ढूंढ रहा है, फिर इसे \ 1 के खिलाफ मैच करने में विफल रहा, फिर ठीक से छोटे तारों के पीछे नहीं।

— 16

@ Random832 फिर आपको अपने रेगेक्स का परीक्षण करने के लिए कुछ और खोजने की आवश्यकता है।

— mbomb007

Answer 19

के, 24 बाइट्स

{(+/&\=/(&/#:'x)#'x)#*x}

प्रत्येक स्ट्रिंग की लंबाई का न्यूनतम पता लगाएं। ( (&/#:'x))। प्रत्येक स्ट्रिंग को उस लंबाई ( #'x) में ट्रिम करें । फिर परिणामी अनुक्रम की तुलना करें, स्मियर करें और योग करें:

  =/("globaa";"glossa")
1 1 1 0 0 1
  &\=/("globaa";"glossa")
1 1 1 0 0 0
  +/&\=/("globaa";"glossa")
3

अंत में, प्रदान किए गए तारों में से पहले से कई अक्षर लें (#*x ) ।

कार्रवाई में:

 f: {(+/&\=/(&/#:'x)#'x)#*x};
 f'(("global";"glossary")
    ("department";"depart")
    ("glove";"dove")
    ("aaa";"aaaaa")
    ("identical";"identical")
    ("aca";"aba"))
("glo"
 "depart"
 ()
 "aaa"
 "identical"
 ,"a")

Answer 20

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

स्ट्रिंग्स की तुलना करें, पहले को सिकोड़ें जब तक यह या तो मेल नहीं खाता (प्रिंट और बाहर निकलता है) या स्ट्रिंग शून्य है और लूप समाप्त हो जाता है।

param($a,$b)while($a){if($b-like"$a*"){$a;exit}$a=$a-replace".$"}

Answer 21

जूलिया, 62 बाइट्स

f(a,b)=(c="";for(i,j)=zip(a,b) i!=j?break:(c*=string(i))end;c)

Ungolfed:

function f(a::AbstractString, b::AbstractString)
    # Initialize an output string
    c = ""

    # Iterate over the pairs of characters in a and b,
    # truncated to the shorter of the two lengths
    for (i, j) in zip(a, b)
        if i == j
            # If they match, append to the output string
            c *= string(i)
        else
            # Otherwise stop everything!
            break
        end
    end

    return c
end

एक मुद्दा फिक्स्ड (14 बाइट्स की भारी लागत पर) xnor के लिए धन्यवाद!

Answer 22

C99, 73 बाइट्स

main(int c,char *a[]){for(char *x=a[1],*y=a[2];*x==*y++;putchar(*x++));}

इस उत्तर के समान , लेकिन छोटा और युक्ति से मिलता है (स्टड से इनपुट लेता है)।

Comments

युक्ति यह नहीं कहती है कि इनपुट को स्टडिन से आना है। यदि आप जोड़ते हैं #include<stdio.h>, तो यह वास्तव में अन्य उत्तर से अधिक लंबा है , जो कार्यक्रम को संकलित करने के लिए आवश्यक है।

— मसरथिमिया

@AndrewCashner - यह स्टड पर होने की आवश्यकता नहीं है, लेकिन इसे इनपुट लेने की आवश्यकता है। अन्य उत्तर हार्ड कोडित है। इसके अलावा, निहितार्थ के उपयोग के बारे में सनकी कहते हैं, लेकिन यह शामिल किए बिना ठीक संकलन करता है।

— कोमिन्टर्न

अस्थायी लोगों के बिना बहुत कम: main(int c,char**a){for(;*a[1]==*a[2]++;putchar(*a[1]++));}(59 बाइट्स)।

— टोबी स्पाइट

Answer 23

MATLAB, 50 40 बाइट्स

एक फ़ंक्शन को परिभाषित करता है जो इनपुट के रूप में 2 तारों को स्वीकार करता है, कमांड विंडो के लिए आउटपुट

function t(a,b);a(1:find([diff(char(a,b)) 1],1)-1)

यह समाधान किसी भी स्ट्रिंग, आउटपुट के लिए काम करेगा

ans =

   Empty string: 1-by-0

अगर कोई मैच नहीं दिया जाता है।

किसी फ़ंक्शन के बजाय स्क्रिप्ट का उपयोग करके गोल्फ किया जा सकता है (स्थानीय चर a, b का उपयोग करके) (-16 बाइट्स)।

इसलिए 34 बाइट्स मिल रही हैं

a(1:find([diff(char(a,b)) 1],1)-1)

फ़ंक्शन शैली (जो स्वीकृत शैली प्रतीत होती है), पैदावार

@(a,b)a(1:find([diff(char(a,b)) 1],1)-1)

(साभार @Stewie ग्रिफिन)

Comments

40 बाइट्स @(a,b)a(1:find([diff(char(a,b)) 1],1)-1):। =)

— स्टिव ग्रिफ़िन

Answer 24

पर्ल 6 , 28 बाइट्स

मैं दो के साथ आया हूं जो STDIN से उनके मूल्यों को लेते हैं जो पर्ल 5 उत्तर पर आधारित हैं।

lines~~/(.*).*' '$0/;say ~$0

lines~~/:s(.*).* $0/;say ~$0

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

---

यह मेरे द्वारा आजमाई गई पहली चीज़ से काफी कम है, जो कमांड लाइन से मान लेता है।

say [~] map ->($a,$b){$a eq$b&&$a||last},[Z] @*ARGS».comb # 58 bytes

या यहां तक ​​कि इसका लंब संस्करण भी:

{[~] map ->($a,$b){$a eq$b&&$a||last},[Z] @_».comb} # 52 bytes

हालांकि यह समायोजित करने के लिए बहुत आसान है ताकि यह केवल एक स्ट्रोक की कीमत पर किसी भी संख्या में इनपुट स्ट्रिंग्स को स्वीकार करे।

{[~] map ->@b {([eq] @b)&&@b[0]||last},[Z] @_».comb} # 53 bytes
#          ┗━┛ ┗━━━━━━━┛  ┗━━━┛

my &common-prefix = {[~] map ->@b {([eq] @b)&&@b[0]||last},[Z] @_».comb}

say common-prefix <department depart>; # "depart"
say common-prefix; # ""
say common-prefix <department depart depot deprecated dependant>; # "dep"

# This code does not work directly with a single argument, so you have
# to give it an itemized List or Array, containing a single element.

say common-prefix $('department',); # "department"

# another option would be to replace `@_` with `(@_,)`

Answer 25

जाप, 27 बाइट्स

Japt , Ja vaScri pt का छोटा संस्करण है । दुभाषिया

Um$(X,Y)=>$A&&X==VgY ?X:A=P

(तार इनपुट बॉक्स में जाते हैं जैसे: "global" "glossary" )

यह कोड निम्नलिखित JS के समतुल्य है:

A=10;(U,V)=>U.split``.map((X,Y)=>A&&X==V[Y]?X:A="").join``

मैंने अभी तक अनाम कार्यों को लागू नहीं किया है, जो यह $...$है: जेएस के स्विच में डॉलर के संकेतों के बीच कुछ भी अछूता नहीं है। मेरे द्वारा फ़ंक्शन जोड़ने के बाद, यह 21-बाइट कोड पर्याप्त होगा:

UmXY{A&&X==VgY ?X:A=P

और मैं कुछ और सुविधाएँ लागू करने के बाद, यह आदर्श रूप से 18 बाइट्स होगा:

UmXY{AxX=VgY ?X:AP

सुझावों का स्वागत है!

---

तो यह पता चला है कि यह कार्यक्रम आधुनिक जाप में केवल 15 बाइट्स है:

¡A©X¥VgY ?X:A=P

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

Answer 26

MATL , 11 9 बाइट्स

y!=XdYpf)

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

(-2 बाइट्स ग्यूसेप के लिए धन्यवाद)

 y  % implicitly input the two strings, then duplicate the
    %  first one into the stack again
    %  stack: ['department' 'deported' 'department']
 !  % transpose the last string into a column vector
 =  % broadcast equality check - gives back a matrix comparing
    %  every letter in first input with the letters in the second
 Xd % diagonal of the matrix - comparison result of each letter with
    %  only corresponding letter in the other string
    %  stack: ['department' [1; 1; 1; 0; 1; 1; 0; 0;]]
 Yp % cumulative product (so only initial sequence of 1s remains
    %  1s, others become 0)
    %  stack: ['department' [1; 1; 1; 0; 0; 0; 0; 0;]]
 f  %  find the indices of the 1s
 )  % index at those elements so we get those letters out
    % (implicit) convert to string and display

Comments

धन्यवाद! यह yविचार बहुत अच्छा है, मैंने itiइसके बजाय शुरुआती चीजों की कोशिश की 1Gw, लेकिन इसके yलिए उपयोग करने के बारे में नहीं सोचा ।

— सूंदर -

Answer 27

क्लोजर / क्लोजुरस्क्रिप्ट, 51

(defn f[[a & b][c & d]](if(= a c)(str a(f b d))""))

बहुत सीधा। दुर्भाग्य से पैरामीटर विनाश के आसपास के रिक्त स्थान आवश्यक हैं (यह [a & b]सामान है)। कम से कम नहीं, लेकिन मैंने भाषाओं के कुछ अन्य जवाबों को हराया जो उनके थकाऊपन के बारे में डींग मारना पसंद करते हैं इसलिए मैं इसे पोस्ट करूंगा।

Answer 28

अजगर 2, 50 बाइट्स

for a,b in zip(*input()):print(1/0if a!=b else a),

---

इनपुट

इनपुट को दो तारों के रूप में लिया जाता है:

"global", "glossary"

---

उत्पादन

आउटपुट प्रत्येक वर्ण है जिसके बाद एक स्थान है; जो, उम्मीद है, एक समस्या नहीं है। हालाँकि, अगर ऐसा है, तो मैं अपना उत्तर संपादित करूँगा।

g l o 

Comments

मुझे पूरा यकीन है कि यह अमान्य है; स्पेस के बिना स्ट्रिंग के रूप में आउटपुट का प्रारूप स्पष्ट रूप से दिया गया था।

— lirtosiast

हां, लेकिन इनपुट प्रारूप "global" , "glossary"(दो अलग-अलग तारों) में भी दिया गया था .. कितने अन्य उत्तर पत्र का अनुसरण करते हैं? @ThomasKwa

— Zach गेट्स

"दो तार लेता है" ओपी द्वारा इस्तेमाल की जाने वाली भाषा है; आमतौर पर जब ऐसा कुछ होता है जो बिना किसी क्वालिफायर के उल्लेख किया जाता है, तो यह हमारे डिफ़ॉल्ट I / O में से एक को संदर्भित करता है , जिसका अर्थ है कि हम कमांड लाइन से एक स्ट्रिंग और एसटीडीआईएन से एक या दो तार की एक सरणी ले सकते हैं, या जो कुछ भी उनका अनुसरण करता है। नियम।

— lirtosiast

मुझे लगता है कि आप मेरे उत्तर को थोड़ा गंभीरता से ले रहे हैं। यह सिर्फ एक मजेदार सबमिशन है और एक बिल्ट-इन पिटाई का मेरा सबसे अच्छा प्रयास है। अगर ओपी आउटपुट फॉर्मेट को पसंद नहीं करता है, तो यह हो; मैं अपना उत्तर हटा दूंगा। @ThomasKwa

— Zach गेट्स

कैसे के बारे में print(exit()if a!=b else a,end='')? मुझे नहीं पता कि वह काम करेगा या नहीं, लेकिन यह हो सकता है

— बीटा डिके

Answer 29

TeaScript, 16 बाइट्स 20

xf»l¦y[i]?1:b=0)

प्रत्येक इनपुट को एक स्थान से अलग करता है।

Answer 30

PHP, 52 बाइट्स

शानदार नहीं है लेकिन काम करता है:

$a=$argv;while($a[1][$i]==$a[2][$i])echo$a[1][$i++];

दो कमांड लाइन तर्क देता है:

php prefix.php department depart

Comments

PHP7 आपको एक और बाइट बचाने की अनुमति देता है while(($a=$argv)[1][$i]==$a[2][$i])echo$a[1][$i++];- एक और PHP7 एकमात्र समाधान (और सबसे अच्छा मैं @ 50 बाइट्स के साथ आ सकता है) <?=substr(($a=$argv)[1],0,strspn($a[1]^$a[2],~ÿ));- सुनिश्चित करें कि आपका संपादक एससीआई मोड में है, यह महत्वपूर्ण है कि ~ÿयह यूनिकोड में परिवर्तित न हो।

— लेह