Suatu kegiatan yang kadang-kadang saya lakukan ketika saya bosan adalah menulis beberapa karakter berpasangan. Saya kemudian menggambar garis (di atas tidak pernah di bawah) untuk menghubungkan karakter ini. Sebagai contoh saya dapat menulis $abcbac$ dan kemudian saya akan menggambar garis sebagai:

Atau saya mungkin menulis $abbcac$

Setelah saya menggambar garis-garis ini, saya mencoba menggambar loop tertutup di sekitar potongan sehingga loop saya tidak memotong garis yang saya gambar. Sebagai contoh, pada yang pertama, satu-satunya loop yang dapat kita gambar ada di sekitar semuanya, tetapi pada yang kedua kita bisa menggambar lingkaran di sekitar hanya $b$ s (atau yang lainnya)

Jika kita bermain-main dengan ini sebentar, kita akan menemukan bahwa beberapa string hanya dapat ditarik sehingga loop tertutup berisi semua atau tidak ada huruf (seperti contoh pertama kami). Kami akan menyebut string tersebut sebagai string yang terhubung dengan baik.

Perhatikan bahwa beberapa string dapat ditarik dengan berbagai cara. Misalnya $bbbb$ dapat ditarik dalam dua cara berikut (dan yang ketiga tidak termasuk):

atau

Jika salah satu dari cara-cara ini dapat digambar sedemikian sehingga loop tertutup dapat dibuat untuk mengandung beberapa karakter tanpa memotong salah satu garis, maka string tidak terhubung dengan baik. (jadi $bbbb$ tidak terhubung dengan baik)

Tugas

Tugas Anda adalah menulis sebuah program untuk mengidentifikasi string yang terhubung dengan baik. Input Anda akan terdiri dari string di mana setiap karakter muncul beberapa kali, dan output Anda harus menjadi salah satu dari dua nilai konsisten yang berbeda, satu jika string terhubung dengan baik dan yang lainnya sebaliknya.

Selain itu, program Anda harus memiliki makna string yang tertaut dengan baik

• Setiap karakter muncul beberapa kali dalam program Anda.

• Itu harus menampilkan nilai kebenaran ketika melewati itu sendiri.

Program Anda harus dapat menghasilkan output yang benar untuk string apa pun yang terdiri dari karakter dari ASCII yang dapat dicetak atau program Anda sendiri. Dengan setiap karakter muncul beberapa kali.

Jawaban akan dinilai sebagai panjangnya dalam byte dengan lebih sedikit byte menjadi skor yang lebih baik.

Petunjuk

Sebuah string tidak terhubung dengan baik jika ada substring ketat yang tidak kosong yang berdekatan sehingga setiap karakter muncul beberapa kali dalam substring tersebut.

Uji Kasus

abcbac -> True
abbcac -> False
bbbb -> False
abacbc -> True
abcbabcb -> True
abcbca -> False

Regex (ECMAScript 2018 atau .NET), 140 126 118 100 98 82 byte

^(?!(^.*)(.+)(.*$)(?<!^\2|^\1(?=(|(<?(|(?!\8).)*(\8|\3$){1}){2})*$).*(.)+\3$)!?=*)

Ini jauh lebih lambat daripada versi 98 byte, karena ^\1kiri dari lookahead dan karenanya dievaluasi setelah itu. Lihat di bawah untuk switcheroo sederhana yang mendapatkan kembali kecepatan. Tetapi karena ini, dua TIO di bawah ini terbatas untuk menyelesaikan set kasus uji yang lebih kecil daripada sebelumnya, dan .NET terlalu lambat untuk memeriksa regexnya sendiri.

Cobalah online! (ECMAScript 2018)
Cobalah online! (.BERSIH)

Untuk menjatuhkan 18 byte (118 → 100), saya tanpa malu-malu mencuri optimasi yang sangat bagus dari regex Neil yang menghindari perlunya menempatkan lookahead di dalam tampilan negatif (menghasilkan regex tanpa batas 80 byte). Terima kasih, Neil!

