Wenn Sie eine Zeichenfolge als Eingabe angeben, suchen Sie die längste zusammenhängende Teilzeichenfolge, die mindestens zweimal kein Zeichen enthält. Wenn es mehrere solcher Teilzeichenfolgen gibt, können Sie beide ausgeben. Wenn Sie möchten, können Sie davon ausgehen, dass sich die Eingabe im druckbaren ASCII-Bereich befindet.

Wertung

Die Antworten werden zuerst nach der Länge ihrer längsten nicht wiederholten Teilzeichenfolge und dann nach ihrer Gesamtlänge geordnet. Niedrigere Punktzahlen sind für beide Kriterien besser. Je nach Sprache wird dies wahrscheinlich eine Code-Golf- Herausforderung mit einer Quellenbeschränkung sein.

Trivialität

In einigen Sprachen ist es ziemlich einfach, eine Punktzahl von 1, x (Sprache) oder 2, x (Brain-Flak und andere Tarpits) zu erreichen. In anderen Sprachen ist es jedoch eine Herausforderung, die längste nicht wiederholte Teilzeichenfolge zu minimieren. Es hat mir sehr viel Spaß gemacht, in Haskell eine Punktzahl von 2 zu erreichen. Ich empfehle Ihnen daher, Sprachen zu suchen, in denen diese Aufgabe Spaß macht.

Testfälle

"Good morning, Green orb!" -> "ing, Gre"
"fffffffffff" -> "f"
"oiiiiioiiii" -> "io", "oi"
"1234567890"  -> "1234567890"
"11122324455" -> "324"

Bewertung Vorlage

Sie können Ihre Programme mit dem folgenden Snippet bewerten:

input.addEventListener("input", change);

// note: intentionally verbose :)
function isUnique(str) {
  var maxCount = 0;
  var counts = {};
  for(var i = 0; i < str.length; i++) {
    var c = str.charAt(i);
    counts[c] |= 0;
    counts[c]++;
    if(maxCount < counts[c]) {
      maxCount = counts[c];
    }
  }
  return maxCount <= 1;
}

function maximizeSubstring(str, pred, cost) {
  var mostExpensive = -1;
  // iterate over substrings
  function iterate(start, end) {
    var slice = str.slice(start, end);
    if(pred(slice)) {
      var profit = cost(slice);
      if(profit > mostExpensive) {
        mostExpensive = profit;
      }
    }
    end++;
    if(start >= str.length) {
      return;
    }
    else if(end > str.length) {
      start++;
      iterate(start, start);
    }
    else {
      iterate(start, end);
    }
  }
  iterate(0, 0);
  return mostExpensive;
}

function size(x) {
  return x.length;
}

function longestNonRepeatingSize(str) {
  return maximizeSubstring(str, isUnique, size);
}

function change() {
  var code = input.value;
  output.value = "Your score is: " + longestNonRepeatingSize(code);
}

change();

* {
  font-family: monospace;
}

Input code here:
<br>
<textarea id="input"></textarea>
<br>
<textarea id="output"></textarea>

C, Score 2,  747   720  662 Bytes

L  [  1  <<  7  ]  ,  *  q  ,  *  r  ,  l  ,  d  ,  i  ,  c  ,  j  ,  s  ,  t  ,  k  =  1  <<  7  ;  h  (  )  {  q  =  s  +  i  +  j  ++  ;  *  q  %  k  &&  !  L  [  *  q  %  k  ]  ++  &&  h  (  ++  c  )  ;  }  g  (  )  {  q  =  s  +  i  ;  *  q  %  k  ?  z  (  k  )  ,  h  (  j  =  c  =  0  )  ,  c  >  d  &&  (  d  =  c  )  &&  (  l  =  i  )  ,  g  (  ++  i  )  :  0  ;  }  f  (  S  ,  T  )  {  s  =  S  ;  l  =  i  =  d  =  0  ;  g  (  t  =  T  )  ;  p  (  i  =  0  )  ;  }  p  (  )  {  q  =  s  +  l  +  i  ;  r  =  t  +  i  ;  i  ++  <  d  ?  p  (  *  r  =  *  q  )  :  (  *  r  =  0  )  ;  }  z  (  i  )  {  L  [  --  i  ]  =  0  ;  i  &&  z  (  i  )  ;  }

Funktioniert mindestens mit 32-Bit-MinGW (mit deaktivierten Optimierungen). Verwendet kein einziges Schlüsselwort.

