Memecahkan Enigma?

65

pengantar

Enigma adalah salah satu mesin sandi rotor elektro-mekanis pertama yang digunakan dalam Perang Dunia II. Itu berarti bahwa setelah satu huruf dikodekan, itu akan mengubah kunci untuk huruf berikutnya. Ini dianggap tidak bisa dipecahkan oleh Jerman, karena ruang utama yang sangat besar. Bahkan pemaksaan kasar hampir tidak mungkin. Namun, ada kesalahan desain dalam Enigma. Mengenkripsi surat tidak akan pernah menghasilkan sendiri. Itu berarti bahwa surat itu Adapat mengenkripsi ke setiap huruf kecuali surat itu A.

Mari kita ambil contoh pesan kode:

BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ

Kata khas Jerman adalah WETTERBERICHT, atau laporan cuaca dalam bahasa Inggris. Dengan prinsip di atas, kita dapat menentukan di mana lokasi kata itu mungkin:

BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ
WETTERBERICHT
         ^

Ini tidak mungkin, karena Itidak dapat dienkripsi ke dirinya sendiri, jadi kami pindah ke 1 tempat:

BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ
 WETTERBERICHT
             ^

Ini juga tidak mungkin, jadi kami pindah lagi ke tempat lain:

BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ
  WETTERBERICHT
   ^

Ini lagi tidak mungkin. Bahkan, kemungkinan yang pertama kali terjadi WETTERBERICHTadalah:

BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ
             WETTERBERICHT
0123456789012345678901234567890123456789012345678901234567890123
             ^
             13

Jadi, kami mengembalikan posisi 0-diindeks dari kemungkinan pertama, yaitu 13 .

Tugas

  • Diberikan pesan kode dan kata, cari indeks kemungkinan yang pertama kali muncul .
  • Asumsikan bahwa hanya karakter alfabet huruf besar dasar yang akan digunakan ( ABCDEFGHIJKLMNOPQRSTUVWXYZ).
  • Jika tidak ada kemunculan yang ditemukan, Anda dapat menampilkan bilangan bulat negatif , karakter, atau tidak sama sekali (misalnya -1, X).
  • Masukan dapat diterima sebagai argumen, pada baris baru yang terpisah, daftar atau apa pun.
  • Ini adalah kode-golf , jadi pengiriman dengan jumlah byte paling sedikit menang!

Uji kasus

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 
— Adnan
sumber
1
Umm, mengapa string yang disandikan berubah di tengah contoh?
— Gagang Pintu
36
@Doorknob 冰 ¯ \ _ (ツ) _ / ¯
— Adnan
Ada masalah dengan pendahuluan: 1. itu tidak dianggap tidak bisa dipecahkan karena ruang utama, tetapi karena sistem bahwa surat mengubah apa yang diterjemahkan menjadi 2. "Mengenkripsi surat tidak akan pernah menghasilkan menjadi dirinya sendiri." - ya itu akan, setelah jumlah karakter yang tersedia harus mengulanginya.
— Zelphir Kaltstahl
3
@ Zelphir dengan mengenkripsi sendiri, maksud saya bahwa Etidak akan pernah menghasilkan E. Itulah yang menjadi tantangan seluruh ini.
— Adnan

Jawaban:

9

Pyth, 14 byte

f!s.eqb@>zTkQ0

Saya tidak yakin apakah ini OK tetapi jika input tidak mungkin, tidak ada yang ditulis untuk stdout dan kesalahan pembagian nol ditulis ke stderr. Mengambil input pada 2 baris, yang kedua dikelilingi oleh tanda kutip.

Penjelasan:

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

Coba di sini!

— Biru
sumber
55

JavaScript, 40

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

Dengan menggunakan replace, ini memetakan input plaintext ke dalam ekspresi reguler bentuk /[^H][^E][^L][^L][^O]/(misalnya, untuk input plaintext HELLO) dan kemudian menggunakan searchuntuk menguji indeks pertama dari substring ciphertext yang cocok dengan regex itu. Regex ini berarti "pola di mana karakter pertama tidak H, karakter kedua tidak E, dll."

$&adalah urutan khusus untuk replaceoutput yang menggantikan nilai yang cocok dengan replaceargumen pertama (dalam hal ini, setiap karakter tunggal cocok dengan /./).

