분리 된 문자는 같은 유형의 인접 문자가없는 문자 (개행 문자 제외)입니다. 인접한 문자는 왼쪽, 오른쪽 위 또는 아래에있을 수 있지만 대각선에는있을 수 없습니다. 예를 들어 다음 텍스트 H는 분리되어 있습니다.

Ybb
YH%
%%%%

다른 모든 문자는 같은 유형의 다른 문자가 하나 이상 인접 해 있기 때문에 분리되지 않습니다.

당신의 임무는 입력으로 문자열을 취하고 분리 문자 수를 결정하는 프로그램을 작성하는 것입니다.

채점

당신은 두 가지 메트릭으로 점수를 매길 것입니다. 첫 번째는 프로그램에서 분리 된 문자 수입니다. 이를 최소화하는 것을 목표로해야합니다. 두 번째는 프로그램의 바이트 수입니다. 이것을 최소화해야합니다. 프로그램 규모는 첫 번째 기준의 타이 브레이커 역할을합니다.

추가 규칙

• 인쇄 가능한 ASCII 범위와 프로그램에서 사용하는 모든 문자의 입력을 지원해야합니다.

• 줄 바꿈을 줄 바꿈 문자 또는 줄 바꿈 뒤에 오는 줄 바꿈으로 간주 할 수 있습니다.

• 합리적인 형식으로 입력 할 수 있습니다. 여기에는 줄 목록이 포함됩니다.

테스트 사례

Ybb
YH%
%%%%

$1$

Aaaab
uuu
yyybbb

$2$

A

$1$

qqWWaaww

$0$

파이썬 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
 

온라인으로 사용해보십시오!

_{Jo King 덕분에 -7 바이트}

클린 , 0 ( 439 ... 415 바이트)

Ørjan Johansen 덕분에 -11

Clean으로 0 점을 얻을 수있는 도전!
(일반적으로 소스 레이아웃 문제는 나쁩니다 !)

//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 링크는 TIO에서 module main정리가 구현되는 방식으로 인해 사용 되지만 TIO가 아닌 module d파일 이름을 지정하면 작동합니다 .d.iclmain.icl

이전 행 중 하나가 설명되었습니다 (새 버전은 다른 순서로 동일합니다).

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
   ]

자바 스크립트 (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'}.

온라인으로 사용해보십시오! 또는 테스트 사례 및 소스 코드를 확인하십시오 .

파이썬 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에서 기만적으로 어렵습니다. 다른 접근 방식 (또는 비슷한 접근 방식)을 사용하여 바이트 수를 적어도 절반으로 줄이거 나 심지어 3/4 배 작을 수는 있지만, 현재 방법을 알지 못합니다. 다른 사람이 현명한 속임수로 훨씬 더 짧은 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, 237209 바이트

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

온라인으로 사용해보십시오!

라인 배열로 입력을받습니다.