शीर्षक में आसन्न अक्षर किसके हैं? [३, ४]!

Question

_{शीर्षक उद्देश्य पर चूक गया। क्यों पता लगाने के लिए और पढ़ें।}

आपका कार्य: पात्रों सहित एक सीमांकित स्ट्रिंग या सूची दी गई है A,B,C,D, सभी आसन्न समान वर्णों के अनुक्रमित को आउटपुट करें। आउटपुट कई लाइनों, एक सूची / सरणी या एक सीमांकित स्ट्रिंग पर कई तार / पूर्णांक हो सकते हैं।

सभी आउटपुट एक सूची या स्ट्रिंग, या कई मुद्रित लाइनों में होना चाहिए। प्रत्येक मुद्रित लाइन, यदि कई हैं, तो केवल 1 स्ट्रिंग या संख्या होनी चाहिए। अनुगामी क्या ठीक है।

इनपुट / आउटपुट के मानक तरीके। मानक खामियां लागू होती हैं।

उदाहरण के लिए, इनपुट 'ABCDDCBA'को आउटपुट होना चाहिए 3,4या 4,5, यह निर्भर करता है कि यह 0- से 1- अनुक्रमित है, क्योंकि वे संख्या इसके Dऔर इसके Dआगे के सूचकांक हैं ।

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

टेस्ट मामलों में एकल स्ट्रिंग के रूप में इनपुट दिया जाता है, और आउटपुट ,-delimited स्ट्रिंग के रूप में। आउटपुट 0-अनुक्रमित हैं, इसे 1-अनुक्रमित करने के लिए प्रत्येक आउटपुट आइटम में 1 जोड़ें।

Input: 'ABCDCABCD'
Output: ''

Input: 'AABBCCDD'
Output: '0,1,2,3,4,5,6,7'

Input: 'ABCDDDCBA'
Output: '3,4,5'

Input: 'ABBCDD'
Output: '1,2,4,5'

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है!

Comments

हम उत्पादन में एक अनुगामी सीमांकक हो सकता है?

— बिजनेस कैट

@ बेसिकसुंट ज़रूर

— कॉमरेड स्पार्कलपोनी

@JonathanAllan यह ठीक है क्योंकि यह केवल एक सूची को आउटपुट करता है।

— कॉमरेड स्पार्कलपनी

क्या लगातार पात्रों के सूचकांक कई बार दिखाई दे सकते हैं? उदाहरण के लिए तीसरे परीक्षण के मामले में भी 3,4,4,5मान्य है?

— ल्यूक

क्या आप एक परीक्षण मामला जोड़ सकते हैं जिसमें सममित मैच नहीं हैं? जैसेAABBCD -> 1,2,3,4

— रिले

Answer 1

MATL , 8 7 बाइट्स

d~ftQvu

आउटपुट 1-आधारित है।

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

उदाहरण सहित व्याख्या

इनपुट पर विचार करें 'ABCDDDCBA'।

d     % Implicitly input a string. Consecutive differences
      % STACK: [1  1  1  0  0 -1 -1 -1]
~     % Negate. Each character that equals the next gives true
      % STACK: [0 0 0 1 1 0 0 0]
f     % Find: (1-based) indices of true elements
      % STACK: [4 5]
tQ    % Duplicate, add 1 element-wise
      % STACK: [4 5], [5 6]
v     % Concatenate vertically
      % STACK: [4 5; 5 6]
u     % Unique (remove duplicates). This doesn't automatically sort, but the 
      % output will be sorted because the input, read in column-major order, is 
      % Implicitly display
      % STACK: [4; 5; 6]

Answer 2

रेटिना , 33 29 23 बाइट्स

मार्टिन एंडर की बदौलत 6 बाइट्स बचाए

T`L`:`(.)\1+
:
$.`¶
T`L

सूचकांकों की एक लाइनफीड-पृथक सूची आउटपुट करता है।

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

व्याख्या

T`L`:`(.)\1+

कॉलोनी में एक ही चरित्र के ट्रांसपेरेंट रन, पदों को चिह्नित करने के लिए जहां डुप्लिकेट अक्षर हैं।

