सबसे छोटा अनोखा पदार्थ

Question

दिया (एसटीडीआईएन पर, कमांड लाइन तर्क के रूप में, या फ़ंक्शन तर्क के रूप में) दो अलग-अलग गैर-खाली स्ट्रिंग्स, पहले स्ट्रिंग के सबसे छोटे विकल्प को ढूंढें और वापस लौटें जो दूसरे का विकल्प नहीं है। यदि ऐसा कोई विकल्प मौजूद नहीं है, तो आप खाली स्ट्रिंग वापस कर सकते हैं, कोई भी स्ट्रिंग लौटा सकते हैं जो मूल स्ट्रिंग का विकल्प नहीं है, या एक अपवाद फेंकें। यदि आप किसी फ़ंक्शन से लौट रहे हैं, तो आप इस मामले में अशक्त (या अपरिभाषित, कोई नहीं, आदि) भी लौट सकते हैं। यदि इस तरह के कई सबस्ट्रिंग कम से कम बंधे हैं, तो आप उनमें से किसी एक को वापस कर सकते हैं।

स्ट्रिंग्स में किसी भी मुद्रण योग्य एएससीआई अक्षर शामिल हो सकते हैं।

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

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

कुछ टेस्ट केस

इनपुट:

STRING ONE
STRING TWO

उत्पादन:

E

इनपुट:

A&&C
A&$C

वैध परिणाम:

&&
&C

इनपुट:

(दो बेतरतीब ढंग से उत्पन्न 80-अक्षर तार)

QIJYXPYWIWESWBRFWUHEERVQFJROYIXNKPKVDDFFZBUNBRZVUEYKLURBJCZJYMINCZNQEYKRADRYSWMH
HAXUDFLYFSLABUCXUWNHPSGQUXMQUIQYRWVIXGNKJGYUTWMLLPRIZDRLFXWKXOBOOEFESKNCUIFHNLFE

सभी वैध परिणाम:

AD
BJ
BR
CZ
DD
EE
ER
EY
EY
FF
FJ
FW
FZ
HE
IJ
IN
IW
JC
JR
JY
KL
KP
KR
KV
LU
MH
MI
NB
NQ
OY
PK
PY
QE
QF
QI
RA
RB
RF
RO
RV
RY
RZ
SW
UE
UH
UN
UR
VD
VQ
VU
WB
WE
WI
WU
XN
XP
YI
YK
YK
YM
YS
YW
YX
ZB
ZJ
ZN
ZV

Comments

सबसे छोटा या सबसे लंबा?

— लीक नून

@FryAmTheEggman तब मुझे अभी भी अपना समाधान पोस्ट करना चाहिए ...

— लीक नून

"प्रत्येक पंक्ति पर एक स्ट्रिंग" उद्धरण के साथ या बिना?

— लीक नन

क्या हम तार की एक सरणी ले सकते हैं?

— डेनिस

क्या "बी" "एबीसी" का एक विकल्प है?

— downrep_nation

Answer 1

ब्रेकीलॉग , 23 बाइट्स

