Tentang Subjek Kata Sandi

10

Dalam Keep Talking and Nobody Explodes , pemain ditugasi menjinakkan bom berdasarkan informasi dari "pakar" mereka (orang lain dengan manual). Setiap bom terdiri dari modul-modul, salah satunya bisa berupa kata sandi, di mana pakar diberikan daftar kata sandi yang mungkin, panjangnya lima huruf:

about   after   again   below   could
every   first   found   great   house
large   learn   never   other   place
plant   point   right   small   sound
spell   still   study   their   there
these   thing   think   three   water
where   which   world   would   write

Dan pemain diberikan daftar 6 huruf yang mungkin untuk setiap tempat di kata sandi. Dengan kombinasi huruf yang memungkinkan, berikan kata sandi yang benar. Input dapat dalam format apa pun yang wajar (array 2D, string dipisahkan oleh baris baru, dll.) Anda dapat mengabaikan kode yang Anda gunakan untuk mengompres / membuat daftar / string / array / apa pun kata sandi. (Terima kasih @DenkerAffe)

CATATAN: Kata sandi tidak sensitif huruf besar / kecil. Anda dapat berasumsi bahwa input hanya akan menyelesaikan satu kata sandi.

Contoh / Kasus Uji

Input di sini akan direpresentasikan sebagai array string. 

["FGARTW","LKSIRE","UHRKPA","TGYSTG","LUOTEU"] => first
["ULOIPE","GEYARF","SHRGWE","JEHSDG","EJHDSP"] => large
["SHWYEU","YEUTLS","IHEWRA","HWULER","EUELJD"] => still
code-golf 
— MayorMonty
sumber
— Rɪᴋᴇʀ
8
Saya sarankan mengizinkan daftar kata sandi yang mungkin sebagai input ke program. Kalau tidak, ini turun ke mana bahasa memiliki kompresi string terbaik.
— Denker
5
Tidak apa-apa jika Anda mengubahnya; Saya tidak keberatan (sebagian besar karya saya akan tetap tidak berubah).
— Gagang Pintu
4
Saya setuju dengan DenkerAffe - memiliki kata sandi yang mungkin diberikan sebagai input daripada daftar statis membuat tantangan yang jauh lebih menarik.
— Mego
5
Mungkin menyederhanakan hal-hal jika Anda menggunakan daftar string sebagai input kedua, juga, karena itu membuatnya jelas byte mana yang dihitung. Saya tidak yakin apakah akan menghitung <dalam solusi Bash saya, misalnya.
— Gagang Pintu

Jawaban:

6

Pyth, 13 byte

:#%*"[%s]"5Q0c"ABOUTAFTERAGAINBELOWCOULDEVERYFIRSTFOUNDGREATHOUSELARGELEARNNEVEROTHERPLACEPLANTPOINTRIGHTSMALLSOUNDSPELLSTILLSTUDYTHEIRTHERETHESETHINGTHINKTHREEWATERWHEREWHICHWORLDWOULDWRITE"5

Suite uji.

 #             filter possible words on
:           0  regex match, with pattern
  %        Q   format input as
    "[%s]"     surround each group of letters with brackets (regex char class)
   *      5    repeat format string 5 times for 5 groups of letters
— Gagang pintu
sumber
Anda lupa memperbarui blok kode pertama Anda: P
— Downgoat
@Downgoat Apa yang saya lupa perbarui? Itu terlihat benar bagi saya.
— Gagang Pintu
Aneh, blok kode pertama tampaknya tidak cocok dengan contoh (tampaknya merupakan revisi lama?)
— Downgoat
1
— Leaky Nun
6

Bash, 22 byte

grep `printf [%s] $@`< <(echo ABOUTAFTERAGAINBELOWCOULDEVERYFIRSTFOUNDGREATHOUSELARGELEARNNEVEROTHERPLACEPLANTPOINTRIGHTSMALLSOUNDSPELLSTILLSTUDYTHEIRTHERETHESETHINGTHINKTHREEWATERWHEREWHICHWORLDWOULDWRITE | sed 's/...../&\n/g')

Jalankan seperti itu:

llama@llama:~$ bash passwords.sh FGARTW LKSIRE UHRKPA TGYSTG LUOTEU
FIRST

      printf [%s] $@    surround all command line args with brackets
grep `              `   output all input lines that match this as a regex
                     <  use the following file as input to grep
— Gagang pintu
sumber
Tidak ada bedanya dengan skor Anda, tetapi saya masih tidak bisa menahan golf ini:fold -5<<<ABOUTAFTERAGAINBELOWCOULDEVERYFIRSTFOUNDGREATHOUSELARGELEARNNEVEROTHERPLACEPLANTPOINTRIGHTSMALLSOUNDSPELLSTILLSTUDYTHEIRTHERETHESETHINGTHINKTHREEWATERWHEREWHICHWORLDWOULDWRITE|grep `printf [%s] $@`
— Digital Trauma
2

JavaScript (ES6), 62 byte

