Saya terus mendengar bahwa berpikir di luar kotak adalah tujuan yang layak dicapai, tetapi bagaimana saya bisa tahu jika saya berhasil melakukannya?
Untuk mengatasi dilema ini saya sudah menulis -translator Brainwave-to-ASCII yang secara teori harus menghasilkan output seperti
#
+------------+ #
| thinking | #
| | #
+------------+ #
#
atau
#
+------+ #
| | thinking #
| | #
| | #
+------+ #
#
yang membuatnya cukup mudah untuk mengetahui apakah seseorang berpikir di luar kotak atau tidak. (Ini #
bukan bagian dari output dan mewakili baris baru.)
Namun, karena bug terkadang hanya sebagian kecil dari output yang dikembalikan:
| | #
+---------+ #
thinking #
#
+#
|#
inking |#
#
#
Tugas
Tolong bantu saya untuk secara otomatis mengklasifikasikan output -translator Brainwave-to-ASCII dengan menulis sebuah program atau fungsi yang membaca reprensentasi ascii dan mengembalikan apakah thinking
ada di dalam kotak, di luarnya atau tidak dapat diketahui dari input.
Memasukkan
Satu set string dengan panjang yang sama baik sebagai daftar atau dibatasi oleh baris baru yang mengandung
- string
thinking
atau pre- atau suffix yang valid - karakter yang
+-|
membentuk kotak persegi panjang atau bagian yang valid dari itu - spasi
- TIDAK
#
, itu hanya termasuk dalam tantangan untuk menandai ujung jalur input.
Keluaran
- sebuah truthy nilai jika
thinking
berada di luar kotak - sebuah falsy nilai jika
thinking
dalam kotak - sepertiga yang berbeda mungkin bernilai jika tidak dapat ditentukan dari input apakah
thinking
ada di dalam kotak atau tidak
Contohnya
Benar:
#
+------+ #
| | thinking #
| | #
| | #
+------+ #
#
| | #
+---------+ #
thinking #
#
+#
|#
|#
inking |#
thinking #
-------+ #
++ # (thinking is not in the box, so it must be outside)
++ # (this is also the smallest possible box)
+ #
t#
+----+# (The box is not wide enough to contain "thinking")
---# (The box is not high enough to contain "thinking")
---#
Sebagai input string:
" \n +------+ \n | | thinking \n | | \n | | \n +------+ \n "
" | | \n +---------+ \n thinking "
" \n +\n |\n |\ninking |"
"thinking \n-------+ "
" ++ \n ++ "
"+ \n t"
"+----+"
"---\n---"
"g++"
"k\n+"
Falsy:
#
+------------+ #
| thinking | #
| | #
+------------+ #
#
+---------------#
| #
| #
| thinking #
| #
king | #
------+ #
+---#
|thi#
+---#
-#
n#
-#
Sebagai input string:
" \n +------------+ \n | thinking | \n | | \n +------------+ \n "
" +---------------\n | \n | \n | thinking "
" | \nking | \n------+ "
"+---\n|thi\n+---"
"-\nn\n-"
Mungkin:
thinking#
g|#
think#
-----#
| |# (box large enough to possibly contain the string)
| |#
+--#
| #
# (empty input)
Sebagai input string:
"thinking"
"g|"
"|t"
"-\ni"
"h\n-"
"think\n-----"
"| |\n| |"
" +--\n | "
""
Aturan
- Ini adalah kode-golf , jadi coba gunakan sesedikit mungkin byte.
- Nilai mungkin dapat dipilih secara bebas asalkan berbeda dari nilai true / falsy dan sama untuk semua mungkin-input. Ini juga bisa menjadi kesalahan.
- Anda dapat mengasumsikan bahwa input selalu valid (mis. Tidak mengandung karakter lain selain
+-ghiknt|
, tidak lebih dari satu kotak, ...).
sumber
+\n+
kotak terlalu kecil untuk satu kataJawaban:
Javascript (ES6),
274263 byteFungsi
f
mengembalikantrue
,,false
atau-1
sebagai nilainya "mungkin". Itu harus dipanggil dengan satu argumen: input. Dua parameter lainnya hanya ada untuk mempersingkat kode.Berikut adalah versi yang tidak begitu terkenal dengan komentar:
Bersenang-senang dengan yang satu ini. Terima kasih!
Sunting: Disimpan 6 byte, terima kasih @L. Serné dengan memodifikasi
b
untuk menggunakan argumen default, menyimpan 3 byte, dan mengubah[a-z]
ke\w
, menyimpan 3 byte lagi. Juga menghemat 5 byte lebih dengan membuat penggantian kata non-global, menghemat 1 byte, dan mengubah"a"
ke5
dan","
ke4
, menghemat 4 byte.sumber
console.log(f("input"))
. Tampaknya bekerja. Pekerjaan yang bagus untuk bermain golf ini.b=(b,c)
menjadib=(b,c="")
, dan kemudian Anda dapat menghapus argumen terakhir dari dua panggilanb
dengan string kosong sebagai argumen kedua, menyimpan (2 * 3-3 =) total 3 byte. Selain itu, Anda dapat mempersingkat kata regex dari[a-z]+
menjadi\w+
(lakukan ini sebelum yang lain menggantikan, karena ini juga akan cocok dengan angka) menghemat 3 byte lebih.Python 2.7,
532494453 byteYang ini pasti punya banyak kasus khusus. Nilai-nilai kebenaran dan kepalsuan saya masing-masing adalah string "Benar" dan "Salah". Nilai mungkin saya adalah Kesalahan Indeks, karena mudah dipicu dan salah satu kasus pengujian saya memicunya jika inputnya berupa string kosong, yang merupakan kasus mungkin. Saya menggunakan ekspresi reguler sedikit.
Saya tidak sering bermain golf dengan python, jadi saya yakin ini bisa diturunkan lebih banyak lagi, tapi ini kode saya:
Dalam versi golf saya, saya menampilkan jawaban Benar / Salah dengan menelepon
exit(bool as string)
. Inilah versi yang dikomentari, di mana pernyataan keluar diganti dengan pernyataan pengembalian, dan semuanya telah dipindahkan ke fungsi:Solusi saya mengasumsikan bahwa input tersebut valid, yaitu 'Berpikir' (atau substringnya) dieja dengan benar, hanya ada satu kotak, dll.
Sunting: Disimpan 10 byte berkat saran @ ais523 untuk diubah
c
menjadii.count('+')
, 3 byte berkat saran @ Pavel untuk menggantiTrue
dengan1<2
danFalse
dengan2>1
, 23 byte dengan menghapus blok orang lain yang tidak dibutuhkan, dan 2 byte dengan menghapus beberapa spasi.Sunting 2: Disimpan 36 byte berkat @Wheat Wizard yang dengan ramah menunjukkan bahwa 'tab' saya sebenarnya 5 spasi (D'oh!) Dan menyarankan beberapa peningkatan lainnya.
sumber
i
tidak pernah berubah, kan? Jadi Anda mungkin bisa menghemat byte dengan menyimpani.count('+')
dic
bukani.count
, karena Anda tidak pernah menyebutnya dengan argumen tapi+
.Befunge, 535 byte
Ini tidak cantik, dan hampir tidak bersaing dengan jawaban yang ada, tapi itu yang terbaik yang bisa saya capai di Befunge.
Pengembalian
1
jika berpikir di luar kotak,0
jika berpikir di dalam kotak, dan-1
untuk mungkin .Cobalah online!
sumber