:1foh.,{,.[A:B]hs?'~sB}

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

दुर्भाग्य से मैंने अभी तक नए प्रोल ट्रांसपाइलर में निर्मित सबसेट को कोडित नहीं किया है।

व्याख्या

:1f               Find all bindings which satisfy predicate 1 with that binding as input and
                  with the Input of the main predicate as output.
   oh.,           Order that list of bindings, and unify the output with the first one.

{
 ,.[A:B]          Unify the output with the list [A,B]
        hs?       Unify the input with a subset of A
           '~sB   Check that no subset of B can be unified with the input
               }

Answer 2

अजगर, 119 115 91

lambda a,b:[a[m:m+n]for n in range(1,len(a)+1)for m in range(len(a))if a[m:m+n]not in b][0]

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

| Input 1  | Input 2     | Output        |
|----------+-------------+---------------|
| 'abcd'   | 'abc'       |  'd'          |
| 'abcd'   | 'dabc'      |  'cd'         |
| 'abcd'   | 'dcbabbccd' |  'abc'        |
| 'abcdf'  | 'abcdebcdf' |  'abcdf'      |
| 'abc'    | 'abc'       |  (IndexError) |

इसे छोटा बनाने पर काम कर रहा है, लेकिन यह मेरी दिमागी वृत्ति है। अभी तक एक गोल्फ खिलाड़ी का वास्तव में नहीं है।

अतिरिक्त बाइट्स के लिए @ user81655 और @NonlinearFruit को धन्यवाद।

संपादित करें :

डैंग। इस कोड की कोशिश की:

def z(a,b):
 for s in [a[m:m+n]for n in range(1,len(a)+1)for m in range(len(a)-n+1)]:
  if s not in b:return s
 return''

सोचा कि यह कुछ बाइट्स छोटा था। पता चलता है कि मैं संपादित करने से पहले क्या था की तुलना में 1 बाइट लंबा था।

Comments

मैं बहुत अजगर नहीं जानता, लेकिन शायद आप (r=range)(1,len(a)+1)तब उपयोग कर सकते हैं r?

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ इसे इस तरह से नहीं कर सकते। अगर मैं ऊपर की लाइन में असाइन rangeकरता हूं r, तो यह वास्तव में एक बाइट जोड़ता है। अच्छा विचार है, यद्यपि। शायद सबस्ट्रिंग के माध्यम से पुनरावृति करने का एक छोटा तरीका है।

— टेलर लोपेज

range(1,len(a))और range(len(a)-1)यह काम नहीं करना चाहिए? इसके अलावा, मुझे लगता है कि दो अंतरिक्ष इंडेंट के लिए एक टैब चरित्र का उपयोग एक बाइट को बचाएगा।

— user81655

नहीं, के साथ range(1,len(a)), 4 वें परीक्षण कास्ट विफल हो जाता है क्योंकि यह पूर्ण स्ट्रिंग की कोशिश नहीं करेगा; यह केवल स्ट्रिंग की लंबाई तक ही जाएगा - 1. और range(len(a)-1), 1 परीक्षण का मामला विफल हो 'cd'जाता है बस के बजाय वापस आ रहा है 'd'। हालांकि वहाँ कुछ हो सकता है।

— टेलर लोपेज

क्षमा करें, मैं पायथन से परिचित नहीं हूं और मैंने माना कि सीमाएं समावेशी थीं। उस मामले में range(1,len(a)+1)और प्रयास करें range(len(a))।

— user81655

Answer 3

पायथन, 87 86 बाइट्स

lambda s,t,e=enumerate:[s[i:i-~j]for j,_ in e(s)for i,_ in e(s)if(s[i:i-~j]in t)<1][0]

यदि यह मौजूद है, तो यह सबसे छोटे अनूठे सबस्ट्रिंग में से सबसे पीछे लौटेगा।

यदि कोई अद्वितीय विकल्प नहीं है, तो एक IndexError उठाया जाता है।

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

Comments

वो रहा। मैं अपने गैर-लंबू कार्यान्वयन को मारने के लिए किसी की प्रतीक्षा कर रहा था। अच्छा लोल

— टेलर लोपेज

मुझे लगता है कि आप वैकल्पिक दूसरा तर्क को आपूर्ति के द्वारा इस छोटे से कर सकते हैं enumerateशुरू करने के लिए jपर i+1।

— user2357112

@ user2357112 यह दुर्भाग्य से, NameError फेंकता है । कोड jपहले परिभाषित करता है , फिर i।

— डेनिस

@ डेनिस: हाँ, लेकिन इसकी आवश्यकता नहीं है। आप लूप ऑर्डर को स्विच कर सकते हैं।

— user2357112

@ user2357112 यदि मैं लूप ऑर्डर को स्विच करता हूं, तो यह पाया जाने वाला पहला अनूठा विकल्प सबसे छोटा नहीं हो सकता है। बस 'ab'इनपुट के लिए ऑर्डर रिटर्न स्वैप करना 'abc','aaa'।

— डेनिस

Answer 4

पायथन, 82 बाइट्स

g=lambda u:{u}|g(u[1:])|g(u[:-1])if u else{''}
f=lambda s,t:min(g(s)-g(t),key=len)

उपयोग: f('A&&C', 'A&$C')-> रिटर्न'&&'

अगर कोई उपयुक्त विकल्प नहीं है, तो ValueError बढ़ाएं।

स्पष्टीकरण:

g=lambda u:{u}|g(u[1:])|g(u[:-1])if u else{''}पुनरावर्ती u f=lambda s,t:min(g(s)-g(t),key=len)सेट के अंतर से सबसे कम स्थानापन्न ले जाता है, का एक सेट का निर्माण करता है

Answer 5

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

f=
(a,b)=>[...a].some((_,i,c)=>c.some((_,j)=>b.indexOf(s=a.substr(j,i+1))<0))?s:''

<div oninput=o.textContent=f(a.value,b.value)><input id="a"/><input id="b"/><pre id=o>

यदि वापसी falseस्वीकार्य है, तो &&sइसके बजाय का उपयोग करके 2 बाइट्स बचाएं ?s:''।

Answer 6

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

Jwhf!}TJ.:z

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

