हैस्टैक में सुई का पता लगाएं

38

कम से कम 2x2 के आकार के एक आयताकार हिस्टैक को देखते हुए सभी समान मुद्रण योग्य ASCII वर्णों से बना है, सुई के स्थान (शीर्ष-बाएं से गिनती) का उत्पादन करता है जो एक अलग चरित्र है।

उदाहरण के लिए, यदि निम्नलिखित बाधा इनपुट है:

#####
###N#
#####
#####

उत्पादन 3,1तब होना चाहिए जब शून्य-अनुक्रमित (मैं इस चुनौती में क्या उपयोग करूंगा) या 4,2जब एक-अनुक्रमित हो।

हिस्टैक किसी भी मुद्रण योग्य ASCII वर्ण से बना हो सकता है:

^^^
^^^
^N^
^^^
^^^
^^^

उत्पादन: 1,2

और सुई कोई अन्य मुद्रण योग्य ASCII वर्ण होगा:

jjjjjj
j@jjjj
jjjjjj

उत्पादन 1,1

कोने में सुई होना भी संभव है:

Z8
88

उत्पादन 0,0

88
8Z

उत्पादन 1,1

या किनारे पर सुई रखना:

>>>>>>>>>>
>>>>>>>>>:
>>>>>>>>>>

उत्पादन 9,1

नियम और स्पष्टीकरण

  • इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है । इसका मतलब है कि आप इनपुट की सूची की सूची के रूप में इनपुट ले सकते हैं, एक स्ट्रिंग के रूप में, आदि।
  • आप परिणाम को STDOUT में प्रिंट कर सकते हैं या इसे फ़ंक्शन परिणाम के रूप में वापस कर सकते हैं। कृपया अपने सबमिशन में बताएं कि आउटपुट किस क्रम में है (जैसे, क्षैतिज, फिर लंबवत, जैसा कि चुनौती में उपयोग किया जाता है, या इसके विपरीत)।
  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं।
  • आपको कौन-कौन से वर्णों का उपयोग करने के लिए नहीं मिलता है। यही चुनौती है।
  • घास का मैदान आकार में कम से कम 2x2 होने की गारंटी है, इसलिए यह अस्पष्ट है जो सुई है और जो घास है।
  • इनपुट में केवल एक सुई है, और यह आकार में केवल एक ही वर्ण है।
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।
code-golf  string 
— AdmBorkBork
स्रोत
सुझाया गया परीक्षण मामला: 88\n8Z(पाठ्यक्रम के किसी भी दो वर्णों के साथ)।
— केविन क्रूज़सेन
क्या हम इनपुट को बहुआयामी सरणी के रूप में ले सकते हैं? मैं en','#'], ['#' , '#', '#', '#', '#'], ['#', '#', '#', '#', '#']];
— 640KB
2
@gwaugh पात्रों की सूची की तरह? हां, यह ठीक है (और स्पष्ट रूप से इसे ओके कहा जाता है)।
— AdmBorkBork
3
क्या हम नए सिरे के बिना स्ट्रिंग की एक जोड़ी के रूप में इनपुट ले सकते हैं और हाईस्टैक की चौड़ाई (या ऊंचाई)? अर्थात("########N###########", 5)
— मेरा सर्वनाम
3
@someone हाँ, हालाँकि इसमें वास्तविक कोरम नहीं है , मुझे लगता है कि इसकी अनुमति दी जानी चाहिए।
— AdmBorkBork

जवाबों:

17

आर , 49 47 44 बाइट्स

function(m,`?`=which)m==names(?table(m)<2)?T

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

मैट्रिक्स के रूप में इनपुट लेता है, 1-अनुक्रमित निर्देशांक लौटाता है

— किरिल एल।
स्रोत
4
यह whichकार्य घृणित रूप से सहज है।
— आपराधिक रूप से
4
आर में इस चुनौती की कोशिश करने के लिए मैं बहुत उत्साहित था, फिर मैंने इसे देखा और इसके बदले विस्मय में रोने का फैसला किया
— सुमेर १41
9

पर्ल 6 ,४१ ३ 38 37 बाइट्स

3 बाइट्स ने @nwellnhof को धन्यवाद दिया।

1 बाइट ने जो किंग को धन्यवाद दिया।

{map {[+] ^∞Z*!<<.&[Z~~]},$_,.&[Z]}

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

