Bei einer zweidimensionalen Matrix von 0 und 1s. Finden Sie die Anzahl der Inseln für 1s und 0s, bei denen die Nachbarn nur horizontal und vertikal sind.

Given input:

1 1 1 0
1 1 1 0

output = 1 1
Number of 1s island = 1

xxx-
xxx-

Number of 0s island = 1 

---x
---x

------------------------------

Given input:

0 0 0 0
1 1 1 1
0 0 0 0
1 1 1 1

output = 2 2
Number of 1s island = 2

----
xxxx  <-- an island of 1s
----
xxxx  <-- another island of 1s

Number of 0s island = 2

xxxx  <-- an island
----
xxxx  <-- another island
----

------------------------------

Given input:

1 0 0
0 0 0
0 0 1
output = 2 1
Number for 1's island = 2:

x--  <-- an island of 1s
---
--x  <-- an island of 1s

Number of 0's island = 1:

-xx  \
xxx   > 1 big island of 0s
xx-  / 


------------------------------

Given input:

1 1 0
1 0 0
output = 1 1
Number for 1's island =1 and number of 0's island = 1

------------------------------

Given input:

1 1
1 1
output = 1 0
Number for 1's island =1 and number of 0's island = 0

APL (Dyalog Unicode) , 29 28 Bytes ^SBCS

-1 danke an @ Adám

{≢∪∨.∧⍨⍣≡2>+/↑|∘.-⍨⍸⍵}¨⊂,~∘⊂

Probieren Sie es online!

⊂,~∘⊂ die Matrix und ihre Negation

{ }¨ für jeden von ihnen

⍸⍵ Liste der Koordinatenpaare von 1s

+/↑|∘.-⍨ Matrix von Manhattan Entfernungen

2> Nachbarmatrix

∨.∧⍨⍣≡ Transitive Schließung

≢∪ Anzahl eindeutiger Zeilen

J , 57 Bytes