Itu menjadi usang ketika menjatuhkan 16 byte lebih luar biasa (98 → 82) berkat ide-ide jaytea yang menyebabkan regex tanpa batas 69 byte! Jauh lebih lambat, tapi itu golf!

Perhatikan bahwa (|(no-ops untuk membuat regex-linked dengan baik memiliki hasil membuatnya mengevaluasi sangat lambat di bawah .NET. Mereka tidak memiliki efek ini dalam ECMAScript karena kecocokan dengan lebar nol diperlakukan sebagai tidak cocok .

ECMAScript melarang penjumlah pada pernyataan, jadi ini membuat bermain golf persyaratan sumber terbatas lebih sulit. Namun, pada titik ini sangat baik bermain golf sehingga saya tidak berpikir mengangkat batasan tertentu akan membuka kemungkinan golf lebih lanjut.

Tanpa karakter tambahan yang diperlukan untuk membuatnya melewati batasan ( 101 69 byte):

^(?!(.*)(.+)(.*$)(?<!^\2|^\1(?=((((?!\8).)*(\8|\3$)){2})*$).*(.)+\3))

Ini lambat, tetapi pengeditan sederhana ini (hanya untuk 2 byte tambahan) mendapatkan kembali semua kecepatan yang hilang dan lebih banyak lagi:

^(?!(.*)(.+)(.*$)(?<!^\2|(?=\1((((?!\8).)*(\8|\3$)){2})*$)^\1.*(.)+\3))

^
(?!
    (.*)               # cycle through all starting points of substrings;
                       # \1 = part to exclude from the start
    (.+)               # cycle through all ending points of non-empty substrings;
                       # \2 = the substring
    (.*$)              # \3 = part to exclude from the end
    (?<!               # Assert that every character in the substring appears a total
                       # even number of times.
        ^\2            # Assert that our substring is not the whole string. We don't
                       # need a $ anchor because we were already at the end before
                       # entering this lookbehind.
    |                  # Note that the following steps are evaluated right to left,
                       # so please read them from bottom to top.
        ^\1            # Do not look further left than the start of our substring.
        (?=
            # Assert that the number of times the character \8 appears in our
            # substring is odd.
            (
                (
                    ((?!\8).)*
                    (\8|\3$) # This is the best part. Until the very last iteration
                             # of the loop outside the {2} loop, this alternation
                             # can only match \8, and once it reaches the end of the
                             # substring, it can match \3$ only once. This guarantees
                             # that it will match \8 an odd number of times, in matched
                             # pairs until finding one more at the end of the substring,
                             # which is paired with the \3$ instead of another \8.
                ){2}
            )*$
        )
        .*(.)+         # \8 = cycle through all characters in this substring
        # Assert (within this context) that at least one character appears an odd
        # number of times within our substring. (Outside this negative lookbehind,
        # that is equivalent to asserting that no character appears an odd number
        # of times in our substring.)
        \3             # Skip to our substring (do not look further right than its end)
    )
)

Saya menulisnya menggunakan molekuler lookahead ( 103 69 bytes) sebelum mengubahnya menjadi variabel-lookbehind di belakang:

^(?!.*(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$))

^
(?!
    .*(?*(.+)(.*$))       # cycle through all non-empty substrings;
                          # \1 = the current substring;
                          # \2 = the part to exclude from the end
    (?!                   # Assert that no character in the substring appears a
                          # total even number of times.
        ^\1$              # Assert that our substring is not the whole string
                          # (i.e. it's a strict substring)
    |
        (?*(.)+.*\2$)    # \3 = Cycle through all characters that appear in this
                          # substring.
        # Assert (within this context) that this character appears an odd number
        # of times within our substring.
        (
            (
                ((?!\3).)*
                (\3|\2$)
            ){2}
        )*$
    )
)

Dan untuk membantu membuat regex saya sendiri terhubung dengan baik, saya telah menggunakan variasi dari regex di atas:

(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$)\1

Ketika digunakan dengan regex -xml,rs -o, ini mengidentifikasi substring ketat dari input yang berisi angka genap setiap karakter (jika ada). Tentu, saya bisa menulis program non-regex untuk melakukan ini untuk saya, tetapi di mana kesenangannya?

Jelly, 20 byte

ĠẈḂẸẆṖÇ€Ạ
ĠẈḂẸ
ẆṖÇ€Ạ

Cobalah online!

Baris pertama diabaikan. Itu hanya ada untuk memenuhi syarat bahwa setiap karakter muncul beberapa kali.

Baris berikutnya pertama Ġroups indeks dengan nilainya. Jika kita kemudian mengambil panjang setiap sublist di daftar yang dihasilkan ( Ẉ), kita mendapatkan berapa kali setiap karakter muncul. Untuk memeriksa apakah semua ini adalah non-genap, kami mendapatkan yang terakhir Ḃdari setiap penghitungan dan menanyakan apakah ada nilai Ẹkebenaran (bukan nol).

Oleh karena itu, tautan helper ini mengembalikan apakah suatu substring tidak dapat dilingkari.

Di tautan utama, kami mengambil semua substring dari input ( Ẇ), Ṗop off yang terakhir (sehingga kami tidak memeriksa apakah seluruh string dapat dilingkari), dan menjalankan helper link ( Ç) pada €substring lainnya. Hasilnya kemudian apakah Ạsubstring ll tidak dapat dilingkari.

J , 34 byte

2:@':.,|~*'>1(#.,)*/@(1>2|#/.~)\.\

Cobalah online!

-8 Bytes berkat FrownyFrog

asli

J , 42 byte

(*#'.,012&|@~#')=1#.[:,([:*/0=2&|@#/.~)\.\

Cobalah online!

penjelasan

(*#'.,012&|@~#') = 1 #. [: , ([: */ 0 = 2&|@#/.~)\.\

(*#'.,012&|@~#')                                       NB. this evaluates to 1
                                                       NB. while supplying extra
                                                       NB. chars we need.  hence...
                 =                                     NB. does 1 equal...
                   1 #.                                NB. the sum of...
                        [: ,                           NB. the flatten of...
                             (                  )\.\   NB. the verb in parens applied
                                                       NB. to every suffix of every
                                                       NB. prefix, ie, all contiguous 
                                                       NB. substrings
                             ([: */ 0 = 2&|@#/.~)      NB. def of verb in paren:
                                             /.~       NB. when we group by each
                                                       NB. distinct char...
                              [: */                    NB. is it the case that
                                                       NB. every group...
                                           @#          NB. has a length...
                                    0 = 2&|            NB. divisible by 2...

Python 3.8 (pra-rilis) , 66 byte

lambda l,b={id}:len({str(b:=b^{c})for(c)in l})<len(l)#,<^fmnost{}#

Cobalah online!

Era Ekspresi Penugasan ada pada kita. Dengan PEP 572 termasuk dalam Python 3.8, golf tidak akan pernah sama. Anda dapat menginstal pratinjau pengembang awal 3.8.0a1 di sini .

Ekspresi penugasan memungkinkan Anda gunakan :=untuk menetapkan inline variabel saat mengevaluasi nilai itu. Misalnya, (a:=2, a+1)memberi (2, 3). Ini tentu saja dapat digunakan untuk menyimpan variabel untuk digunakan kembali, tetapi di sini kita melangkah lebih jauh dan menggunakannya sebagai akumulator dalam pemahaman.

Misalnya, kode ini menghitung jumlah kumulatif [1, 3, 6]

t=0
l=[1,2,3]
print([t:=t+x for x in l])

Perhatikan bagaimana setiap lulus melalui pemahaman daftar, jumlah kumulatif tmeningkat sebesar xdan nilai baru disimpan dalam daftar yang dihasilkan oleh pemahaman.

Demikian pula, b:=b^{c}memperbarui set karakter buntuk beralih apakah itu termasuk karakter c, dan mengevaluasi ke nilai baru b. Jadi, kode ini [b:=b^{c}for c in l]lebih dari satu karakter cdalam ldan mengakumulasikan kumpulan karakter yang terlihat beberapa kali ganjil di setiap awalan yang tidak kosong.

Daftar ini diperiksa untuk duplikat dengan membuatnya menjadi kumpulan pemahaman dan melihat apakah panjangnya lebih kecil dari itu s, yang berarti bahwa beberapa pengulangan runtuh. Jika demikian, pengulangan berarti bahwa dalam porsi yang sterlihat di antara saat-saat itu setiap karakter menemukan angka genap, membuat string tidak terhubung dengan baik. Python tidak mengizinkan set himpunan menjadi tidak dapat pecah, jadi set batin dikonversi ke string sebagai gantinya.

Set bdiinisialisasi sebagai argumen opsional, dan berhasil dimodifikasi dalam lingkup fungsi. Saya khawatir ini akan membuat fungsi tersebut tidak dapat digunakan kembali, tetapi tampaknya untuk mengatur ulang antar berjalan.

Untuk pembatasan sumber, karakter yang tidak berpasangan dimasukkan ke dalam komentar di bagian akhir. Menulis for(c)in ldaripada for c in lmembatalkan paren tambahan secara gratis. Kami menempatkan idke dalam set awal b, yang tidak berbahaya karena dapat dimulai sebagai set apa pun, tetapi set kosong tidak dapat ditulis {}karena Python akan membuat kamus kosong. Karena surat-surat idan di dantara mereka yang membutuhkan pasangan, kita dapat menempatkan fungsinya di idsana.

Perhatikan bahwa output kode meniadakan boolean, sehingga kode itu akan memberikan Falsedirinya sendiri dengan benar .

Python 2 , 74 byte

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)

Cobalah online!

Iterasi melalui string, melacak Pset karakter yang dilihat dalam jumlah ganjil sejauh ini. Daftar dmenyimpan semua nilai masa lalu P, dan jika melihat saat ini Psudah dalam d, ini berarti bahwa dalam karakter yang terlihat sejak saat itu, setiap karakter telah muncul beberapa kali genap. Jika demikian, periksa apakah kami telah melalui seluruh input: jika ada, terima karena seluruh string dipasangkan seperti yang diharapkan, dan jika tidak, tolak.

Sekarang tentang batasan sumber. Karakter yang membutuhkan pasangan dimasukkan ke berbagai tempat yang tidak berbahaya, yang digarisbawahi di bawah ini:

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)
_____              _              _      _    _    ___        ___    

The f<smengevaluasi ke 0saat memasangkan off f, mengambil keuntungan dari nama fungsi juga menjadi fsehingga didefinisikan (pada saat fungsi ini dipanggil.) Yang 0^0menyerap sebuah ^simbol.

The 0dalam P={0}sangat disayangkan: Python {}mengevaluasi ke dict kosong daripada himpunan kosong seperti yang kita inginkan, dan di sini kita dapat dimasukkan ke dalam setiap elemen non-karakter dan itu akan menjadi berbahaya. Saya tidak melihat ada cadangan untuk dimasukkan, dan telah dimasukkan 0dan digandakan bmn0, biaya 2 byte. Perhatikan bahwa argumen awal dievaluasi ketika fungsi didefinisikan, sehingga variabel yang kita definisikan sendiri tidak dapat dimasukkan ke sini.

Perl 6 , 76 byte

*.comb[^*X+(^*).map(^*)].grep({$_&[&]($_)}).none.Bag{*}.none%2#*^+XBob2rec%#

Cobalah online!

A Apapun lambda yang mengembalikan Persimpangan Tidak Ada Persimpangan yang dapat didekati dengan nilai true / falsey. Saya akan merekomendasikan untuk tidak menghapus hasil ?pengembalian yang boolify, jika tidak, output akan menjadi agak besar .

Solusi ini sedikit lebih kompleks dari yang diperlukan, karena beberapa fungsi yang terlibat yang dibatalkan, misalnya .., all, >>, %%dll Tanpa pembatasan sumber, ini bisa menjadi 43 bytes:

*.comb[^*X.. ^*].grep(?*).one.Bag{*}.all%%2

Cobalah online!

Penjelasan:

*.comb                     # Split the string to a list of characters
      [^*X+(^*).map(^*)]   # Get all substrings, alongside some garbage
                        .grep({$_&[&]($_)})        # Filter out the garbage (empty lists, lists with Nil values)
                                           .none                 # Are none of
                                                .Bag{*}          # The count of characters in each substring
                                                       .none%2   # All not divisible by 2

                                               #*^+XBob2rec%#    And garbage to even out character counts

Perl 5 -p, 94, 86, 78 byte

m-.+(?{$Q|=@q&grp,$\|=$&eq$_^!grep+/^/&(@m=$g=~/\Q$_/g),($g=$&)=~/./g})(?!)-}{

ouput 0 jika terhubung dengan baik 1 sebaliknya.

78 byte

86 byte

94 byte

Bagaimana itu bekerja

• -pdengan }{trik akhir untuk menghasilkan $\di akhir
• m-.+(?{.. })(?!)-, untuk mengeksekusi kode pada semua substring yang tidak kosong ( .+cocok dengan seluruh string terlebih dahulu, dan setelah mengeksekusi kode antara (?{.. })backtracks karena gagal paksa(?!)
• $Q|=@q&grp, sampah karena pembatasan sumber
• $\|=integer bitwise atau assignment, jika hampir ada 1, $\akan menjadi 1 (true), secara default itu kosong (false)
• $&eq$_kasus di mana sbustring adalah seluruh string bitwise xored ^dengan "tidak ada kejadian karakter yang aneh"
• ($g=$&)=~/./guntuk menyalin substring yang cocok ke $g(karena akan overwirtten setelah pertandingan regex berikutnya) dan mengembalikan array karakter substring.
• /^/ sampah yang dievaluasi menjadi 1
• grep1 &(@m=$g=~/\Q$_/g),untuk setiap karakter dalam substring mendapatkan array karakter dalam $gpencocokan itu sendiri, array dalam skalar mengevaluasi ukurannya dan grepmenyaring pemburu dengan kejadian aneh 1&xsetara denganx%2==1

Retina , 150 96 byte

^(?!(.*)(.+)(.*)$(?<!^\2|^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

Cobalah online! Tautan termasuk kasus uji, termasuk dirinya sendiri. Sunting: Memotong regex yang asli sedikit dengan bantuan dari @Deadcode, lalu kembali dengan agak kurang mewah untuk mempertahankan tata letak sumber. Penjelasan:

^(?!(.*)(.+)(.*)$

Menyatakan bahwa tidak \3ada substring yang cocok dengan batasan berikut.

(?<!^\2|

Menegaskan bahwa substring bukan keseluruhan string asli.

^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

Tegaskan bahwa tidak ada karakter \6yang:

• tidak muncul di antara karakter itu sendiri (eksklusif) dan akhir substring
• muncul beberapa kali antara awal substring dan dirinya sendiri (eksklusif)

Untuk melewati batasan tata letak sumber, saya mengganti ((((dengan (?:(^?(?:(dan ((dengan (|(. Saya masih memiliki satu kendala sumber ))tersisa dan karakter !()1<{}tersisa, jadi saya mengubah +ke dalam {1,}dan memasukkan yang tidak berguna (?!,<)?untuk mengkonsumsi sisanya.

C # (Visual C # Interactive Compiler) , 208 206 200 198 byte

x=>!x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&!Enumerable.Repeat(x.Count,x.Count*x.Count).Where(
(l,i)=>i%l>0&!x.Skip(i/l).Take(i%l).GroupBy(c=>c).Any(g=>g.Count()%2>0)
).Any()/*>!oyAnC0EmeablR*WhiS/T*/

Cobalah online!

-2 byte terima kasih kepada @KevinCruijssen!

Akhirnya mendapatkannya di bawah 200, jadi saya mungkin bermain golf untuk saat ini :) Saya akhirnya membuat TIO kedua untuk menguji hal-hal berdasarkan jawaban sebelumnya.

Cobalah online!

Hal-hal yang membuat tugas ini rumit:

• Operator kesetaraan ==tidak diizinkan
• Operator kenaikan / penetapan ++tidak diizinkan
• All()Fungsi Linq tidak diizinkan

Kode yang dikomentari di bawah ini:

// anonymous function that takes an IList as input
x=>
  // the first condition makes sure the string even
  // counts of each character
  !x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&
  // the second condition generates all proper substrings of x
  // and tests for any that contain even character counts
  // the string length `l` is repeated `l*l` times
  !Enumerable.Repeat(x.Count,x.Count*x.Count)
    .Where((l,i)=>
      // check that the substring length is greater than 0
      i%l>0&
      // use skip/take to generate a substring
      // and check for a character count thats odd
      // negate the result meaning we have found
      // a substring that invalidates the input
      !x.Skip(i/l).Take(i%l)
        .GroupBy(c=>c).Any(g=>g.Count()%2>0)
    )
    // if any invalid substrings are found
    // then the result in invalid
    // the comment string at the end is needed
    // to make the program well-linked
    .Any()/*>!oyAnC0EmeablR*WhiS/T*/

Python 2 , 108 byte

lambda d,e=enumerate:min(max(d[l:l+b].count(k)%2for(k)in d)for b,c in e(d[2:],2)for l,f in e(d) )#b =:x+.%2#

Cobalah online!

-2 Terima kasih kepada Ørjan Johansen .

Brachylog , 16 byte

sᶠb∋p~j&sᶠb∋p~j&

Cobalah online!

Mencetak false.untuk contoh yang benar dan true.untuk contoh yang salah. Versi TIO terlalu lambat untuk ditangani sendiri, tetapi jelas terkait dengan baik karena string dengan karakter unik diulang dua kali.

Penjelasan

    Input is a string: "abcacbaa"
sᶠ  Find all substrings: ["abcacbaa","abcacba","abcacb",..,"a"]
b   Behead (now the proper substrings remain): ["abcacba","abcacb",..,"a"]
∋   Take one of them: "abcacb"
p   Permute it: "abcabc"
~j  It is some string repeated twice: "abc"
&   Get the input again: "abcacbaa"
    Then repeat the above.
    If the constraints can be satisfied, the result is true, otherwise false.

05AB1E , 22 20 byte

Œε¢Pà}KŒIKεSIS¢ÈP}àÈ

Output 1jika string terhubung dengan baik, dan 0jika string tidak terhubung dengan baik.

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

Program dasar adalah ŒsKεsS¢ÈP}à( 11 byte ), yang menghasilkan 0jika terhubung dengan baik dan 1jika tidak terhubung dengan baik. Trailing È(is_even) adalah semi no-op yang membalikkan output, jadi 1untuk string yang terhubung dengan baik dan 0untuk string yang tidak terhubung dengan baik. Bagian lain adalah no-ops untuk mematuhi aturan tantangan.

Œε¢Pà}K         # No-ops: substrings, map, count, product, maximum, close map, remove
                # Due to the last remove, we're back at the (implicit) input again
Π              # Take the substrings of the input
 IK             # Remove the input itself from that list of substrings
   ε            # Map each substring to:
    S           #  No-op: transform the substring into a list of characters
     IS         #  Get the input-string as a list of characters
       ¢        #  Count the occurrence of each character in the current substring
        È       #  Check which counts are even (1 if truthy; 0 if falsey)
         P      #  Take the product of that
          }à    # After the map: check if any are truthy by taking the maximum
            È   # Semi no-op: check if this maximum is even (0 becomes 1; 1 becomes 0)
                # (and output the result implicitly)