व्याख्या

यह इनपुट को पात्रों की सूचियों की सूची के रूप में लेता है और लंबाई 2 की सूची देता है जिसमें सुई के शून्य-आधारित एक्स और वाई निर्देशांक होते हैं।

यह ब्लॉक {[+] ^∞ Z* !<<.&[Z~~]}को इनपुट पर और इसके स्थानान्तरण पर लागू करके काम करता है । .&[Z~~]तर्क के सभी स्तंभों के माध्यम से जाता है और Trueयदि सभी तत्व समान हैं, तो रिटर्न False। फिर हम सभी मानों को नकारते हैं (इसलिए हमारे पास एक कॉलम प्रति एक बूल के साथ एक सूची है, जहां बूल इस सवाल का जवाब देता है "क्या उस कॉलम में सुई है?"), उन्हें एक अनुक्रम 0,1,2 के साथ तत्व-वार गुणा करें। .. ( True = 1और False = 0) और सूची का योग, इसलिए पूरे ब्लॉक का परिणाम उस कॉलम का 0-आधारित नंबर है जहां सुई पाई गई थी।

नेलनहोफ का बेहतर दृष्टिकोण, पर्ल 6 , 34 बाइट्स

{map *.first(:k,*.Set>1),.&[Z],$_}

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

व्याख्या

आम तौर पर एक ही दृष्टिकोण, बस अधिक प्रभावी। यह अभी भी एरे और उसके ट्रांसपोज़ पर एक ब्लॉक का उपयोग करता है, लेकिन अब ब्लॉक सभी पंक्तियों को Setsतत्वों की संख्या के लिए जाँचता है। firstसमारोह तो सूचकांक (के कारण देता है :kपहली पंक्ति है कि अधिक से अधिक 1 तत्व निहित)। इस कारण से, के आदेश $_और .&[Z]जरूरत बदली किया जाना है।

— Ramillies
स्रोत
अच्छा तरीका! 34 बाइट्स के साथ first(:k), Setऔर .&[Z]।
— nwellnhof
@nwellnhof, बहुत अच्छा किया। आपने मूल रूप से वही पाया जो मैं खोजना चाहता था लेकिन ऐसा करने में असफल रहा: (इसके अलावा मुझे कोई अंदाजा नहीं था कि आप लिख सकते हैं .&[Z]।)
— रामलीज
सामान्य तौर पर, .&[op]यह समतुल्य नहीं लगता है , [op] $_लेकिन यह Zकिसी कारण से काम करता है।
— nwellnhof
@ जोकिंग, धन्यवाद!
— रामलीलाज
9

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

lambda m:[map(len,map(set,a)).index(2)for a in zip(*m),m]

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

पायथन 3 के लिए इसका एक बंदरगाह 62 बाइट्स हो सकता है :

lambda m:[[len(set(v))for v in a].index(2)for a in(zip(*m),m)]

सूची बोध, [len(set(v))for v in a]दो बाइट्स के दोहरे मानचित्र से कम है, क्योंकि इसे जैसी सूची में डालने की आवश्यकता होगीlist(map(len,map(set,a)))

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

— जोनाथन एलन
स्रोत
6

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

c≡ᵍ∋Ȯ&;I∋₎;J∋₎gȮ∧I;J

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

आउटपुट [I,J], जहां Iपंक्ति सूचकांक और Jस्तंभ सूचकांक है, दोनों 0-अनुक्रमित हैं।

मूर्खतापूर्ण लंबे समय तक, लेकिन ब्रेकीलॉग में अनुक्रमणिका प्राप्त करना आमतौर पर बहुत क्रिया है।

व्याख्या

c                       Concatenate the Input into a single string
 ≡ᵍ                     Group identical characters together
   ∋Ȯ                   Ȯ is a list of One element, which is the needle character
     &;I∋₎              Take the Ith row of the Input
          ;J∋₎          Take the Jth character of the Ith row
              gȮ        That character, when wrapped in a list, is Ȯ
                ∧I;J    The output is the list [I,J]
— Fatalize
स्रोत
6

PHP ,99 85 बाइट्स