:
$.`¶

फिर प्रत्येक बृहदान्त्र को पाठ की लंबाई के साथ बदलें, उसके बाद एक लाइनफीड।

T`L

अंत में, किसी भी शेष पत्र को हटा दें।

Answer 3

जेली , 7 बाइट्स

JṁŒgḊÐf

1 के आधार पर; ओपी द्वारा अनुमति के अनुसार इंडेक्स के रनों की सूची की सूची देता है।

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

कैसे?

JṁŒgḊÐf - Main link: char-list s       e.g. 'DCCABBBACCCD' (which is a python interpreted input of ['D','C','C','A','B','B','B','A','C','C','C','D'])
J       - range(length(s))                  [1,2,3,4,5,6,7,8,9,10,11,12]
  Œg    - group-runs(s)                     [['D'],['C','C'],['A'],['B','B','B'],['A'],['C','C','C'],['D']]
 ṁ      - mould left like right             [[1],[2,3],[4],[5,6,7],[8],[9,10,11],[12]]
     Ðf - filter keep items that would be truthy (empty is not truthy) after applying:
    Ḋ   -     dequeue (x[1:])               [    [2,3],    [5,6,7],    [9,10,11]     ]        

Comments

ṁ- चीजें जो मैं चाहता हूं कि 05AB1E 500 के लिए कर सकता है, कृपया।

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

मुझे अधिक से अधिक लगता है कि यह भाषा यहाँ की तरह धोखा देने वाली है। : डी

— अवामंदर

@ComradeSparklePony स्वीकार चेक के पूर्ववत क्यों?

— जोनाथन एलन

Answer 4

ब्रेन-फ्लैक , 57 46 बाइट्स

{({}[({})]<(([]<>)[()])>){(<{}{}{}>)}{}<>}<>

के लिए +2 शामिल है -ar

0-आधारित अनुक्रमण का उपयोग करता है।

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

# While true
{

  # Subtract the second value on the stack from the first
  ({}[({})]

  # Push the height of this stack (the main stack) on the other stack
  <(([]<>)

  # Push the height of the main stack - 1
  [()])>

  # Push the difference that we calculated a second ago
  )

  # If they weren't the same character
  {

    # Pop the difference and the two stack heights
    (<{}{}{}>)

  # End if
  }

  # Pop the difference (or the 0 to get out of the if)
  {}

# Switch back to the main stack and end while
<>}

# Switch to the stack with the indexes and implicitly print
<>

Answer 5

गणितज्ञ, 32 बाइट्स

Union@@StringPosition[#,x_~~x_]&

शुद्ध कार्य जो एक समरूप वर्ण से सटे वर्णों के 1-अनुक्रमित पदों को लौटाता है।

स्पष्टीकरण:

StringPosition["string","sub"]शुरू करने और समाप्त होने वाले चरित्र पदों की एक सूची देता है जिस पर "sub"एक विकल्प के रूप में प्रकट होता है "string"। x_~~x_एक है StringExpressionजो दो आसन्न, समान वर्णों से मेल खाता है। उदाहरण के लिए, StringPosition["ABCDDDCBA",x_~~x_]देता है {{4, 5}, {5, 6}}। को लागू करने Unionमें शामिल सूचियों, प्रकार, और हटाए गए डुप्लिकेट।

Answer 6

ब्रेन-फ्लैक , 69, 59 , 56 बाइट्स

{({}[({})]<(())>){((<{}{}>))}{}{([{}]([]<>))(<>)}{}}<>

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

-arझंडे के लिए +2 बाइट्स जो ASCII इनपुट को सक्षम करता है और स्टैक को उलट देता है।

0-आधारित अनुक्रमण का उपयोग करता है। मेरे पुश-पॉप अतिरेक को कम करके 10 बाइट्स बचाए । 1 से 0-आधारित अनुक्रमण से स्विच करके एक और 4 बाइट्स सहेजे गए।

यह बहुत ही एकमात्र स्ट्रिंग आधारित चुनौती है जो ब्रेन-फ्लैक पर अच्छी है। ऐसा इसलिए है क्योंकि ब्रेन-फ्लैक लगातार वर्णों की तुलना में महान है, भले ही यह सामान्य रूप से स्ट्रिंग प्रसंस्करण में भयावह है। यह कैसे काम करता है यह समझाने के लिए टिप्पणियों के साथ कोड का पठनीय संस्करण है:

#While True
{

    #Determine if top two are equal
    ({}[({})]<(())>){((<{}{}>))}{}

    #If so
    {

        #Pop the one, and negate it's value (giving us -1)
        ([{}]

        #Push stack height over
        ([]<>)

        #Then push stack height plus the negated pop (-1)
        ) 

        #Push a zero back onto the main stack
        (<>)

    #Endwhile
    }

    #Pop the zero
    {}

#Endwhile
}

#Toggle back, implicitly display
<>

Comments

थोड़ी अनुकूल प्रतियोगिता :)

