อักขระที่แยกได้คืออักขระ (นอกเหนือจากบรรทัดใหม่) ที่ไม่มีอักขระที่อยู่ติดกันประเภทเดียวกัน อักขระที่อยู่ติดกันสามารถอยู่ทางซ้ายขวาด้านบนหรือด้านล่าง แต่ไม่ใช่ diagonals ตัวอย่างเช่นในข้อความต่อไปนี้Hถูกแยก:

Ybb
YH%
%%%%

อักขระอื่น ๆ ทั้งหมดไม่ได้แยกออกจากกันเพราะอักขระแต่ละตัวมีอักขระอื่นอย่างน้อยหนึ่งตัวที่อยู่ติดกัน

งานของคุณคือการเขียนโปรแกรมที่รับสตริงเป็นอินพุตและกำหนดจำนวนอักขระที่แยกได้

เกณฑ์การให้คะแนน

คำตอบของคุณจะได้คะแนนสองตัวชี้วัด ตัวแรกคือจำนวนอักขระที่แยกได้ในโปรแกรมของคุณ คุณควรตั้งเป้าหมายที่จะย่อให้เล็กสุดนี้ ที่สองจะเป็นจำนวนไบต์ในโปรแกรมของคุณ คุณควรย่อให้เล็กสุดเช่นกัน ขนาดโปรแกรมจะทำหน้าที่เป็นตัวแบ่งไทร์สำหรับเกณฑ์แรก

กฎเพิ่มเติม

• คุณควรสนับสนุนอินพุตในช่วง ascii ที่พิมพ์ได้รวมถึงอักขระใด ๆ ที่คุณใช้ในโปรแกรมของคุณ

• คุณอาจพิจารณาว่าตัวแบ่งบรรทัดเป็นอักขระขึ้นบรรทัดใหม่หรือขึ้นบรรทัดใหม่ตามด้วยตัวดึงข้อมูลบรรทัด

• คุณสามารถป้อนข้อมูลในรูปแบบที่เหมาะสม ซึ่งรวมถึงรายการของเส้น

กรณีทดสอบ

Ybb
YH%
%%%%

$1$

Aaaab
uuu
yyybbb

$2$

A

$1$

qqWWaaww

$0$

Python 2 , 0 ( 350 344 314 309 301 298 291 ไบต์)

def f(tt):11
def f(tt):
 tt=tt.split('\n')
 r =0#.split('\n')
#r  0#
#for
 for  ii,ll in enumerate(tt):
  for jj,cc in enumerate(ll):
##for+=1-(
    r+=1-(cc in ll[(jj or 2)-1:jj+2:2]    +''.join(ll[jj:
 jj+1]for ll in tt[(ii or 2)-1:ii+2:2]))##+''.join(ll[jj:
#  +1]for 
#print r
 print r
 

ลองออนไลน์!

_{-7 ไบต์ขอบคุณ Jo King}

ทำความสะอาด , 0 ( 439 ... 415 ไบต์)

-11 ขอบคุณØrjan Johansen

