स्थानीय काल

एक गैर खाली स्ट्रिंग ले लो रों । स्थानीय अवधि के रों सूचकांक में मैं पूर्णांक सकारात्मक सबसे छोटी है n ऐसा है कि प्रत्येक के लिए 0 ≤ कश्मीर <n , हम रों [i + K] = रों [i-एन + K] जब भी दोनों पक्षों परिभाषित कर रहे हैं। वैकल्पिक रूप से, यह एक नॉनमॉपी स्ट्रिंग डब्ल्यू की न्यूनतम लंबाई है, जैसे कि अगर कॉन्टेक्शन डब्ल्यूडब्ल्यू को एस के बगल में रखा जाता है, ताकि डब्ल्यू की दूसरी प्रति इंडेक्स आई के एस पर शुरू हो , तो दो स्ट्रिंग्स सहमत होते हैं जहां भी वे ओवरलैप करते हैं।

एक उदाहरण के रूप में, आइए (0-आधारित) सूचकांक 2 पर s = "abaabbab" की स्थानीय अवधि की गणना करें ।

N = 1 का प्रयास करें : फिर s [2 + 0] 2- s [2-1 + 0] , इसलिए यह विकल्प सही नहीं है।
N = 2 का प्रयास करें : फिर s [2 + 0] = s [2-2 + 0] लेकिन s [2 + 1] -2 s [2-2 + 1] , इसलिए यह भी सही नहीं है।
N = 3 का प्रयास करें : फिर s [2 + 0-3] परिभाषित नहीं है, s [2 + 1] = s [2-3 + 1] और s [2 + 2] = s [2-3 + 2] । इस प्रकार स्थानीय अवधि 3 है।

यहाँ दूसरी परिभाषा का उपयोग करते हुए स्थानीय अवधियों का एक दृश्य है, जिसमें स्पष्टता के लिए w की दो प्रतियों के बीच अर्धविराम जोड़े गए हैं :

index      a b a a b b a b      period
 0       a;a                     1
 1       b a;b a                 2
 2       a a b;a a b             3
 3             a;a               1
 4     b b a b a a;b b a b a a   6
 5                 b;b           1
 6               a b b;a b b     3
 7                   b a;b a     2

ध्यान दें कि डब्ल्यू आवश्यक रूप से एस का विकल्प नहीं है । इंडेक्स -4 मामले में यहां ऐसा होता है।

काम

आपके इनपुट में अरिक्त स्ट्रिंग है रों लोअरकेस ASCII वर्ण की। यदि वांछित हो तो इसे पात्रों की सूची के रूप में लिया जा सकता है। आपका आउटपुट के स्थानीय अवधि युक्त सूची होगी रों अपनी सूचकांकों में से प्रत्येक में। उपरोक्त उदाहरण में, सही आउटपुट [1,2,3,1,6,1,3,2] होगा ।

प्रत्येक भाषा में सबसे कम बाइट गिनती जीतती है। मानक कोड-गोल्फ नियम लागू होते हैं।

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

a -> [1]
hi -> [1, 2]
www -> [1, 1, 1]
xcxccxc -> [1, 2, 2, 5, 1, 3, 2]
abcbacb -> [1, 4, 7, 7, 7, 3, 3]
nininini -> [1, 2, 2, 2, 2, 2, 2, 2]
abaabbab -> [1, 2, 3, 1, 6, 1, 3, 2]
woppwoppw -> [1, 4, 4, 1, 4, 4, 4, 1, 4]
qwertyuiop -> [1, 10, 10, 10, 10, 10, 10, 10, 10, 10]
deededeededede -> [1, 3, 1, 5, 2, 2, 5, 1, 12, 2, 2, 2, 2, 2]
abababcabababcababcabababcaba -> [1, 2, 2, 2, 2, 7, 7, 7, 7, 2, 2, 2, 19, 19, 5, 5, 2, 5, 5, 12, 12, 2, 2, 2, 7, 7, 5, 5, 2]

code-golf string

— Zgarb
स्रोत

तुम हमेशा एक पा सकते हैं @Arnauld w के रूप में ही लंबाई के साथ रों । के मामले में qwertyuiop, w एक घुमाया हुआ संस्करण होगा qwertyuiop। सूचकांक 4 पर उदाहरण भी देखें: डब्ल्यू जरूरी नहीं कि एस का विकल्प हो ।

— जर्गर

यह समझ आता है। मैंने चुनौती को गलत बताया।

— अरनुलद

एक रैखिक समय समाधान के लिए काल्पनिक बोनस! (कोई और व्यक्ति असली इनाम दे सकता है, इसलिए कोशिश करते रहें)

— user202729

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

— मार्टिन एंडर