— रिले

@ रिले तय! (और अभी भी एक बाइट कम: पी)

— डीजेएमकेम

मैं हमेशा भूल जाता हूं -r। यह मुझे 46 तक ले जाता है।

— रिले

Answer 7

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

l⟦k:?z{sĊtᵐ=∧Ċ∋h}ᶠd

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

व्याख्या

ब्रेकीलॉग आमतौर पर अनुक्रमित के साथ भयानक होता है, जो फिर से यहां दिखाता है।

तो false.ऐसे मामलों में जहां कोई आसन्न वर्ण देखते हैं में एक स्वीकार्य उत्पादन होता है, तो यह जगह से 1 बाइट कम होगा ᶠdद्वारा ᵘ।

l⟦k                      The list [0, …, length(Input) - 1]
   :?z                   Zip the Input with this list
      {         }ᶠd      Find with no duplicates:
            ∧Ċ∋h           The heads of each element of Ċ = [A, B] (i.e. the indexes)…
        Ċtᵐ=               …where the tails of both A and B are equal (i.e. the letters)…
       sĊ                  …and where Ċ = [A, B] is a substring of the Input

Answer 8

ऑक्टेव , 35 बाइट्स

@(s)unique([x=find(~diff(+s)),x+1])

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

मेरे MATL उत्तर के समान । यहाँ uniqueस्वचालित रूप से। इनपुट को diffपरिवर्तित करना होगा double, जो कि यूनेरी द्वारा किया गया है +।

Answer 9

क्यूबिक्स, 37 32 31 29 28 बाइट्स

तीन-बाइट बचत की दिशा में मुझे इंगित करने के लिए ETHProductions का धन्यवाद

$uO@(;Usoi?-!w>;.....S_o\;#O

यहाँ कोशिश करो ! ध्यान दें कि आउटपुट इंडेक्स 1-आधारित हैं और आरोही क्रम में नहीं।

विस्तारित:

      $ u O
      @ ) ;
      U s o
i ? - ! w > ; . . . . .
S _ o \ ; # O . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

व्याख्या

यह चरित्र द्वारा इनपुट चरित्र को पढ़कर काम करता है। दो वर्णों की तुलना करने के लिए, हम उनके वर्ण कोड को घटाते हैं, और यदि परिणाम 0 है, तो हम स्टैक की वर्तमान लंबाई, एक स्थान, स्टैक की वर्तमान लंबाई - 1 और एक अन्य स्थान प्रिंट करते हैं। फिर हम स्टैक को थोड़ा साफ करते हैं, और हम फिर से लूप के साथ शुरू करते हैं। यदि इनपुट स्ट्रिंग का अंत हो जाता है, तो प्रोग्राम बंद हो जाता है।

Comments

हम्म, यदि आप स्टैक को काफी साफ रख सकते हैं, तो #आप ज़रूरत पड़ने पर स्टैक की लंबाई प्राप्त करने के लिए उपयोग करने में सक्षम हो सकते हैं । (इसके अलावा, ;_;कोड में LOL'ed ;))

— ETHproductions

