Data una stringa come input, trova la sottostringa contigua più lunga che non ha alcun carattere due o più volte. Se sono presenti più sottostringhe, è possibile produrre anche. Se lo desideri, puoi supporre che l'ingresso si trovi nell'intervallo ASCII stampabile.

punteggio

Le risposte verranno prima classificate in base alla lunghezza della sottostringa più lunga non ripetuta, quindi in base alla lunghezza totale. I punteggi più bassi saranno migliori per entrambi i criteri. A seconda della lingua, questo probabilmente sembrerà una sfida al code-golf con una limitazione della fonte.

Banalità

In alcune lingue ottenere un punteggio di 1, x (lingua) o 2, x (Brak-flak e altri tarpit di turing) è abbastanza facile, tuttavia ci sono altre lingue in cui ridurre al minimo la sottostringa più lunga non ripetitiva è una sfida. Mi sono divertito molto a ottenere un punteggio di 2 in Haskell, quindi ti incoraggio a cercare lingue in cui questo compito è divertente.

Casi test

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

Punteggio punteggio

Puoi assegnare un punteggio ai tuoi programmi utilizzando il seguente frammento:

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, punteggio 2,  747   720  662 byte

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  )  ;  }

Funziona almeno su MinGW a 32 bit (con ottimizzazioni disabilitate). Non utilizza una sola parola chiave.

Funziona apparentemente anche su TIO con gcc e clang: provalo online! (Grazie @Dennis!)

Chiama con:

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);
}

Produzione:

Il codice con una formattazione leggermente più leggibile:

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);
}

E questo può essere usato per generare la spaziatura corretta per arrivare alla formattazione con il punteggio 2: provalo online!

C, punteggio 3, 309 byte

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
)
;
}

Provalo online!

Haskell , punteggio 2, 492 ... 307 224 212 209 207 byte

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

Provalo online!

Golf letteralmente centinaia di byte grazie a WW e Ørjan Johansen !

Spiegazione

La funzione (??)accetta un carattere ce una stringa se restituisce il prefisso più lungo sche non contienec . Non golfato e non ottimizzato per il punteggio:

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

La funzione ssutilizza(??) per trovare il prefisso più lungo di caratteri univoci di una determinata stringa:

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

(##)è una funzione che accetta due stringhe e restituisce quella più lunga. Il confronto della lunghezza funziona ripetendo la stringa tutte xle volte che xè long ( x>>y) e quanto yè long (y>>x ) e controllando quale delle stringhe risultanti è lessicograficamente più grande.

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

Alla fine ffricorre sulla stringa di input, genera il prefisso più lungo con ss, determina ricorsivamente la sottostringa più lunga non ripetitiva della coda della stringa e restituisce la più lunga delle due con (##):

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

Lua, punteggio 3, 274 byte

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  ","  ",""))(...)

Nota: è richiesto Lua 5.2 o Lua 5.3

Uso:

$ 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

Idea principale: interleave tutto con gli spazi, inserire " " (due spazi) per dividere identificatori lunghi

Codice non golfato:

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
   )
)(...)

Programma effettivo (dopo aver rimosso tutte le coppie di spazi):

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

A proposito, lo snippet JS per il calcolo del punteggio non riesce sul mio codice.

Retina 0.8.2 , 37 byte, punteggio 9

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

O#$^`
$.&
1G`

Provalo online! La traduzione diretta di questa risposta in Retina 1 salva un byte usando Ninvece di O#. Tuttavia, se giochi in modo ingenuo la risposta Retina 1 fino a 28 byte, il suo punteggio sale a 10! Spiegazione:

.
$&$'¶

Genera tutti i suffissi dell'input.

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

Per ogni suffisso, prendi il prefisso fino al primo carattere duplicato.

O#$^`
$.&

Ordinare le stringhe rimanenti in ordine inverso rispetto alla lunghezza (ovvero prima la più lunga).