Funktioniert offenbar auch auf TIO mit gcc und clang: Probieren Sie es online aus! (Danke @Dennis!)

Rufen Sie an mit:

int main()
{
    char str[1024];

    f("Good morning, Green orb!", str);
    puts(str);

    f("fffffffffff", str);
    puts(str);

    f("oiiiiioiiii", str);
    puts(str);

    f("1234567890", str);
    puts(str);

    f("L  [  1  <<  7  ]  ,  *  q  ,  *  r  ,  l  ,  d  ,  i  ,  c  ,  j  ,  s  ,  t  ,  k  =  1  <<  7  ;  h  (  )  {  q  =  s  +  i  +  j  ++  ;  *  q  %  k  &&  !  L  [  *  q  %  k  ]  ++  &&  h  (  ++  c  )  ;  }  g  (  )  {  q  =  s  +  i  ;  *  q  %  k  ?  z  (  k  )  ,  h  (  j  =  c  =  0  )  ,  c  >  d  &&  (  d  =  c  )  &&  (  l  =  i  )  ,  g  (  ++  i  )  :  0  ;  }  f  (  S  ,  T  )  {  s  =  S  ;  l  =  i  =  d  =  0  ;  g  (  t  =  T  )  ;  p  (  i  =  0  )  ;  }  p  (  )  {  q  =  s  +  l  +  i  ;  r  =  t  +  i  ;  i  ++  <  d  ?  p  (  *  r  =  *  q  )  :  (  *  r  =  0  )  ;  }  z  (  i  )  {  L  [  --  i  ]  =  0  ;  i  &&  z  (  i  )  ;  }");
    puts(str);
}

Ausgabe:

Der Code mit etwas besser lesbarer Formatierung:

L[1<<7],
*q, *r, l, d, i, c, j, s, t, k=1<<7;

h()
{
    q = s+i+j++;
    *q%k && !L[*q%k]++ && h(++c);
}

g()
{
    q = s+i;
    *q%k ? z(k), h(j=c=0), c>d && (d=c) && (l=i), g(++i) : 0;
}

f(S, T)
{
    s = S;
    l = i = d = 0;
    g(t=T);
    p(i=0);
}

p()
{
    q = s+l+i;
    r = t+i;
    i++<d ? p(*r=*q) : (*r=0);
}

z(i)
{
    L[--i] = 0;
    i && z(i);
}

Und dies kann verwendet werden, um den richtigen Abstand zu erzeugen, um zur Formatierung mit Punktzahl 2 zu gelangen: Probieren Sie es online aus!

C, Punktzahl 3, 309 Bytes

i
,
j
,
l
,
c
,
d
;
f
(
\
c\
\
h\
\
a\
\
r
*
s
)
{
\
f\
\
o\
\
r
\
(
i
=
l
=
d
=
0
;
s
[
i
]
;
c
>
d
&&
(
d
=
c
)
&&
(
l
=
i
)
,
++
i
)
\
f\
\
o\
\
r
(
\
c\
\
h\
\
a\
\
r

L
[
\
1\
\
2\
\
8
\
]
=
{
j
=
c
=
0
}
;
s
[
i
+
j
]
&&
!
L
[
s
[
i
+
j
++
]
]
++
;
++
c
)
;
\
w\
\
r\
\
i\
\
t\
\
e
(
1
,
s
+
l
,
d
)
;
}

Probieren Sie es online!

Haskell , Score 2, 492 ... 307 224 212 209 207 Bytes

((yy:yyy))??ss|ss==yy  =  ""  |  yy==yy=yy:yyy??ss
ss??sss=ss
ss""=""

ss((ff:fff))  =  ff  :  ss  fff??ff
ff""=""

ff((xxx:xx))  =  ss((xxx:xx))##ff  xx
xx##xxx  |  ((((xx>>xx))<))  $  xxx>>xx=xxx|xx==xx=xx

Probieren Sie es online!

Hunderte von Bytes dank WW und Ørjan Johansen !

Erläuterung

Die Funktion (??)akzeptiert ein Zeichen cund eine Zeichenfolge sund gibt das längste Präfix zurück s, das nicht enthalten ist c. Ungolfed und nicht für Partitur optimiert:

c ?? (y:s)  
    | c==y = ""
    | True = y : c ?? s
c ?? s = s

Die Funktion ssverwendet (??)die längste Präfix der einzigartigen Zeichen einer bestimmten Zeichenfolge zu finden:

