सबसे लंबे समय तक न दोहराने वाला पदार्थ

Question

इनपुट के रूप में एक स्ट्रिंग को देखते हुए सबसे लंबे समय तक सन्निहित विकल्प मिलता है जिसमें दो या दो से अधिक वर्ण नहीं होते हैं। यदि ऐसे कई विकल्प हैं तो आप आउटपुट भी दे सकते हैं। आप मान सकते हैं कि इनपुट मुद्रण योग्य ASCII सीमा पर है यदि आप चाहें।

स्कोरिंग

उत्तर पहले उनकी अपनी सबसे लंबी गैर-दोहराई जाने वाली प्रतिस्थापन की लंबाई से और फिर उनकी कुल लंबाई से क्रमबद्ध होंगे। लोअर स्कोर दोनों मानदंडों के लिए बेहतर होगा। भाषा के आधार पर यह संभवतः स्रोत प्रतिबंध के साथ कोड-गोल्फ चुनौती की तरह महसूस करेगा ।

triviality

कुछ भाषाओं में 1, x (पेंग्वेज़) या 2, x (ब्रेन-फ्लैक और अन्य ट्यूरिंग टारपिट्स) का स्कोर प्राप्त करना बहुत आसान है, हालांकि अन्य भाषाएं भी हैं जिनमें सबसे लंबे समय तक न दोहराने वाले प्रतिस्थापन को कम करना एक चुनौती है। हास्केल में मुझे 2 का स्कोर प्राप्त करने में बहुत मज़ा आया, इसलिए मैं आपको उन भाषाओं की तलाश करने के लिए प्रोत्साहित करता हूं जहां यह कार्य मजेदार है।

परीक्षण के मामलों

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

स्कोरिंग प्रस्तुत करना

आप निम्नलिखित स्निपेट का उपयोग करके अपने कार्यक्रमों को स्कोर कर सकते हैं:

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>

Comments

प्रस्तावित परीक्षण मामला: 11122324455जोनाथन एलन ने महसूस किया कि मेरा पहला संशोधन इसे सही तरीके से नहीं संभाल पाया है।

— डेनिस

@ डेनिस टेस्ट केस जोड़ा गया। मैं उत्सुक हूं कि यह कैसे हुआ।

— गेहूं जादूगर

मैंने सभी सबस्ट्रिंग उत्पन्न किए (पहले से ही लंबाई के आधार पर छांटे गए), फिर सब्सट्रिंग को घटा दिया और उन सबको रखा जो सबस्ट्रिंग बने रहे। दुर्भाग्य से, यह क्रम बदल देता है; 11122के बाद ocurrs 324, लेकिन करने के लिए कटौती हो जाती है 12।

— डेनिस

मैं सोच रहा हूं कि व्हॉट्सएप का जवाब कहां है।

— मैजिक ऑक्टोपस Urn

Answer 1

सी, स्कोर 2,  747   720  662 बाइट्स

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

कम से कम 32-बिट MinGW (अनुकूलन अक्षमता के साथ) पर काम करता है। किसी एक कीवर्ड का उपयोग नहीं करता है।

जाहिरा तौर पर टीसीसी पर gcc और क्लैंग के साथ काम करता है: ऑनलाइन इसे आज़माएं! (साभार @ डेनिस)

के साथ बुलाना:

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

आउटपुट:

थोड़ा अधिक पठनीय स्वरूपण वाला कोड:

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

और यह स्कोर 2 के साथ प्रारूपण में लाने के लिए उचित रिक्ति उत्पन्न करने के लिए इस्तेमाल किया जा सकता है: इसे ऑनलाइन आज़माएं!

---

सी, स्कोर 3, 309 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 2

हास्केल , स्कोर 2, 492 ... 307 224 212 209 207 बाइट्स

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

इसे ऑनलाइन आज़माएं!

डब्ल्यूडब्ल्यू और अर्जन जोहान्सन के लिए धन्यवाद, सचमुच बाइट्स के सैकड़ों गोल्फ !

व्याख्या