एक बुनियादी उदाहरण (शायद पूरी तरह से गोल्फ नहीं); ethproductions.github.io/cubix/… (नोट: यह 1-अनुक्रमित है, 0-अनुक्रमित नहीं है)

— ETHproductions

याद दिलाने के लिए शुक्रिया। मैंने आपके संस्करण के एक बाइट को गोल किया और कहा कि जोड़ा। मैं एक बाइट या दो बंद पाने में सक्षम हो सकता है ...

— ल्यूक

विचार: यदि आपने इसके !$wबजाय !wपाँचवीं पंक्ति के तर्क को चौथी पंक्ति में स्थानांतरित कर दिया तो क्या होगा ? (अभी कोशिश नहीं कर सकता क्योंकि मैं दरवाजे से बाहर जा रहा हूं)

— ETHproductions

मैंने यह भी सोचा था, लेकिन मुझे नहीं लगता कि यह कई बाइट्स बचाएगा। मैं हालांकि यह कोशिश करेंगे।

— ल्यूक

Answer 10

सी, 75 बाइट्स

i;f(char*s){for(i=0;*s;++s,++i)if(s[1]==*s|(i&&s[-1]==*s))printf("%d ",i);}

सीमांकक के रूप में रिक्त स्थान का उपयोग करता है। (एक अनुगामी अल्पविराम बहुत अच्छा नहीं लगता है।)

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

Answer 11

सी # , 115 बाइट्स

---

golfed

i=>{var o="";for(int x=1,l=i.Length;x<=l;x++)o+=(x<l&&i[x]==i[x-1])||(x>1&&i[x-1]==i[x-2])?(x-1)+" ":"";return o;};

---

Ungolfed

i => {
   var o = "";

   for( int x = 1, l = i.Length; x <= l; x++ )
      o += ( x < l && i[ x ] == i[ x - 1 ] ) || ( x > 1 && i[ x - 1 ] == i[ x - 2 ] )
         ? ( x - 1 ) + " "
         : "";

   return o;
};

---

अनपढ़ पठनीय

i => {
   // List of positions
   var o = "";

   // Cycle through the string
   for( int x = 1, l = i.Length; x <= l; x++ )
      // Check if 'x' is below the string length
      //    and if the current and previous char are the same...
      //    ... or if 'x' is beyong the string length
      //    and the 2 previous chars are the same.
      o += ( x < l && i[ x ] == i[ x - 1 ] ) || ( x > 1 && i[ x - 1 ] == i[ x - 2 ] )

         // If true, add the index to the list of positions...
         ? ( x - 1 ) + " "

         // ...otherwise add nothing
         : "";

   // Return the list of positions.
   return o;
};

---

पूर्ण कोड

using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, String> f = i => {
            // List of positions
            var o = "";

            // Cycle through the string
            for( int x = 1, l = i.Length; x <= l; x++ )
               // Check if 'x' is below the string length
               //    and if the current and previous char are the same...
               //    ... or if 'x' is beyong the string length
               //    and the 2 previous chars are the same.
               o += ( x < l && i[ x ] == i[ x - 1 ] ) || ( x > 1 && i[ x - 1 ] == i[ x - 2 ] )

                  // If true, add the index to the list of positions...
                  ? ( x - 1 ) + " "

                  // ...otherwise add nothing
                  : "";

            // Return the list of positions.
            return o;
         };

         List<String>
            testCases = new List<String>() {
               "ABCDCABCD",
               "AABBCCDD",
               "ABCDDDCBA",
               "",
               "A",
               "AA",
               "AAA",
         };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $"{testCase}\n{f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

---

विज्ञप्ति

• v1.0 - 115 bytes- प्रारंभिक समाधान।

---

टिप्पणियाँ

कुछ भी जोड़ने के लिए नहीं है

Answer 12

जेली , 8 बाइट्स

=2\T’œ|$

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

Comments

हम्म, बिल्कुल वही एल्गोरिथ्म मैंने कोशिश की, हालांकि मेरा थोड़ा लंबा था:Ṗ=ḊTµ2Ḷ+€