ในที่สุดความท้าทายที่ฉันสามารถทำคะแนน 0 ด้วย Clean!
(และโดยปกติแล้วมันจะไม่ดีในการท้าทายการออกแบบเลย์เอาต์!

//module 
  module d
import StdEnv,ArgEnv,Data.List,Data.Maybe
import StdEnv,ArgEnv,Data.List,Data.Maybe
Start=sum[1\\i<-l&v<-[0..],_<-i&u<-[0..]|all((<>)(?u v))[?(u-1)v,?(u+1)v,?u(v-1),?u(v+1)]]
Start=sum[1\\i<-l&v<-[0..],_<-i&u<-[0..]|all((<>)(?u v))[?(u-1)v,?(u+1)v,?u(v-1),?u(v+1)]] 
l=mklines[c\\c<-:getCommandLine.[1]]
l=mklines[c\\c<-:getCommandLine.[1]]
?x=mapMaybe(\k=k!?x)o(!?)l
?x=mapMaybe(\k=k!?x)o(!?)l

ลองออนไลน์!

ลิงก์ TIO ใช้module mainเนื่องจากวิธี Clean ถูกนำไปใช้กับ TIO แต่module dจะใช้งานได้หากคุณตั้งชื่อไฟล์d.iclแทนที่จะmain.iclเป็น TIO

หนึ่งในบรรทัดเก่าอธิบาย (รุ่นใหม่เป็นสิ่งเดียวกันในลำดับที่แตกต่างกัน):

Start                                       // entry point
 = let                                      // define locals
  l = mklines                               // `l` is argument split at newlines
   [c \\ c <-: getCommandLine.[1]];         // the second command-line arg turned into a [Char]
  ? x y                                     // function ? of coordinate (x,y)
   = mapMaybe                               // if the argument isn't Nothing
    (\k = k!?x)                             // try taking the `x`-th index
    (l!?y)                                  // of the `y`-th index of `l`
  in                                        // in the context of
   sum [                                    // the sum of
    1                                       // the integer one
    \\ i <- l & v <- [0..]                  // for every index in `l`
    , _ <- i & u <- [0..]                   // for every subindex in `l`
    | all (                                 // where all of the second argument
      (<>)(?u v)                            // doesn't equal the first argument
     ) [?(u-1)v, ?(u+1)v, ?u(v-1), ?u(v+1)] // over every adjacent element
   ]

JavaScript (ES6), 0 (154 ไบต์)

บันทึกแล้ว2 4 ไบต์ต้องขอบคุณ @ ØrjanJohansen

รับอินพุตเป็นอาร์เรย์ของสตริง

s  =>
s//=>(s,y,a
.map((s,y,a)=>[...s]
.map((c,x  )=>[...s]
&&//++c,x
 s[x+1]==c|
 s[x-1]==c|
(a[y-1]||0)[x]==c|
(a[y+1]||0)[x]==c||
  i++),i=0)
&&i//),i=

ลองออนไลน์!

เยลลี่ , 0 ( 41 27 25 ไบต์)

ŒĠạþ`€Ẏ§CẠ€S
ŒĠạþ`€Ẏ§CẠ€S

ลองออนไลน์!

รับอินพุตเป็นรายการของบรรทัด บรรทัดแรกในโค้ดไม่เคยทำอะไรเลยและมีเพียงเพื่อลดจำนวนอักขระที่แยกออก

ỴŒĠạþ`€Ẏ§1eⱮCS
Ỵ                 Split the text on newlines.
 ŒĠ               Group the multidimensional indices by their value.
      €           For each list of indices:
   ạ                Take the absolute difference...
    þ`              ...between each pair.
       Ẏ          Concatenate the lists of differences.
        §         Sum the x & y differences. This computes the Manhattan distance.
                  At this point we have a list for each character in the text of 
                  Manhattan distances between it and it's identical characters. 
         1eⱮ      Is there a 1 in each of the lists? None for isolated characters.
            C     Complement: 0 <-> 1.
             S    Sum. Counts the isolated characters

MATL , 0 (54 ไบต์)

TTTTf"Go@X!0JQJ&(d@_X!]***ggss
%%%%f"Go@X!0JQJ&(d@_X!]

{'line 1', 'line 2', 'and line 3'}การป้อนข้อมูลเป็นอาร์เรย์เซลล์ของสตริงหนึ่งสำหรับแต่ละบรรทัด:

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบและ source code

Python 3 , 0 (323 ไบต์)

def f(s,e=enumerate):S={(x,y,c)for y,l in e(s.split("\n"))for x,c in e(l)};return-sum(~-any((x+u,y+v,c)in S for u,v in[(1,0),(~0,0),(0,~0),(0,1)])for x,y,c in S)
def f(s,e=enumerate):S={(x,y,c)for y,l in e(s.split("\n"))for x,c in e(l)};return-sum(~-any((x+u,y+v,c)in S for u,v in[(1,0),(~0,0),(0,~0),(0,1)])for x,y,c in S)

ลองออนไลน์!

05AB1E , 0 (101 ไบต์ )

žGçU|€SXζζD"εγεDgDisëXи]"©.V˜sø®.V€Sø˜‚øʒË}ʒXå≠}gq
žGçU|€SXζζD"εγεDgDisëXи]"©.V˜sø®.V€Sø˜‚øʒË}ʒXå≠}gq

ลองออนไลน์

นี่เป็นหนึ่งในโปรแกรม 05AB1E ที่น่าเกลียดที่สุดและยาวที่สุดที่ฉันเคยเขียน .. >.> ความท้าทายนี้ยากที่จะหลอกลวงใน 05AB1E ฉันไม่มีข้อสงสัยในใจว่าอย่างน้อยจำนวนไบต์อาจลดลงครึ่งหนึ่งหรือแม้แต่น้อยสาม / สี่เท่าโดยใช้วิธีการอื่น (หรือแม้กระทั่งด้วยวิธีการที่คล้ายกัน) แต่ตอนนี้ฉันไม่เห็นวิธี ฉันแค่ดีใจที่มันทำงานได้ในขณะนี้ .. ถ้ามีคนโพสต์คำตอบที่สั้นกว่า 05AB1E ด้วยเทคนิคอันชาญฉลาดบางอย่างฉันอาจจะลบคำตอบนี้ด้วยความละอาย ... xD

คำอธิบาย:

žGç                # Character with unicode 32768 ('耀')
   U               # Pop and store it in variable `X`
                   # (This character is not part of the printable ASCII, nor of my 05AB1E code)
