Kutunun dışında düşünmenin başarmaya değer bir hedef olduğunu duymaya devam ediyorum ama başarılı bir şekilde yapıp yapmadığımı nasıl söyleyebilirim?

Bu ikilemi çözmek için teorik olarak aşağıdaki gibi çıktılar üretmesi gereken bir Brainwave-ASCII çevirmen yazdım.

                    #
   +------------+   #
   |   thinking |   #
   |            |   #
   +------------+   #
                    #

veya

                   #
 +------+          #
 |      | thinking #
 |      |          #
 |      |          #
 +------+          #
                   #

Bu, birinin kutunun dışında düşünüp düşünmediğini söylemeyi oldukça kolaylaştırır. ( #Çıktının bir parçası değildir ve yeni satırları temsil eder.)

Ancak, bir hata nedeniyle, bazen çıktının yalnızca daha küçük bir kısmı döndürülür:

   |         |         #
   +---------+         #
    thinking           #

        #
       +#
       |#
inking |#

    #
    #

Görev

Lütfen Brainwave-ASCII çevirmen çıkışını otomatik olarak yeniden toplama işlemini okuyan thinkingve kutuda olup olmadığını , girişin dışında söyleyemeyen ya da girmeyen bir şey yazarak otomatik olarak sınıflandırmamı sağlayın .

Giriş

Liste halinde veya içeren yeni satırlarla sınırlandırılmış aynı uzunlukta dizeler

• dize thinkingveya geçerli ön veya son ekleri
• +-|dikdörtgen bir kutu veya bunun geçerli kısımlarını oluşturan karakterler
• alanlarda
• HAYIR# , bunlar sadece girdi satırlarının uçlarını işaretleme zorluğuna dahil edilmiştir.

Çıktı

• kutunun dışındaysa bir gerçek değerthinking
• Bir falsy değeri ise thinkingkutunun içinde
• bir tat üçüncü belki de girişten olup olmadığını araştırmak edilemiyorsa değer thinkingkutusunda olup

Örnekler

Doğru:

                   #
 +------+          #
 |      | 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")
---#

Dize girişi olarak:

"                   \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#
-#

Dize girişi olarak:

"                    \n   +------------+   \n   |   thinking |   \n   |            |   \n   +------------+   \n                    "
"  +---------------\n  |               \n  |               \n  |   thinking    "
"      | \nking  | \n------+ "
"+---\n|thi\n+---"
"-\nn\n-"

Olabilir:

thinking#

g|#

think#
-----#

|          |# (box large enough to possibly contain the string)
|          |#

   +--#
   |  #

# (empty input)

Dize girişi olarak:

"thinking"
"g|"
"|t"
"-\ni"
"h\n-"
"think\n-----"
"|          |\n|          |"
"   +--\n   |  "
""

kurallar

• Bu kod-golf , bu yüzden mümkün olduğunca az byte kullanmaya çalışın.
• Belki değeri sürece truthy / falsy değerden farklı olduğunu ve tüm belki-girişler için aynıdır serbestçe seçilebilir. Aynı zamanda bir hata olabilir.
• Girişin her zaman geçerli olduğunu varsayabilirsiniz (örneğin +-ghiknt|, birden fazla kutudan başka bir karakter içermez , ...).

Javascript (ES6), 274 263 bayt

f=(a,b=(b,c="")=>a=a.replace(b,c),c=b=>b.test(`,${a},`))=>(b(/\w+/,5),b(/\+/g,1),b(/\-/g,2),b(/\|/g,3),b(/\n/g,4),c(/[13][2 ]{0,7}[13]|[12] *4 *[12]/)||(b(/ /g),b(/43+(?=4)/g),!c(/353|24542|12+435|21453|35412|5342+1/)&&(!c(/^([^1]*|([^15]*1){1,2}[^15]*)$/)||-1)))

Fonksiyon fdöner true, falseya -1da "belki" değeri olarak. Girdi: Bir argüman ile çağrılmalıdır. Diğer iki parametre yalnızca kodu kısaltmak için vardır.

İşte yorumlarla daha az golf oynayan bir sürüm:

var f = (input) => {
    var replace = (re, s) => input = input.replace(re, s);
    var test = re => re.test(input);

    /*
        Replace some "special" characters with ones that are shorter to put in a regex.
        "+" --> "1"
        "-" --> "2"
        "|" --> "3"
        "\n" --> ","
    */
    replace(/\+/g,1);
    replace(/\-/g,2);
    replace(/\|/g,3);
    replace(/\n/g,',');

    /*
        Shorten the word, if there is one, to just a single character "a".
    */
    replace(/[a-z]+/g,'a');

    /*
        Append a newline to the beginning and end of the input.
    */
    input = ','+input+',';

    /*
        Test the size of the box. These are the cases covered:
        /[13][2 ]{0,7}[13]/ : A horizontal edge or middle section has an inner width of fewer than 8 characters.
        /[12] *, *[12]/     : There are two horizontal edges in a row, with no space between.

        If either of these match, the word must be outside of the box. Return the truthy value (true).
    */
    if (test(/[13][2 ]{0,7}[13]|[12] *, *[12]/)) return true;

    /*
        Remove any spacing from the input. It it unnecessary from this point onwards.
    */
    replace(/ /g,'');

    /*
        Remove any lines with only vertical bars. These are also unnecessary.
    */
    replace(/,3+(?=,)/g,'');

    /*
        Edge / corner cases (heh). These are the cases covered:
        /3a3/    : two vertical bars with the word between.
        /2,a,2/  : two horizontal bars with the word between.
        /12+,3a/ : word inside the top left corner.
        /21,a3/  : word inside the top right corner.
        /3a,12/  : word inside the bottom left corner.
        /a3,2+1/ : word inside the bottom right corner.

        If any of these match, the word is inside the box. Return the falsy value (false).
    */
    if (test(/3a3|2,a,2|12+,3a|21,a3|3a,12|a3,2+1/)) return false;

    /*
        "Maybe" cases. These are the cases covered:
        /^[^1]*$/                : Input contains no corners, and may or may not contain a word.
        /^([^1a]*1){1,2}[^1a]*$/ : Input contains 1 or 2 corners, and no word.

        If either of these match, assuming the previous test cases have not been hit,
        we cannot tell if the word is inside or outside the box. Return the maybe value (-1).
    */
    if (test(/^([^1]*|([^1a]*1){1,2}[^1a]*)$/)) return -1;

    /*
        If none of the previous cases matched, the word must be outside of the box. Return the truthy value (true).
    */
    return true;
};

Bununla çok eğlendim. Teşekkürler!

Düzenleme: Kaydedilen 6 bayt teşekkürler @ L. Değiştirerek Serné b, varsayılan bir argüman kullanmak için 3 bayt tasarrufu ve değişen [a-z]için \w3 daha bayt tasarruf. Ayrıca, sözcük değişimini global olmayan hale getirerek, 1 bayt tasarruf "a"ederek 5ve 4 bayt tasarruf ","ederek değiştirerek 45 bayt daha tasarruf ettim.

Python 2.7, 532 494 453 bayt

Bunun bir çok özel durumu vardı. Gerçeğim ve sahtekarlık değerlerim sırasıyla "Doğru" ve "Yanlış" şeklindedir. Belki de değerim, tetiklemesi kolay olmaları ve girdi vakalarımdan biri girişin boş bir dizge olması durumunda tetiklenmesidir. Düzenli ifadeler biraz kullandım.

Python'da sık sık golf oynamıyorum, bu yüzden daha çok golf oynayabileceğinden eminim ama işte benim kodum:

import re
def e(s):exit(str(s))
i=input()
T=1<2
F=2<1
a=len(i)+1
c=i.count('+')
s='[a-z]'
x=re.search
p=x(s,i)
k=x('\+.*'+s,i)
l=x(s+'.*\|',i)
r=x('\|.*'+s,i)
f=i.find('+')
g=i[f-1]=='-'and f>0
if x('\-.*\n.*\-',i):e(T)
if x('\+.{0,7}\+',i):e(T)
if c>1 and not p:i[a]
if c>3:e(not(r and l))
if c>0:
 if r and l:e(F)
 if g:
    if l:e(F)
    if p or k:e(T)
    i[a]
 if r or k:e(F)
 if p:e(T)
 i[a]
if x('-.*\s[a-z].*\s-',i):e(F)
if x('\|.*[a-z].*\|',i):e(F)
i[a]

Golf versiyonumda Doğru / Yanlış cevabını arayarak görüntülüyorum exit(bool as string). İşte exit ifadelerinin return ifadeleriyle değiştirildiği ve her şeyin bir fonksiyona taşındığı yorumlanmış bir sürümü:

import re
i=input()
T=True
F=False
def z():
    # some variables and shortcuts useful for testing

    # length of input +1. Used to throw an index out of bounds error on 'maybe'
    a=len(i)+1
    # c for i.Count()
    c=i.count
    # string used in regular expressions often
    s='[a-z]'
    # shorten regeX calls
    x=re.search
    # p is true is 'thinking' is Present on canvas
    p=x(s,i)
    # k is true if 'thinking' is Right of a 'Korner' (corner)
    k=x('\+.*'+s,i)
    # l is true if 'thinking' is Left of a pipe (|)
    l=x(s+'.*\|',i)
    # r is true if 'thinking' is right of a pipe
    r=x('\|.*'+s,i)
    # f is First corner (+) index
    f=i.find('+')

    # g is true if box is facing riGht (i.e. there is a dash before the first +)
    # for example, '---+' indicates the box faces right. if the + is the 0th
    # character, then the box must be facing left.
    # Note that this assignment also checks for the empty string 'maybe'
    # case, which is signalled by an IndexOutofBounds error
    # CASE 1: Empty Input
    # ex: ''
    g=i[f-1]=='-' and f>0

    # Begin testing all possible scenarios

    # CASE 2: Box is too short (vertically)
    # ex: ------
    #     ------
    if x('\-.*\n.*\-',i):return T

    # CASE 3: box is too short (horizontally)
    # ex: ||
    if x('\+.{0,7}\+',i):return T

    # CASE 4: box is not too short yet no corners (+) or text are present on canvas
    # ex:
    # |       |         --------
    # |       |   or
    # |       |         --------
    # this is a maybe case, so throw out of bounds error
    if c('+')>1 and not p:i[a]

    # CASE 5: Four corners visible (whole box visible)
    # ex: +---+
    #     | X |
    #     +---+
    # return false if text is both right of and left of pipes (i.e. in box)
    if c('+')>3:return not(r and l)

    # CASE 6: one or two corners visible
    # ex:
    # ----+        |    |          |
    #     |    or  +----+   or  ---+  etc
    # ----+
    # in this case, we idenify which way the box faces
    if c('+')>0:

        # CASE 6-A: Text is between two pipes
        # ex:
        #     |   X   |
        #     +-------+
        # if text is between pipes (box is extending from top or bottom of
        # canvas), then it is inside box
        if r and l:return F

        # CASE 6-B: Box faces right
        # if the box is riGht-facing, ex:
        # ----+
        #     |    or  ----+  etc
        # ----+            |
        if g:

            # CASE 6-B-a: Letters are left of a pipe or a + in a right facing box
            # ----+
            #  X  |   or  ----+
            # ----+         X |
            if l :return F

            # CASE 6-B-b: Letters are right of a pipe or + in a right facing box
            # ----+
            #     | X  or  ----+
            # ----+            | X
            if p or k:return T

            # CASE 6-B-c: right-facing otherwise
            # otherwise, it is a 'maybe' case
            # use an index out of bounds error to signal 'maybe'
            i[a]

        # CASE 6-C: Box faces left (or letters are on canvas yet not inside box)
        # ex:
        #   +----
        #   |        or   +---  or
        #   +----         |
        else:

            # CASE 6-C-a: Letters are right of a pipe or a + in a left facing box
            # if letters are right of pipe, they are inside box, ex:
            #   +----
            #   | X       or   +---  or X +---
            #   +----          | X        |
            if r or k:return F

            # CASE 6-C-b: Letters are left of a pipe in a left facing box
            # ex:
            #     +----
            #   X |        or     +---
            #     +----         X |

            # CASE 6-C-c: Letters are on canvas yet not left or right of
            # a pipe or a + (they must therefore be outside the box)
            # ex:
            #  |     |
            #  +-----+
            #     X
            if p:return T

            # CASE 6-C-d: text is not visible on canvas, and only part of the box is
            # ex:
            #  |     |
            #  +-----+
            #
            # this is a 'maybe' case, as text is off canvas
            # use an index out of bounds error to signal 'maybe'
            i[a]

    # CASE 7: No corners visible, nonempty input

    # CASE 7-A: No corners visible, letters sandwitched between dashes
    # ex:
    # -----
    #   X
    # -----
    # if there are no corners, yet letters are sandwitched between dashes,
    # then word is in box
    if x('-.*\s[a-z].*\s-',i):return F

    # CASE 7-B: No corners visible, letters sandwitched bewteen pipes
    # ex: |  X  |
    # in this case, word is inside box
    if x('\|.*[a-z].*\|',i):return F

    # If none of the above cases are met, it is a maybe, so throw the error
    i[a]

print z()

Çözümüm, girişin geçerli olduğunu varsayar, yani 'Düşünme' (veya alt dizgilerinin) doğru yazıldığını, yalnızca tek bir kutunun olduğunu vb.

Düzenleme: @ ais523 öneri kaydedildi 10 bayt sayesinde değiştirmek ciçin i.count('+')değiştirilmesi Pavel'ın öneri @ 3 bayt sayesinde Trueile 1<2ve Falseile 2>1gereksiz bir başka blok kaldırarak 23 bayt, ve bazı boşlukları kaldırarak 2 bayt.

Düzenleme 2: 'Sekmelerimin' aslında 5 boşluk (D'oh!) Olduğuna işaret eden ve diğer bazı iyileştirmeler öneren @Wheat Wizard sayesinde 36 bayt kaydedildi.

Befunge, 535 bayt

Bu hoş değil ve mevcut cevaplarla rekabet etmeye yaklaşmıyor, ama Befunge'de elde edebileceğim en iyisi.

İade 1, kutunun dışında düşünme eğer 0kutunun içine düşünce ve eğer -1için belki .

p10p20p130p140p150p9-:60p70p"~":80p90pvp8p04+1:g04p03:$p9g04+g9g\<<
0$$$$"xxxx"5p041p031p$_v#!-+55:_v#`0:~<p05+1g
v01g04$_v#*`\"|"\`"-"::<>0g\8\p"0"-!!40g1-\8\p:4-!:00g0`*!:00g\6\p40g\8\p00g!*4v
>p50g20p>8%:30g88+*+:3-v4v\-1g05!!*-"3"\-"4"::p\7\g05!!-3:+*+88g8g04:p00+g00*g0<
v!*-"3"\-"5"::p\6\g04!!<!>>7\p::"C"-\"3"-*!!50g\9\p"0"-!!50g1-\9\p:5-!:40g9g48*v
>!40g1-\6\p::"S"-\"3"-*!^>0#4g#p9#\g#94#\8#g*#0-#5!#p*#\5#70#\g#-*^#84g9g04:!*`<
>80g60g-8`90g70g-1`**+!:10g80g`60g10g`20g90g`70g20g`+++!!*\!-.@
^!g01***`"}"g09`"}"g08`g070`g060<

Çevrimiçi deneyin!