('########N###########', 5इनपुट के रूप में न्यूलाइन्स और चौड़ाई (या ऊंचाई) के बिना स्ट्रिंग का उपयोग करना ।

  • -5 बाइट्स chr () कॉल को हटाकर, @Titus को सहारा देता है
  • दो फ़ंक्शन आर्ग के रूप में इनपुट लेने से -9 बाइट्स, @ प्रोटिट्स के लिए भी सहारा लेती हैं
function($a,$l){return[($p=strpos($a,array_flip(count_chars($a,1))[1]))%$l,$p/$l|0];}

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

Ungolfed:

function need_hay( $a, $l ) {

    // identify the "needle" by counting the chars and 
    // looking for the char with exactly 1 occurrence
    // note: this is 1 byte shorter than using array_search()
    $n = array_flip( count_chars( $a, 1 ) )[1];

    // find the location in the input string
    $p = strpos( $a, $n );

    // row is location divided by row length, rounded down
    $r = floor( $p / $l );

    // column is remainder of location divided by row length
    $c = $p % $l;

    return array( $c, $r );

}

आउटपुट:

#####
###N#
#####
#####
[3,1]

^^^
^^^
^N^
^^^
^^^
^^^
[1,2]

jjjjjj
j@jjjj
jjjjjj
[1,1]
— 640KB
स्रोत
1
1) इसके लिए कोई आवश्यकता नहीं है chr: यदि स्ट्रैप के लिए दूसरा पैरामीटर एक पूर्णांक है, तो इसे एएससीआईआई कोड के रूप में व्याख्या किया जाएगा। -> -5 बाइट्स। 2) दो फ़ंक्शन पैरामीटर $s,$wएक और 9 बाइट्स बचा सकते हैं।
— टाइटस
@ तित्स, chr को हटाकर () जो शानदार है। धन्यवाद! फंक पारम्स मेरे साथ भी हुए, मैं सिर्फ इनपुट रीक का उल्लू नहीं चलाना चाहता था। मैं डब्ल्यू / ओपी को स्पष्ट करूंगा।
— 640KB
5

05AB1E , 9 6 बाइट्स

सहेजे गए 3 बाइट्स स्विचिंग इनपुट प्रारूप।

इनपुट को एक स्ट्रिंग और एक पंक्ति-लंबाई के रूप में लिया जाता है।
आउटपुट फॉर्म की एक शून्य-आधारित सूची है[y, x]

D.mks‰

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

D           # duplicate the input string
 .m         # get the least frequent character
   k        # get its index in the string
    s       # swap the row length to the top of the stack
     ‰      # divmod the index of the least frequent char with the row length
— Emigna
स्रोत
डांग, तुम मुझे इसके लिए हरा दो। एक उत्तर पर काम कर रहा था। अभी-अभी एक 13 बटर खत्म हुआ था। लेकिन आपका तरीका बेहतर है, इसलिए इसके बजाय +1 करें। :) पूरी तरह से भूल गया .m..
— केविन क्रूज़सेन
@ केविनक्रूजसेन: हाँ। मुझे नहीं लगता कि मैंने पहले कभी इस्तेमाल किया है .m, लेकिन मुझे यकीन है कि मैंने इसे किसी बिंदु पर देखा था :)
— Emigna
5

पायथन 3 + न्यूमपी , 75 66 बाइट्स

-9 बाइट्स @ ASCII- केवल के लिए धन्यवाद

lambda x:where(x.view('i')-median(x.view('i')))
from numpy import*

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

यह मानता है कि इनपुट एक NumPy सरणी है। उत्पादन शून्य-अनुक्रमित है, और पहले ऊर्ध्वाधर, फिर क्षैतिज है।

यह इनपुट charको intतब से धर्मान्तरित करता है , जो सरणी के माध्य की गणना करता है, जो कि हैस्टैक वर्ण होगा। हम उस सरणी से घटाते हैं, जो सुई को केवल गैर-शून्य तत्व बनाता है। अंत में, उस तत्व के सूचकांक को वापस लौटाएं numpy.where()।