फ़ंक्शन (??)एक वर्ण cऔर एक स्ट्रिंग लेता है और sइसमें सबसे लंबा उपसर्ग sशामिल होता है जिसमें शामिल नहीं होता है c। Ungolfed और स्कोर के लिए अनुकूलित नहीं:

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

फ़ंक्शन किसी दिए गए स्ट्रिंग के अनूठे वर्णों के सबसे लंबे उपसर्ग को खोजने के लिए ssउपयोग करता (??)है:

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

(##)एक ऐसा फंक्शन है जो दो स्ट्रिंग्स लेता है और एक लंबा रिटर्न देता है। लंबाई की तुलना स्ट्रिंग xको दोहराते हुए काम करती है जो अक्सर xलंबी होती है ( x>>y) और जितनी yलंबी ( y>>x) होती है और यह जांचती है कि परिणामी तारों में से कौन सा बड़ा है।

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

अंत ffमें इनपुट स्ट्रिंग पर ssपुनरावृत्ति करता है, साथ सबसे लंबे समय तक उपसर्ग उत्पन्न करता है , पुन: स्ट्रिंग की पूंछ के सबसे लंबे गैर-दोहराए जाने वाले प्रतिस्थापन को निर्धारित करता है और दोनों के साथ लंबे समय तक रिटर्न करता है (##):

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

Comments

224 , मुख्य रूप से मध्यवर्ती सूची को दूर करके।

— अर्जन जोहानसन

मैंने इस उत्तर को संयुक्त रूप से चैट में पोस्ट किए गए एक के साथ 216 प्राप्त करने के लिए जोड़ा ।

— गेहूं जादूगर

209 चीजों को पुनः व्यवस्थित करके।

— अर्जन जोहान्सन

इनाम की घोषणा के साथ, मैंने एक और रूप ले लिया और महसूस किया कि @चाल वास्तव में दो बाइट्स बनाने में 2 बाइट्स का खर्च करती है ?: 207

— Ørr जोहानसन

Answer 3

लुआ, स्कोर 3, 274 बाइट्स

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

नोट: लुआ 5.2 या लुआ 5.3 की आवश्यकता है

उपयोग:

$ 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

मुख्य विचार: " "लंबे पहचानकर्ताओं को विभाजित करने के लिए रिक्त स्थान डालें (दो रिक्त स्थान) के साथ सब कुछ इंटरलेव करें

अघोषित कोड:

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

वास्तविक कार्यक्रम (सभी स्थानों के जोड़े हटाने के बाद):

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

BTW, स्कोर की गणना के लिए JS स्निपेट मेरे कोड पर विफल रहता है।

Answer 4

रेटिना 0.8.2 , 37 बाइट्स, स्कोर 9

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

O#$^`
$.&
1G`

इसे ऑनलाइन आज़माएं! रेटिना 1 के लिए इस उत्तर का सीधा अनुवाद Nइसके बजाय का उपयोग करके एक बाइट बचाता है O#। हालांकि, अगर आप भोली गोल्फ रेटिना 1 को 28 बाइट्स के नीचे जवाब देते हैं, तो इसका स्कोर वास्तव में 10 हो जाता है! स्पष्टीकरण:

.
$&$'¶

इनपुट के सभी प्रत्यय उत्पन्न करें।

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

प्रत्येक प्रत्यय के लिए, पहले दोहराए गए वर्ण तक उपसर्ग लें।

O#$^`
$.&

लंबाई के उल्टे क्रम में शेष तारों को क्रमबद्ध करें (अर्थात सबसे पहले)।

1G`

सबसे लंबे समय तक ले लो।

Answer 5

जेली , स्कोर 2, 14 बाइट्स

Ẇµµff  Q  €  Ṫ

@JonathanAllan को स्कोर -1, +7 बाइट्स के लिए धन्यवाद और एक बग को सूचित करने के लिए।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

Answer 6

क्लीन , स्कोर 7 5, 276 बाइट्स

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

इसे ऑनलाइन आज़माएं! मुझे दिखाने के लिए @ tourous के लिए धन्यवाद कि एबीसी मशीन कोड को सीधे क्लीन के भीतर से कॉल करना संभव है। यह पिछली बोतल-गर्दन से छुटकारा पाने की अनुमति देता है importजो न्यूनतम स्कोर 7 पर सेट करता है, लेकिन उस कीवर्ड की आवश्यकता होती है codeजो इस दृष्टिकोण के लिए न्यूनतम स्कोर 5 से सेट करता है।

उपरोक्त कोड का एक अन -गोल्ड और स्कोर-अनुकूलित संस्करण यहां नहीं पाया जा सकता है: इसे ऑनलाइन आज़माएं!

---

पिछले संस्करण के साथ स्कोर 7, 158 154 130 बाइट्स

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

इसे ऑनलाइन आज़माएं!

importस्कोर के साथ नीचे नहीं जा सकता है 7. बिना आयात के किसी को किसी लाइब्रेरी फ़ंक्शंस के बिना स्ट्रिंग्स या चार्ट पर समानता को लागू करने की आवश्यकता होगी जो संभवतः संभव नहीं है, जैसा कि ऊपर नए संस्करण में देखा जा सकता है।

Comments

आप इनलाइन एबीसी का उपयोग करके वास्तव में समानता को लागू कर सकते हैं, जिससे स्कोर कम होना चाहिए। यदि आप रुचि रखते हैं तो मैं आज एक संशोधित संशोधन के साथ वापस आऊंगा।

— Οवसंत

जैसे: चार समानता: tio.run/##S85JTcz7/…

— aturous

@ A code block with raw ABC instructions, which can be used for primitive functions like integer addition, for linking with C, bypassing the type system... welcome down the rabbit hole!( क्लॉगल से ) निश्चित रूप से आमंत्रित लगता है। मैं इसे कल देखूंगा, सुझाव के लिए धन्यवाद!

— लकोनी

@ Ityurous धन्यवाद फिर से, अपने चार समानता परीक्षण के साथ स्कोर अब 5 पर है

— लाईकोनी

संयोग से, आपको या तो -ILध्वज की आवश्यकता नहीं है, क्योंकि कुछ भी आयात नहीं किया जा रहा है।

— Οवसंत

Answer 7

पायथन 3 , स्कोर 4, 155 बाइट्स

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

यह एक फ़ंक्शन को परिभाषित करता है l।

यह इंगित करने के लिए @xnor के लिए धन्यवाद कि लंबाई 3 के तार स्कोर को बढ़ाते नहीं हैं, जिससे 32 बाइट बचती हैं।

इसे ऑनलाइन आज़माएं!

Comments

स्ट्रिंग 3 के विखंडू में हो सकती है, है ना?

— xnor

@xnor फ़ंक्शन का नाम बदलना, वास्तव में। धन्यवाद!

— डेनिस

Answer 8

ब्रेकीलॉग , स्कोर 2, 19 बाइट्स

s  ᶠ  l  ᵒ  ≠  ˢ  t

इसे ऑनलाइन आज़माएं!

बस एक उबाऊ पुराना "अंतरिक्ष सब कुछ बाहर" उत्तर। कम से कम मुझे पता चला कि मेटाप्रेडिकेट्स को विधेय से दूर रखा जा सकता है और अभी भी काम कर सकता है (और (पैरामीट्रिक) सदस्यता और सुपरस्क्रिप्ट नहीं कर सकता)।

s ᶠ - दिए गए स्ट्रिंग के सभी सबस्ट्रिंग का पता लगाएं

l ᵒ - उन्हें उनकी लंबाई के अनुसार क्रम दें (डिफ़ॉल्ट रूप से आरोही)

≠ ˢ - उन सभी का चयन करें जिनमें सभी अलग-अलग तत्व हैं

t - उस की पूंछ (अंतिम तत्व) प्राप्त करें - सबसे बड़ी लंबाई के साथ

Answer 9

पायथ , 11 बाइट्स, स्कोर 4

-4 स्कोर डेनिस की बदौलत

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

इसे ऑनलाइन आज़माएं!

Answer 10

भूसी , स्कोर 2, 10 बाइट्स

►IIËII≠IIQ

इसे ऑनलाइन आज़माएं!

व्याख्या

कार्यक्रम इसके बराबर है:

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

निर्मित Ëमूल्यांकन करता है ≠अपने तर्क के सभी आदेश दिया जोड़े पर x, और रिटर्न length(x)+1अगर हर परिणाम अन्यथा, truthy है 0। जब हम इसे अधिकतम करते हैं, तो हमें सबसे लंबी स्ट्रिंग मिलती है जिसमें कोई दोहराए जाने वाले अक्षर नहीं होते हैं।

सबमिशन में, मैं सिर्फ Iदो बार प्रत्येक फंक्शन के बीच आइडेंटिटी फंक्शन डालता हूं । चूंकि IËरूप में ही है Ë, I≠के रूप में ही है ≠और इतने पर, इस अर्थ विज्ञान नहीं बदलता है। एकमात्र खतरा यह है कि एक उच्च क्रम फ़ंक्शन Iअपने तर्क के रूप में एस में से एक का उपयोग करने का निर्णय ले सकता है, लेकिन सौभाग्य से हमारे कार्यक्रम में एक प्रकार की त्रुटि होती है, इसलिए ऐसा नहीं होता है।

Answer 11

क्लोजर, स्कोर 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)))))

अरे यार ये दर्दनाक था! Nऔजार next, Rहै reduce, Cहै count, Jहै conj(केवल वैक्टर के लिए काम करता है) और Iहै iterate। apply strवहाँ दो बार है क्योंकि अन्यथा "आआआ" इनपुट एक स्ट्रिंग नहीं बल्कि एक वेक्टर लौटाएगा [\a]। सौभाग्य से मुझे उपयोग करना पड़ा applyऔर assoc, मुझे नहीं पता था कि आप वेक्टर के अंतिम तत्व से परे एक सूचकांक को ग्रहण कर सकते हैं: ओ

Comments

मैंने कुछ स्थान का मुंडन किया: इसे ऑनलाइन आज़माएं!

— अर्जन जोहान्सन

Answer 12

जेली , स्कोर 5, 10 बाइट्स

ẆµQQ⁼µÐfµṪ

इसे ऑनलाइन आज़माएं!

Comments

आप अपने कोड में रिक्त स्थान जोड़कर स्कोर को 3 तक कम कर सकते हैं। उदाहरण के लिए: ẆµQQ ⁼ µ Ðf µ Ṫ(शायद अब बहुत सारे रिक्त स्थान जोड़े गए हैं, लेकिन यह सिर्फ एक उदाहरण है। मैं बाइट-काउंट बनाम रिक्त स्थान आपके ऊपर अनुकूलन करना छोड़ दूंगा)।

— केविन क्रूज़सेन

Answer 13

पायथन 3 , स्कोर 4, 317 बाइट्स

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

इसे ऑनलाइन आज़माएं!

असुरक्षित कोड:

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 aजिसमें mbda स्कोर 5 होता है, और एक फ़ंक्शन की आवश्यकता होती है returnजो जाहिरा तौर पर execएड नहीं हो सकती है (इसलिए कम से कम 5 के लिए स्कोर लेता है eturn), इसलिए एक पूर्ण कार्यक्रम आवश्यक था। संभवत: अनएक्सपेक्टेड कोड साइज़ को थोड़ा नीचे करना गोल्फ के लिए संभव है, लेकिन मैं एक त्वरित स्पष्ट सुधार नहीं देख सकता।

Answer 14

ऐलिस , 40 बाइट्स

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

(अनुगामी न्यूलाइन)

इसे ऑनलाइन आज़माएं!

निर्देश सूचक आरेखीय मोड में तिरछे चलता है, इसलिए केवल हर दूसरे वर्ण को निष्पादित किया जाता है।

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

Answer 15

पर्ल 6 , स्कोर: 15 10 8, लंबाई: 46 55 62 बाइट्स

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

झसे आज़माओ

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

झसे आज़माओ

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

झसे आज़माओ

विस्तारित:

{    # 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)
}

Comments

88 बाइट के लिए 5 का स्कोर । वहाँ गोल्फ बाइट्स के लिए कुछ स्थानों पर हो सकता है

— जो किंग

Answer 16

जावा 8, स्कोर 9 (384 बी) 7 (401 बी)

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

• प्रारंभिक संस्करण। यहां से नीचे जाएंगे। के कारण स्कोर 9 है "ubstring ", इसलिए substringप्रतिस्थापित करने वाला पहला भाग होगा।
• स्कोर अब 7 के कारण है " length", जिसे मैं शायद आगे कम नहीं कर पाऊंगा .. मुझे संदेह है कि इसके चार उपयोगों को छोड़ना संभव है length। यदि यह संभव है, " eturn"(6) अंतिम सुधार के रूप में स्कोर को 1 से कम कर सकता है, लेकिन मुझे लगता है कि यह है (बाइट-गिनती में एक छोटे से कमी को छोड़कर) ..

इसे ऑनलाइन आज़माएं।

Answer 17

हास्केल , स्कोर 7

-4 लायकोनी को धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

Comments

f s=snd$maximum[(0<$i,i)|i<-tails=<<inits s,nub i==i]स्कोर पर एक बाइट और दो बचाता है।

— लैकोनी

कुछ स्थानों को जोड़ने से स्कोर 7 से नीचे आता है: इसे ऑनलाइन आज़माएं!

— लाकोनी

Answer 18

गणितज्ञ, स्कोर ११ ९

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

फ़ंक्शन के नाम को अस्पष्ट करते हुए सबसे लंबे समय तक गैर-छिद्रण स्ट्रिंग से बाइट्स के कुछ जोड़े को शेविंग करें:

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

Answer 19

कोटलिन , स्कोर: 11 10 9 बाइट्स, लंबाई: 227 246 245 बाइट्स

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 }

सबसे लंबा है ubstring, जो 9 वर्ण है

इसे इस तरह कहा जाता है:

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

Comments

आप के बीच एक अतिरिक्त अंतरिक्ष जोड़कर 10 के लिए इसे कम करने के लिए सक्षम नहीं हैं roupingByऔर {?

— केविन क्रूज़सेन

अच्छा लगा, मैंने अन्य 11 को बदल दिया और 10 से नीचे उतर गया

— पहुंच गया

यह है 10 वर्ण, लेकिन सबसे लंबे समय तक सबस्ट्रिंग नहीं है roupingBy(जो 9 वर्ण है), लेकिन eachCount(अंतरिक्ष अनुगामी के साथ)।

— आउटगोल्फर

roupingBy एक अनुगामी स्थान है (मार्कडाउन में दिखाई देता है, लेकिन रेंडरर इसे पट्टी करता है)

— मार्कडाउन

इसे 9 को कम करने के लिए प्रबंधित, ट्रिमिंग मुद्दे को ठीक करते हुए

— jrtapsell

Answer 20

पायथ , स्कोर 3 (  18  14 बाइट)

e  fq  T{T  .:

इसे ऑनलाइन आज़माएं!

सबसे लंबे समय तक न दोहराने वाला पदार्थ है  .:।

Comments

एक प्यारा-ईश विकल्प e f {I T .::।

— मिस्टर एक्सकोडर

Answer 21

05AB1E , 22 बाइट्स | स्कोर: 2

Œ  ʒ  D  Ù  Q  }  é  ¤

-1 स्कोर + 7 बाइट्स HeebyJeeby की बदौलत

इसे ऑनलाइन आज़माएं!

---

05AB1E , 15 बाइट्स | स्कोर: 3

Œ ʒ D Ù Q } é ¤

इसे ऑनलाइन आज़माएं!

---

05AB1E , 8 बाइट्स | स्कोर: 8

ŒʒDÙQ}é¤

इसे ऑनलाइन आज़माएं!

---

05AB1E वास्तव में सस्ते के बजाय कुछ कर सकता है ... 05AB1E में व्हॉट्सएप को जोड़ने से कुछ नहीं होता है।

यदि इसके विरुद्ध कोई नियम है, तो मैं ´7 अन्य वर्णों का भी उपयोग और पसंद कर सकता हूं ।

Comments

@HeebyJeebyMan क्योंकि मैं एक मूर्ख हूँ, उस के साथ एक समस्या है?

— मैजिक ऑक्टोपस Urn

@HeebyJeebyMan हाहा मारते हुए, विचार के लिए धन्यवाद।

— मैजिक ऑक्टोपस Urn