|                  # Take the multi-line input as list
                   #  i.e. "Ybb\nYH%\n%%%%" → ["Ybb","YH%","%%%%"]
 €S                # Convert each string to a list of characters
                   #  i.e. ["Ybb","YH%","%%%%"] → [["Y","b","b"],["Y","H","%"],["%","%","%","%"]]
   Xζζ             # Zip with character `X` as filler twice to make the lines of equal length
                   #  i.e. [["Y","b","b"],["Y","H","%"],["%","%","%","%"]]
                   #   → [["Y","b","b","耀"],["Y","H","%","耀"],["%","%","%","%"]]
      D            # Duplicate this list
"             "    # Create a string
               ©   # Which we store in the register (without popping)
                .V # And execute that string as 05AB1E code
 ε                 #  Map each inner list to:
  γ                #   Split in chunks of the same characters
                   #    i.e. [["Y","b","b"],["Y","H","%"],["%","%","%","%"]]
                   #     → [[["Y"],["b","b"]],[["Y"],["H"],["%"]],[["%","%","%","%"]]]
   ε               #   Map each of those to:
    D              #    Duplicate the current inner list
     gDi           #    If its length is exactly 1:
        s          #     Swap so the mapping keeps the duplicated single character (as list)
       ë           #    Else:
        Xи         #     Take character `X` repeated the length amount of times
                   #      i.e. ["%","%","%","%"] (length 4) → ["耀","耀","耀","耀"]
          ]        #  Close the if-else and both maps
           ˜       #  Flatten the list to a single list of characters
                   #   i.e. [[["Y"],["耀","耀"],["耀"]],[["Y"],["H"],["%"],["耀"]],[["耀","耀","耀","耀"]]]
                   #    → ["Y","耀","耀","耀","Y","H","%","耀","耀","耀","耀","耀"]
s                  # Swap so the duplicate list is at the top of the stack
 ø                 # Swap its rows and columns
                   #  i.e. [["Y","b","b","耀"],["Y","H","%","耀"],["%","%","%","%"]]
                   #   → [["Y","Y","%"],["b","H","%"],["b","%","%"],["耀","耀","%"]]
  ®.V              # Execute the same piece of code again that we've stored in the register
     €S            # Convert each to a list of characters
                   #  i.e. [[["耀","耀"],["%"]],[["b"],["H"],["%"]],[["b"],["耀","耀"]],[["耀","耀"],["%"]]]
                   #   → [["耀","耀","%"],["b","H","%"],["b","耀","耀"],["耀","耀","%"]]
       ø           # Swap its rows and columns back again
                   #  i.e. [["耀","b","b","耀"],["耀","H","耀","耀"],["%","%","耀","%"]]
        ˜          # Flatten this list as well
‚                  # Pair both lists together
                   #  i.e. [["Y","耀","耀","耀","Y","H","%","耀","耀","耀","耀","耀"],
                   #        ["耀","b","b","耀","耀","H","耀","耀","%","%","耀","%"]]
 ø                 # Swap its rows and columns to create pairs
                   #  i.e. [["Y","耀"],["耀","b"],["耀","b"],["耀","耀"],["Y","耀"],["H","H"],["%","耀"],["耀","耀"],["耀","%"],["耀","%"],["耀","耀"],["耀","%"]]
  ʒË}              # Filter out any inner lists where both characters are not equal
                   #  i.e. [["耀","耀"],["H","H"],["耀","耀"],["耀","耀"]]
     ʒXå≠}         # Filter out any inner lists that contain the character `X`
                   #  i.e. [["H","H"]]
g                  # Take the length as result
                   #  i.e. [["H","H"]] → 1
 q                 # Stop the program, making all other characters no-ops
                   # (and output the length above implicitly)

ทับทิมคะแนน 0, 237 209 ไบต์

##->a{['',*a,''].each_cons(3).sum{|a,b,c|(0..b.size).count{|x|[[x>0&&b[x-1],a[x],b[x+1],c[x]]&[b[x
  ->a{['',*a,''].each_cons(3).sum{|a,b,c|(0..b.size).count{|x|[[x>0&&b[x-1],a[x],b[x+1],c[x]]&[b[x]]]==[[]]}}}

ลองออนไลน์!

JavaScript (Node.js) , 0 (279 ไบต์)

  s=>(b=s.map(Buffer)).map((x,i)=>x.filter((y,j)=>y-(g=(x,y)=>~~(b[x]&&b[x][y]))(i,j-1)&&y-g(i,j+1)&&y-g(i-1,j)&&y-g(i+1,j))).join``.length
//s=>(b=s.map(Buffer)).map((x,i)=>x.filter((y,j)=>y-(g=(x,y)=>~~(b[x]&&b[x][y]))(i,j-1)&&y-g(i,j+1)&&y-g(i-1,j)&&y-g(i+1,j))).join``.length

ลองออนไลน์!

รับอินพุตเป็นอาร์เรย์ของบรรทัด