परिचय

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

आइए एक कूट संदेश का एक उदाहरण लेते हैं:

BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ

एक सामान्य जर्मन शब्द था WETTERBERICHT, या अंग्रेजी में मौसम की रिपोर्ट। उपरोक्त सिद्धांत के साथ, हम यह निर्धारित कर सकते हैं कि शब्द किन स्थानों पर संभवतः हो सकता है:

BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ
WETTERBERICHT
         ^

यह संभव नहीं है, क्योंकि Iखुद को एन्क्रिप्ट नहीं किया जा सकता है, इसलिए हम 1 स्थान पर चलते हैं:

BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ
 WETTERBERICHT
             ^

यह भी संभव नहीं है, इसलिए हम फिर से दूसरी जगह जाते हैं:

BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ
  WETTERBERICHT
   ^

यह फिर संभव नहीं है। वास्तव में, पहली संभावित घटना WETTERBERICHTहै:

BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ
             WETTERBERICHT
0123456789012345678901234567890123456789012345678901234567890123
             ^
             13

तो, हम पहली संभावित घटना के 0-अनुक्रमित स्थिति को वापस करते हैं, जो कि 13 है ।

काम

एक कोडित संदेश और एक शब्द को देखते हुए, पहले संभावित घटना के सूचकांक को ढूंढें ।
मान लें कि केवल मूल अपरकेस वर्णमाला वर्ण ( ABCDEFGHIJKLMNOPQRSTUVWXYZ) का उपयोग किया जाएगा ।
यदि कोई घटना नहीं पाई जाती है, तो आप किसी भी नकारात्मक पूर्णांक, वर्ण या कुछ भी (उदाहरण -1के लिए X) का उत्पादन कर सकते हैं ।
इनपुट को तर्क के रूप में स्वीकार किया जा सकता है, नई सूचियों, सूचियों या कुछ और पर।
यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ सबमिशन!

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

Input: BHGEFXWFTIUPITHHLPETTTCLOEWOELM, WETTERBERICHT
Output: 13

Input: ABCDEFGHIJKL, HELLO
Output: 0

Input: EEEEEEEEEEEE, HELLO
Output: -1

Input: XEEFSLBSELDJMADNADKDPSSPRNEBWIENPF, DEUTSCHLAND
Output: 11

Input: HKKH, JJJJJ
Output: -1

code-golf string

— अदनान
स्रोत

1

उम्म, एन्कोडेड स्ट्रिंग को उदाहरण के बीच में क्यों बदलता है?

— दरवाज़े

36

@Doorknob 冰 ¯ \ _ (_) _ / Ad

— अदनान

परिचय के साथ समस्याएँ हैं: 1. यह महत्वपूर्ण स्थान के कारण अटूट नहीं माना जाता था, लेकिन इस प्रणाली के कारण कि एक पत्र में क्या परिवर्तन होता है, इसका अनुवाद 2. "पत्र को एन्क्रिप्ट करने से कभी भी परिणाम नहीं होगा।" - हाँ, यह उपलब्ध वर्णों की संख्या के बाद इसे एक दोहराना होगा।

— ज़ेल्फ़िर कलस्तहल

3

@Zelphir खुद को एन्क्रिप्ट करने के साथ, मेरा मतलब था कि Eकभी भी परिणाम नहीं होगा E। यही पूरी चुनौती है।

— अदनान

9

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

f!s.eqb@>zTkQ0

मुझे यकीन नहीं है कि यह ठीक है, लेकिन अगर इनपुट असंभव है, तो कुछ भी लिखा नहीं जाता है और stderr को एक शून्य विभाजन त्रुटि लिखी जाती है। 2 लाइनों पर इनपुट लेता है, दूसरा एक उद्धरण से घिरा हुआ है।

व्याख्या:

               - autoassign z to first input
               - autoassign Q to second input