@MartinEnder वैचारिक रूप से क्लीनर होगा, लेकिन यह परिभाषा स्ट्रिंग पर लूपिंग द्वारा आउटपुट का उत्पादन करना आसान बनाती है, और आउटपुट खाली नहीं होगा।

— ज़गारब

4

रेटिना , 89 86 बाइट्स

.
$`¶$<'¶
/(^|.+)¶.+/_(Lw$`^(.+)?(.*)(.+)?¶(?(1)|(.*))\2(?(3)$)
$2$3$4
G`.
%C`.
N`
0G`

इसे ऑनलाइन आज़माएं! संपादित करें: @MartinEnder के लिए 3 बाइट्स सहेजे गए। स्पष्टीकरण:

.
$`¶$<'¶

प्रत्येक वर्ण पर इनपुट को विभाजित करें, एक जोड़ी रेखाओं का निर्माण, एक उपसर्ग के लिए और एक उपसर्ग के प्रत्यय के लिए।

/(^|.+)¶.+/_(

प्रत्येक परिणामी जोड़ी पर बाकी स्क्रिप्ट चलाएँ।

Lw$`^(.+)?(.*)(.+)?¶(?(1)|(.*))\2(?(3)$)
$2$3$4

सभी अतिव्यापी मिलान खोजें और परिणामों को सूचीबद्ध करें। (निचे देखो।)

G`.

खाली मैच को त्याग दें।

%C`.

प्रत्येक मैच की लंबाई लें।

N`

संख्यात्मक रूप से क्रमबद्ध करें।

0G`

सबसे छोटा लें।

उपसर्ग और प्रत्यय को तीन भागों में विभाजित करके मिलान कार्य करता है। विचार करने के लिए चार वैध मामले हैं:

AB|BC   B matches B to the left and B to the right
B|ABC   AB matches [A]B to the left and AB to the right
ABC|B   BC matches BC to the left and B[C] to the right
BC|AB   ABC matches [A]BC to the left and AB[C] to the right

रेगेक्स इसलिए केवल ए और सी को एक समय में एक तरफ से मैच करने की अनुमति देता है।

— नील
स्रोत