— hbaderts
स्रोत
1
चूँकि आप जानते हैं कि इनपुट ASCII होगा (यानी एक बाइट में फिट होता है) uint8एक बाइट के लिए कम क्यों नहीं ?
— ड्रेकोनिस
1
भाषा को यहां "पायथन 3 + सुन्न" होना है क्योंकि सुपीह को सामान्य अजगर वितरण के साथ शामिल नहीं किया गया है
— ASCII-only
@ ड्रैकॉन जो वास्तव में मेरी योजना थी, लेकिन सही ASCII- uint8कोड के बीच शून्य को पेश किया । मुझे लगता है यह है क्योंकि Python3 स्ट्रिंग्स के लिए मानक इनपुट प्रारूप के रूप में यूनिकोड का उपयोग करता है।
— 7
1
66
— एएससीआईआई-केवल
1
यह ठीक है, आखिरकार यह न केवल आपके समाधान पर आधारित है, बल्कि मैं आम तौर पर वैसे भी संख्यात्मक उपयोग नहीं करता हूं। इसके अलावा, यह थोड़े अपरिहार्य है कि एक समाधान वैसे भी बहुत समान हो सकता है, क्योंकि सभी समाधान सार्वजनिक हैं और यह एक अपेक्षाकृत आसान चुनौती है
— ASCII-only
4

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

आउटपुट [ऊंचाई, चौड़ाई] (1-अनुक्रमित)।

ŒĠLÐṂ

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

ŒĠLÐṂ – Monadic link / Full program. Takes a list of strings M as input.
ŒĠ    – Group the multidimensional indices by their values (treating M as a matrix).
  LÐṂ – And retrieve the shortest group of indices (those of the unique character).

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

ŒĠḊÐḟ

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

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

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

शायद यह श्री Xcoder के लिए एक टिप्पणी हो सकती है यह बहुत समान है ...

ŒĠEƇ

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

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

कैसे?

ŒĠEƇ - Link: matrix, M
ŒĠ   - multi-dimensional indices grouped by Value
     -  ...due to the 2*2 minimum size and one needle this will be a list of two lists one
     -     of which will have length one (the needle coordinates as a pair) and the other
     -     containing all other coordinates as pairs
   Ƈ - filter keeping those for which this is truthy:
  E  -   all equal?
     -   ... 1 for the list of length 1, 0 for the list of at least 3 non-equal coordinates
— जोनाथन एलन
स्रोत
1
खैर ... यह सीमा रेखा लगती है, चूंकि EƇचतुर है।
— एर्ग आउटफोलर
4

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

के रूप में इनपुट लेता है (रों)(w), कहा पे रों एक तार और है wमैट्रिक्स की चौड़ाई है। रिटर्न[एक्स,y]।

s=>w=>[(i=s.indexOf(/(.)\1+(.)/.exec(s+s)[2]))%w,i/w|0]

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

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

@Neil को 1 बाइट धन्यवाद दिया

वर्णों के मैट्रिक्स के रूप में इनपुट लेता है। रिटर्न[एक्स,y]।

m=>m.some((r,y)=>r.some((c,x)=>!m[p=[x,y],~y&1].includes(c)))&&p

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

कैसे?

हम पहले किरदार की तलाश करते हैं सी स्थित है (एक्स,y) जो दूसरी पंक्ति में कहीं दिखाई नहीं देता है आर[Y]। हम इस परीक्षण को किसी भी पंक्ति में, जब तक चाहें कर सकते हैंY≠y। क्योंकि इनपुट मैट्रिक्स कम से कम होने की गारंटी है2×2, हम बस का उपयोग कर सकते हैं Y=0 अगर y अजीब है या Y=1 अगर y सम है।

— Arnauld
स्रोत
1
~y&1एक बाइट बचाता है y&1^1।
— नील
4

जावा 8, 132 111 बाइट्स

m->{int c=m[0][0],i=0,j;for(c=m[1][0]!=c?m[1][1]:c;;i++)for(j=m[i].length;j-->0;)if(m[i][j]!=c)return i+","+j;}

-8 बाइट्स (और -13 अधिक अंतर्निहित) @ डाना के लिए धन्यवाद ।

चरित्र-मैट्रिक्स के रूप में इनपुट।

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

स्पष्टीकरण:

m->{                    // Method with char-matrix parameter and String return-type
  int c=m[0][0],        //  Character to check, starting at the one at position 0,0
      i=0,j;            //  Index integers
  for(c=m[1][0]!=c?     //  If the second character does not equal the first:
         m[1][1]        //   Use the character at position 1,1 instead
        :c;             //  Else: keep the character the same
      ;i++)             //  Loop `i` from 0 indefinitely upwards:
    for(j=m[i].length;j-->0;)
                        //   Inner loop `j` in the range (amount_of_columns, 0]:
      if(m[i][j]!=c)    //    If the `i,j`'th character doesn't equal our character to check:
        return i+","+j;}//     Return `i,j` as result