— apsillers
sumber
16
Oh, wow, itu solusi yang sangat pintar!
— Gagang Pintu
2
Saya tidak tahu tentang $&! Terima kasih telah mengajarkan sesuatu kepada saya hari ini.
— ETHproductions
1
@ ETHproductions Me juga, sampai hari ini! Saya juga belajar tentang $ `dan$' dalam proses meneliti jawaban ini, yang menyediakan" bagian dari string yang mendahului / mengikuti substring yang cocok "
— apsillers
1
Wow, itu luar biasa! Saya harus lebih sering membaca dokumen;)
— ETHproduksi
43

Turing Machine Simulator - 15660 bytes (Tidak Bersaing)

Tidak dapat memiliki tantangan Enigma tanpa menggunakan kode mesin.

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

Uji di sini

Gambaran singkat:

  1. Siapkan penghitung di sebelah kiri
  2. Temukan huruf besar pertama di target dan buat huruf kecil. Jika semua huruf kecil, pindah ke langkah 5.
  3. Temukan huruf besar pertama dalam kode. Jika sebagian besar huruf terakhir cocok, lanjutkan ke langkah 4. Lain, buat huruf kecil dan kembali ke langkah 2.
  4. Bertambah counter, buat semua huruf kapital, hapus huruf pertama dalam kode. Kembali ke langkah 2. Jika tidak ada huruf yang tersisa dalam kode, kembalikan pita yang jelas dan cetak x.
  5. Bersihkan semua kaset kecuali konter.
— Kacamata Korea
sumber
Juga, saat pengujian, format input harus: kode, target (tanpa spasi)
— KoreanwGlasses
Berapa lama untuk membuat ini?
— Adnan
18
Mulai pekerjaan rumah saya pukul 2:00. Mengalihkan perhatian pada 2:15. Mulai ini pada 2.20. Diposting pada pukul 4:20. Jadi sekitar 2 jam.
— KoreanwGlasses
5
+1, di PPCGSE, tidak harus bersaing untuk dihargai!
9575 bytes (dan bytecount saat ini di header adalah false, ada spasi yang asing dan beberapa nama negara yang panjang tidak perlu)
— Erik the Outgolfer
8

SWI-Prolog, 115 byte

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.

Contoh penggunaan: a(`ABCDEFGHIJKL`,`HELLO`,R).. Ini menggunakan string kode karakter yang dideklarasikan dengan backticks. Jawabannya disatukan dengan R. Jika tidak ada kecocokan yang ditemukan, ini menghasilkan false..

Penjelasan:

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.

Coba di sini

— Fatalisasi
sumber
7

Ruby, 91 79 byte

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

Mengutuk Anda, Enumerator! Mengapa saya harus mengkonversi dari string ke array ke Enumerator ke array dan membuang byte yang berharga? > :(

->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)
}}}
— Gagang pintu
sumber
Menggunakan [*...]sebagai alternatif golf untuk #to_a adalah sentuhan yang bagus.
— Wayne Conrad
7

CJam, 17 16 byte

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

Coba di sini .

Terima kasih kepada @PeterTaylor karena telah menghemat satu byte.

Penjelasan:

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
sumber
array block #dapat menyelamatkan Anda char:ll:A,ew{A.=:+!}#
— Peter Taylor
Luar biasa seberapa jauh CJam dapat bermain golf di hampir setiap tugas ...: -o
— agto
@agtoever saya tidak akan mengatakan itu benar-benar golf, karena 17 byte adalah percobaan pertama saya. Fitur kuncinya adalah ew(membuat irisan), yang lainnya hanya mengikuti.
— geokavel
6

MATL , 27 byte

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

Contohnya

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

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

Penjelasan

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
— Luis Mendo
sumber
4

Haskell, 72 byte

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

Penggunaan: h 0 "DEUTSCHLAND" "XEEFSLBSELDJMADNADKDPSSPRNEBWIENPF"-> 11.

Pendekatan rekursif sederhana: jika kata wdapat ditempatkan di awal string s, kembalikan penghitung indeks i, ulangi dengan ikenaikan dan ekor s. Berhenti dan kembali -1jika panjangnya skurang dari panjang w.

— nimi
sumber
4

Python 2.7, 111 karakter

Mencoba semua posisi awal (a) dan memeriksa semua huruf yang cocok (menggunakan pemahaman daftar). Ia mengembalikan "Tidak Ada" (Python "NULL") jika tidak ada yang ditemukan (untuk loop berakhir dan tidak ada yang dikembalikan, yang secara default adalah "Tidak Ada".

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

Testsuite:

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
sumber
Anda sebenarnya memiliki 114 byte, bukan 111. Ini adalah versi 106-byte: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
— movatica
4

Brachylog , 48 byte

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

Ini adalah terjemahan langsung dari jawaban Prolog saya. The brachylog_main/2predikat dihasilkan mengharapkan daftar dua kode karakter string dengan string kode pertama sebagai masukan, dan mengembalikan indeks sebagai output, misalnya brachylog_main([`ABCDEFGHIJKL`,`HELLO`],R)..

Penjelasan

[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)
— Fatalisasi
sumber
3

Japt, 12 byte (tidak kompetitif)

UàVr'."[^$&]

Aku butuh bantuan untuk yang ini.

— Mama Fun Roll
sumber
Uhhh ... Japt tidak punya .search? facepalm
— ETHproduk
Ini sekarang dapat dilakukan dengan UàVr'."[^$&]untuk 12.
— ETHproduk
Keren, kami menang sekarang!
— Mama Fun Roll
Karena revisi terbaru dari jawaban ini menggunakan fungsionalitas yang mengeposkan tanggal pertanyaan, saya menandainya sebagai tidak kompetitif.
— Mego
Oh lupa tentang itu: P Terima kasih!
— Mama Fun Roll
2

PHP - 155 byte

<?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";

Simpan sebagai crack.phpdan jalankan dengan argumen di baris perintah. Misalnya:

$ php crack.php BHGEFXWFTIUPITHHLPETTTCLOEWOELM WETTERBERICHT
13
Anda dapat menyimpan 25 byte dan menurunkannya hingga 130 byte :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↵";
— masukkanusername di sini
@insertusernamehere - Wow, itu mengesankan! Sedemikian rupa sehingga saya tidak merasa benar menggunakannya! Saya pikir saya pandai menggunakan levenshtein, tapi mungkin iterasi langsung dalam iterasi bisa melakukannya dalam lebih sedikit byte.
2

JavaScript, 129 121 118 119 * 118 byte

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

wadalah pesan kode, tadalah string tes. Ini tidak menggunakan regex, tetapi hanya membandingkan huruf per huruf, menggeser string uji (yaitu "WETTERBERICHT") dengan menambahkan spasi sebelum itu. Mudah dan membosankan.

* test case tanpa korek api tidak berfungsi, sekarang tidak berfungsi

— nicael
sumber
2

𝔼𝕊𝕄𝕚𝕟, 14 karakter / 25 byte

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

Try it here (Firefox only).

Kudos to @apsillers untuk idenya.

Penjelasan

               // implicit: î = input1, í = input2
îĊ             // search for first occurrence of:
  Ɱ(í,↪`⁅⦃$}]` // regex created by wrapping each word in [^ and ] (negation matches)
— Mama Fun Roll
sumber
Siapa pun yang memilih ini, apakah ada alasan mengapa?
— Mama Fun Roll
2

TeaScript, 14 byte 20

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

Mirip dengan @aspillers, solusi JavaScript yang cerdas .

Non-bersaing karena ini menggunakan fitur yang dibuat setelah kontes ini.

Penjelasan

             // 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
sumber
Tidak $&bekerja di tempat ${l}?
— ETHproduk
@ ETHproductions tidak dalam kasus ini karena saya menggunakan loop daripada ganti
— Downgoat
2

Ruby, 43 36 byte

sunting: Interpolasi string di dalam interpolasi string di dalam regex, ya.

Pendekatan malas: menerjemahkan kata ke regex "negatif" - =~Operator mengerjakan sisanya.

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

Uji:

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
sumber
2

05AB1E , 14 byte

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

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

Π              # 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)
— Kevin Cruijssen
sumber
2
Kawan, ini seharusnya jawaban @ Emigna;). Saya ingin datang ke sini dan membuat lelucon tentang dia menjawab pertanyaan adnan dengan hampir namanya di dalamnya. +1 (Melihat Anda menjawab 4 tahun setelah fakta setelah saya memposting komentar setelah fakta ini).
— Guci Gurita Ajaib
@MagicOctopusUrn Ketika saya melihat tantangan saya memikirkan hal yang sama, tetapi @Emigna biasanya menjawab jawaban baru dan tidak sering melihat jawaban yang ada. Jadi karena yang ini tidak punya jawaban 05AB1E saya pikir saya akan menambahkan satu. Anda memang benar bahwa @Emigna akan paling cocok untuk menjawab tantangan ini. ; p
— Kevin Cruijssen
1

Perl, 38 + 1 = 39 byte

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

di mana input terlihat seperti:

WETTERBERICHT
BHGEFXWFTIUPITHHLPETTTCLOEWOELMRXXPAKAXMAMTXXUDLTWTNHKELEPPLHPRQ

Ini adalah ide yang sama dengan javascript.

— alexander-brett
sumber
'X' tidak perlu
— Zaid
1

Java, 136 Karakter

Solusi berbasis regex yang terinspirasi oleh versi JavaScript apsillers .

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);}}
— Minimal
sumber
1

Brachylog (v2), 16 byte

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

Cobalah online!

Brachylog biasanya sangat pandai gagal ketika memecahkan sesuatu tidak mungkin.

Ini bukan salah satu dari waktu-waktu itu.

(mengambil input sebagai daftar [message, word]. Header mencetak semuanya dengan sangat bagus tetapi output dari predikat sebenarnya hanyalah angka jika berhasil)

                    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₁≠ᵐ∧ tampaknya berfungsi dengan baik untuk jumlah byte yang sama.

— String yang tidak terkait
sumber
0

C ++ (gcc) , 160 153 150 byte

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

Cobalah online!

— movatica
sumber
1
@ceilingcat: Anda dapat melakukan 157 byte . Kode gagal untuk dua testcases (seperti halnya yang asli). Saya memperbaikinya untuk beberapa byte tambahan.
— movatica
1
Plus, inisialisasi k Anda di loop luar memperkenalkan bug lain, di mana dengan setiap iterasi, satu karakter lebih sedikit dibandingkan.
— movatica
Ternyata, ini bahkan lebih pendek tanpa gotodan tanpa semua bug ...
— movatica
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.