— ETHproductions

Answer 13

k, 18 बाइट्स

{?,/-1 0+/:&:=':x}

उदाहरण:

k){?,/-1 0+/:&:=':x}"AABCDDDCBAA"
0 1 4 5 6 9 10
k){?,/-1 0+/:&:=':x}"ABCDCBA"
()

qसमझने के लिए अनुवाद करना आसान है:

{distinct raze -1 0+/:where not differ x}

Comments

यह मेरा प्रारंभिक समाधान भी था! : D

— zgrep

Answer 14

जावास्क्रिप्ट, 52 बाइट्स

1 बाइट को बंद करने के लिए धन्यवाद @ नील

x=>x.map((a,i)=>a==x[++i-2]|a==x[i]&&i).filter(a=>a)

वर्णों के 0-अनुक्रमित सरणी के रूप में इनपुट प्राप्त करता है 1-अनुक्रमित सरणी के
रूप में आउटपुट देता है

व्याख्या

x.map()

स्ट्रिंग में प्रत्येक वर्ण के लिए

(a,i)=>(a==x[++i-2]|a==x[i])*i

यदि यह पिछले वर्ण या अगले वर्ण के बराबर है, तो इंडेक्स + 1 वापस करें अन्यथा वापस नहीं लौटें (सरणी में अपरिभाषित छोड़ें)

.filter(a=>a)

परिणामी सरणी से सभी अपरिभाषित तत्वों को हटा दें

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

Comments

चाहेंगे &&iपर एक बाइट को बचाने (...)*i?

— नील

@ नील && की तुलना में तेज़ है |, जिसके परिणामस्वरूप यह हमेशा वापस आ जाएगा

— fɛnɛtɪk

0|0&&6है ०, 1|0&&6६ है, ६ है, 0|1&&6६ 1|1&&6है। ६ यह नहीं है कि आप क्या चाहते हैं?

— नील

मुझे लगता है कि मैं सोच रहा था मैं अभी भी था || के बजाय |

— f --n 21tɪk

आह हाँ, यह समझाएगा।

— नील

Answer 15

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

m=j=0
for i in input():
 if m==i:print~-j,j,
 j+=1;m=i

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

रिक्त स्थान द्वारा अलग किए गए आउटपुट सूचकांकों (ध्यान दें कि यह कुछ सूचकांकों को ओपी द्वारा अनुमति के अनुसार दो बार प्रदर्शित करता है)

Answer 16

पर्ल 5 , 37 बाइट्स

कोड + plझंडे के 35 बाइट्स ।

s/(?<=(.))\1|(.)(?=\2)/print pos/ge

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

(?<=(.))\1|(.)(?=\2)दो दोहराए गए वर्णों ( (?<=(.))\1) के बीच या फिर दोहराए जाने वाले वर्ण से पहले मेल खाएगा ( (.)(?=\2))।
फिर, print posमैच की स्थिति को प्रिंट करता है। ( संशोधक के posसाथ रेगेक्स में उपयोग किए जाने पर वर्तमान मैच का सूचकांक शामिल है /g)।

Answer 17

पर्ल 6 ,  66  57 बाइट्स

*.comb.rotor(2=>-1).kv.flatmap({($^a,$a+1)xx[eq] $^b[0,1]}).squish

कोशिश करो

{m:ex/[(.)<($0|(.))>$0]{make $/.from}/».ast.sort.squish}

कोशिश करो

Answer 18

PHP, 100 बाइट्स

for(;$i<strlen($s=$argn);$i++)$s[$i]==$s[$i+1]||$s[$i]==$s[$i-1]&&$i?$r[$i]=+$i:0;echo join(",",$r);

Answer 19

रूबी , 51 + 1 = 52 बाइट्स

-nझंडे का उपयोग करता है ।

i=0;d=[];gsub(/./){$&==$_[i+=1]?d+=[i-1,i]:0};p d&d

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

Answer 20

बैच, 139 बाइट्स

@set/ps=
@set/ai=c=0
:l
@if %s:~,1%==%s:~1,1% set c=2
@if %c% gtr 0 echo %i%
@set/ai+=1,c-=1
@if not "%s:~1%"=="" set s=%s:~1%&goto l

STDIN पर इनपुट लेता है। cचर में प्रिंट करने के लिए कितने नंबर का ट्रैक रखते हुए काम करता है , जो एक जोड़ी का पता चलने पर 2 पर रीसेट हो जाता है। नोट: 6 बाइट्स की लागत पर, अधिकांश ASCII वर्णों के साथ काम करने के लिए कठोर किया जा सकता है और न केवल ABCD।

Answer 21

सी #, 89 बाइट्स

using System.Linq;s=>string.Join("",s.Skip(1).Select((a,i)=>a==s[i]?i+" "+(i+1)+" ":""));

यदि एक पंक्ति में तीन या अधिक वर्ण हैं, तो अनुक्रमित दोहराए जाते हैं। जो @ कॉम्रेड स्पार्कलपनी ने टिप्पणियों में अनुमति दी।

पूरा कार्यक्रम:

using System;
using System.Collections.Generic;
using System.Linq;

namespace Namespace
{
    class Class1
    {
        static void Main(string[] args)
        {
            Func<string, string> f2 =
                s => string.Join("" ,         //Combine the results into one string
                s.Skip(1)                     //Start with the second element
                .Select(
                    (a, i) =>                 // 'a' is the current element, 'i' is the index of the element in the result of 'Skip'
                    a == s[i] ?               // therefore 's[i]' is the previous element; compare it with the current one
                    i + " " + (i + 1) + " " : //If true, return the indexes
                    ""                        //Otherwise an empty string
                ));

            var tests = new string [] {
               "ABCDCABCD",
               "AABBCCDD",
               "ABCDDDCBA",
               "ABBCDD"
            };

            foreach (var test in tests)
            {
                Console.WriteLine(test);
                Console.WriteLine(string.Join("", f2(test)));
                Console.WriteLine();
            }

            Console.ReadLine();
        }
    }
}

Answer 22

QBIC , 42 बाइट्स

;[2,_lA||~mid$(A,a-1,1)=mid$(A,a,1)|?a-1,a

नमूना उत्पादन:

Command line: AADCDBBD
 1             2 
 6             7 

स्पष्टीकरण:

;               Get A$ from the cmd line
[2,    |        FOR a% = 2 TO
   _lA|              the length of A$
~mid$(A,a-1,1)  IF the character at index a%
=mid$(A,a,1)    equals the char at index a%-1
|               THEN
?a-1,a          PRINT both indexes, tab-separated
                Any further doubles are printed on a separate line
                The IF and FOR are closed implicitly

---

संपादित करें: QBIC अब सबस्ट्रिंग है! इस चुनौती को अब 32 बाइट्स में हल किया जा सकता है:

;[2,_lA||~_sA,a-1|=_sA,a||?a-1,a

कहा पे:

_s      This is the substring function; it takes 1, 2 or 3 arguments. 
        Arguments are comma-seperated, the list is delimited with |
        In this answer we see Substring take 2 arguments:
  A,    The string to take from
    a|  Starting position (note:uppercase represents strings, lowercase is for nums)
        Any omitted argument (in this case 'length to take') is set to 1.

Answer 23

k, 14 बाइट्स

यह एक फ़ंक्शन है, यह एक स्ट्रिंग में लेता है, और सूचकांकों की एक सूची देता है।

&{x|1_x,0}@=':

स्पष्टीकरण:

           =': /compare each letter to the previous, return binary list
 {       }@    
    1_x,0      /shift left
  x|           /combine shifted and unshifted with binary or
&              /get indices of 1s

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

कैसे इस्तेमाल करे:

&{x|1_x,0}@=':"STRINGGOESHERE"

Answer 24

PHP, 70 बाइट्स

for(;a&$c=$argn[$i];)$i++&&$argn[$i-2]==$c||$argn[$i]==$c?print$i._:0;

STDIN से इनपुट लेता है; साथ चलाना -R।