— Kevin Cruijssen
स्रोत
1
124 - the final return statement should never get hit. There might be a better way to keep the outer loop going?
— dana
@dana Thanks! As for: "There might be a better way to keep the outer loop going?", there certainly is; just removing it so it becomes an infinite loop. And then the return""; is unreachable and can be removed as well. :D So -21 bytes thanks to you.
— Kevin Cruijssen
Interesting... I had tried removing the outer loop condition and was getting an unreachable code error. Didn't know that removing the final return was the fix.
— dana
What exactly does the --> operator do in the inner loop? I was trying to find the java docs for that syntax but couldnt find anything
— KBusc
1
@KBusc It's two operators: i-- and >. :) See this SO answer for more info. So the i > 0 is executed first, checking if i is larger than 0. And then i is decreased by 1 with i--, before it enters the body of the loop.
— Kevin Cruijssen
3

MATL, 12 8 bytes

tX:XM-&f

Try it online!

Using the mode function as the majority-detector. Returns 1-based indices. 

 t           % duplicate the input
  X:         % turn the copy into a linear array
    XM       % find the arithmetic mode of that (the 'haystack' character)
      -      % Subtract that from the original input
       &f    % find the position of the non-zero value in that result

-4 characters thanks to @LuisMendo

— sundar - Reinstate Monica
स्रोत
1
@LuisMendo Thanks. I don't think I knew about the 2 output version of find, even in MATLAB. (Hi, btw!)
— sundar - Reinstate Monica
3

Wolfram Language 37 58 bytes

My earlier entry did not correctly handle the case where the "odd character out" was at the upper left corner of the matrix. This does.

#~Position~Keys[TakeSmallest[Counts@Flatten@#,1]][[1]]&

Counts@Flatten@# lists how many of each character are in the array, #.

TakeSmallest[...,1] returns the least frequent count, in the form of an association rule such as <| "Z"->1|>

Keys...[[1]]एसोसिएशन में एकमात्र आइटम के लिए "कुंजी" देता है, कम से कम इस्तेमाल किया चरित्र। (वर्तमान मामले में "जेड")

#~Position~...मूल मैट्रिक्स में कुंजी की स्थिति तब रिटर्न #।

— DavidC
स्रोत
3

पर्ल 5 -p00, 52 45 बाइट्स

/^(.)(\1*
)*(\1*)|^/;$_=$&=~y/
//.$".length$3

45 बाइट्स

52 बाइट्स

किस तरह

  • -p00 : पसंद -n लेकिन प्रिंट, पैरा मोड भी
  • /^(.)(\1* )*(\1*)|^/ : या तो मेल खाता है
    • प्रारंभ से $1: पहला वर्ण $2: पुनरावृत्ति (प्रयुक्त नहीं) $3,: पंक्ति में "सुई" से पहले वर्ण,$& पूरे मैच
    • या अशक्त स्ट्रिंग (स्थिति 0) कोई कब्जा नहीं।
  • $_= : डिफ़ॉल्ट इनपुट / तर्क चर असाइन करने के लिए
  • इसलिए $&=~y/ //की नई संख्या की संख्या$&
  • .$".: संगति $"(स्थान वर्ण डिफ़ॉल्ट रूप से) और संगति करें
  • length$3 : इसकी लंबाई $3
— नहुएल फौलीउल
स्रोत
3

आर 42 बाइट्स

function(m)which(ave(m,m,FUN=length)==1,T)

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

इनपुट: एक हाईस्टैक मैट्रिक्सm

आउटपुट: (row,col) वेक्टर - इंडेक्स की शुरुआत1

— निको
स्रोत
1
अच्छा काम है, और PPCG में आपका स्वागत है! मेरा मानना ​​है कि यह 42 बाइट्स हैं, क्योंकि f=बाइट काउंट से छोड़ा जा सकता है, लेकिन नहीं function(m)=।
— बीएलटी
@ बीएलटी मुझे उस बारे में निश्चित नहीं था, लेकिन सिर के लिए धन्यवाद :)
— niko
2

Python 2, 53 47 bytes

lambda s,w:divmod(s.find(min(s,key=s.count)),w)

Try it online!

Call as f("########N###########", 5) (allowed in a comment). Outputs (y, x).