f            0 - The first value starting from 0 where the output is truthy
   .e       Q  - Enumerate over the second value
        >zT    - z[T:]
       @   k   - The kth item (number in enumeration)
      b        - The character in the enumeration
     q         - Are the two characters equal?
  s            - Sum the values
 !             - Invert them (want first where there isn't a collision)

यहाँ कोशिश करो!

— नीला
स्रोत

55

जावास्क्रिप्ट, 40

(c,p)=>c.search(p.replace(/./g,"[^$&]"))

का उपयोग करते हुए replace, यह प्लेनटेक्स्ट इनपुट को फॉर्म की एक नियमित अभिव्यक्ति में /[^H][^E][^L][^L][^O]/(उदाहरण के लिए, प्लेनटेक्स्ट इनपुट के लिए HELLO) मैप करता है और फिर searchरेफ़ैक्स से मेल खाने वाले सिफरटेक्स्ट सबस्टेशन के पहले सूचकांक के लिए परीक्षण करने के लिए उपयोग करता है। इस रेगेक्स का अर्थ है "एक पैटर्न जहां पहला चरित्र नहीं है H, दूसरा चरित्र नहीं है E, आदि"

$&replaceआउटपुट के लिए एक विशेष अनुक्रम है जो पहले replaceतर्क (इस मामले में, प्रत्येक एकल वर्ण द्वारा मिलान किया गया /./) द्वारा मिलान किए गए मूल्य में स्थानापन्न करता है ।

— apsillers
स्रोत

16

ओह, वाह, यह वास्तव में चतुर समाधान है!

— दरवाज़े

2

मुझे पता नहीं था $&! आज मेरा कुछ सिखाने के लिए धन्यवाद।

— ETHproductions

1

@ETHproductions मुझे न तो आज तक! मैंने $ `के$' बारे में भी सीखा और इस उत्तर पर शोध करने की प्रक्रिया में, जो" स्ट्रिंग के उस हिस्से को प्रदान करता है जो मिलान किए गए विकल्प के पहले / बाद में आता है "

— अप्सिलर्स

1

वाह! यह बढ़िया है! मुझे डॉक्स को अधिक बार पढ़ना चाहिए;)

— ETHproductions

43

ट्यूरिंग मशीन सिम्युलेटर - 15660 बाइट्स (गैर-प्रतिस्पर्धात्मक)

मशीन कोड को ट्यूर किए बिना एक पहेली चुनौती नहीं हो सकती।

0 * * l 0
0 _ _ l ,
, _ , l 1
1 _ 0 r 2
2 * * r 2
2 , * r 3
3 * * r 3
3 , * r 4
4 * * r 4
4 _ * r 13
4 A a l a'                                                                                                                                                                                                        
4 B b l b'                                                                                                                                                                                                        
4 C c l c'                                                                                                                                                                                                        
4 D d l d'                                                                                                                                                                                                        
4 E e l e'                                                                                                                                                                                                        
4 F f l f'                                                                                                                                                                                                        
4 G g l g'                                                                                                                                                                                                        
4 H h l h'                                                                                                                                                                                                        
4 I i l i'                                                                                                                                                                                                        
4 J j l j'                                                                                                                                                                                                        
4 K k l k'                                                                                                                                                                                                        
4 L l l l'                                                                                                                                                                                                        
4 M m l m'                                                                                                                                                                                                        
4 N n l n'                                                                                                                                                                                                        
4 O o l o'                                                                                                                                                                                                        
4 P p l p'                                                                                                                                                                                                        
4 Q q l q'                                                                                                                                                                                                        
4 R r l r'                                                                                                                                                                                                        
4 S s l s'                                                                                                                                                                                                        
4 T t l t'                                                                                                                                                                                                        
4 U u l u'                                                                                                                                                                                                        
4 V v l v'                                                                                                                                                                                                        
4 W w l w'                                                                                                                                                                                                        
4 X x l x'                                                                                                                                                                                                        
4 Y y l y'                                                                                                                                                                                                        
4 Z z l z'
a' * * l a'
a' , * l a
b' * * l b'
b' , * l b
c' * * l c'
c' , * l c
d' * * l d'
d' , * l d
e' * * l e'
e' , * l e
f' * * l f'
f' , * l f
g' * * l g'
g' , * l g
h' * * l h'
h' , * l h
i' * * l i'
i' , * l i
j' * * l j'
j' , * l j
k' * * l k'
k' , * l k
l' * * l l'
l' , * l l
m' * * l m'
m' , * l m
n' * * l n'
n' , * l n
o' * * l o'
o' , * l o
p' * * l p'
p' , * l p
q' * * l q'
q' , * l q
r' * * l r'
r' , * l r
s' * * l s'
s' , * l s
t' * * l t'
t' , * l t
u' * * l u'
u' , * l u
v' * * l v'
v' , * l v
w' * * l w'
w' , * l w
x' * * l x'
x' , * l x
y' * * l y'
y' , * l y
z' * * l z'
z' , * l z

a * * l a
a _ * r A
a a * r A
a b * r A
a c * r A
a d * r A
a e * r A
a f * r A
a g * r A
a h * r A
a i * r A
a j * r A
a k * r A
a l * r A
a m * r A
a n * r A
a o * r A
a p * r A
a q * r A
a r * r A
a s * r A
a t * r A
a u * r A
a v * r A
a w * r A
a x * r A
a y * r A
a z * r A
b * * l b
b _ * r B
b a * r B
b b * r B
b c * r B
b d * r B
b e * r B
b f * r B
b g * r B
b h * r B
b i * r B
b j * r B
b k * r B
b l * r B
b m * r B
b n * r B
b o * r B
b p * r B
b q * r B
b r * r B
b s * r B
b t * r B
b u * r B
b v * r B
b w * r B
b x * r B
b y * r B
b z * r B
c * * l c
c _ * r C
c a * r C
c b * r C
c c * r C
c d * r C
c e * r C
c f * r C
c g * r C
c h * r C
c i * r C
c j * r C
c k * r C
c l * r C
c m * r C
c n * r C
c o * r C
c p * r C
c q * r C
c r * r C
c s * r C
c t * r C
c u * r C
c v * r C
c w * r C
c x * r C
c y * r C
c z * r C
d * * l d
d _ * r D
d a * r D
d b * r D
d c * r D
d d * r D
d e * r D
d f * r D
d g * r D
d h * r D
d i * r D
d j * r D
d k * r D
d l * r D
d m * r D
d n * r D
d o * r D
d p * r D
d q * r D
d r * r D
d s * r D
d t * r D
d u * r D
d v * r D
d w * r D
d x * r D
d y * r D
d z * r D
e * * l e
e _ * r E
e a * r E
e b * r E
e c * r E
e d * r E
e e * r E
e f * r E
e g * r E
e h * r E
e i * r E
e j * r E
e k * r E
e l * r E
e m * r E
e n * r E
e o * r E
e p * r E
e q * r E
e r * r E
e s * r E
e t * r E
e u * r E
e v * r E
e w * r E
e x * r E
e y * r E
e z * r E
f * * l f
f _ * r F
f a * r F
f b * r F
f c * r F
f d * r F
f e * r F
f f * r F
f g * r F
f h * r F
f i * r F
f j * r F
f k * r F
f l * r F
f m * r F
f n * r F
f o * r F
f p * r F
f q * r F
f r * r F
f s * r F
f t * r F
f u * r F
f v * r F
f w * r F
f x * r F
f y * r F
f z * r F
g * * l g
g _ * r G
g a * r G
g b * r G
g c * r G
g d * r G
g e * r G
g f * r G
g g * r G
g h * r G
g i * r G
g j * r G
g k * r G
g l * r G
g m * r G
g n * r G
g o * r G
g p * r G
g q * r G
g r * r G
g s * r G
g t * r G
g u * r G
g v * r G
g w * r G
g x * r G
g y * r G
g z * r G
h * * l h
h _ * r H
h a * r H
h b * r H
h c * r H
h d * r H
h e * r H
h f * r H
h g * r H
h h * r H
h i * r H
h j * r H
h k * r H
h l * r H
h m * r H
h n * r H
h o * r H
h p * r H
h q * r H
h r * r H
h s * r H
h t * r H
h u * r H
h v * r H
h w * r H
h x * r H
h y * r H
h z * r H
i * * l i
i _ * r I
i a * r I
i b * r I
i c * r I
i d * r I
i e * r I
i f * r I
i g * r I
i h * r I
i i * r I
i j * r I
i k * r I
i l * r I
i m * r I
i n * r I
i o * r I
i p * r I
i q * r I
i r * r I
i s * r I
i t * r I
i u * r I
i v * r I
i w * r I
i x * r I
i y * r I
i z * r I
j * * l j
j _ * r J
j a * r J
j b * r J
j c * r J
j d * r J
j e * r J
j f * r J
j g * r J
j h * r J
j i * r J
j j * r J
j k * r J
j l * r J
j m * r J
j n * r J
j o * r J
j p * r J
j q * r J
j r * r J
j s * r J
j t * r J
j u * r J
j v * r J
j w * r J
j x * r J
j y * r J
j z * r J
k * * l k
k _ * r K
k a * r K
k b * r K
k c * r K
k d * r K
k e * r K
k f * r K
k g * r K
k h * r K
k i * r K
k j * r K
k k * r K
k l * r K
k m * r K
k n * r K
k o * r K
k p * r K
k q * r K
k r * r K
k s * r K
k t * r K
k u * r K
k v * r K
k w * r K
k x * r K
k y * r K
k z * r K
l * * l l
l _ * r L
l a * r L
l b * r L
l c * r L
l d * r L
l e * r L
l f * r L
l g * r L
l h * r L
l i * r L
l j * r L
l k * r L
l l * r L
l m * r L
l n * r L
l o * r L
l p * r L
l q * r L
l r * r L
l s * r L
l t * r L
l u * r L
l v * r L
l w * r L
l x * r L
l y * r L
l z * r L
m * * l m
m _ * r M
m a * r M
m b * r M
m c * r M
m d * r M
m e * r M
m f * r M
m g * r M
m h * r M
m i * r M
m j * r M
m k * r M
m l * r M
m m * r M
m n * r M
m o * r M
m p * r M
m q * r M
m r * r M
m s * r M
m t * r M
m u * r M
m v * r M
m w * r M
m x * r M
m y * r M
m z * r M
n * * l n
n _ * r N
n a * r N
n b * r N
n c * r N
n d * r N
n e * r N
n f * r N
n g * r N
n h * r N
n i * r N
n j * r N
n k * r N
n l * r N
n m * r N
n n * r N
n o * r N
n p * r N
n q * r N
n r * r N
n s * r N
n t * r N
n u * r N
n v * r N
n w * r N
n x * r N
n y * r N
n z * r N
o * * l o
o _ * r O
o a * r O
o b * r O
o c * r O
o d * r O
o e * r O
o f * r O
o g * r O
o h * r O
o i * r O
o j * r O
o k * r O
o l * r O
o m * r O
o n * r O
o o * r O
o p * r O
o q * r O
o r * r O
o s * r O
o t * r O
o u * r O
o v * r O
o w * r O
o x * r O
o y * r O
o z * r O
p * * l p
p _ * r P
p a * r P
p b * r P
p c * r P
p d * r P
p e * r P
p f * r P
p g * r P
p h * r P
p i * r P
p j * r P
p k * r P
p l * r P
p m * r P
p n * r P
p o * r P
p p * r P
p q * r P
p r * r P
p s * r P
p t * r P
p u * r P
p v * r P
p w * r P
p x * r P
p y * r P
p z * r P
q * * l q
q _ * r Q
q a * r Q
q b * r Q
q c * r Q
q d * r Q
q e * r Q
q f * r Q
q g * r Q
q h * r Q
q i * r Q
q j * r Q
q k * r Q
q l * r Q
q m * r Q
q n * r Q
q o * r Q
q p * r Q
q q * r Q
q r * r Q
q s * r Q
q t * r Q
q u * r Q
q v * r Q
q w * r Q
q x * r Q
q y * r Q
q z * r Q
r * * l r
r _ * r R
r a * r R
r b * r R
r c * r R
r d * r R
r e * r R
r f * r R
r g * r R
r h * r R
r i * r R
r j * r R
r k * r R
r l * r R
r m * r R
r n * r R
r o * r R
r p * r R
r q * r R
r r * r R
r s * r R
r t * r R
r u * r R
r v * r R
r w * r R
r x * r R
r y * r R
r z * r R
s * * l s
s _ * r S
s a * r S
s b * r S
s c * r S
s d * r S
s e * r S
s f * r S
s g * r S
s h * r S
s i * r S
s j * r S
s k * r S
s l * r S
s m * r S
s n * r S
s o * r S
s p * r S
s q * r S
s r * r S
s s * r S
s t * r S
s u * r S
s v * r S
s w * r S
s x * r S
s y * r S
s z * r S
t * * l t
t _ * r T
t a * r T
t b * r T
t c * r T
t d * r T
t e * r T
t f * r T
t g * r T
t h * r T
t i * r T
t j * r T
t k * r T
t l * r T
t m * r T
t n * r T
t o * r T
t p * r T
t q * r T
t r * r T
t s * r T
t t * r T
t u * r T
t v * r T
t w * r T
t x * r T
t y * r T
t z * r T
u * * l u
u _ * r U
u a * r U
u b * r U
u c * r U
u d * r U
u e * r U
u f * r U
u g * r U
u h * r U
u i * r U
u j * r U
u k * r U
u l * r U
u m * r U
u n * r U
u o * r U
u p * r U
u q * r U
u r * r U
u s * r U
u t * r U
u u * r U
u v * r U
u w * r U
u x * r U
u y * r U
u z * r U
v * * l v
v _ * r V
v a * r V
v b * r V
v c * r V
v d * r V
v e * r V
v f * r V
v g * r V
v h * r V
v i * r V
v j * r V
v k * r V
v l * r V
v m * r V
v n * r V
v o * r V
v p * r V
v q * r V
v r * r V
v s * r V
v t * r V
v u * r V
v v * r V
v w * r V
v x * r V
v y * r V
v z * r V
w * * l w
w _ * r W
w a * r W
w b * r W
w c * r W
w d * r W
w e * r W
w f * r W
w g * r W
w h * r W
w i * r W
w j * r W
w k * r W
w l * r W
w m * r W
w n * r W
w o * r W
w p * r W
w q * r W
w r * r W
w s * r W
w t * r W
w u * r W
w v * r W
w w * r W
w x * r W
w y * r W
w z * r W
x * * l x
x _ * r X
x a * r X
x b * r X
x c * r X
x d * r X
x e * r X
x f * r X
x g * r X
x h * r X
x i * r X
x j * r X
x k * r X
x l * r X
x m * r X
x n * r X
x o * r X
x p * r X
x q * r X
x r * r X
x s * r X
x t * r X
x u * r X
x v * r X
x w * r X
x x * r X
x y * r X
x z * r X
y * * l y
y _ * r Y
y a * r Y
y b * r Y
y c * r Y
y d * r Y
y e * r Y
y f * r Y
y g * r Y
y h * r Y
y i * r Y
y j * r Y
y k * r Y
y l * r Y
y m * r Y
y n * r Y
y o * r Y
y p * r Y
y q * r Y
y r * r Y
y s * r Y
y t * r Y
y u * r Y
y v * r Y
y w * r Y
y x * r Y
y y * r Y
y z * r Y
z * * l z
z , * r Z
z a * r Z
z b * r Z
z c * r Z
z d * r Z
z e * r Z
z f * r Z
z g * r Z
z h * r Z
z i * r Z
z j * r Z
z k * r Z
z l * r Z
z m * r Z
z n * r Z
z o * r Z
z p * r Z
z q * r Z
z r * r Z
z s * r Z
z t * r Z
z u * r Z
z v * r Z
z w * r Z
z x * r Z
z y * r Z
z z * r Z
A * * * 5
A A * l 6
B * * * 5
B B * l 6
C * * * 5
C C * l 6
D * * * 5
D D * l 6
E * * * 5
E E * l 6
F * * * 5
F F * l 6
G * * * 5
G G * l 6
H * * * 5
H H * l 6
I * * * 5
I I * l 6
J * * * 5
J J * l 6
K * * * 5
K K * l 6
L * * * 5
L L * l 6
M * * * 5
M M * l 6
N * * * 5
N N * l 6
O * * * 5
O O * l 6
P * * * 5
P P * l 6
Q * * * 5
Q Q * l 6
R * * * 5
R R * l 6
S * * * 5
S S * l 6
T * * * 5
T T * l 6
U * * * 5
U U * l 6
V * * * 5
V V * l 6
W * * * 5
W W * l 6
X * * * 5
X X * l 6
Y * * * 5
Y Y * l 6
Z * * * 5
Z Z * l 6
5 , * r 15
5 A a r 7
5 B b r 7
5 C c r 7
5 D d r 7
5 E e r 7
5 F f r 7
5 G g r 7
5 H h r 7
5 I i r 7
5 J j r 7
5 K k r 7
5 L l r 7
5 M m r 7
5 N n r 7
5 O o r 7
5 P p r 7
5 Q q r 7
5 R r r 7
5 S s r 7
5 T t r 7
5 U u r 7
5 V v r 7
5 W w r 7
5 X x r 7
5 Y y r 7
5 Z z r 7
7 * * r 7
7 , * r 4
6 * * l 6
6 _ * r 8
8 * _ r 9
9 * * r 9
9 _ * l 10
9 a A r 9
9 b B r 9
9 c C r 9
9 d D r 9
9 e E r 9
9 f F r 9
9 g G r 9
9 h H r 9
9 i I r 9
9 j J r 9
9 k K r 9
9 l L r 9
9 m M r 9
9 n N r 9
9 o O r 9
9 p P r 9
9 q Q r 9
9 r R r 9
9 s S r 9
9 t T r 9
9 u U r 9
9 v V r 9
9 w W r 9
9 x X r 9
9 y Y r 9
9 z Z r 9
10 * * l 10
10 , * l 11
11 * * l 11
11 , * l 12
12 _ 1 r 2
12 0 1 r 2
12 1 2 r 2
12 2 3 r 2
12 3 4 r 2
12 4 5 r 2
12 5 6 r 2
12 6 7 r 2
12 7 8 r 2
12 8 9 r 2
12 9 0 l 12
13 * _ l 13
13 , _ l 14
14 * _ l 14
14 , _ l halt
15 * * r 15
15 _ * l 16
16 * _ l 16
16 , _ l 17
17 * _ l 17
17 , _ l 18
18 * _ l 18
18 _ x * halt

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

संक्षिप्त अवलोकन:

बाईं ओर एक काउंटर स्थापित करें
लक्ष्य में पहले अपरकेस अक्षर ढूंढें और इसे लोअरकेस करें। यदि सभी अक्षर चरण 5 से नीचे हैं।
कोड में पहला अपरकेस अक्षर ढूंढें। यदि सबसे हाल के पत्र मेल खाते हैं, तो चरण 4 पर जाएं। अक्षर पत्र को कम करें और चरण 2 पर वापस जाएं।
इंक्रीमेंट काउंटर, सभी अक्षरों को पूंजी बनाएं, पहले अक्षर को कोड में हटा दें। चरण 2 पर वापस जाएं। यदि कोड में कोई अक्षर नहीं बचा है, तो स्पष्ट टेप और प्रिंट x लौटाएं।
सभी टेप लेकिन काउंटर को साफ़ करें।

— KoreanwGlasses
स्रोत

इसके अलावा, परीक्षण करते समय, इनपुट का प्रारूप इस प्रकार होना चाहिए: कोड, लक्ष्य (कोई स्थान नहीं)

— कोरियाईविलास

इसे बनाने में कितना समय लगा?

— अदनान

18

2:00 पर अपना होमवर्क शुरू किया। 2:15 बजे विचलित हुए। 2.20 पर इसकी शुरुआत हुई। 4:20 पर यह पोस्ट किया। तो लगभग 2 घंटे।

— कोरियाईवेल्स

5

+1, PPCGSE में, इसकी सराहना करने के लिए प्रतिस्पर्धा करने की आवश्यकता नहीं है!

9575 बाइट्स (और हेडर में वर्तमान बायटेकाउंट झूठा है, बाहरी स्थान हैं और कुछ अनावश्यक रूप से लंबे राज्य के नाम हैं)।

— आउटगॉल्फ

8

एसडब्ल्यूआई-प्रोलॉग, 115 बाइट्स

a(S,W,R):-length(S,L),length(W,M),N is L-M,between(0,N,I),\+ (between(0,M,J),K is I+J,nth0(J,W,A),nth0(K,S,A)),R=I.

उपयोग उदाहरण a(`ABCDEFGHIJKL`,`HELLO`,R).:। यह बैकटीक्स के साथ घोषित वर्ण कोड स्ट्रिंग्स का उपयोग करता है। उत्तर के साथ एकीकृत है R। यदि कोई मेल नहीं मिलता है, तो यह आउटपुट करता है false.।

व्याख्या:

a(S,W,R):-
    length(S,L),length(W,M),     
    N is L-M,
    between(0,N,I),             % I is successively unified with an integer between 0 
                                % and the last possible index of the coded message

    \+ (                        % This will only be true if what's inside the parentheses 
                                % cannot be proven to be true

        between(0,M,J),         % J is successively unified with an integer between 0 
                                % and the length of the desired word
        K is I+J,
        nth0(J,W,A),nth0(K,S,A) % Check if one letter is the same in both string at 
                                % the same index
    ),                          % If it the case, then it will be 'true' and thus 
                                % the predicate \+ will be false, meaning we need to
                                % backtrack to try a different value of I

    R=I.                        % If we get here it means it didn't find any matching 
                                % letter for this value of I, which is then the answer.

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

— Fatalize
स्रोत

7

रूबी, 91 79 बाइट्स

->a,b{[*a.chars.each_cons(b.size)].index{|x|x.zip(b.chars).all?{|y|y.uniq==y}}}

आपको शाप है Enumerator,! मुझे स्ट्रिंग से एनामुलेटर तक सरणी में और कीमती बाइट को बर्बाद करने के लिए क्यों बदलना है? > :(

->a,b{                  # define lambda
[*                      # convert to array...
  a.chars               # get enumerator from string
  .each_cons(b.size)    # each consecutive group of (b.size) letters
]
.index{|x|              # find index of...
  x.zip(b.chars)        # zip group with second input string
  .all?{|y|             # is the block true for every element?
    y.uniq==y           # uniqueify results in same array (no dups)
}}}

— Doorknob
स्रोत

[*...]#To_a के लिए एक गोल्फ विकल्प के रूप में उपयोग करना एक अच्छा स्पर्श है।

— वेन कॉनराड

7

CJam, 17 16 बाइट्स

ll:A,ew{A.=:+!}#

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

एक बाइट को बचाने के लिए @PeterTaylor को धन्यवाद।

व्याख्या:

ll:A,ew    e# Finds every slice in the coded message with the length of the word
{A.=:+     e# Compare the characters in each slice to the characters in the word, and add up the result. If the sum is zero, then the slice and the word have no characters in common.
!}#        e# Invert truthiness (0 -> 1, non-0 -> 0) Return index of first truthy value.

— geokavel
स्रोत

array block #क्या आप एक चार बचा सकते हैं:ll:A,ew{A.=:+!}#

— पीटर टेलर

कमाल है कि CJam को लगभग हर काम में कैसे आगे बढ़ाया जा सकता है ...: -o

— agtoever

@agtoever मैं नहीं कहूंगा कि यह वास्तव में गोल्फ है, क्योंकि 17 बाइट्स मेरी पहली कोशिश थी। मुख्य विशेषता ew(स्लाइस बनाना) है, बाकी सब कुछ इस प्रकार है।

— जियोकॉवेल

6

MATL , 27 बाइट्स

jYbZ)tnb!wlhYCw!=a~ftn?1)1-

उदाहरण

>> matl jYbZ)tnb!wlhYCw!=a~ftn?1)1-
> EEEEEEEEEEEE, HELLO

>> matl jYbZ)tnb!wlhYCw!=a~ftn?1)1-
> XEEFSLBSELDJMADNADKDPSSPRNEBWIENPF, DEUTSCHLAND
11

व्याख्या

j           % input string
YbZ)        % split into two strings based on space. Trailing comma is not a problem
tnb!wlhYC   % arrange first string into sliding columns of the size of the second
w!=         % compare with transposed second string, element-wise with broadcast
a~          % detect columns where all values are 0 (meaning unequal characters)
f           % find indices of such columns
tn?         % if there's at least one such column
1)1-        % pick index of the first and subtract 1 for 0-based indexing

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

4

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

l=length
h i w s|l s<l w= -1|and$zipWith(/=)w s=i|1<2=h(i+1)w$tail s
h 0

उपयोग: h 0 "DEUTSCHLAND" "XEEFSLBSELDJMADNADKDPSSPRNEBWIENPF"-> 11।

सरल पुनरावर्ती दृष्टिकोण: यदि शब्द wको स्ट्रिंग की शुरुआत में रखा जा सकता है s, तो इंडेक्स काउंटर लौटाएं i, अन्यथा बढ़ा हुआ iऔर की पूंछ के साथ दोहराएं s। रुकें और लौटें -1यदि की लंबाई से sकम है w।

— nimi
स्रोत

4

पायथन 2.7, 111 वर्ण

सभी आरंभिक पदों (ए) और किसी भी पत्र के मिलान के चेक (सूची की समझ का उपयोग करके) की कोशिश करता है। यह "कोई नहीं" (पायथन के "NULL") लौटाता है अगर कुछ नहीं मिला (लूप अंत के लिए और कुछ भी नहीं लौटा है, जो "कोई नहीं" के लिए चूकता है)।

def d(c,s):
 for a in range(len(c)):
  if a not in [((c+s)[a+i:]).index(l)+a for i,l in enumerate(s)]:
   return a

परीक्षण सूट:

cases = {
         ("BHGEFXWFTIUPITHHLPETTTCLOEWOELM","WETTERBERICHT"):13,
         ("ABCDEFGHIJKL","HELLO"):0,
         ("EEEEEEEEEEEE","HELLO"):-1,
         ("XEEFSLBSELDJMADNADKDPSSPRNEBWIENPF","DEUTSCHLAND"):11
        }

for idx,(code,string) in enumerate(cases):
    output=d(code,string)
    print "Case: {}: d({:<35},{:<16}) gives: {}. Correct answer is: {}.".format(idx+1,code,string,output,cases[(code,string)])

— agtoever
स्रोत

आपके पास वास्तव में 114 बाइट्स हैं, 111 नहीं। यहां एक 106-बाइट संस्करण है:def d(c,s): for a in range(len(c)): if a not in[a+(c+s)[a+i:].index(l)for i,l in enumerate(s)]:return a

— मूविका

4

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

[S:W]hlL,WlM,L-M=:0reI,'(0:MeJ+I=:SrmA,W:JmA),I.

यह मेरे प्रोलॉग उत्तर का सीधा अनुवाद है। brachylog_main/2उत्पन्न विधेय कोडित स्ट्रिंग पहले इनपुट के रूप में के साथ दो चरित्र कोड स्ट्रिंग की एक सूची की उम्मीद है, और उत्पादन, जैसे के रूप में सूचकांक रिटर्न brachylog_main([`ABCDEFGHIJKL`,`HELLO`],R).।

व्याख्या

[S:W]                                            § Unify the input with the list [S,W]

     hlL,WlM,                                    § L and M are the length of S and W

             L-M=:0reI,                          § Enumerate integers between 0 and the 
                                                 § last possible index

                       '(                   ),I. § Unify the output with the current 
                                                 § enumerated integer if what's inside the 
                                                 § parenthesis cannot be proven to be true

                         0:MeJ                   § Enumerate integers between 0 and the
                                                 § length of the word desired

                              +I=:SrmA,W:JmA     § Check if both strings contain at matching
                                                 § indexes the same letter (unified with A)

— Fatalize
स्रोत

3

Japt, 12 बाइट्स (गैर-प्रतिस्पर्धी)

UàVr'."[^$&]

मैं इस एक के साथ कुछ मदद की ज़रूरत है।

— मामा फन रोल
स्रोत

बेनाम: उह ... बेनाम: Japt नहीं है .search? facepalm

— ETHproductions

यह अब UàVr'."[^$&]12 के लिए किया जा सकता है

— ETHproductions

कूल, हम अब जीत रहे हैं!

— मामा फन रोल

चूंकि इस उत्तर का नवीनतम संशोधन कार्यक्षमता का उपयोग करता है जो प्रश्न को पोस्टड करता है, मैं इसे गैर-प्रतिस्पर्धी के रूप में चिह्नित कर रहा हूं।

— Mego

ओह इसके बारे में भूल गया: पी धन्यवाद!

— मामा फन रोल

2

PHP - 155 बाइट्स

<?php for($p=$argv[1],$q=$argv[2],$l=strlen($q),$i=0,$r=-1;$i<strlen($p)-$l;$i++)if(levenshtein($q,substr($p,$i,$l),2,1,2)==$l){$r=$i;break;}echo$r."\n";

के रूप में सहेजें crack.phpऔर कमांड लाइन में तर्कों के साथ चलाएं। उदाहरण के लिए:

$ php crack.php BHGEFXWFTIUPITHHLPETTTCLOEWOELM WETTERBERICHT
13

आप 25 बाइट्स को बचा सकते हैं और इसे 130 बाइट तक नीचे कर सकते हैं :

for($r=-1;$i<strlen($p=$argv[1])-$l=strlen($q=$argv[2]);$i++)if(levenshtein($q,substr($p,$i,$l),2,1,2)==$l&&$r=$i)break;echo"$r↵";

— इनसर्कुर्नामेयर 19

@insertusernamehere - वाह, यह प्रभावशाली है! इतना है कि मैं इसे का उपयोग कर सही नहीं लगेगा! मुझे लगा कि मैं उपयोग करने में चतुर था levenshtein, लेकिन शायद एक पुनरावृति के भीतर एक सीधा चलना इसे कम बाइट्स में कर सकता था।

2

जावास्क्रिप्ट, 129 121 118 119 ^* 118 बाइट्स

(w,t){for(j=0;(x=t.length)<(y=w.length);t=' '+t,j++){for(a=i=0;++i<y;)w[i]==t[i]?a=1:a;if(!a)break}return x==y?-1:j}

wकोडित संदेश tहै, परीक्षण स्ट्रिंग है। यह regexes का उपयोग नहीं करता है, लेकिन बस पत्र की तुलना करता है, परीक्षण स्ट्रिंग को स्थानांतरित करना (यानी "WETTERBERICHT") इसके पहले स्थान को जोड़कर। आसान और उबाऊ।

^{* कोई मैच नहीं के साथ परीक्षण के मामले में काम नहीं किया, अब यह करता है}

— nicael
स्रोत

2

S, 14 चार्ट / 25 बाइट्स

îĊⱮ(í,↪`⁅⦃$}]`

Try it here (Firefox only).

विचार के लिए कुडोस से @apsillers।

व्याख्या

               // implicit: î = input1, í = input2
îĊ             // search for first occurrence of:
  Ɱ(í,↪`⁅⦃$}]` // regex created by wrapping each word in [^ and ] (negation matches)

— मामा फन रोल
स्रोत

जो किसी ने भी इसे ठुकरा दिया, क्या उसका एक कारण है?

— मामा फन रोल

2

TeaScript, 14 बाइट्स 20

xc(yl#`[^${l}]