,&([:(0#@-.~~.@,)](*@[*[:>./((,-)#:i.3)|.!.0])^:_ i.@$)-.

Probieren Sie es online!

Dies ist eine von denen, bei denen die Idee unglaublich einfach ist (und ich denke, dass sie Spaß macht), aber die Ausführung hatte eine gewisse mechanische Länge, die die Einfachheit maskiert ... ZB ist das Verschieben der ursprünglichen Matrix in alle Richtungen mit 0-Füllung die ausführliche ((,-)#:i.3) |.!.0.

Es ist wahrscheinlich, dass diese mechanische Länge weiter verbessert werden kann, und ich werde es vielleicht morgen Abend versuchen, aber ich werde jetzt den Kern davon veröffentlichen.

Sagen wir, unser Input ist:

0 0 0 0
1 1 1 1
0 0 0 0
1 1 1 1

Wir beginnen mit einer Matrix eindeutiger Ganzzahlen gleicher Größe:

 0  1  2  3
 4  5  6  7
 8  9 10 11
12 13 14 15

Dann finden wir für jede Zelle das Maximum aller Nachbarn und multiplizieren mit der Eingabemaske:

 0  0  0  0
 8  9 10 11
 0  0  0  0
13 14 15 15

Wir wiederholen diesen Vorgang, bis sich die Matrix nicht mehr ändert:

 0  0  0  0
11 11 11 11
 0  0  0  0
15 15 15 15

Zählen Sie dann die Anzahl der eindeutigen Elemente ungleich Null. Das sagt uns die Anzahl der 1-Inseln.

Wir wenden den gleichen Prozess auf "1 minus der Eingabe" an, um die Anzahl der 0-Inseln zu erhalten.

JavaScript (ES7),  138 ... 107  106 Bytes

Gibt ein Array zurück [ones, zeros].

f=(m,X,Y,V=.5,c=[0,0])=>m.map((r,y)=>r.map((v,x)=>V-v|(x-X)**2+(y-Y)**2>1||f(m,x,y,v,r[c[v^1]++,x]=2)))&&c

Probieren Sie es online!

Wie?

$0$$1$$c[0]$$c[1]$$2$

Um Bytes zu sparen, wird sowohl für die Root-Iteration als auch für die rekursiven Iterationen derselbe Code verwendet, der sich jedoch etwas anders verhält.

Während der ersten Iteration:

• $V=0.5$$V-v$$0$$v=0$$v=1$
• $X$$Y$$(x-X)^2+(y-Y)^2$$(x,y)$

Während der rekursiven Iterationen:

• $c$$2$c[v ^ 1]++$c$

Kommentiert

f = (                 // f is a recursive function taking:
  m,                  //   m[]  = input binary matrix
  X, Y,               //   X, Y = coordinates of the previous cell, initially undefined
  V = .5,             //   V    = value of the previous cell, initially set to 0.5
                      //          so that the integer part of V - v is 0 for v = 0 or 1
  c = [0, 0]          //   c[]  = array of counters of 1's and 0's islands
) =>                  //          (or an integer when called recursively)
  m.map((r, y) =>     // for each row r[] at position y in m[]:
    r.map((v, x) =>   //   for each value v at position x in r[]:
      V - v |         //     abort if |V - v| ≥ 1
      (x - X) ** 2 +  //     or X and Y are defined and the quadrance between
      (y - Y) ** 2    //     (X, Y) and (x, y)
      > 1 ||          //     is greater than 1
      f(              //     otherwise, do a recursive call to f:
        m,            //       leave m[] unchanged
        x, y,         //       pass the new coordinates
        v,            //       pass the new reference value
        r[c[v ^ 1]++, //       increment c[v ^ 1] (ineffective if c is an integer)
          x           //       and set the current cell ...
        ] = 2         //       ... to 2
      )               //     end of recursive call
    )                 //   end of inner map()
  ) && c              // end of outer map(); return c

MATL , 14 12 Bytes

,G@-K&1ZIugs

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

,        % Do twice
  G      %   Push input
  @      %   Push iteration index: first 0, then 1
  -      %   Subtract. This converts 0 and 1 into -1 and 0 in the second iteration 
  K      %   Push 4
  &1ZI   %   Label connected components of matrix using 4-connectedness. Zeros in the
         %   matrix are background. This replaces the nonzeros by 1, 2, 3, ..., where 
         %   each number defines a connected component
  u      %   Unique values. This gives [0; 1; 2; ..., L], where L is the number of
         %   connected components.
  g      %   Convert nonzeros to 1
  s      %   Sum. This gives L, to be output
         % End (implicit).
         % Display stack (implicit)

K (ngn / k) , 60 55 51 50 46 Bytes

{#?{|/'x*\:x}/2>+/x*x:x-\:'x:(0,#*x)\&,/x}'~:\

Probieren Sie es online!

~:\ ein Paar der Eingabe und ihrer Negation (wörtlich: Iteration-Konvergenz negieren)

{ }' für jeden

,/x mach das arg platt

&Wo sind die Einsen? - Liste der Indizes

(0,#*x)\ divmod width (input), um zwei separate Listen für ys und xs zu erhalten

x-\:'x: Achsabstände ∆x und ∆y

x*x: Quadrieren Sie sie

+/ addiere ∆x² und ∆y²

2> Nachbarmatrix

{|/'x*\:x}/ Transitive Schließung

#? Zählen Sie eindeutige Zeilen

Wolfram Language (Mathematica) , 64 62 Bytes

Max@MorphologicalComponents[#,CornerNeighbors->1<0]&/@{#,1-#}&

Probieren Sie es online!

Dank attinat : wir können 1<0statt Falsezwei Bytes schreiben und sparen.

Ungolf-Version:

F[M_] := {Max[MorphologicalComponents[M,   CornerNeighbors -> False]], 
          Max[MorphologicalComponents[1-M, CornerNeighbors -> False]]}

Es gibt natürlich ein Mathematica- Objekt MorphologicalComponents, das ein Array (oder ein Bild) aufnimmt und dasselbe zurückgibt, wobei die Pixel jeder morphologisch verbundenen Insel durch den Inselindex ersetzt werden. Aus Maxdiesem Ergebnis ergibt sich die Anzahl der Inseln (die Hintergrundnullen bleiben bei Null, und der Inselindex beginnt bei 1). Wir müssen dies separat für das Array (Angabe der Anzahl der 1-Inseln) und eins minus des Arrays (Angabe der Anzahl der 0-Inseln) tun. Damit diagonale Nachbarn nicht als Nachbarn gelten, muss die Option CornerNeighbors->Falseangegeben werden.

Python 3, 144 127 Bytes

Diese Lösung nutzt cv2die unglaubliche Bildverarbeitungsleistung. Trotz der weniger beeindruckenden, superlangen und lesbaren Methodennamen von cv schlägt es die beiden anderen Python-Antworten!

Golf gespielt:

import cv2,numpy as n
f=lambda b:n.amax(cv2.connectedComponents(b*255,0,4)[1])
def g(a):b=n.array(a,n.uint8);print(f(1-b),f(b))

Erweitert:

import cv2
import numpy as np

# Finds the number of connected 1 regions 
def get_components(binary_map):
    _, labels = cv2.connectedComponents(binary_map*255, connectivity=4) # default connectivity is 8
    # labels is a 2d array of the binary map but with 0, 1, 2, etc. marking the connected regions
    components = np.amax(labels)
    return components

# Takes a 2d array of 0s and 1s and returns the number of connected regions
def solve(array): 
    binary_map = np.array(input_map, dtype=np.uint8)
    black_regions = get_components(1 - binary_map) # 0s
    white_regions = get_components(binary_map) # 1s
    return (black_regions, white_regions)

J , 46 44 43 Bytes

-1 Byte dank @miles

,&#&~.&([:+./ .*~^:_:2>1#.[:|@-"1/~4$.$.)-.

Probieren Sie es online!

Tests und der ,& -.Wrapper von @ jonahs Antwort gestohlen

,& -. für die Eingabe und deren Negation machen Sie:

4$.$. (y, x) Koordinaten der Einsen als n × 2 Matrix

1#.[:|@-"1/~ manhattan entfernungen: abs (∆x) + abs (∆y)

2> Nachbarmatrix

[:+./ .*~^:_: Transitive Schließung

#&~.&( ) Anzahl eindeutiger Zeilen

Retina 0,8,2 , 155 Bytes

s`1(.*)
;$1a
}+`(?<=(.)*)(1|;)(.*¶(?<-1>.)*(?(1)$))?(?!\2)[1;]
;$3;
s`0(.*)
:$1b
}+`(?<=(.)*)(0|:)(.*¶(?<-1>.)*(?(1)$))?(?!\2)[0:]
:$3:
\W+(a*)(b*)
$.1 $.2

Probieren Sie es online! Link enthält Testfall. Erläuterung:

s`1(.*)
;$1a

Wenn es eine gibt 1, ändern Sie sie in ;und fügen Sie eine aan das Ende der Eingabe an, damit sie nicht im Weg ist.

}+`(?<=(.)*)(1|;)(.*¶(?<-1>.)*(?(1)$))?(?!\2)[1;]
;$3;

Fülle alle angrenzenden 1s mit ;s.

}

Wiederholen, bis alle Inseln von 1s zu ;s geworden sind.

s`0(.*)
:$1b

Wenn es eine gibt 0, ändern Sie sie in :und fügen Sie eine ban das Ende der Eingabe an, damit sie nicht im Weg ist.

+`(?<=(.)*)(0|:)(.*¶(?<-1>.)*(?(1)$))?(?!\2)[0:]
:$3:

Fülle alle angrenzenden 0s mit :s.

}

Wiederholen, bis alle Inseln von 0s zu :s geworden sind.

\W+(a*)(b*)
$.1 $.2

Zählen Sie getrennt die Anzahl der Inseln 1s und 0s.

Haskell , 228 227 225 224 Bytes

import Data.List
z=zipWith
a!b=div(max(a*a)(a*b))a
l x=z(!)(z(!)x(0:x))$tail x++[0]
s=(\x->length.($x).filter<$>[(>0),(<0)]).nub.(>>=id).(until=<<((==)=<<))((.)>>=id$transpose.map l).z(\i->z(\j x->2^i*j*(2*x-1))[1,3..])[1..]

Probieren Sie es online!

Erläuterung:

Die Idee für diese Lösung lautet wie folgt: Initialisieren Sie die Matrix mit eindeutigen Werten in jeder Zelle, positiv für 1und negativ für 0. Vergleichen Sie dann wiederholt jede Zelle mit ihren Nachbarn und ersetzen Sie die Zellennummer durch die Nummer des Nachbarn, wenn der Nachbar das gleiche Vorzeichen, aber eine Nummer mit einem größeren absoluten Wert hat. Sobald dies einen festen Punkt erreicht, zählen Sie die Anzahl der eindeutigen positiven Zahlen für die Anzahl der 1Regionen und die eindeutigen negativen Zahlen für die Anzahl der 0Regionen.

In Code:

s=(\x->length.($x).filter<$>[(>0),(<0)]).nub.(>>=id).(until=<<((==)=<<))((.)>>=id$transpose.map l).z(\i->z(\j x->2^i*j*(2*x-1))[1,3..])[1..]

kann in die Vorverarbeitung (Zuweisen von Zahlen zu Zellen), die Iteration und die Nachverarbeitung (Zählen von Zellen) unterteilt werden

Vorverarbeitung

Der Vorverarbeitungsteil ist die Funktion

z(\i->z(\j x->2^i*j*(2*x-1))[1,3..])[1..]

Wofür zals Abkürzung verwendet wird zipWith, um ein paar Bytes abzukürzen . Was wir hier tun, ist das zweidimensionale Array mit Integer-Indizes in den Zeilen und ungeraden Integer-Indizes in den Spalten zu komprimieren. Wir tun dies, da wir (i,j)mithilfe der Formel eine eindeutige Ganzzahl aus einem Paar von Ganzzahlen erstellen können (2^i)*(2j+1). Wenn wir nur ungerade Ganzzahlen für generieren j, können wir die Berechnung überspringen 2*j+1und drei Bytes einsparen.

Mit der eindeutigen Zahl müssen wir nur noch ein Vorzeichen multiplizieren, das auf dem Wert in der Matrix basiert, die erhalten wird als 2*x-1

Iteration

Die Iteration erfolgt durch

(until=<<((==)=<<))((.)>>=id$transpose.map l)

Da die Eingabe in Form einer Liste von Listen erfolgt, führen wir den Nachbarvergleich für jede Zeile durch, transponieren die Matrix, führen den Vergleich für jede Zeile erneut durch (was aufgrund der Transponierung die vorherigen Spalten ist) und transponieren erneut. Der Code, der einen dieser Schritte ausführt, lautet

((.)>>=id$transpose.map l)

Wo list die Vergleichsfunktion (siehe unten) und transpose.map lführt die Hälfte der Vergleichs- und Umsetzungsschritte aus. (.)>>=idführt sein Argument zweimal aus, wobei es \f -> f.fin diesem Fall die punktfreie Form von und um ein Byte kürzer ist , da die Regeln für die Rangfolge der Operatoren gelten.

list in der obigen Zeile definiert als l x=z(!)(z(!)x(0:x))$tail x++[0]. Dieser Code führt einen Vergleichsoperator (!)(siehe unten) für jede Zelle mit zuerst ihrem linken Nachbarn und dann mit ihrem rechten Nachbarn durch, indem die Liste xmit der rechtsverschobenen Liste 0:xund der linksverschobenen Liste nacheinander gezippt wird tail x++[0]. Wir verwenden Nullen, um die verschobenen Listen aufzufüllen, da sie in der vorverarbeiteten Matrix niemals auftreten können.

a!bist in der Zeile darüber definiert als a!b=div(max(a*a)(a*b))a. Was wir hier machen wollen, ist die folgende Fallunterscheidung:

• Wenn sgn(a) = -sgn(b)wir zwei gegenüberliegende Bereiche in der Matrix haben und diese nicht vereinheitlichen möchten, ableibt dies unverändert
• Wenn sgn(b) = 0ja, haben wir den Eckfall, in dem bgepolstert wird und bleiben daher aunverändert
• Wenn sgn(a) = sgn(b)ja, möchten wir die beiden Bereiche vereinheitlichen und den Bereich mit dem größeren absoluten Wert verwenden (der Einfachheit halber).

Beachten Sie, dass sgn(a)es niemals sein kann 0. Dies erreichen wir mit der angegebenen Formel. Wenn die Vorzeichen von aund verschieden sind b, a*bkleiner oder gleich Null sind, während sie a*aimmer größer als Null sind, wählen wir sie als Maximum und teilen sie mit a, um zurück zu kommen a. Andernfalls max(a*a)(a*b)ist abs(a)*max(abs(a),(abs(b)), und dies wird durch Division durch a, bekommen wir sgn(a)*max(abs(a),abs(b)), was die Zahl mit dem größeren Absolutwert ist.

Um die Funktion zu iterieren, ((.)>>=id$transpose.map l)bis sie einen festen Punkt erreicht, verwenden wir (until=<<((==)=<<)), der aus dieser Stapelüberlaufantwort entnommen wird .

Nachbearbeitung

Für die Nachbearbeitung verwenden wir das Teil

(\x->length.($x).filter<$>[(>0),(<0)]).nub.(>>=id)

Das ist nur eine Ansammlung von Schritten.

(>>=id)Zerquetscht die Liste der Listen in eine einzelne Liste, entfernt nubDoppelte, unterteilt (\x->length.($x).filter<$>[(>0),(<0)])die Liste in zwei Listen, eine für positive und eine für negative Zahlen, und berechnet deren Länge.

Java 10, 359 355 281 280 261 246 Bytes

int[][]M;m->{int c[]={0,0},i=m.length,j,t;for(M=m;i-->0;)for(j=m[i].length;j-->0;)if((t=M[i][j])<2)c[t^1]+=f(t,i,j);return c;}int f(int v,int x,int y){try{if(M[x][y]==v){M[x][y]|=2;f(v,x+1,y);f(v,x,y+1);f(v,x-1,y);f(v,x,y-1);}}finally{return 1;}}

-74 Bytes dank @NahuelFouilleul .

Probieren Sie es online aus.

Erläuterung:

int[][]M;              // Integer-matrix on class-level, uninitialized

m->{                   // Method with integer-matrix parameter and integer-array return-type
  int c[]={0,0}        //  Counters for the islands of 1s/0s, starting both at 0
      i=m.length,      //  Index of the rows
      j,               //  Index of the columns
      t;               //  Temp-value to decrease the byte-count
  for(M=m;             //  Set the class-level matrix to the input-matrix
      i-->0;)          //  Loop over the rows
    for(j=m[i].length;j-->0)
                       //   Inner loop over the columns
      if((t=M[i][j])   //    Set the temp value `t` to the value of the current cell
         <2)           //    And if this value is a 0 or 1:
        c[t^1]+=       //     Increase the corresponding counter by:
          f(t,i,j);    //      Call the recursive flood-fill method with value `t`
                       //      Which always returns 1 to increase the counter
  return c;}           //  After the nested loops: return the counters-array as result

// Recursive method with value and cell-coordinate as parameters,
// This method will flood-fill the matrix, where 0 becomes 2 and 1 becomes 3
int f(int v,int x,int y){
  try{if(M[x][y]==v){  //   If the cell contains the given value:
    M[x][y]|=2;        //    Fill the cell with 0→2 or 1→3 depending on the value
    f(v,x+1,y);        //    Do a recursive call downwards
    f(v,x,y+1);        //    Do a recursive call towards the right
    f(v,x-1,y);        //    Do a recursive call upwards
    f(v,x,y-1);}       //    Do a recursive call towards the left
  }finally{return 1;}} //  Ignore any ArrayIndexOutOfBoundsExceptions with a finally-return,
                       //  which is shorter than manual checks
                       //  And return 1 to increase the counter

Python 3 , 167 Bytes

def f(m):
 n=[0,0];i=-2
 for r in m:
  j=0;i+=1
  for c in r:n[c^1]+=1-((i>=0)*(m[i][j]==c)*(1+({*r[:j]}=={c})*({*m[i][:j]}=={c^1}))or(j>0)*(r[j-1]==c));j+=1
 print(n)

Probieren Sie es online!

Python 2 , 168 Bytes

def f(m):
 n=[0,0];i=-2
 for r in m:
	j=0;i+=1
	for c in r:n[c^1]+=1-((i>=0)*(m[i][j]==c)*(1+(set(r[:j])=={c})*(set(m[i][:j])=={c^1}))or(j>0)*(r[j-1]==c));j+=1
 print n

Probieren Sie es online!

-2 Bytes dank Kevin Cruijssen

+2 Bytes Formatierungskorrektur

Erläuterung

Ein Zähler wird für 0s und 1s gehalten. Für jeden Eintrag in der Matrix werden die folgenden Aktionen ausgeführt:

• Inkrasenzähler für aktuellen Wert um 1
• Wenn derselbe Wert direkt über oder links vorhanden ist, verringern Sie ihn um 1

Dies führt zu einem Fehlalarm für linksbündige Fälle wie

0 0 1
1 1 1

oder

0 1
1 1

In diesem Fall wird der Zähler um 1 verringert.

Rückgabewert ist [#1, #0]

Perl 5 ( -0777p), 110 Bytes

Kann verbessert werden, verwendet einen regulären Ausdruck zum Ersetzen 1durch 3und dann 0durch 2.

/
/;$m="(.{@-})?";sub f{($a,$b,$c)=@_;1while s/$b$m\K$a|$a(?=$m$b)/$b/s||s/$a/$b/&&++$c;$c}$_=f(1,3).$".f(0,2)

TIO

Jelly , 44 36 Bytes

ŒJfⱮ+€¥Ø.,UŻ¤œịƇþ,¬$¹ƇfƇⱮ`ẎQ$€QƲÐL€Ẉ

Probieren Sie es online!

Ein monadischer Link, der eine Liste mit Ganzzahllisten als Argument akzeptiert und eine Liste mit der Anzahl der Inseln 1 und 0 in dieser Reihenfolge zurückgibt.

Erläuterung

Schritt 1

Liste aller Matrixindizes mit den Indizes des Nachbarn rechts (außer rechts) und unten (außer unten) erstellen

ŒJ            | Multi-dimensional indices (e.g. [1,1],[1,2],[1,3],[2,1],[2,2],[2,3])
      ¥       | Following as as a dyad:
  fⱮ          | - Filter the indices by each of:
    +€      ¤ |   - The indices added to the following
       Ø.     |     - 0,1
         ,U   |     - Paired with itself reversed [0,1],[1,0]
           Ż  |     - Prepended with zero 0,[0,1],[1,0]

Schritt 2

Teilen Sie diese Indizes auf, indem Sie angeben, ob die Eingabe 1 oder 0 enthält. Gibt eine Liste von Indizes mit Nachbarn für 1s und eine andere für 0s zurück.

  Ƈþ   | Filter each member of the output of stage 1 using the following criteria:
œị   $ | - Corresponding value for the multi-dimensional indices in each of the following as a monad:
   ,¬  |   - The input paired with its inverse

Schritt 3

Zusammenführen von Listen mit gemeinsamen Mitgliedern und Ausgabezahlen

           ƲÐL€  | For each of the outputs from stage 2, do the following as a monad and repeat until no changes
¹Ƈ               | - Filter out empty lists (only needed on first pass through but included here to save a byte)         
  fƇⱮ`           | - Take each list of indices and filter the list of indices for those containing a match for any of them
        $€       | - For each resulting list of lists:
      Ẏ          |   - Tighten (concatenate top level of lists)
       Q         |   - Uniquify
          Q      | - Uniquify
               Ẉ | Finally output the lengths of the final lists

T-SQL 2008, 178 Byte

Die Eingabe ist eine Tabellenvariable.

x und y sind die Koordinaten

v ist der Wert 0 und 1 (kann auch andere numerische Werte verarbeiten)

Die in diesem Beispiel verwendeten Testdaten:

100
000
001

DECLARE @ table(x int, y int, v int)

INSERT @ values
(1,1,1),(1,2,0),(1,3,0),
(2,1,0),(2,2,0),(2,3,0),
(3,1,0),(3,2,0),(3,3,1)
SELECT*,y-x*99r INTO # FROM @
WHILE @@rowcount>0UPDATE #
SET r=b.r
FROM #,# b
WHERE abs(#.x-b.x)+abs(#.y-b.y)=1and #.v=b.v and #.r>b.r
SELECT v,count(distinct r)FROM #
GROUP BY v

Probieren Sie es online aus

R , 194 172 Bytes

function(m,u=!1:2){for(i in 1:2){w=which(m==i-1,T)
N=1:nrow(w)
A=!!N
for(s in N){u[i]=u[i]+A[s]
while(any(s)){A[s]=F
s=c(N[as.matrix(dist(w))[s[1],]==1&A],s[-1])}}}
rev(u)}

Probieren Sie es online!

Führen Sie eine Tiefensuche durch, beginnend in jeder Zelle der Matrix, die gleich 1 (oder Null) ist.

• -2 Bytes dank @Giuseppe