$&$'के बराबर है $<'और कंप्यूटिंग लाइन की लंबाई कम है %C`.। tio.run/##K0otycxLNPz/X49LJeHQNhUb9UPbuPQ14mr0tDUPbdPT1o/…

— मार्टिन

4

जावा 8, 167 154 152 बाइट्स

s->{int l=s.length,r[]=new int[l],i=0,n,k;for(;i<l;r[i++]=n)n:for(n=0;;){for(k=++n;k-->0;)if(i+k<l&i+k>=n&&s[i+k]!=s[i-n+k])continue n;break;}return r;}

-2 बाइट्स @ceilingcat की बदौलत ।

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

स्पष्टीकरण:

s->{                          // Method with char-array parameter and int-array return-type
  int l=s.length,             //  Length of the input-array
      r[]=new int[l],         //  Result-array of the same size 
      i=0,n,k;                //  Integers `i`, `n`, and `k` as defined in the challenge
  for(;i<l;                   //  Loop `i` in the range [0, `l`):
      r[i++]=n)               //    After every iteration: Add `n` to the array
    n:for(n=0;;){             //   Inner loop `n` from 0 upwards indefinitely
      for(k=++n;k-->0;)       //    Inner loop `k` in the range [`n`, 0]:
                              //    (by first increasing `n` by 1 with `++n`)
        if(i+k<l&i+k>=n)      //     If `i+k` and `i-n+k` are both within bounds,
           &&s[i+k]!=s[i-n+k])//     and if `s[i+k]` is not equal to `s[i-n+k]`:
          continue n;         //      Continue loop `n`
                              //    If we haven't encountered the `continue n` in loop `k`:
      break;}                 //     Break loop `n`
  return r;}                  //  Return the result

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

1

जावास्क्रिप्ट (ईएस 6), 84 बाइट्स

वर्णों के एक सरणी के रूप में इनपुट लेता है।

s=>s.map((_,i)=>s.some(_=>s.every(_=>k<j|!s[k]|s[k-j]==s[k++]|k-i>j,++j,k=i),j=0)*j)

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

कोड स्निपेट दिखाएं

let f =

s=>s.map((_,i)=>s.some(_=>s.every(_=>k<j|!s[k]|s[k-j]==s[k++]|k-i>j,++j,k=i),j=0)*j)

console.log(JSON.stringify(f([...'a']))) // [1]
console.log(JSON.stringify(f([...'hi']))) // [1, 2]
console.log(JSON.stringify(f([...'www']))) // [1, 1, 1]
console.log(JSON.stringify(f([...'xcxccxc']))) // [1, 2, 2, 5, 1, 3, 2]
console.log(JSON.stringify(f([...'abcbacb']))) // [1, 4, 7, 7, 7, 3, 3]
console.log(JSON.stringify(f([...'nininini']))) // [1, 2, 2, 2, 2, 2, 2, 2]
console.log(JSON.stringify(f([...'abaabbab']))) // [1, 2, 3, 1, 6, 1, 3, 2]
console.log(JSON.stringify(f([...'woppwoppw']))) // [1, 4, 4, 1, 4, 4, 4, 1, 4]
console.log(JSON.stringify(f([...'qwertyuiop']))) // [1, 10, 10, 10, 10, 10, 10, 10, 10, 10]
console.log(JSON.stringify(f([...'deededeededede']))) // [1, 3, 1, 5, 2, 2, 5, 1, 12, 2, 2, 2, 2, 2]
console.log(JSON.stringify(f([...'abababcabababcababcabababcaba']))) // [1, 2, 2, 2, 2, 7, 7, 7, 7, 2, 2, 2, 19, 19, 5, 5, 2, 5, 5, 12, 12, 2, 2, 2, 7, 7, 5, 5, 2]

स्निपेट का विस्तार करें

— Arnauld
स्रोत

मुझे यकीन नहीं है कि अगर पात्रों की एक सरणी लेने की अनुमति है, तो क्या आप सुनिश्चित हैं कि वे सिर्फ 1-वर्ण तार नहीं हैं?

— एरिक आउटगॉल्फ

@EriktheOutgolfer JS में कोई चरित्र प्रकार नहीं है, इसलिए हाँ: यह तकनीकी रूप से 1-वर्ण स्ट्रिंग्स की एक सरणी है। मेरी समझ यह है कि अगर यह एक स्ट्रिंग की तरह है, तो यह एक स्ट्रिंग है। (यहाँ इस बारे में एक मेटा पोस्ट है, लेकिन एक अधिक प्रासंगिक एक मौजूद हो सकता है - या एक जो वास्तव में मेरी धारणा का खंडन करता है।)

— अरनौल

1

या इसे दूसरे शब्दों में कहें: यह उतना ही करीब है जितना हम जेएस के पात्रों की सूची में प्राप्त कर सकते हैं , जिन्हें ओपी द्वारा स्पष्ट रूप से अनुमति दी गई थी।

— अरनुलद

1

रूबी , 104 102 बाइट्स

->s{l=s.size-1
(0..l).map{|i|n=0
loop{n+=1
(n-i..l-i).all?{|k|k<0||k>=n||s[i+k]==s[i-n+k]}&&break}
n}}

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

एक लंबोदर एक स्ट्रिंग को स्वीकार करता है और एक सरणी लौटाता है।

-2 बाइट्स: इंडेक्स बाउंड गार्ड्स के साथ स्वैप रेंज एंडपॉइंट्स

Ungolfed:

->s{
  l=s.size-1                # l is the maximum valid index into s
  (0..l).map{ |i|           # i is the current index
    n=0                     # n is the period being tested
    loop{                   # Repeat forever:
      n+=1                  # Increment n
      (n-i..l-i).all?{ |k|  # If for all k where i+k and i-n+k are valid indexes into s
        k<0 || k>=n ||      #   We need not consider k OR
          s[i+k]==s[i-n+k]  #   The characters at the relevant indexes match
      } && break            # Then stop repeating
    }
  n                         # Map this index i to the first valid n
  }
}

— benj2240
स्रोत

1

जाप , 33 32 बाइट्स

@ बस्ती के लिए 1 बाइट का धन्यवाद सहेजा गया

¬Ë@¯E f'$iUtED ú.D r."($&|^)"}aÄ

इसे ऑनलाइन टेस्ट करें!

व्याख्या

¬Ë@¯E f'$iUtED ú.D r."($&|^)"}aÄ   Implicit: U = input string
¬Ë                                 Split the input into chars, and map each index E to
  @                          }aÄ     the smallest positive integer D where
   ¯E                                  the first E chars of U
      f                                matches the regex formed by
          UtED                         taking D chars of U from index E,
                ú.D                     padding to length D with periods,
                    r."($&|^)"          replacing each char C with "(C|^)",
        '$i                             and placing a '$' at the very end.

मेरा पहला विचार था कि बाएं विकल्प में प्रत्येक वर्ण की तुलना दाएं विकल्प में संगत चार वर्ण के साथ की जाए, जैसा कि JS उत्तर में किया गया है। हालांकि, यह काम नहीं करेगा, क्योंकि एक चरित्र प्राप्त करने के लिए जाप की विधि केवल स्ट्रिंग के दूसरे छोर तक लपेटती है यदि सूचकांक नकारात्मक या बहुत बड़ा है।

इसके बजाय, मेरा समाधान दूसरे सबरिंग में से एक रेगेक्स बनाता है और इसे पहले विकल्प पर परीक्षण करता है। abaabbabएक उदाहरण के रूप में परीक्षण के मामले में 5 वां आइटम लेते हैं :

abaabbab
    ^ split point -> abaa for testing regex, bbab for making regex

   slice  regex                              matches abaa
1. b      /(b|^)$/                           no
2. bb     /(b|^)(b|^)$/                      no
3. bba    /(b|^)(b|^)(a|^)$/                 no
4. bbab   /(b|^)(b|^)(a|^)(b|^)$/            no
5. bbab.  /(b|^)(b|^)(a|^)(b|^)(.|^)$/       no
6. bbab.. /(b|^)(b|^)(a|^)(b|^)(.|^)(.|^)$/  yes: /^^ab..$/

मुख्य चाल यह है कि ^एक वास्तविक चरित्र से मेल खाने तक असीम रूप से मेल खा सकता है। यह हमें रेगेक्स की शुरुआत से किसी भी वर्ण की उपेक्षा करने देता है, जबकि यह सुनिश्चित करता है कि बाकी सभी लगातार मेल खाते हैं, परीक्षण स्ट्रिंग के अंत में समाप्त होते हैं।

मुझे यकीन नहीं है कि मैंने इसे बहुत अच्छी तरह से समझाया है, इसलिए कृपया मुझे बताएं कि क्या कुछ ऐसा है जिसे आप स्पष्ट करना चाहते हैं, या कुछ और जिसे समझाया जाना चाहिए।

— ETHproductions
स्रोत

32 बाइट्स ।

— झबरा

@ शगुन थैंक्स, उस अर्धविराम से मुझे गुस्सा आ रहा था: P

— ETHproductions

1

C (gcc) , 143 142 140 139 128 126 123 बाइट्स

एक बाइट को बचाया। को गोल्फ !b&&printfदी b||printf।
केविन क्रूज़सेन के लिए धन्यवाद दो बाइट्स बचाए । प्लेसमेंट को टालते हुए forलूप बॉडी कोष्ठकों को हटा दिया printf।
एक बाइट को बचाया। को गोल्फ b+=S[i+k]!=S[i-n+k]दी b|=S[i+k]-S[i-n+k]।
बची हुई ग्यारह बाइट्स। l=strlen(S)स्ट्रिंग के अंत (एक नल बाइट '\0') तक पहुंचने पर तोड़ने के लिए दोनों स्ट्रिंग हैंडलिंग लूप कंडीशनिंग द्वारा की आवश्यकता को हटा दिया ।
दो बाइट्स बचाए। को गोल्फ i-n+k>~0दी i-n>~k।
छत के लिए धन्यवाद तीन बाइट्स सहेजा गया ; b||printf("|"),n++के बराबर है n+=b||printf("|")।

i,b,k,n;f(char*S){for(i=~0;S[++i];)for(b=n=1;b;n+=b||printf("%d,",n))for(b=k=0;k<n&&S[i+k];k++)b|=n-i>k?0:S[i+k]-S[i-n+k];}

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

— जोनाथन फ्रेच
स्रोत

आप कोष्ठक को हटाकर और b||printf("%d,",n)लूप के अंदर रखकर 2 बाइट्स बचा सकते हैं :

i,b,k,n,l;f(char*S){for(l=strlen(S),i=-1;++i<l;)for(b=n=1;b;b||printf("%d,",n),n++)for(b=k=0;k<n;k++)i+k<l&i-n+k>=0&&(b+=S[i+k]!=S[i-n+k]);}

140 बाइट्स

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

@ केविनक्रूजसेन धन्यवाद।

— जोनाथन फ्रीच

@ceilingcat धन्यवाद; स्वच्छ तुल्यता, वह एक।

— जोनाथन फ्रीच

0

पायथन 2 , 115 बाइट्स

lambda s:[min(j+1for j in R(len(s))if all(s[k+~j]==s[k]for k in R(i,i-~j)if len(s)>k>j))for i in R(len(s))]
R=range

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

— चास ब्राउन
स्रोत

तार की स्थानीय अवधि

स्थानीय काल

काम

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

रेटिना , 89 86 बाइट्स

जावा 8, 167 154 152 बाइट्स

जावास्क्रिप्ट (ईएस 6), 84 बाइट्स

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

रूबी , 104 102 बाइट्स

जाप , 33 32 बाइट्स

व्याख्या

C (gcc) , 143 142 140 139 128 126 123 बाइट्स

पायथन 2 , 115 बाइट्स