Một nhân vật bị cô lập là một nhân vật (không phải là một dòng mới) không có một nhân vật liền kề cùng loại. Các ký tự liền kề có thể ở bên trái, bên phải hoặc bên dưới, nhưng không phải là đường chéo. Ví dụ trong văn bản sau đây Hđược phân lập:

Ybb
YH%
%%%%

Tất cả các nhân vật khác không bị cô lập vì mỗi người trong số họ có ít nhất một nhân vật khác cùng loại liền kề.

Nhiệm vụ của bạn là viết một chương trình lấy một chuỗi làm đầu vào và xác định số lượng ký tự bị cô lập.

Chấm điểm

Bạn trả lời sẽ được ghi bởi hai số liệu. Đầu tiên là số lượng nhân vật bị cô lập trong chương trình của bạn. Bạn nên nhằm mục đích giảm thiểu điều này. Thứ hai sẽ là số byte trong chương trình của bạn. Bạn nên giảm thiểu điều này là tốt. Kích thước chương trình sẽ hoạt động như một bộ ngắt kết nối cho tiêu chí đầu tiên.

Quy tắc bổ sung

• Bạn nên hỗ trợ đầu vào trên phạm vi ascii có thể in cộng với bất kỳ ký tự nào bạn sử dụng trong chương trình của mình.

• Bạn có thể coi ngắt dòng là ký tự dòng mới hoặc dòng mới theo sau là nguồn cấp dữ liệu.

• Bạn có thể lấy đầu vào ở bất kỳ định dạng hợp lý. Điều này bao gồm một danh sách các dòng.

Các trường hợp thử nghiệm

Ybb
YH%
%%%%

$1$

Aaaab
uuu
yyybbb

$2$

A

$1$

qqWWaaww

$0$

Python 2 , 0 ( 350 344 314 309 301 298 291 byte)

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
 

Hãy thử trực tuyến!

_{-7 byte, nhờ Jo King}

Sạch , 0 ( 439 ... 415 byte)

-11 cảm ơn Ørjan Johansen

Cuối cùng là một thử thách mà tôi có thể ghi điểm 0 với Clean!
(và thông thường nó rất tệ ở các thử thách bố trí nguồn!)

//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

Hãy thử trực tuyến!

Liên kết TIO sử dụng module maindo cách Clean được triển khai trên TIO, nhưng module dsẽ hoạt động nếu bạn đặt tên tệp d.iclthay vì main.iclnhư TIO.

Một trong những dòng cũ được giải thích (phiên bản mới là cùng một thứ tự khác):

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 byte)

Đã lưu 2 4 byte nhờ @ janrjanJohansen

Đưa đầu vào như một mảng của chuỗi.

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=

Hãy thử trực tuyến!

Jelly , 0 ( 41 27 25 byte)

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

Hãy thử trực tuyến!

Lấy đầu vào là danh sách các dòng. Dòng đầu tiên trong mã không bao giờ làm bất cứ điều gì và chỉ ở đó để giảm thiểu các ký tự bị cô lập.

ỴŒĠạþ`€Ẏ§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 byte)

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

Đầu vào là một mảng ô của các chuỗi, một cho mỗi dòng : {'line 1', 'line 2', 'and line 3'}.

Hãy thử trực tuyến! Hoặc xác minh các trường hợp thử nghiệm và mã nguồn .

Python 3 , 0 (323 byte)

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)

Hãy thử trực tuyến!

05AB1E , 0 (101 byte )

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

Hãy thử trực tuyến.

Đây là một trong những chương trình 05AB1E xấu nhất và dài nhất tôi từng viết ..>.> Thử thách này thật khó khăn trong 05AB1E. Tôi không nghi ngờ gì nữa, số lượng byte ít nhất có thể giảm một nửa hoặc thậm chí gấp ba hoặc bốn lần bằng cách sử dụng một cách tiếp cận khác (hoặc thậm chí với một cách tiếp cận tương tự), nhưng hiện tại tôi không thấy cách nào. Tôi chỉ vui mừng vì nó hoạt động ngay bây giờ .. Nếu người khác đăng câu trả lời 05AB1E ngắn hơn nhiều với một số thủ thuật thông minh có lẽ tôi sẽ xóa câu trả lời này vì xấu hổ ... xD

Giải trình:

ž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)

Ruby , điểm 0, 237 209 byte

##->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]]]==[[]]}}}

Hãy thử trực tuyến!

JavaScript (Node.js) , 0 (279 byte)

  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

Hãy thử trực tuyến!

Nhận đầu vào dưới dạng mảng của dòng.