Answer 7

जावास्क्रिप्ट (फ़ायरफ़ॉक्स), 80 बाइट्स

solution=

a=>b=>[for(_ of(i=0,a))for(_ of(j=!++i,a))if(b.includes(s=a.substr(j++,i)))s][0]

document.write("<pre>"+
[ [ "test", "best" ], [ "wes", "west" ], [ "red", "dress" ] ]
.map(c=>c+": "+solution(c[0])(c[1])).join`\n`)

टेस्ट फ़ायरफ़ॉक्स में ही काम करता है। undefinedयदि कोई विकल्प नहीं है, तो लौटाता है।

Comments

स्ट्रिंग्स में मुद्रण योग्य ASCII वर्ण हो सकते हैं जैसे कि \ या अन्य RegExp मेटाचैकर्स, लेकिन यदि आप फ़ायरफ़ॉक्स के लिए खुद को सीमित कर रहे हैं, तो b.includesइसके बजाय इसका उपयोग क्यों करें ?

— नील

@ नील सवाल यह नहीं कहा कि तार किसी भी चरित्र से पहले हो सकता है लेकिन मुझे बताने के लिए धन्यवाद! उपयोग करने के लिए अद्यतन किया गया includes।

— user81655

टेस्ट स्निपेट फेंकता हैSyntaxError: unexpected token 'for'

— NoOneIsHere

@NoOneIsHere अगर आप फ़ायरफ़ॉक्स का उपयोग नहीं कर रहे हैं तो यह त्रुटि आपको मिलेगी ...

— user81655

Answer 8

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

M!&`\G(.+?)(?!.*¶.*\1)
O$#`.+
$.&
G1`

यदि कोई मान्य विकल्प नहीं मिला है तो आउटपुट खाली है A।

इसे ऑनलाइन आज़माएं! (एक साथ कई परीक्षण मामलों को चलाने के लिए थोड़ा संशोधित किया गया है। इनपुट प्रारूप वास्तव में लाइनफीड अलग है, लेकिन परीक्षण सूट प्रति पंक्ति एक टेस्ट केस के साथ लिखना सबसे आसान है। परीक्षण रूपरेखा वास्तविक कोड शुरू होने से पहले स्थान को एक लाइनफीड में बदल देती है।)

व्याख्या

M!&`\G(.+?)(?!.*¶.*\1)

प्रत्येक संभावित शुरुआती स्थिति के लिए A, सबसे छोटी सबस्ट्रिंग से मेल खाएं जो अंदर दिखाई नहीं देती है B। &मैच, ऐसा है कि हम वास्तव में हर प्रारंभिक स्थिति की कोशिश है, भले ही एक मैच एक वर्ण से अधिक लंबा है ओवरलैपिंग के लिए है। यह \Gसुनिश्चित करता है कि हम किसी भी स्थिति को नहीं छोड़ते हैं - विशेष रूप से, इस तरह से हमें लाइनफीड पर रोकना होगा, जैसे कि हमें Bखुद से अतिरिक्त मैच नहीं मिलते हैं । यह चीजों को गड़बड़ाने का कारण वास्तव में काफी सूक्ष्म नहीं है: क्योंकि अगर वहाँ एक प्रारंभिक स्थिति है Aजहाँ हम किसी भी वैध विकल्प को नहीं ढूंढ सकते हैं, तो यह भी एक विफलता है जिसके कारण \Gकिसी भी आगे की स्थिति की जाँच करना बंद हो जाएगा । हालांकि, यदि (वर्तमान प्रारंभिक स्थिति से) सभी सबस्ट्रिंग दिखाई देते हैंB, इसलिए सभी सबस्ट्रिंग जो वर्तमान स्थिति के आगे सही शुरू करते हैं, इसलिए उन लोगों को छोड़ना एक मुद्दा नहीं है (और वास्तव में प्रदर्शन में सुधार करता है)।

M!कॉन्फ़िगरेशन के कारण , इन सभी मैचों को मंच से लौटाया जाएगा, लाइनफीड के साथ जोड़ा जाएगा।

O$#`.+
$.&