1G`

Prendi il più a lungo.

Gelatina , punteggio 2, 14 byte

Ẇµµff  Q  €  Ṫ

Grazie a @JonathanAllan per il punteggio -1, +7 byte e per aver notato un bug.

Provalo online!

Come funziona

Ẇµµ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.

Pulito , punteggio 7 5, 276 byte

@[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

Provalo online! Grazie a @ Οurous per avermi mostrato che è possibile chiamare il codice macchina ABC direttamente da Clean. Ciò consente di eliminare il precedente collo di bottiglia importche imposta il punteggio minimo su 7, ma richiede la parola chiavecode per questo approccio è che imposta il punteggio minimo su 5.

Una versione non modificata e non ottimizzata per il punteggio del codice sopra può essere trovata qui: provala online!

Versione precedente con punteggio 7, 158 154 130 byte

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

Provalo online!

Con il importpunteggio non si può scendere al di sotto di 7. Senza l'importazione si dovrebbe implementare l'uguaglianza su stringhe o caratteri senza alcuna funzione di libreria che probabilmente non è possibile, come si può vedere nella nuova versione sopra.

Python 3 , punteggio 4, 155 byte

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

Questo definisce una funzione l.

Grazie a @xnor per aver sottolineato che le stringhe di lunghezza 3 non aumentano il punteggio, risparmiando 32 byte.

Provalo online!

Brachylog , punteggio 2, 19 byte

s  ᶠ  l  ᵒ  ≠  ˢ  t

Provalo online!

Solo una vecchia noiosa risposta "spazio tutto fuori". Almeno ho appreso che i metapredicati possono essere distanziati dai predicati e funzionano ancora (e che i pedici e gli apice (parametrici) non possono).

s ᶠ - trova tutte le sottostringhe della stringa specificata

l ᵒ - ordinali per la loro lunghezza (crescente per impostazione predefinita)

≠ ˢ - seleziona quelli che hanno tutti elementi distinti

t - prendi la coda (ultimo elemento) di quello - quello con la lunghezza maggiore

Pyth , 11 byte, punteggio 4

-4 punti grazie a 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

Provalo online!

Buccia , punteggio 2, 10 byte

►IIËII≠IIQ

Provalo online!

Spiegazione

Il programma è equivalente a questo:

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

Il built-in Ëvaluta ≠su tutte le coppie ordinate del suo argomento xe restituisce length(x)+1se ogni risultato è veritiero, altrimenti 0. Quando massimizziamo questo, troviamo la stringa più lunga che non ha caratteri ripetuti.

Nella presentazione, inserisco solo Idue volte la funzione identità tra ciascuna funzione. Poiché IËè uguale a Ë,I≠ è lo stesso di ≠e così via, questo non cambia la semantica. L'unico pericolo è che una funzione di ordine superiore possa decidere di utilizzare una delle Is come argomento, ma per fortuna ciò porta a un errore di tipo nel nostro programma, quindi non accade.

Clojure, punteggio 4

#(  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 amico, è stato doloroso! Nimplementa next, Rè reduce, Cè count, Jè conj(funziona solo per i vettori) ed Iè iterate. apply strc'è due volte perché altrimenti l'input "aaaa" non restituirebbe una stringa ma un vettore [\a]. Fortunatamente ho avuto modo di usare applye assoc, non sapevo che si potesse associare un indice oltre l'ultimo elemento di un vettore: o

Gelatina , punteggio 5, 10 byte

ẆµQQ⁼µÐfµṪ

Provalo online!

Python 3 , punteggio 4, 317 byte

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','])')))

Provalo online!

Codice non eseguito:

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 acontiene mbda quale ha il punteggio 5 e una funzione returnche a quanto pare non può essere modificata exec(quindi richiede un punteggio di almeno 5 per eturn), quindi era necessario un programma completo. Probabilmente è possibile ridurre un po 'la dimensione del codice ineccepibile, ma non riesco a vedere un rapido miglioramento chiaro.

Alice , 40 byte

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

(Newline finale)

Provalo online!

Il puntatore dell'istruzione si sposta in diagonale in modalità ordinale, quindi viene eseguito solo ogni altro carattere.

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 , punteggio: 15 10 8, lunghezza: 46 55 62 byte

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

Provalo

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

Provalo

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

Provalo

Allargato:

{    # 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, punteggio 9 (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;}

• Versione iniziale. Scenderà da qui. Il punteggio è 9 a causa di "ubstring ", quindi substringsarà la prima parte da sostituire.
• Il punteggio ora è 7 a causa " length", che probabilmente non sarò in grado di ridurre ulteriormente .. Dubito che sia possibile abbandonare i quattro usi di length. Se è possibile, " eturn"(6) potrebbe abbassare il punteggio di 1 come miglioramento finale, ma immagino che sia così (tranne forse una piccola riduzione nel conteggio dei byte ..)

Provalo online.

Haskell , punteggio 7

-4 grazie a Laikoni.

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

Provalo online!

Mathematica, punteggio 11 9

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

Rimozione di un paio di byte dalla stringa non ripetuta più lunga oscurando il nome della funzione:

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 , punteggio: 11 10 9 byte, lunghezza: 227 246 245 byte

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 }

Il più lungo è ubstring, ovvero 9 caratteri

Si chiama così:

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 , punteggio 3 (  18  14 byte)

e  fq  T{T  .:

Provalo online!

Le sottostringhe non ripetute più lunghe sono  .:.

05AB1E , 22 byte | Punteggio: 2

Œ  ʒ  D  Ù  Q  }  é  ¤

-1 punteggio + 7 byte grazie a HeebyJeeby

Provalo online!

05AB1E , 15 byte | Punteggio: 3

Œ ʒ D Ù Q } é ¤

Provalo online!

05AB1E , 8 byte | Punteggio: 8

ŒʒDÙQ}é¤

Provalo online!

05AB1E can actually do something rather cheap... adding whitespace into 05AB1E does nothing.

If there is a rule against this, I can also use ´ and like 7 other chars.