एरिक ने 6 बाइट्स बचाए, आउटपुट + का उपयोग करते हुए पुन: व्यवस्थित करने का सुझाव दिया divmod। धन्यवाद!

— लिन
स्रोत
आप आउटपुट को फिर से व्यवस्थित कर सकते हैंdivmod , ताकि आप बिलिन का उपयोग कर सकें ।
— आउटगोल्फ़र
2

पॉवरशेल , 107 98 82 77 बाइट्स

$l=@{}
$args|%{if($_-10){$l.$_+=$x++,+$y}else{$x=0;++$y}}
$l|% v*|? c*t -eq 2

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

LFs के साथ एक चपटा स्ट्रिंग लेता है। शून्य-अनुक्रमित स्थान x, y देता है। unrolled:

$locations=@{}                      # make a hashtable. key=char, value=location array
$args|%{
    if($_-10){                      # if current char is not LF
        $locations.$_+=$x++,+$y     # add $x,$y to hashtable value and move $x to next pos
    }else{
        $x=0;++$y                   # move $x,$y to next line
    }
}
$locations|% Values|? Count -eq 2   # find and output location array with 2 elements (x,y)
— Mazzy
स्रोत
1

Retina 0.8.2, 41 bytes

s`(?=(.)+\1)(.*?¶)*(.*)(?!\1|¶).+
$.3,$#2

Try it online! 0-indexed. Explanation:

s`

.नई सूचियों से मिलान करने की अनुमति दें । इसकी लागत 3 बाइट्स (3rd बाइट है)? before the ) but saves 6 bytes.

(?=(.)+\1)

दो समान वर्णों के लिए आगे देखें। \1फिर घास बन जाता है।

(.*?¶)*

सुई से पहले नए सिरे की संख्या गिनें।

(.*)

सुई के बाईं ओर घास पर कब्जा।

(?!\1|¶)

सुनिश्चित करें कि सुई धुंध या एक नई रेखा नहीं है।

.+

बाकी की घास से मिलान करें ताकि परिणाम इसे बदल दे।

$.3,$#2

बाएँ घास की चौड़ाई और newlines की संख्या का उत्पादन।

— नील
स्रोत
1

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 82 बाइट्स

x=>w=>{int y=x.IndexOf(x.GroupBy(c=>c).Last(g=>g.Count()<2).Key);return(y%w,y/w);}

6 बाइट्स शेविंग करने के लिए दाना के लिए धन्यवाद!

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

पुराना घोल, 106 बाइट्स

n=>m=>{var z=n.Distinct();int d=n.IndexOf(n.Count(c=>c==z.First())>1?z.Last():z.First());return(d%m,d/m);}

दोनों एक स्ट्रिंग के रूप में इनपुट लेते हैं और एक पूर्णांक कॉलम की मात्रा निर्दिष्ट करते हैं।

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

— अज्ञान का अवतार
स्रोत
@ डाना ने कभी नहीं जाना कि Enumerable.Last()एक प्रतिनिधि को स्वीकार किया, धन्यवाद
— अज्ञानता का अवतार
1

जावा 8, 104 बाइट्स

(x,w)->{int i=0,p=x.length;for(;i<p;i++)if(x[i]!=x[(i+1)%p]&&x[i]!=x[(i+2)%p])break;return i/w+","+i%w;}

इनपुट चार की सरणी है, और पंक्ति चौड़ाई का संकेत पूर्णांक।

उत्पादन शून्य-आधारित है, ऊर्ध्वाधर है फिर क्षैतिज (यानी, पंक्ति संख्या फिर स्तंभ संख्या)

स्पष्टीकरण:

(x,w)->{
    int i=0, p=x.length;
    for (;i<p;i++)          //iterate through characters in x
      if (x[i]!=x[(i+1)%p] && x[i]!=x[(i+2)%p])    //compare x[i] with the two subsequent characters in array, wrapping around if necessary
        break;
    return i/w+","+i%w;}  //return row number then column number, zero-based
— jkenney
स्रोत
1

पायथन 3 , 93 89 85 58 बाइट्स

इनपुट को फिर से लिखें concatenated string, width:

lambda g,w:divmod(g.index({g.count(c):c for c in g}[1]),w)

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

मूल उत्तर: 

def k(g):t=''.join(g);return divmod(t.index({t.count(c):c for c in t}[1]),len(g[0]))