यह लंबाई द्वारा पिछले परिणाम की पंक्तियों को क्रमबद्ध करता है। यह रेखा के साथ मेल करके किया जाता है .+। फिर $"सॉर्ट-बाय" के एक रूप को सक्रिय करता है, जैसे कि $.&सॉर्ट क्रम के निर्धारण के लिए मैच को प्रतिस्थापित किया जाता है । $.&खुद इसकी लंबाई के साथ मैच बदल देता है। अंत में, #विकल्प रेटिना को संख्यात्मक रूप से सॉर्ट करने के लिए कहता है (अन्यथा, यह परिणामी संख्याओं को स्ट्रिंग्स के रूप में मानता है और उन्हें लेक्सोग्राफोग्राफ के आधार पर सॉर्ट करता है)।

G1`

अंत में, हम एक खाली रेगेक्स (जो हमेशा मेल खाता है) और एक सीमा के साथ एक grep चरण का उपयोग करके, हम केवल पहली पंक्ति रखते हैं 1।

Answer 9

पर्ल, 87 85

sub{(grep{$_[1]!~/\Q$_/}map{$}=$_;map{substr($_[0],$_,$})}@}}(@}=0..length$_[0]))[0]}

यह एक अनाम फ़ंक्शन है जो सबसे छोटे सबस्ट्रिंग के पहले (स्थिति के अनुसार) वापस आता है, जिसमें $_[0]ऐसा नहीं होता है $_[1]या undefयदि ऐसा कोई विकल्प मौजूद नहीं है।

@ IAmMortos के उत्तर से लिए गए तार के साथ परीक्षण कार्यक्रम, पर्ल 5.22.1 के साथ परीक्षण किया गया:

#!/usr/bin/perl -l
use strict;
use warnings;

my $f = <see above>;
print $f->('abcd', 'abc');
print $f->('abcd', 'dabc');
print $f->('abcd', 'dcbabbccd');
print $f->('abcdf', 'abcdebcdf');
print $f->('abc', 'abc');

Answer 10

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

import Data.Lists
a#b=argmin length[x|x<-powerslice a,not$isInfixOf x b]

प्रयोग उदाहरण: "abcd" # "dabc"-> "cd"।

एक सीधा क्रियान्वयन: aउन सभी पदार्थों का निर्माण करें और उन लोगों को रखें जो अंदर दिखाई नहीं देते हैं b। argminएक सूची का एक तत्व देता है जो कि द्वितीय तर्क दिए गए फ़ंक्शन को कम करता है, यहां length:।

Comments

मुझे पता नहीं था argmin! यह बेहद उपयोगी लगता है।

— ज़र्गब

Answer 11

पायथ - 9 6 बाइट्स

h-Fm.:

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

Comments

9 पर पार अभी भी 9 है

— बिल्ली

मुझे यह जानकर अच्छा लगेगा कि यह कैसे काम करता है।

— मरमैन

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

— माल्टासेन

Answer 12

सी #, 152 बाइट्स

string f(string a,string b){int x=a.Length;for(int i=1;i<=x;i++)for(int j=0;j<=x-i;j++){var y=a.Substring(j,i);if(!b.Contains(y))return y;}return null;}

Answer 13

रूबी, 70 बाइट्स

पहली स्ट्रिंग से एक निश्चित लंबाई के सभी सबस्ट्रिंग्स को इकट्ठा करता है, और अगर कोई ऐसा है जो दूसरी स्ट्रिंग में नहीं है, तो इसे वापस लौटाएं।

->a,b{r=p;(1..l=a.size).map{|i|(0...l).map{|j|b[s=a[j,i]]?0:r||=s}};r}

Answer 14

बर्लेस्क - 26 बाइट्स

अभी सबसे छोटा तरीका है जिसके साथ मैं आ सकता हूं:

lnp^sujbcjz[{^p~[n!}f[-][~

Answer 15

जाप , 14 बाइट्स

Êõ!ãU c k!èV g

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

undefinedयदि कोई वैध विकल्प नहीं है, तो लौटाता है । यह स्ट्रिंग "अपरिभाषित" लौटने से अलग है अलग है, हालांकि अंतर केवल -Q ध्वज के कारण दिखाई देता है।

स्पष्टीकरण:

Ê                 :Length of the first input
 õ                :For each number in the range [1...length]:
  !ãU             : Get the substrings of the first input with that length
      c           :Flatten to a single array with shorter substrings first
        k         :Remove ones which return non-zero to:
         !èV      : Number of times that substring appears in second input
             g    :Return the shortest remaining substring

Answer 16

जाप -h, 11 बाइट्स

à f@øX «VøX

कोशिश करो

                :Implicit input of strings U & V
à               :All combinations of U
  f@            :Filter each as X
    øX          :  Does U contain X?
       «        :  Logical AND with the negation of
        VøX     :  Does V contain X?
                :Implicit output of last element