एक मार्ग पर सभी निर्देशांक खोजें

Question

इनपुट के रूप में 2 डी स्ट्रिंग को देखते हुए, या तो न्यूलाइन या लाइनों की सूची के साथ एक स्ट्रिंग के रूप में, सूची (x, y)में सभी हैश ( #) के निर्देशांक को आउटपुट करते हैं । इनपुट में केवल हैश और स्पेस होंगे। (और newlines, यदि आप 2D स्ट्रिंग के रूप में इनपुट लेना चुनते हैं)

यदि कोई हैश नहीं है, तो आप कुछ भी आउटपुट कर सकते हैं।

आउटपुट असंदिग्ध होना चाहिए कि किन संख्याओं के साथ जोड़ा गया है।

उदाहरण:

##

उत्पादन करना चाहिए:

(0,0), (1,0)

यह 0-आधारित इंडेक्सिंग को मानता है, जो शीर्ष बाएं से शुरू होता है। आप किसी भी कोने से शुरू कर सकते हैं, पहले 0 या 1-आधारित इंडेक्सिंग, और / या आउटपुट का उपयोग कर सकते हैं y। (जैसे फॉर्म में y,x)।

अधिक परीक्षण मामले (फिर से, सभी 0-आधारित शीर्ष-बाएं (x, y)अनुक्रमण का उपयोग करके ):

    #
#####
#

(4, 0), (0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (0, 2)


# ###
### #

(0, 0), (2, 0), (3, 0), (4, 0), (0, 1), (1, 1), (2, 1), (4, 1)

ध्यान दें कि ये परीक्षण सभी पंक्तियों द्वारा सूचीबद्ध होते हैं, पथ का अनुसरण करके नहीं।

आप मान सकते हैं कि हैश एक सतत निशान # #बनाएगा , यानी इनपुट कभी नहीं होगा। (शायद कोई फर्क नहीं पड़ेगा, लेकिन मामले में किसी को यह regex करना चाहता है)

आप किसी भी क्रम में निर्देशांक को आउटपुट कर सकते हैं जो आप चाहते हैं, अर्थात ऊर्ध्वाधर कॉलम, क्षैतिज पंक्तियाँ, या सिर्फ एक अनसोल्ड सूची।

Comments

क्या हम मान सकते हैं कि इनपुट में केवल हैश और स्पेस हैं?

— DJMcMayhem

@DJMcMayhem हाँ, उस प्रश्न में संपादन।

— R

क्या यह या यह मान्य आउटपुट स्वरूप होगा?

— जर्गब

@ ज़ारब मूल रूप से अतिरिक्त 1,1 और हैश के साथ? एह, ज़रूर।

— 19

क्या मेरा वैकल्पिक प्रारूप मान्य होगा?

— 19

Answer 1

पर्ची , 2 + 1 = 3 बाइट्स

pध्वज के लिए +1 बाइट । कोड:

`#

स्पष्टीकरण:

p-Flag रिटर्न निम्नलिखित की प्रत्येक क्रिया की स्थिति:

`#      // The character '#'

यहाँ कोशिश करो!

Comments

मुझे लगता है कि हमारे पास एक विजेता है

— Adám

कोई स्पष्टीकरण?

— 20

@EasterlyIrk बैकटिक स्ट्रिंग के रूप में एकल वर्ण से बच जाता है। झंडा स्थितिगत परिणामों का अनुरोध करता है।

— आदम

@ एडम ओह, कूल!

— 20

Answer 2

पीस , 5 बाइट्स

pa`\#

इसे ऑनलाइन आज़माएं! आउटपुट स्वरूप थोड़ा फंकी है, लेकिन ओपी ने कहा है कि यह वैध है।

व्याख्या

Grime मेरी 2D पैटर्न से मेल खाने वाली भाषा है। बाद `का हिस्सा पैटर्न है , इस मामले में एक 1 × 1 वर्ग जिसमें एक #-चैचर होता है। Grime एक मैच के लिए इनपुट ग्रिड की खोज करेगा, और पहले वाले को डिफ़ॉल्ट रूप से खोजता है। पहले वाले हिस्से `में विकल्प शामिल हैं, इस मामले में यह दर्शाता है कि सभी मैच ( a) मुद्रित किए जाने चाहिए, साथ ही उनकी स्थिति और आकार ( p)।

Answer 3

MATL , 7 6 5 बाइट्स

यह (1,1)शीर्ष बाएं कोने में 1-आधारित अनुक्रमणिका का उपयोग कर रहा है ।

oo&fh

स्पष्टीकरण:

o        % convert char to double 
 o       % remainder mod 2 ('#' == 35, ' '==32) makes spaces falsy
  &f     % apply `find` with 2d-output 
    h   % concatenate outputs to display x- and y-coordinates side by side

धन्यवाद #DJMcMayhem और @LuisMendo के लिए प्रत्येक -1 बाइट!

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

Comments

आप ooH#fhएक बाइट को बचाने के लिए कर सकते हैं । (परिवर्तित पूर्णांकों, mod2 करने के लिए) अंतरिक्ष के बाद से भी (आधुनिक 2 == 0, falsy) है और #अजीब है (आधुनिक 1 == 1, truthy)

— DJMcMayhem

ओह, महान, आपको बहुत बहुत धन्यवाद! =)

— 18

Answer 4

पायथन , 67 बाइट्स

यह वास्तव में एक समान विषय पर मेरे स्टैक ओवरफ्लो जवाब का सिर्फ एक गोल्फ है ।

lambda a,e=enumerate:[[(i,j)for j,B in e(A)if'!'<B]for i,A in e(a)]

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

2 डी सूची के माध्यम से छोरों, हैश पात्रों की रिकॉर्डिंग, और परिणाम देता है। हम char > '!'इसके बजाय का उपयोग करके एक बाइट को बचाते हैं char == '#', क्योंकि इनपुट में केवल हैश और रिक्त स्थान शामिल होंगे, और इसलिए हैश ( 0x23) विस्मयादिबोधक चिह्न ( 0x21) की तुलना में केवल बड़े अक्षर होंगे ।

Answer 5

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

s=>s.replace(/./g,(c,i)=>c>' '?[i%l,i/-l|0]+' ':'',l=~s.indexOf`
`)

निर्देशांक की एक नई लाइन और अंतरिक्ष से अलग सूची आउटपुट, जैसे

4,0
0,1 1,1 2,1 3,1 4,1
0,2

आप एक अजीब आउटपुट प्रारूप के साथ बहुत कम प्राप्त कर सकते हैं:

s=>s.replace(/#/g,(c,i)=>[i%l,i/-l|0]+c,l=~s.indexOf`
`)

यह आउटपुट

    4,0#
0,1#1,1#2,1#3,1#4,1#
0,2#

दूसरे टेस्ट केस के लिए। यह अभी भी स्पष्ट है कि कौन से अंक किसके साथ जोड़े गए हैं ...

Answer 6

जे , 12 बाइट्स

$#:'#'I.@:=,

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

व्याख्या

$#:'#'I.@:=,  Input is y.
           ,  Flatten y
   '#'    =   and form bit vector of equality with #.
      I.@:    Compute positions of 1s
 #:           and convert each to base
$             shape of y.

Answer 7

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

n⁶T€,€"J

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

वर्णों के 2D सरणी को देखते हुए (= स्ट्रिंग्स की एक सूची):

            Implicit input (example):
               [[' ', ' ', ' ', ' ', '#']
               ,['#', '#', '#', '#', '#']
               ,['#', ' ', ' ', ' ', ' ']]
n⁶          Not-equal to space (⁶).
               [[0, 0, 0, 0, 1]
               ,[1, 1, 1, 1, 1]
               ,[1, 0, 0, 0, 0]]
  T€        Indices of 1s in each row
               [[5], [1,2,3,4,5], [1]]
    ,€"J    Pair each, vectorizing, with y-indices
               [[[5,1]], [[1,2],[2,2],[3,2],[4,2],[5,2]], [[1,3]]]

Answer 8

डायलॉग एपीएल 16.0, 5 चार्ट = 9 बाइट्स या 6 चार्ट = 8 बाइट्स

शीर्ष बाएं से (y, x) जोड़े की सूची देता है।

⍸⎕='#'

⍸ कहा पे

⎕ इनपुट

= बराबरी

'#' यह वर्ण*

* एक बाइट की कीमत पर एक चरित्र को सहेजना संभव है (रूट नेमस्पेस प्रारूप के '#'साथ ⍕#)

TryAPL ऑनलाइन! ध्यान दें कि ⍸इसके साथ अनुकरण किया गया है i क्योंकि TryAPL 14.0 संस्करण चलाता है।

Comments

Dyalog APL एन्कोडिंग में बहुत अच्छा लगता है 1 char = 1 बाइट, नहीं?

— devRicher

@devRicher आम तौर पर, लेकिन ⍸सिंगल बाइट संस्करण में शामिल नहीं है। "बाइट्स" लिंक देखें।

— आदम

Answer 9

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 61 बाइट्स

s=>[for(c of(x=0,y=1,s))if(c<' '?(y++,x=0):(x++,c>' '))[y,x]]

1-आधारित निर्देशांक लौटाता है। आसानी से बीच [y, x]और [x, y]आदेश देने योग्य। Ungolfed:

function coords(s) {
    var x = 0;
    var y = 1;
    for (Var c of s) {
        if (c == "\n") {
            y++;
            x=0;
        } else {
            x++;
        }
        if (c == "#") {
            console.log(y, x);
        }
    }
}

Answer 10

विम, 37 बाइट्स

:%s/#/\=line('.').','.col('.').' '/g<cr>

चूंकि V ज्यादातर पीछे की ओर संगत है, आप इसे ऑनलाइन आज़मा सकते हैं !

एक सीधा रेगेक्स समाधान, जहां यह प्रत्येक '#' को उस स्थान से प्रतिस्थापित करता है जो इसमें (एक-आधारित अनुक्रमण) पाया गया था। मैं इसे लिखते समय थोड़ा चिंतित था कि एक पंक्ति में पहले एक को प्रतिस्थापित करने के बाद स्थान बदल जाएगा, लेकिन यह एक मुद्दा नहीं लगता है। टीबीएच मैं सुखद आश्चर्यचकित हूं कि यह समाधान कितना सरल था।

दुर्भाग्य से, विम्सस्क्रिप्ट बहुत ही क्रियात्मक है, इसलिए अधिकांश बाइट्स परिणामों को अलग करने से आते हैं, जो अभी भी सुपाठ्य है। नहीं तो हम कर सकते थे

:%s/#/\=line('.').col('.')/g

लेकिन यह आउटपुट की व्याख्या करने के लिए बहुत कठिन है। इसके अतिरिक्त, यह केवल यह काम करेगा ग्रिड हमेशा 9x9 या छोटा है।

यह वास्तव में एक मजेदार समाधान है क्योंकि यह हैश के स्थान पर निर्देशांक के प्रत्येक जोड़े को दर्शाता है। उदाहरण के लिए, इनपुट

# ###
### #

आउटपुट

1,1  1,3 1,4 1,5 
2,1 2,2 2,3  2,5 

बेशक, अगर हम वी का उपयोग कर रहे थे, तो हम अनुगामी न्यूलाइन को हटा सकते हैं, और रेगेक्स को संपीड़ित कर सकते हैं। तब यह बस हो सकता है

Í#/½line('.').','.col('.').' '/g

(32 बाइट्स)

लेकिन चूंकि यह ठीक वैसा ही दृष्टिकोण है और अभी भी दर्दभरी क्रिया है, इसलिए गोल्फिंग भाषा का उपयोग करना उचित नहीं लगता।

Comments

ठीक है, पूरे "हैश के स्थान पर निर्देशांक के प्रत्येक जोड़े को दिखाता है" बहुत सुंदर है। +1

— Rɪᴋᴇʀ

Answer 11

हास्केल, 53 बाइट्स

concat.zipWith(\y l->[(x,y)|(x,'#')<-zip[0..]l])[0..]

इनपुट को स्ट्रिंग्स की सूची के रूप में लिया जाता है। आउटपुट (x,y)जोड़े की सूची (0 अनुक्रमित) है, उदाहरण के लिए

*Main> concat.zipWith(\y l->[(x,y)|(x,'#')<-zip[0..]l])[0..] $ ["# ###","### #"]
[(0,0),(2,0),(3,0),(4,0),(0,1),(1,1),(2,1),(4,1)]

Answer 12

लूआ, 141 बाइट्स

w=io.read()x=w:sub(1,w:find("\n")-1):len()_,c=w:gsub("\n","")for i=0,x do for j=0,c+1 do if w:sub(c*x+i,c*x+i)=="#"then print(i,j)end end end

यह 2:30 बजे है, मैं अपने फोन पर बिस्तर पर हूँ। मैं यह क्यों कर रहा हूँ?

Answer 13

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

Position@"#"

का संचालक रूप Position। वर्णों का 2D सरणी मानता है। 1-अनुक्रमित शीर्ष बाईं प्रविष्टि पर शुरू होता है। प्रपत्र में निर्देशांक की एक सूची आउटपुट करता है {row,column}।

Comments

जिस तरह से मैं कार्य विवरण पढ़ता हूं, मुझे नहीं लगता कि स्ट्रिंग का समर्थन करने वाली भाषाओं के लिए 2 डी सरणी लेने की अनुमति है।

— SMLS

@smls meta.codegolf.stackexchange.com/a/2216/61980

— ngenisis

मैं आश्वस्त नहीं हूं। एक बात के लिए, यह सवाल उस पर केंद्रित है char[], जो वास्तव में सी-आधारित भाषाओं में तार को संग्रहीत करने का एक सामान्य तरीका है। इसके अलावा, इस कार्य विवरण में विशेष रूप से "या तो नई लाइनों के साथ एक स्ट्रिंग के रूप में या लाइनों की एक सूची" का उल्लेख है, और सूची-में-वर्ण या वर्णों के 2 डी मैट्रिक्स का उल्लेख नहीं करता है।

— SMLS

@smls बिल्कुल। सर्वसम्मति यह थी कि यदि कोई प्रश्न एक स्ट्रिंग निर्दिष्ट करता है, तो इसका मतलब वर्णों का एक क्रम है, और यदि आपकी भाषा में व्यक्त करने का एक से अधिक तरीका है, तो आप अपनी गोल्फ की जरूरतों के अनुरूप एक का चयन करने के लिए स्वतंत्र हैं। "या तो newlines या लाइनों की एक सूची के साथ एक स्ट्रिंग के रूप में" को बदलने के लिए कुछ भी नहीं है कि अगर आप वर्णों के एक सरणी के रूप में प्रत्येक पंक्ति का प्रतिनिधित्व करते हैं तो आपको वर्णों का एक 2D सरणी मिलता है।

— 19

Answer 14

PHP, 69 बाइट्स

for(;$a=$argv[++$i];)for($j=0;""<$c=$a[$j++];)echo$c>" "?"$j $i,":"";

1-आधारित अनुक्रमण का उपयोग शीर्ष बाएं से शुरू होता है।
जैसे उपयोग करें:

php -r 'for(;$a=$argv[++$i];)for($j=0;""<$c=$a[$j++];)if($c>" ")echo"$j $i,";' '    #' '#####' '#    '

उत्पादन होगा:

5 1,1 2,2 2,3 2,4 2,5 2,1 3,

Answer 15

सी, 113 बाइट्स

i,j,k,l;f(char**p){i=strlen(*p);l=strlen(p);for(j=0;j<l;j++)for(k=0;k<i;k++)if(p[j][k]==35)printf("%d,%d ",k,j);}

परीक्षण मामलों से आउटपुट:

0,0 2,0 3,0 4,0 0,1 1,1 2,1 4,1 
4,0 0,1 1,1 2,1 3,1 4,1 0,2 

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

Answer 16

RBX.Lua, 131 बाइट्स

मान लेना इनपुट वैध है (जेड फ्लैट अक्ष है, व्हॉट्सएप Whiteटाइल्स हैं, हैश किसी भी अन्य रंग का हो सकता है, शीर्ष-बाएं भाग स्थित है 0, 0, 0) और सभी भाग एक ही मॉडल का हिस्सा हैं M, और मॉडल अन्यथा खाली है।

for k,v in pairs(workspace.M:GetChildren())do if v.BrickColor~=BrickColor.new("White")then print(v.Position.X,-v.Position.Y)end end

नमूना इनपुट / आउटपुट:

Comments

क्या आप एक मान्य i / o उदाहरण प्रदान कर सकते हैं?

— R

@EasterlyIrk वहाँ, जवाब संपादित किया।

— देवरीचेर

Answer 17

पर्ल 6 , 25 बाइट्स (22 अक्षर)

{^∞ZX@_».indices("#")}

इनपुट को लाइनों की सूची के रूप में लेता है।
निर्देशांक के लिए प्रति पंक्ति एक सूची, प्रत्येक युक्त (y, x) tuples को आउटपुट करता है।
इसे ऑनलाइन आज़माएं!

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

{                    }  # A lambda.
{    @_»             }  # For each input line:
        .indices("#")   #    get x-coordinates.  (4) (0 1 2 3 4) (0)
 ^∞                     # Range from 0 to Inf.    0   1           2 ...
   Z                    # Zip with:              (0 (4)) (1 (0 1 2 3 4)) (2 (0))
    X                   #    Cartesian product.  ((0 4)) ((1 0) (1 1) (1 2) (1 3) (1 4)) ((2 0))

Answer 18

ग्रूवी, 80 68 बाइट्स

{y=0;it.each{it.eachWithIndex{x,i->print(x=='#'?"($i,$y)":"")};y++}}

उदाहरण इनपुट:

[#   #,#   #,#####]

उदाहरण आउटपुट:

(0,0)(4,0)(0,1)(4,1)(0,2)(1,2)(2,2)(3,2)(4,2)

Comments

इनपुट को लाइनों में विभाजित क्यों करें, जब कार्य विवरण लाइनों की पहले से विभाजित सूची लेने की अनुमति देता है?

— SMLS

Answer 19

रूबी , 24 + 1 = 25 बाइट्स

-nझंडे के लिए +1 बाइट । निर्देशांक 1-आधारित, प्रति पंक्ति एक संख्या है।

gsub(/#/){p$`.size+1,$.}

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

Answer 20

सी, 80 बाइट्स

x,y;f(char*s){for(x=y=0;*s;printf(*s-35?"":"%d,%d ",x,y),*s++==10?++y,x=0:++x);}

न्यूलाइन-सीमांकित चार सरणी के रूप में इनपुट की आवश्यकता है, स्क्रीन पर आउटपुट प्रिंट करता है।

असंगठित और उपयोग:

x,y;

f(char*s){
 for(
  x = y = 0;             //init coordinates
  *s;                //iterate until end
  printf(*s-35 ? "" : "%d,%d ", x, y),     //print coordinates or empty string
  *s++==10 ? ++y, x=0 : ++x              //advance to the right or the next line
 );
}


main(){
 f("    #\n#####\n#    ");
 puts("");
 f("# ###\n### #");
}

Comments

78 बाइट्स:x,y;f(char*s){for(x=y=0;*s;*s++==10?++y,x=0:++x)*s==35&&printf("%d,%d ",x,y);}

— गैस्ट्रोपनर