ss (x:r) = x : (x ?? ss r)
ss "" = ""

(##)ist eine Funktion, die zwei Zeichenketten benötigt und die längere zurückgibt. Der Längenvergleich funktioniert, indem die Zeichenfolge xso oft wie xlang ( x>>y) und wie ylang ( y>>x) wiederholt wird und geprüft wird, welche der resultierenden Zeichenfolgen lexikographisch größer ist.

x ## y
  | (x>>x) < (y>>x) = y
  | True = x

Schließlich ffrecurses über die Eingabezeichenfolge erzeugt das längste Präfix mit ssrekursiv die längste nicht wiederholenden Teilzeichenkette des Schwanzes der Zeichenfolge und kehrt die längere der beiden bestimmt , mit (##):

ff "" = ""
ff (x:r) = ss(x:r) ## ff r

Lua, Punktzahl 3, 274 Bytes

g='g'..'s'..'u'..'b'  _G  [  'l'..'o'..'a'..'d'  ](  g[g  ](  "s  =...f  o  r d = # s - 1 , 0 , - 1 d  o f  or r = 1 , # s - d d  o t = s :s  ub  (r  ,r  +d  )i  f n  ot t:  fi  nd  '(  .)  .*  %1  't  he  n p  ri  nt  (t  )r  et  ur  n en  d e  n  d e  nd  ","  ",""))(...)

Hinweis: Lua 5.2 oder Lua 5.3 ist erforderlich

Verwendung:

$ lua lnrs.lua "Good morning, Green orb!"
ing, Gre
$ lua lnrs.lua "fffffffffff"
f
$ lua lnrs.lua "oiiiiioiiii"
oi
$ lua lnrs.lua "1234567890"
1234567890
$ lua lnrs.lua "11122324455"
324

Hauptidee: Verschachteln Sie alles mit Leerzeichen, fügen Sie " "(zwei Leerzeichen) ein, um lange Bezeichner zu teilen

Ungolfed-Code:

g = "gsub"
_G["load"](
   g[g](      -- g[g] == string.gsub - a function for substitution of substrings
      "The source of actual program, but two-space sequences were inserted in some places", 
      "  ",   -- we are replacing all two-space substrings
      ""      -- with an empty string
   )
)(...)

Aktuelles Programm (nach Entfernen aller Leerzeichenpaare):

s = ...
for d = #s - 1, 0, -1 do
   for r = 1, #s - d do
      t = s:sub(r, r+d)
      if not t:find"(.).*%1" then
         print(t)
         return
      end
   end
end

Übrigens, das JS-Snippet zur Berechnung der Punktzahl schlägt in meinem Code fehl.

Retina 0.8.2 , 37 Bytes, 9 Punkte

.
$&$'¶
(.)(?<=\1.+).*

O#$^`
$.&
1G`

Probieren Sie es online! Die direkte Übersetzung dieser Antwort auf Retina 1 spart ein Byte durch Verwenden von Nanstelle von O#. Wenn Sie jedoch die Antwort von Retina 1 auf 28 Bytes reduzieren, steigt die Punktzahl tatsächlich auf 10! Erläuterung:

.
$&$'¶

Generieren Sie alle Suffixe der Eingabe.

(.)(?<=\1.+).*

Übernehmen Sie für jedes Suffix das Präfix bis zum ersten duplizierten Zeichen.

O#$^`
$.&

Sortieren Sie die verbleibenden Zeichenfolgen in umgekehrter Reihenfolge der Länge (dh längste zuerst).

1G`

Nimm das längste.

Jelly , Punktzahl 2, 14 Bytes

Ẇµµff  Q  €  Ṫ

Vielen Dank an @JonathanAllan für die Bewertung -1, +7 Bytes und für das Bemerken eines Fehlers.

Probieren Sie es online!

Wie es funktioniert

Ẇµµff  Q  €  Ṫ  Main link. Argument: s (string)

Ẇ               Window; yield all substrings of s, sorted by length.
 µ              Begin a new chain. Argument: A (array of substrings)
  µ             Begin a new chain. Argument: A (array of substrings)
   f            Filter A by presence in itself. Does nothing.
       Q  €     Unique each; deduplicate all strings in A.
    f           Filter A by presence in the array of deduplicated substrings,
                keeping only substrings composed of unique characters.
             Ṫ  Tail; take the last (longest) kept substring.

Sauber , Ergebnis 7 5, 276 Bytes

@[ss:s]=rr(pp[][ss:s])((@s))
@s=s
ee x[rr:xx]|e x rr=True=ee x xx
ee x xx=f
f=e'e'' '
e::!  Char  !  Char  ->Bool
e  _ _=  code  {

eqC
}
pp p[r:rr]|ee r p=p=pp(a r p)rr
pp a _=a
a  x[ll:l]=[ll:a x  l]
a l ll=[l]
l[]rr=e'l''l'
l ff[]=f

l[r:rr][ss:ll]=l rr ll
rr x y|l x y=y=x

Probieren Sie es online! Vielen Dank an @ Οurous , der mir gezeigt hat, dass es möglich ist, ABC-Maschinencode direkt aus Clean heraus aufzurufen. Dies ermöglicht es, den vorherigen Flaschenhals loszuwerden, der die importMindestpunktzahl auf 7 codefestlegt , benötigt jedoch das Schlüsselwort, das die Mindestpunktzahl für diesen Ansatz auf 5 festlegt.

Eine ungolfed und nicht score-optimierte Version des obigen Codes finden Sie hier: Probieren Sie es online!

Vorherige Version mit Punktzahl 7, 158 154 130 Bytes

import  StdEnv  
@[xx:rr]=c(%[][xx:rr])(@rr)
@e=e
c s b|  length  s<  length  b=b=s
%s[xx:r]|  isMember xx s=s= %(s++[xx])r
%r _=r

Probieren Sie es online!

Mit dem kann importdie Punktzahl nicht unter 7 fallen. Ohne den Import müsste man Gleichheit auf Strings oder Zeichen implementieren, ohne irgendwelche Bibliotheksfunktionen, die wahrscheinlich nicht möglich sind, wie in der neuen Version oben zu sehen ist.

Python 3 , Score 4, 155 Bytes

exec(('l=la''mbd''a f'',e=en''ume''rat''e:m''ax''([f[ j  :k]  for  j,i in e ( f)f''or  k,i in e ( f )if  len  ( { *''f[j'':k]''})==k-''j],''key''=le''n)'))

Dies definiert eine Funktion l.

Vielen Dank an @xnor für den Hinweis, dass Zeichenfolgen der Länge 3 die Punktzahl nicht erhöhen und 32 Byte einsparen.

Probieren Sie es online!

Brachylog , Score 2, 19 Bytes

s  ᶠ  l  ᵒ  ≠  ˢ  t

Probieren Sie es online!

Nur eine langweilige alte "space everything out" Antwort. Zumindest habe ich gelernt, dass Metapredikate von den Prädikaten beabstandet sein können und immer noch funktionieren (und die (parametrischen) Indizes und die hochgestellten Indizes nicht).

s ᶠ - Finde alle Teilstrings des angegebenen Strings

l ᵒ - ordne sie nach ihrer Länge (standardmäßig aufsteigend)

≠ ˢ - Wählen Sie diejenigen aus, die alle unterschiedlichen Elemente haben

t - Holen Sie sich den Schwanz (letztes Element) davon - den mit der größten Länge

Pyth , 11 Bytes, 4 Punkte

-4 Punkte dank Dennis

e lD {I# .:

elD{I#.:Q      Full program, inputs "string" from stdin and outputs to stdout
e              The last element of the list generated by taking
      .:Q      All substrings of the input
     #         Filtered for
   {I          Being invariant over deduplicate i.e. being "non-repeating"
 lD            and sorted by length

Probieren Sie es online!

Schale , Punktzahl 2, 10 Bytes

►IIËII≠IIQ

Probieren Sie es online!

Erläuterung

Das Programm ist dazu äquivalent:

►Ë≠Q  Implicit input.
   Q  List of substrings.
►     Find one that maximizes:
 Ë    all ordered pairs
  ≠   are inequal.

Die integrierte Funktion Ëwertet ≠alle geordneten Argumentpaare aus xund gibt length(x)+1ansonsten zurück, ob jedes Ergebnis wahr ist0 . Wenn wir dies maximieren, finden wir die längste Zeichenfolge, die keine wiederholten Zeichen enthält.

In der Einreichung füge ich die Identitätsfunktion einfach Izweimal zwischen die einzelnen Funktionen ein. Da IËist das gleiche wie Ë, I≠ist das gleiche wie ≠und so weiter, ändert dies nichts an der Semantik. Die einzige Gefahr besteht darin, dass eine Funktion höherer Ordnung entscheiden könnte, eines der Is als Argument zu verwenden. Glücklicherweise führt dies jedoch zu einem Tippfehler in unserem Programm, sodass dies nicht der Fall ist.

Clojure, 4 Punkte

#(  let  [N  (fn  [[_ & r]] r) R  (fn  R [f v c]  (if  c (R f (f v (  nth  c 0))  ( N  c)) v)) C  (fn  C  (  [i]  (C (  seq  i) 0)) ( [i  n]  (if i (C ( N  i )  (  inc n)) n)))  J  (fn  [c  i]  (assoc c (C  c) i)) I  (fn  F [f i n R]  (if ( =  (C  R) n) R (F f (f  i) n ( J  R (f  i)))))] ( apply  str  (R ( fn  [a  b] ( if  (< (C  a)  (C  b)) b a )) "" (  for  [k  (I N % (C  % ) [])]  (R  ( fn [ t  c ] ( if ( or ( = t (  str t) ) ((  set t)c))(apply  str t) ( J  t c)))[]k)))))

Oh man das war schmerzhaft! Nimplementiert next, Rist reduce, Cist count, Jist conj(funktioniert nur für Vektoren) und Iist iterate. apply strGibt es zweimal, da andernfalls "aaaa" -Eingaben keine Zeichenfolge, sondern einen Vektor zurückgeben würden [\a]. Zum Glück musste ich applyund verwenden assoc, ich wusste nicht, dass Sie einen Index jenseits des letzten Elements eines Vektors zuordnen können: o

Gelee , Score 5, 10 Bytes

ẆµQQ⁼µÐfµṪ

Probieren Sie es online!

Python 3 , Punktzahl 4, 317 Bytes

exec(('%s'  *58  %(  's=','in','pu','t(',');','pr','in','t(','so','rt','ed','((s','[i',':j',']f','or',' j',' i','n ','ra','ng','e(','1,','le','n(','s)','+1',')f','or',' i',' i','n ','ra','ng','e(','j)','if',' l','en','(s','et','(s','[i',':j',']))','==l','en','(s','[i',':j',']))',',k','ey','=l','en',')[','-1','])')))

Probieren Sie es online!

Unerwarteter Code:

s=input();print(sorted((s[i:j]for j in range(1,len(s)+1)for i in range(j)if len(set(s[i:j]))==len(s[i:j])),key=len)[-1])

lambda aenthält, mbda was die Note 5 hat, und eine Funktion benötigt, returndie anscheinend nicht execbearbeitet werden kann (benötigt also eine Note von mindestens 5 für eturn), so dass ein vollständiges Programm erforderlich war. Es ist wahrscheinlich möglich, die unerreichte Codegröße ein wenig zu verringern, aber ich kann keine schnelle deutliche Verbesserung feststellen.

Alice , 40 Bytes

/ii..nn$$@@BBww..DD~~FF..!!nn$$KK??oo@@

(Hinterer Zeilenumbruch)

Probieren Sie es online!

Der Befehlszeiger bewegt sich im Ordnungsmodus diagonal, sodass nur jedes zweite Zeichen ausgeführt wird.

i.n$@Bw.D~F.!n$K?o@

i     take input
.n$@  terminate if empty
B     push all nonempty substrings, with the longest on the top of the stack
w     push return address (start main loop)
.     make copy of current substring
D     deduplicate characters
~     swap: this places the original above the deduplicated copy
F     Push the original string if it is a substring of the deduplicated copy
      (which can only happen if they're equal); otherwise push empty string
.!    place a copy on the tape
n$K   if the empty string was pushed, return to start of loop
o     output
@     terminate

Perl 6 , Score: 15 10 8, Länge: 46 55 62 Bytes

{~m:ov/(.+)<!{$0.comb.repeated}>/.max(&chars)}

Probier es aus

{~m:ov/(..*)<!{(($0)).comb.repeated}>{{}}/.max(&chars)}

Probier es aus

{m:ov:i/(..*)<!{(($0)).comb.repeated}>{{}}/.max((&chars)).Str}

Probier es aus

Erweitert:

{    # bare block lambda with implicit parameter ｢$_｣

    m                          # match (implicitly against ｢$_｣)
    :overlap                   # in every single way possible
    :ignorecase                # add a ｢:｣ to break up substring
    /

      (..*)                    # match at least one character

      <!{
        (($0)).comb.repeated  # backtrack if there were repeats
      }>

      {{}}                    # anon hash in code block (no-op)
    /

    .max((&chars))            # get the longest

    .Str                      # coerce to a Str (from a Match object)
}

Java 8, 9 Punkte (384 B) 7 (401 B)

S -> { int s = 0 , e = 0 , l = 0 , x = 0 , y = 0 , b [ ] = new int [ 256 ] ; for ( ; x <S.  length  & y <S.  length  & l <S.  length  - x ; x ++ ) { b [S[x]] = 1 ; for ( y ++ ; y <S.  length  && b [S[y]] < 1 ; b [S[y ++]] = 1 ) ; if ( l < y - x ) { s = x ; e = y ; l = y - x ; } for ( ; y <S.  length  && x < y & S[x] != S[y  ];)b [S[x ++]] = 0 ; }  String g=""; for( ; s<e ; g+= S[s++]);  return  g;}

• Erste Version. Werde von hier runter gehen. Das Ergebnis liegt bei 9 "ubstring ", substringwird also der erste Teil sein, der ersetzt werden muss.
• Das Ergebnis liegt nun bei 7 " length", was ich wahrscheinlich nicht weiter reduzieren kann. Ich bezweifle, dass es möglich ist, die vier Verwendungen von fallen zu lassen length. Wenn es möglich ist, kann " eturn"(6) die Punktzahl als endgültige Verbesserung um 1 senken, aber ich denke, das ist es (außer vielleicht eine kleine Verringerung der Byteanzahl).

Probieren Sie es online aus.

Haskell , Punktzahl 7

-4 danke an Laikoni.

import  Data.List  
f s=snd $ maximum [ (0<$i ,i)|i<-  tails  =<<inits s, nub i==i]

Probieren Sie es online!

Mathematica, Partitur 11 9

Length@Last@Select[Subsequences[Characters@#],#==DeleteDuplicates  @#&]&

Ein paar Bytes von der längsten nicht wiederholten Zeichenfolge entfernen, indem der Name der Funktion verdeckt wird:

Length@Last@Select[Subsequences[Characters  @#],#==(  ToExpression@ 
StringJoin@@FromCharacterCode@{{68},{101},{108},{101},{116},{101},{68},{117},
{112},{108},{105},{99},{97},{116},{101},{115}}))@#&]&

Kotlin , Punktzahl: 11 10 9 Bytes, Länge: 227 246 245 Bytes

indices
  .flatMap { p -> indices . map { p to p + it } }
  .  filter { (r,i) -> i < length  }
  .map { ( s , a )->substring  (  s,  a  ) }
  .  filter { it  .  groupBy  { it } .  none { ( k , v )->v . size>1 } }
  .maxBy { it.length }

Das längste ubstringist 9 Zeichen

Es heißt so:

val c = "Good morning, Green orb!"

fun String.c(): String? = indices
    .flatMap { p -> indices . map { p to p + it } }
    .  filter { (r,i) -> i < length  }
    .map { ( s , a )->substring  (  s,  a  ) }
    .  filter { it  .  groupBy  { it } .  none { ( k , v )->v . size>1 } }
    .maxBy { it.length }

fun main(args: Array<String>) {
    val text = """indices
    .flatMap { p -> indices . map { p to p + it } }
    .  filter { (r,i) -> i < length  }
    .map { ( s , a )->substring  (  s,  a  ) }
    .  filter { it  .  groupBy  { it } .  none { ( k , v )->v . size>1 } }
    .maxBy { it.length }"""
    val message = text.c()!!
    println(message)
    println(text.length)
    println(message.length)
    println(c.c())
}

Pyth , Punktzahl 3 (  18  14 Bytes)

e  fq  T{T  .:

Probieren Sie es online!

Die längste nicht wiederholende Teilzeichenfolge ist  .:.

05AB1E , 22 Byte | Prüfungsergebnis: 2

Œ  ʒ  D  Ù  Q  }  é  ¤

-1 Punktzahl + 7 Bytes dank HeebyJeeby

Probieren Sie es online!

05AB1E , 15 Bytes | Prüfungsergebnis: 3

Œ ʒ D Ù Q } é ¤

Probieren Sie es online!

05AB1E , 8 Bytes | Prüfungsergebnis: 8

ŒʒDÙQ}é¤

Probieren Sie es online!

05AB1E kann eigentlich etwas ziemlich Billiges tun ... das Hinzufügen von Whitespace in 05AB1E bewirkt nichts.

Wenn es eine Regel dagegen gibt, kann ich auch ´7 andere Zeichen verwenden und mögen.