(l,p)=>p.find(w=>l.every((s,i)=>eval(`/[${s}]/i`).test(w[i])))

53 byte pada Firefox 48 atau sebelumnya:

(l,p)=>p.find(w=>l.every((s,i)=>~s.search(w[i],"i")))

Akan menjadi 49 byte jika bukan karena persyaratan ketidaksensitifan kasus:

(l,p)=>p.find(w=>l.every((s,i)=>~s.search(w[i])))

Tampilkan cuplikan kode

— Neil
sumber
2

Brachylog , 25 byte

:@laL,["about":"after":"again":"below":"could":"every":"first":"found":"great":"house":"large":"learn":"never":"other":"place":"plant":"point":"right":"small":"sound":"spell":"still":"study":"their":"there":"these":"thing":"think":"three":"water":"where":"which":"world":"would":"write"]:Jm.'(:ImC,L:Im'mC)

Bytes yang tidak terhitung adalah array kata, termasuk tanda kurung.

Penjelasan

:@laL                          Unifies L with the input where each string is lowercased
     ,[...]:Jm.                Unifies the Output with one of the words
               '(            ) True if what's in the parentheses is false,
                               else backtrack and try another word
                 :ImC          Unify C with the I'th character of the output
                     ,L:Im'mC  True if C is not part of the I'th string of L
— Fatalisasi
sumber
2

Ruby, 48 42 39 byte

Sekarang sudah selesai, sangat mirip dengan solusi Pyth, tetapi tanpa %smemformat ke titik di mana itu pada dasarnya adalah port langsung sekarang.

Jika Anda hanya menampilkan hasilnya dengan puts , Anda tidak perlu [0]pada akhirnya karena putsakan berurusan dengan itu untuk Anda.