संपादित करें: अर्धविराम के लिए लाइनब्रेक / इंडेंट स्वैप करके 4 बाइट्स सहेजे गए। एक और 4 बाइट्स का उपयोग करके बचाया divmod(धन्यवाद @JonathanFrech)।

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

मुझे पता है कि यह बहुत छोटा हो सकता है, लेकिन मैं बस इस dictसमझ के इर्द-गिर्द एक दृष्टिकोण की कोशिश करना चाहता था ।

— steenbergh
स्रोत
1
उपयोग करने से divmodपाँच बाइट बचती हैं।
— जोनाथन फ्रीच
0

MATL , 11 बाइट्स

tX:YmyYk-&f

आउटपुट पंक्ति है, फिर स्तंभ; 1 के आधार पर।

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

व्याख्या

t    % Implicit input. Duplicate
X:   % Linearize into a column
Ym   % Compute mean (characters are converted to ASCII codes)
y    % Duplicate from below: pushes input again
Yk   % Closest value: gives the input value that is closest to the mean
-    % Subtract, element-wise. Gives non-zero for the value farthest from the mean
&f   % Two-output find: gives row and column indices of nonzeros. Implicit display
— लुइस मेंडो
स्रोत
0

पायथ, 15 14 12 बाइट्स

.Dxz-zh.-z{z

इनपुट को पंक्ति की लंबाई और लाइनों और आउटपुट के बिना इनपुट को [पंक्ति, स्तंभ] के रूप में लेता है।
इसे यहाँ आज़माएँ

व्याख्या

.Dxz-zh.-z{z
       .-z{z    Subtract one of each character from the input.
      h         Take the first.
    -z          Remove all instances from the input.
  xz            Find the remaining character in the input.
.D          Q   Take the result divmod the (implicit) length of the row.

पुराना दृष्टिकोण

mxJmt{kdeSJ.TB

इसे यहाँ आज़माएँ

व्याख्या

mxJmt{kdeSJ.TB
           .TBQ   Take the (implicit) input and its transpose...
m      d          ... and for each...
   mt{k           ... deduplicate each row...
 xJ     eSJ       ... and find the index of the largest.
— स्मृति सहायक
स्रोत
0

चारकोल , 40 बाइट्स

≔§⎇⌕θ§θ¹ηθ⁰ζＳθＷ⁼№θζＬθ«⊞υωＳθ»Ｉ⌕Ｅθ⁼ιζ⁰,ＩＬυ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। मुझे कुछ गलत करना चाहिए क्योंकि यह रेटिना के उत्तर के लगभग बराबर है। स्पष्टीकरण:

≔§⎇⌕θ§θ¹ηθ⁰ζ

जांचें कि क्या पहले स्ट्रिंग में दूसरा वर्ण भी पहला वर्ण है, और यदि पहले स्ट्रिंग का पहला चरित्र है तो यदि नहीं तो दूसरे स्ट्रिंग का पहला वर्ण लें। यह तो घास है।

ＳθＷ⁼№θζＬθ«⊞υωＳθ»

स्ट्रिंग को तब तक पढ़ते रहें जब तक कि उसकी लंबाई कम न हो जाए।

Ｉ⌕Ｅθ⁼ιζ⁰,ＩＬυ

Output the position of the mismatching element and then the number of strings previously read.

— Neil
स्रोत
0

MATLAB, 68 22 bytes

[r,c]=find(v~=v(1));if size(r,1)>1 disp([1,1]);else disp([r,c]);end;

If I could exclude any one case, such as [1,1] in this solution, I could have saved several bytes.

Updated solution:

@(v)find(v-mode(v(:)))

Thanks to @sundar for helping me with the special case problem and saving 42 bytes! Also, thanks to @Luis_Mendo for the suggestions and saving me another 2 bytes!

— DimP
स्रोत
I think you can get rid of the check for [1,1] case by using mode(v(:)) instead of v(1).
— sundar - Reinstate Monica
You need to wrap your code so that it is a full program or a function; you cannot assume that the input is in a variable v. Also, you can probably replace ~= by -, and remove the final ;
— Luis Mendo
0

Röda, 81 bytes

f a{i=indexOf;l=i("
",a)+1;chars a|sort|count|[[_2,_1]]|min|i _[1],a|[_%l,_1//l]}

Try it online!

Takes input as a string containing newline-terminated lines. Returns a stream containing 0-indexed horizontal and vertical indexes.

— fergusq
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.