Ein isoliertes Zeichen ist ein Zeichen (außer einem Zeilenumbruch), das kein benachbartes Zeichen desselben Typs enthält. Benachbarte Zeichen können links, rechts oben oder unten sein, aber keine Diagonalen. Zum Beispiel wird im folgenden Text Hisoliert:

Ybb
YH%
%%%%

Alle anderen Zeichen sind nicht isoliert, da an jedes mindestens ein anderes Zeichen desselben Typs angrenzt.

Ihre Aufgabe ist es, ein Programm zu schreiben, das eine Zeichenfolge als Eingabe verwendet und die Anzahl der isolierten Zeichen bestimmt.

Wertung

Ihre Antwort wird anhand von zwei Metriken bewertet. Das erste ist die Anzahl der isolierten Zeichen in Ihrem Programm. Sie sollten versuchen, dies zu minimieren. Die zweite ist die Anzahl der Bytes in Ihrem Programm. Sie sollten dies ebenfalls minimieren. Die Programmgröße fungiert als Verbindungsunterbrecher für das erste Kriterium.

Zusätzliche Regeln

• Sie sollten die Eingabe in den druckbaren ASCII-Bereich sowie alle Zeichen unterstützen, die Sie in Ihrem Programm verwenden.

• Sie können einen Zeilenumbruch entweder als Zeilenumbruchzeichen oder als Zeilenumbruch gefolgt von einem Zeilenvorschub betrachten.

• Sie können Eingaben in jedem vernünftigen Format vornehmen. Dies beinhaltet eine Liste von Zeilen.

Testfälle

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
 

Probieren Sie es online aus!

_{-7 Bytes, danke an Jo King}

Sauber , 0 ( 439 ... 415 Bytes)

-11 danke an Ørjan Johansen

Endlich eine Herausforderung, bei der ich mit Clean 0 erzielen kann!
(und normalerweise ist es schlecht bei Herausforderungen im Quelllayout!)

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

Probieren Sie es online aus!

Der TIO-Link wird module mainaufgrund der Implementierung von Clean in TIO verwendet, module dfunktioniert jedoch, wenn Sie die Datei d.iclanstelle von main.iclTIO benennen .

Eine der alten Zeilen erklärt (neue Version ist dasselbe in einer anderen Reihenfolge):

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)

Gespeichert 2 4 Bytes dank @ ØrjanJohansen

Nimmt die Eingabe als Array von Zeichenfolgen auf.

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=

Probieren Sie es online aus!

Gelee , 0 ( 41 27 25 Bytes)

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

Probieren Sie es online aus!

Nimmt die Eingabe als Liste der Zeilen entgegen. Die erste Zeile im Code macht nie etwas und dient nur dazu, isolierte Zeichen zu minimieren.

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

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

Die Eingabe ist ein Zellenarray von Zeichenfolgen, eine für jede Zeile : {'line 1', 'line 2', 'and line 3'}.

Probieren Sie es online aus! Oder überprüfen Sie Testfälle und Quellcode .

Python 3 , 0 (323 Bytes)

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)

Probieren Sie es online aus!

05AB1E , 0 (101 Bytes )

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

Probieren Sie es online aus.

Dies ist eines der hässlichsten und längsten 05AB1E-Programme, die ich je geschrieben habe.>.> Diese Herausforderung ist in 05AB1E täuschend schwer. Ich habe keinen Zweifel daran, dass die Anzahl der Bytes durch Verwendung eines anderen Ansatzes (oder sogar mit einem ähnlichen Ansatz) mindestens halbiert oder sogar drei- bis viermal so klein werden kann, aber ich sehe derzeit nicht, wie. Ich bin nur froh, dass es gerade funktioniert. Wenn jemand anderes eine viel kürzere 05AB1E-Antwort mit einigen cleveren Tricks veröffentlicht, werde ich diese Antwort wahrscheinlich aus Scham löschen ... xD

Erläuterung:

ž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 , Punktzahl 0, 237 209 Bytes

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

Probieren Sie es online aus!

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

Probieren Sie es online aus!

Empfangen Sie Eingaben als Array von Zeilen.