->w,l{w.grep(/#{'[%s]'*l.size%l}/i)[0]}

Dengan uji kasus:

f=->w,l{w.grep(/#{'[%s]'*l.size%l}/i)[0]}

w = %w{about after again below could
every first found great house
large learn never other place
plant point right small sound
spell still study their there
these thing think three water
where which world would write}

puts f.call(w, ["FGARTW","LKSIRE","UHRKPA","TGYSTG","LUOTEU"]) # first
puts f.call(w, ["ULOIPE","GEYARF","SHRGWE","JEHSDG","EJHDSP"]) # large
puts f.call(w, ["SHWYEU","YEUTLS","IHEWRA","HWULER","EUELJD"]) # still
— Nilai Tinta
sumber
1

JavaScript (ES6), 71 byte

w=>l=>w.filter(s=>eval("for(b=1,i=5;i--;)b&=!!~l[i].indexOf(s[i])")[0])

Pemakaian:

f=w=>l=>w.filter(s=>eval("for(b=1,i=5;i--;)b&=!!~l[i].indexOf(s[i])")[0])
f(array_of_words)(array_of_letters)
— Patrick Roberts
sumber
1

Python, 64 60 57 byte

Kode untuk membuat daftar kata wsebagai string, kata-kata dipisahkan oleh ruang (byte didiskon dari panjang kode solusi):

w="about after again below could every first found great house large learn never other place plant point right small sound spell still study their there these thing think three water where which world would write"

Solusi saat ini (57 byte): disimpan 3 byte berkat @RootTwo

import re;f=lambda a:re.findall("(?i)\\b"+"[%s]"*5%a,w)[0]

Fungsi ini mengambil tuple(tidak list!) Persis 5 string yang mewakili huruf yang mungkin untuk setiap karakter kata sandi sebagai input.

Lihat kode ini berjalan di ideone.com

Versi kedua (60 byte):

import re;f=lambda a:re.findall("\\b"+"[%s]"*5%a+"(?i)",w)[0]

Fungsi ini mengambil tuple(tidak list!) Persis 5 string yang mewakili huruf yang mungkin untuk setiap karakter kata sandi sebagai input.

Lihat kode ini berjalan di ideone.com

Versi pertama (64 byte):

import re;f=lambda a:re.findall("\\b["+"][".join(a)+"](?i)",w)[0]

Fungsi ini mengambil semua iterable (misalnya listatautuple ) dari tepat 5 string yang mewakili huruf yang mungkin untuk setiap karakter kata sandi sebagai input.

Lihat kode ini berjalan di ideone.com

— Komandan Byte
sumber
1
Simpan tiga byte dengan menggunakan regex ini:"(?i)\\b"+"[%s]"*5%a
— RootTwo
Tentu saja, "kesalahan" yang jelas dari pihak saya ... Terima kasih telah menunjukkan ini pada @RootTwo, saya mengedit jawaban saya dan memberi Anda kredit.
— Byte Commander
@ByteCommander Saya tidak melihat kredit sama sekali.
— Erik the Outgolfer
@ ΈρικΚωνσταντόπουλος Tepat di bawah w=...baris kode: " Solusi aktual (57 byte, disimpan 3 byte berkat @RootTwo): "
— Byte Commander
@ByteCommander Mungkin saya melihat pratinjau versi sebelumnya setelah membangunkan pc saya dari hibernasi.
— Erik the Outgolfer
0

Hoon , 125 byte

|=
r/(list tape)
=+
^=
a
|-
?~
r
(easy ~)
;~
plug
(mask i.r)
(knee *tape |.(^$(r t.r)))
==
(skip pass |*(* =(~ (rust +< a))))

Tidak Disatukan:

|=  r/(list tape)
=+  ^=  a
|-
  ?~  r
    (easy ~)
  ;~  plug
    (mask i.r)
    (knee *tape |.(^$(r t.r)))
  ==
(skip pass |*(* =(~ (rust +< a))))

Hoon tidak memiliki regex, hanya sistem pengurai parser. Ini membuatnya cukup rumit untuk membuat semuanya berfungsi: (mask "abc")diterjemahkan secara kasar ke regex's [abc], dan merupakan inti dari parser yang sedang kita bangun.

;~(plug a b) adalah ikatan monadik dua parser di bawah ++plug pengurai di , yang harus mengurai yang pertama dan kemudian yang kedua atau gagal.

++kneedigunakan untuk membangun parser rekursif; kami memberikannya tipe ( *tape) dari hasilnya, dan panggilan balik untuk memanggil untuk menghasilkan parser yang sebenarnya. Dalam hal ini, callback adalah "panggil seluruh penutupan lagi, tetapi dengan bagian belakang daftar sebagai gantinya". The ?~tes Rune adalah daftar kosong, dan memberikan (easy ~)(melakukan apa pun tidak mengurai dan kembali ~) atau menambahkan yang lainmask dan recurse lagi.

Setelah membuat parser, kita bisa menggunakannya. ++skipmenghapus semua elemen daftar di mana fungsi mengembalikan ya untuk. ++rustmencoba mengurai elemen dengan aturan kami, mengembalikan yang unitmana salah satu [~ u=result]atau ~(versi Haskell's Maybe kami). Jika itu~ (Tidak ada, dan aturan gagal mem-parsing atau tidak mem-parsing seluruh konten), maka fungsi mengembalikan true dan elemen dihapus.

Yang tersisa adalah daftar, hanya berisi kata di mana setiap huruf adalah salah satu opsi dalam daftar yang diberikan. Saya berasumsi bahwa daftar kata sandi sudah dalam konteks di bawah nama pass.

> =pass %.  :*  "ABOUT"  "AFTER"   "AGAIN"   "BELOW"   "COULD"
   "EVERY"   "FIRST"   "FOUND"   "GREAT"   "HOUSE"
   "LARGE"   "LEARN"   "NEVER"   "OTHER"   "PLACE"
   "PLANT"   "POINT"   "RIGHT"   "SMALL"   "SOUND"
   "SPELL"   "STILL"   "STUDY"   "THEIR"   "THERE"
   "THESE"   "THING"   "THINK"   "THREE"   "WATER"
   "WHERE"   "WHICH"   "WORLD"   "WOULD"   "WRITE"
   ~  ==  limo
> %.  ~["SHWYEU" "YEUTLS" "IHEWRA" "HWULER" "EUELJD"]
  |=
  r/(list tape)
  =+
  ^=
  a
  |-
  ?~
  r
  (easy ~)
  ;~
  plug
  (mask i.r)
  (knee *tape |.(^$(r t.r)))
  ==
  (skip pass |*(* =(~ (rust +< a))))
[i="STILL" t=<<>>]
— Pengaturan rendering
sumber
0

Python 3, 81 byte

from itertools import*
lambda x:[i for i in map(''.join,product(*x))if i in l][0]

Fungsi anonim yang mengambil input dari daftar string xdan mengembalikan kata sandi.

Daftar kemungkinan kata sandi ldidefinisikan sebagai:

l=['ABOUT', 'AFTER', 'AGAIN', 'BELOW', 'COULD',
   'EVERY', 'FIRST', 'FOUND', 'GREAT', 'HOUSE',
   'LARGE', 'LEARN', 'NEVER', 'OTHER', 'PLACE',
   'PLANT', 'POINT', 'RIGHT', 'SMALL', 'SOUND',
   'SPELL', 'STILL', 'STUDY', 'THEIR', 'THERE',
   'THESE', 'THING', 'THINK', 'THREE', 'WATER',
   'WHERE', 'WHICH', 'WORLD', 'WOULD', 'WRITE']

Ini adalah kekuatan kasar yang sederhana; Saya tertarik melihat betapa singkatnya saya bisa mendapatkan ini tanpa regex.

Bagaimana itu bekerja

from itertools import*  Import everything from the Python module for iterable generation
lambda x                Anonymous function with input list of strings x
product(*x)             Yield an iterable containing all possible passwords character by
                        character
map(''.join,...)        Yield an iterable containing all possible passwords as strings by
                        concatenation
...for i in...          For all possible passwords i...
i...if i in l           ...yield i if i is in the password list
:[...][0]               Yield the first element of the single-element list containing the
                        correct password and return

Cobalah di Ideone

— TheBikingViking
sumber
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.