@Aspillers चतुर जावास्क्रिप्ट समाधान के समान ।

गैर-प्रतिस्पर्धात्मक क्योंकि यह इस प्रतियोगिता के बाद बनी सुविधाओं का उपयोग करता है ।

व्याख्या

             // Implicit: x = 1st input, y = 2nd input
x            // First input
 c           // returns index of regex match
 yl#         // Loop through every char in `y`
    `[^${l}] // Replace template, ${l} because current char in `y`

— Downgoat
स्रोत

के $&स्थान पर काम नहीं करता है ${l}?

— 20

@ETHproductions इस मामले में नहीं है क्योंकि मैं एक लूप का उपयोग कर रहा हूँ बजाय एक जगह पर

— डाउनगेट

2

रूबी, 43 36 बाइट्स

संपादित करें: स्ट्रिंग रेपोलेशन के अंदर स्ट्रिंग इंटरपोलेशन एक रेगेक्स के अंदर, yikes।

आलसी दृष्टिकोण: शब्द को "नकारात्मक" रेगेक्स में अनुवाद =~करता है - ऑपरेटर बाकी काम करता है।

->m,w{m=~/#{"[^#{w.chars*'][^'}]"}/}

परीक्षा:

f=->m,w{m=~/#{"[^#{w.chars*'][^'}]"}/}

require "minitest/autorun"

describe :f do
  it "works for the given test cases" do
    assert_equal 13, f["BHGEFXWFTIUPITHHLPETTTCLOEWOELM", "WETTERBERICHT"]
    assert_equal 0, f["ABCDEFGHIJKL", "HELLO"]
    assert_equal nil, f["EEEEEEEEEEEE", "HELLO"]
    assert_equal 11, f["XEEFSLBSELDJMADNADKDPSSPRNEBWIENPF", "DEUTSCHLAND"]
    assert_equal nil, f["HKKH", "JJJJJ"]
  end
end

— daniero
स्रोत

2

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

lambda x,y:[sum(map(str.__eq__,x[i:],y))for i in range(len(x)-len(y))].index(0)

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

— alexz02
स्रोत

2

05AB1E , 14 बाइट्स

ŒIgùDʒø€Ëà_}нk

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

व्याख्या:

Œ               # Get all substrings of the first (implicit) input
 Ig             # Get the length of the second input
   ù            # Only leave the substrings of that length
    D           # Duplicate the list of remaining substrings
     ʒ          # Filter the copy by:
      ø         #  Zip/transpose; swapping rows/columns the current substring with
                #  the second (implicit) input
       €Ë       #  Check for each if both characters are equal (1 if truthy; 0 if falsey)
         à      #  Get the maximum (basically equal to an `any` builtin)
          ≠     #  And invert the boolean (!= 1)
           }н   # After the filter: only leave the first substring
             k  # And get its index in the duplicated list (-1 if none are found)
                # (which is output implicitly as result)

— केविन क्रूज़सेन
स्रोत

2

यार, यह पूरी तरह से @ एमिग्ना का जवाब था;)। मैं यहाँ आना चाहता था और उसके बारे में लगभग अपना नाम लेकर अदनान-सवाल का जवाब देने के बारे में मज़ाक बनाता था। +1 (आपने इस तथ्य-संबंधी टिप्पणी के पोस्ट होने के बाद आपने 4 साल बाद जवाब दिया था)।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn जब मैंने चुनौती देखी तो मैंने भी यही सोचा था, लेकिन @Eignign आमतौर पर नए उत्तरों का जवाब देता है और मौजूदा उत्तरों पर अक्सर गौर नहीं करता है। इसलिए जब से यह कोई भी 05AB1E उत्तर नहीं था मुझे लगा कि मैं एक जोड़ दूंगा। आप वास्तव में सही हैं कि @Eignign इस चुनौती का जवाब देने के लिए सबसे उपयुक्त होगा। ; पी

— केविन क्रूज़सेन

1

जोल्फ , 14 बाइट्स

यहाँ कोशिश करो!

 siρI".'[^$&]
_s            search
  i            input 1 for
    I          input 2
   ρ            replacing (2 byte rho character)
     ".'         all characters
        [^$&]    with that

— कोनोर ओ ब्रायन
स्रोत

1

पर्ल, 38 + 1 = 39 बाइट्स

perl -E "$r=<>=~s!.![^$&]!gr;say@-if<>=~/$r/x" < input

जहां इनपुट जैसा दिखता है:

WETTERBERICHT
BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ

यह एक जावास्क्रिप्ट के रूप में एक ही विचार है।

— सिकंदर-ब्रेट
स्रोत

'X' अनावश्यक है

— Zaid

1

जावा, 136 वर्ण

एप्सिलर्स जावास्क्रिप्ट संस्करण से प्रेरित रेगेक्स-आधारित समाधान ।

class L{public static void main(String[]a){a=a[0].split(a[1].replaceAll("(.)","[^$1]"));System.out.print(a.length>1?a[0].length():-1);}}

— कम से कम
स्रोत

1

ब्रेकीलॉग (v2), 16 बाइट्स

bʰ↙.Pz₁≠ᵐzhc~hP∧

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

ब्रैकलॉग आमतौर पर असफल होने पर बहुत अच्छा होता है जब कुछ हल करना असंभव होता है।

यह उन समयों में से एक नहीं है।

(एक सूची के रूप में इनपुट लेता है [message, word]। शीर्ष लेख यह सब बहुत ही सावधानी से छापता है लेकिन वास्तविक विधेय का उत्पादन केवल एक संख्या है यदि यह सफल होता है)

                    The input
b                   with a number of letters removed from the beginning
 ʰ                  of its first element
  ↙.                where that number is the output
    P               is P
     z₁             which with its elements zipped, without cycling
       ≠ᵐ           contains no duplicate pairs
         z          and which zipped back
          h         has a first element
           c        which concatenated
            ~h      is the first element of
              P     P
               ∧    (which is not the output).

bʰ↙.Plᵐ≥₁∧Pz₁≠ᵐ∧ बस एक ही बाइट गिनती के लिए काम करने लगता है।

— असंबंधित स्ट्रिंग
स्रोत

0

सी ++ (जीसीसी) , 160 153 150 बाइट्स

#include<map>
int f(std::string c,std::string w){int i=-1,k,e=1;while(e&&w.size()+i++<c.size())for(e=k=0;k<w.size();)e+=c[i+k]==w[k++];return e?-1:i;}

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

— movatica
स्रोत

1

@ceilingcat: आप 157 बाइट्स कर सकते हैं । कोड दो टेस्टकेस के लिए विफल रहता है, हालांकि (जैसा कि मेरा मूल एक है)। मैंने इसे कुछ अतिरिक्त बाइट्स के लिए तय किया।

— चलत

1

साथ ही, बाहरी लूप में k के आपके आरंभीकरण ने एक और बग पेश किया, जहां प्रत्येक पुनरावृत्ति के साथ, एक कम चरित्र की तुलना की गई थी।

— २१:०२ पर मूविका

पता चला, यह बगैर gotoऔर सभी बग्स के बिना भी छोटा है ...

— 21

0

पर्ल 5 , 46 बाइट्स

@Apsillers 'regex विचार का उपयोग करता है।

$a=<>=~s/./[^$&]/gr;/$a/g;$_=(length$a)/-4+pos

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

— Xcali
स्रोत

एनिग्मा क्रैकिंग?

परिचय

काम

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

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

जावास्क्रिप्ट, 40

ट्यूरिंग मशीन सिम्युलेटर - 15660 बाइट्स (गैर-प्रतिस्पर्धात्मक)

एसडब्ल्यूआई-प्रोलॉग, 115 बाइट्स

व्याख्या:

रूबी, 91 79 बाइट्स

CJam, 17 16 बाइट्स

MATL , 27 बाइट्स

उदाहरण

व्याख्या

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

पायथन 2.7, 111 वर्ण

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

व्याख्या

Japt, 12 बाइट्स (गैर-प्रतिस्पर्धी)

PHP - 155 बाइट्स

जावास्क्रिप्ट, 129 121 118 119 * 118 बाइट्स

S, 14 चार्ट / 25 बाइट्स

व्याख्या

TeaScript, 14 बाइट्स 20

व्याख्या

रूबी, 43 36 बाइट्स

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

05AB1E , 14 बाइट्स

जोल्फ , 14 बाइट्स

पर्ल, 38 + 1 = 39 बाइट्स

जावा, 136 वर्ण

ब्रेकीलॉग (v2), 16 बाइट्स

सी ++ (जीसीसी) , 160 153 150 बाइट्स

पर्ल 5 , 46 बाइट्स

जावास्क्रिप्ट, 129 121 118 119 ^* 118 बाइट्स