होटल का कमरा नंबरिंग

Question

एक एकल कमरे के साथ ASCII कला में "होटल" के इनपुट को चिह्नित करते हुए, कुछ नियमों के अनुसार कमरे की संख्या को आउटपुट करता है।

यहां ASCII होटल का एक उदाहरण दिया गया है:

               ##
               ##
#####          ##
#####  ######  ##
#####  ######  ##
#####  ######  ##

यहां ASCII होटलों के बारे में कुछ और बातें हैं:

• प्रत्येक "भवन" को #पात्रों की एक आयत द्वारा दर्शाया जाता है , जहाँ प्रत्येक #"कक्ष" का प्रतिनिधित्व करता है।

• उपरोक्त होटल में तीन इमारतें हैं। प्रत्येक इमारत को रिक्त स्थान के दो स्तंभों से अलग किया जाता है, और सबसे कम "मंजिल" हमेशा अंतिम पंक्ति पर होगी।

• प्रत्येक भवन में हमेशा प्रत्येक मंजिल पर 1-9 "मंजिल" (पंक्तियाँ) और 1-9 "कमरे" होंगे। हमेशा 1-9 इमारतें भी होंगी।

• कमरे के रूप में इस गिने जा रहे हैं: [building #][floor #][room on floor #]। उदाहरण के लिए, आइए उपरोक्त ड्राइंग में कुछ कमरों को चिह्नित करें:

                 ##
                 ##
  #####          ##
  #####  ####$#  ##
  ##%##  ######  ##
  #####  ######  #@
  

  %कमरा 123 (इमारत 1, फर्श 2, मंजिल पर 3 कमरा) के साथ चिह्नित कमरा है । इसी तरह, $कमरा 235 है, और @कमरा 312 है।

• भवन, फर्श और फर्श पर "nth कमरा" हमेशा 1-अनुक्रमित होते हैं।

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

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीतता है।

परीक्षण मामले (ऊर्ध्वाधर स्थान के संरक्षण के लिए एक एकल कोड ब्लॉक के भीतर):

Input:
*

Output: 111

Input:
#  #  *  #  #

Output: 311

Input:
#####
#####
####*
#####
#####

Output: 135

Input:
         #####
         #####           ######
         #####           ######
#  #  #  #####  #  #  #  ######  *

Output: 911

Input:
#
#  #
#  #  ##
#  #  ##  ###
#  #  ##  ###  #####
#  #  ##  ###  ##*##  ########
#  #  ##  ###  #####  ########

Output: 523

Input:
           #
           *
           #
           #
           #
           #
           #
           #
#########  #  #

Output: 281

Input:
                        ########*
                        #########
                        #########
                        #########
                        #########
                        #########
                        #########
                        #########
#  #  #  #  #  #  #  #  #########

Output: 999

Comments

क्या कभी भी पूरी तरह से खाली इनपुट होगा

— डाउनगैट

@ Do @ हमेशा कहीं न कहीं एक तारांकन होगा, इसलिए नहीं।

— दरवाज़े

कुछ अजीब कारणों से आप 1 पर गिनना शुरू करते हैं, 0. पर नहीं ;

— पीपी

गंभीरता से: यह जोड़ना उपयोगी हो सकता है कि आप इमारतें हमेशा आकार में आयताकार (दाईं ओर?)

— 6

@agtoever नहीं, यह एक स्ट्रिंग होना चाहिए, जैसा कि प्रश्न में कहा गया है।

— दरवाज़े

Answer 1

CJam, 34 31 बाइट्स

qN/W%zSf-La%{_{s'*&}#_)@@=}3*;\

इसके लिए रिक्त स्थान के साथ इनपुट को एक आयत में गद्देदार करने की आवश्यकता होती है।

इसे ऑनलाइन आज़माएं! वैकल्पिक रूप से, सभी परीक्षण मामलों को चलाएं।

व्याख्या

qN/      e# Read input and split into lines.
W%z      e# Rotate 90° counter-clockwise.
Sf-      e# Remove all spaces from the rows.
La%      e# Split into buildings. We've now got a 3D array of rooms, where the first
         e# dimension is the building, the second the room number and the third is the
         e# the floor number.
{        e# Run this block three times. At each stage it will find the index of the "*"
         e# along the current dimension and leave the element at that index on the stack
         e# for the next round...
  _      e#   Duplicate the current array.
  {      e#   Find the index of the first element where this block yields something
         e#   truthy...
    s    e#     Flatten into a single string.
    '*&  e#     Set intersection with "*".
  }#
  _)     e#   Duplicate the index and increment it, because the results should be 1-based.
  @@=    e#   Pull up the array and the other copy of the index and select the
         e#   corresponding element.
}3*
;\       e# We've now got the building, room and floor index on the stack, as well as the
         e# "*" character itself. We discard the character and swap the room and the floor
         e# floor number. When the three indices are printed back-to-back at the end of
         e# the program, that will yield the desired result.

Answer 2

पायथ, 34 बाइट्स

LxKh/#\*b\*jkhM[//<hJ_.zyJd2xJKycK

प्रदर्शन

यह एक गोल्फ चाल का उपयोग करता है जिसका मैंने पहले कभी उपयोग नहीं किया है: उस फ़ंक्शन से आंशिक परिणाम को बचाने के लिए Kएक फ़ंक्शन ( y) के अंदर एक चर ( ) को असाइन करना ।

स्पष्टीकरण:

LxKh/#\*b\*jkhM[//<hJ_.zyJd2xJKycK
L                                     Define y(b):      (b is a list of strigs)
    /#\*b                             Filter b for strings containing '*'
   h                                  Take the first such string
  K                                   Store it in K
 x       \*                           And return the index of '*' in that string.
                      .z              Take the input as a list of strings
                     _                Reverse it (bottom to top)
                    J                 Store in J
                   h                  Take the bottommost row
                        yJ            Find y(J). This is the index in whichever
                                      row of J has the * of the *. Also store
                                      that row in K.
                  <                   Slice J up to that index.
                 /        d           Count the number of spaces
                /          2          Divide by 2. This is the building number.
                            xJK       Take the index in J of K. This is the floor.
                                cK    Chop K on whitespace.
                               y      Find the index in whatever element of K has
                                      the * of the *. This is the room number.
                                      This also overwrites K, but we don't care.
               [                      Gather the above into a list.
             hM                       Convert 0-indexing to 1-indexing.
           jk                         Concatenate. Print implicitly.

Answer 3

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

h=>h.split`
`.reverse(r=0).map((t,i,l)=>r?0:(f=i+1,b=1,l[o=0].slice(0,r=t.indexOf`*`+1).replace(/  /g,(_,s)=>o=++b&&s+2),r-=o))&&[b]+f+r

6 बाइट्स @nderscore की बदौलत बच गईं !

व्याख्या

h=>
  h.split`
`                            // get each line of the input string
  .reverse(                  // reverse the lines to make getting the ground floor easy
    r=0)                     // initialise r to 0
  .map((t,i,l)=>             // for each line of the reversed input string
    r?0:(                    // if the marked room has not been found yet:
      f=i+1,                 // f = floor number
      b=1,                   // b = building number, default to 1
      l[o=0].slice(0,        // get the substring of 0 to the marked room, default o to 0
        r=t.indexOf`*`+1)    // r = absolute index of room + 1 (or 0 if not found)
      .replace(/  /g,(_,s)=> // count the spaces between buildings
        o=++b&&s+2),         // increment b, o = index of marked room's building
      r-=o                   // make r relative to the room's building
    )
  )
  &&[b]+f+r                  // output the result ([b] casts b to a string)

परीक्षा

var solution = h=>h.split`
`.reverse(r=0).map((t,i,l)=>r?0:(f=i+1,b=1,l[o=0].slice(0,r=t.indexOf`*`+1).replace(/  /g,(_,s)=>o=++b&&s+2),r-=o))&&[b]+f+r

<textarea id="input" rows="8" cols="60">#
#  #
#  #  ##
#  #  ##  ###
#  #  ##  ###  #####
#  #  ##  ###  ##*##  ########
#  #  ##  ###  #####  ########</textarea><br />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Comments

कुछ बाइट बचत (-6): .map((t,i,l)=>, slice(0,r=t.indexOf`*`+1), o=++b&&s+2,[b]+f+r

— nderscore

@nderscore धन्यवाद, मैं वास्तव में [b]+f+rटिप पसंद करता हूं !

— user81655

Answer 4

awk, 70

!i{i=index($0,"*")}i{$0=substr($0,0,i);f++}END{print NF f length($NF)}

उदाहरण:

Input:
#
#  #
#  #  ##
#  #  ##  ###
#  #  ##  ###  #####
#  #  ##  ###  ##*##  ########
#  #  ##  ###  #####  ########

While no * was found, do nothing.
#
#  #
#  #  ##
#  #  ##  ###
#  #  ##  ###  #####
A * is found in column 14. From now on, truncate and increment the floor counter.
#  #  ##  ###  ##*    f=1
#  #  ##  ###  ###    f=2
Awk automatically splits $0 into space separated fields, counted by builtin NR.
In the end, NR and f hold hotel and floor number.
The room number is the length of the last hotel.

Answer 5

सी, 131 130 119 113 बाइट्स

b,f,i,j=111;main(c){for(;c=~getchar();)c&32?f+=10,b=i=0:++i<j?c%3?f=j,j=i:c&2?b+=50-b%50:++b:0;printf("%d",b+f);}

स्टडिन पर इनपुट लेता है; इनपुट में टर्मिनेटिंग न्यूलाइन नहीं होना चाहिए । 2 का पूरक मानता है।

Ungolfed:

// Declare variables (default type is int) and initialize, by default to 0:
b,    // Building number (multiplied by 100, 0-based) + room number (0-based)
f,    // Floor (111-based, multiplied by 10)
i,    // Current column of input character within line (1-based)
j = 111; // Column of asterisk character once found (1-based), 111 before then
main (c)    // Declare main function and variable c to hold input character
{
  for (;    // Loop on input
    c = ~getchar();  // Read a character into c, bitwise inverted to break
                     // EOF (numeric value -1). This means that following 
                     // operations (on the ASCII value of the input) are 
                     // also inverted.
    )
    c & 32 ?              // Newline?
      f += 10, b = i = 0 :  // Increment floor; reset building, room, column
      ++i < j ?             // Increment column; before asterisk, or asterisk not yet found?
        c % 3 ?               // Asterisk character?
          f = j, j = i :        // Reset floor and record column
          c & 2 ?               // Space character?
            b += 50 - b % 50 :    // Increment building and reset room
            ++b :                 // Otherwise, # character; increment room
        0;                    // After asterisk; do nothing
  printf("%d", b + f);  // Write out results
}

Comments

मुझे यकीन है कि गोल्फ में ट्रिक का बहुत अधिक उपयोग किया जाना चाहिए, लेकिन मैंने इससे पहले कभी ऐसा कार्यक्रम नहीं देखा है जिसमें stdio का उपयोग किया गया हो, फिर भी अगर यह शामिल है तो टूट जाता है!

— डेव

@Dens की एक खाली जोड़ी सिर्फ एक संभावित अभिव्यक्ति की बर्बादी है, और हेडर एक लक्जरी हैं :) इसके अलावा अपने एक या दो विचारों को चुरा लेने के लिए इसे नीचे फेंक दें।

— २२:

अच्छा लगा। मुझे भवन वृद्धि पसंद है - एक और 3 बाइट्स बचाता है। मैंने उस विचार को वापस ले लिया है और आपके नए बायटेकाउंट से मिलान करने में कामयाब रहा, लेकिन मैं इस पर और सुधार नहीं कर सकता।

— डेव

Answer 6

स्टैकगोट , 73 बाइट्स [गैर-प्रतिस्पर्धात्मक]

Stackgoat एक स्टैक-आधारित भाषा है जिसका बकरों से कोई लेना-देना नहीं है।

y'#ZGDYZG'*iVXsV@"\\*"ZGN2/1+y'#ZG' ZG'q:Nq'*i-yXsq'*i@"[#*]+"M0M1-@'*i1+

यह काफी नई भाषा है इसलिए मुझे बताएं कि क्या उन्हें इससे कोई समस्या है। मैं अपने आप को काफी सिरदर्द देता हूं ताकि यह पता चल सके कि यह उतना ही है जितना कि मैं इसे गोल कर रहा हूं।

व्याख्या

इस कार्यक्रम में कक्ष संख्या के प्रत्येक 3 अंकों के लिए 3 भाग हैं

y'#ZG    // Remove all # from input
D        // Duplicate
YZG      // Remove all spaces
'*i      // Index of *
V        // Reverse stack
Xs       // Split on spaces
V@       // Unreverse, item at *'s index
"\\*"ZG  // Remove all *s
N        // Get length
2/1+     // Divide by 2, add 1

y'#ZG    // Remove all #
' ZG     // Remove all spaces
'q:      // Store in q
N        // Get length
q'*i     // *'s index in q
-        // Subtracted from length

yXs      // Split on newlines
q'*i     // Get index of * in q
@        // Get indexed-th line
"[#*]+"M // Match all buildings
0M       // Get *'s building no.
1-       // Subtract one
@        // nth building at right line
'*i      // *'s index
1+       // Added to one

Comments

प्रासंगिक

— एलेक्स ए।

यह चुनौती पोस्ट किए जाने के बाद कार्यान्वित दो नई सुविधाओं का उपयोग करता प्रतीत होता है , इसलिए उत्तर गैरसैण है।

— दरवाज़े

जिज्ञासा से बाहर, @ डॉर्कनोब - उस नियम को कहाँ परिभाषित किया गया है? मैंने सभी तार्किक स्थानों पर खोज करने और देखने की कोशिश की, लेकिन मुझे इस पर कुछ भी नहीं मिला ...

— एलेक्स

@ विशेष रूप से यहाँ नई सुविधाओं के लिए। यहां पूरी तरह से नई भाषाओं के लिए।

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

Answer 7

रूबी, 103

->n{r=x=b=0
n.lines{|s|(t=s=~/\*/)&&(x=t;r=($`.reverse+' ')=~/ /)
r+=10;b=s[0..x].count" "}
b*50+r+101}

परीक्षण कार्यक्रम में अपराजित

g=->n{
  r=x=b=0
  n.lines{|s|                  #for each line in n
    (t=s=~/\*/)&&              #if the line contains an asterisk
      (x=t                     #record its position in x. $` is a special variable containing the part of the string to the left of the last match made.
      r=($`.reverse+' ')=~/ /) #reverse $` and search for the index of the first space to find room number (before the search a space is appended in case it is 1st building.)
    r+=10                      #increment r by 10 for the floor number (obviously this will have been reset to the row ith the asterisk by the previous line)
    b=s[0..x].count" "}        #count the number of spaces left of x in the current row to find building number (loop will exit with calc from bottom row, which is the correct one.) 
b*50+r+101}                    #multiply number of spaces by 50 to get 1st digit, add r for 2nd and 3rd digit. Then add 101 to correct 1st and 3rd digits from 0-indexed to 1-indexed.

puts g["
*"]



puts g["
#  #  *  #  #"]


puts g["
#####
#####
####*
#####
#####"]

puts g["
         #####
         #####           ######
         #####           ######
#  #  #  #####  #  #  #  ######  *"]



puts g["
#
#  #
#  #  ##
#  #  ##  ###
#  #  ##  ###  #####
#  #  ##  ###  ##*##  ########
#  #  ##  ###  #####  ########"]




puts g["
           #
           *
           #
           #
           #
           #
           #
           #
#########  #  #"]



puts g["
                        ########*
                        #########
                        #########
                        #########
                        #########
                        #########
                        #########
                        #########
#  #  #  #  #  #  #  #  #########"]

Comments

मैं वास्तव $`में इस एक के चतुर उपयोग को पसंद करता हूं ।

— दरवाज़े

Answer 8

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

x=>x.split`
`.reverse().map((r,f,h,a=r.indexOf`*`)=>x=~a?(h=h[0].slice(0,a).split`  `).length+[f+1]+-~h.pop().length:x)|x

कम गोल्फ और समझाया

H=x=>x.split`\n` // split in lines
  .reverse() // reverse, so we can scan bottom up
  .map( (r,f,h) => // exectute for each line
         // r is the current row
         // f in the row index, so that f+1 is the floor number
         // h is the reversed array, h[0] is the bottom floor
       ~(a=r.indexOf`*`) // a is the position of '*' in the line, if found - else 0
       && ( // if a >= 0
         h = h[0]        // bottom floor line 
             .slice(0,a) // ... truncated at position of '*'
             .split`  `, // ... and splitted at '  ', as an array
         x = h.length  // the array len is the building number
             + [f+1]   // floor number, using [] to force string concatenation
             + -~ h.pop().length // the length of the last array element is the number 
                                 // of chars in the block before '*'
                                 // increment by 1 to get the room number
      )
  )
  && x // return the found value

परीक्षा

H=x=>x.split`
`.reverse().map((r,f,h,a=r.indexOf`*`)=>x=~a?(h=h[0].slice(0,a).split`  `).length+[f+1]+-~h.pop().length:x)|x

// test
console.log=x=>O.textContent+=x+'\n';

;[['*',111],['#  #  *  #  #',311],
[`#####
#####
####*
#####
#####`,135],
[`         #####
         #####           ######
         #####           ######
#  #  #  #####  #  #  #  ######  *`,911],
[`#
#  #
#  #  ##
#  #  ##  ###
#  #  ##  ###  #####
#  #  ##  ###  ##*##  ########
#  #  ##  ###  #####  ########`,523],
[`           #
           *
           #
           #
           #
           #
           #
           #
#########  #  #`,281],
[`                        ########*
                        #########
                        #########
                        #########
                        #########
                        #########
                        #########
                        #########
#  #  #  #  #  #  #  #  #########`,999]]  
.forEach(t=>{
  var i=t[0],k=t[1],r=H(i)
  console.log(i+'\n' + (k!=r?'Error '+r+' expected '+k:'Ok '+r)+'\n')
})

<pre id=O></pre>

Answer 9

पायथन 2.7, 153 168 वर्ण

मुझे यह चुनौती पसंद आई! यदि एक पायथन सूची इनपुट के रूप में ठीक है (उदाहरण के लिए testuite देखें), यह समाधान काम करता है।

2016-01-05 को संपादित करें: में स्ट्रिंग को विभाजित करने के लिए एक लाइन (10 अक्षर) जोड़े।

संक्षिप्त विवरण:

• t वह पंक्ति है जिसमें कमरा स्थित है (शीर्ष-पंक्ति से सरणी सूचकांक = 0 के रूप में गिना जाता है);
• i इसकी पंक्ति में कमरे का सूचकांक है;
• इमारत की गणना नीचे की पंक्ति में डबल सफेद रिक्त स्थान की संख्या के रूप में की जाती है i ;
• मंजिल पंक्ति माइनस की संख्या है t ;
• कमरा उल्टे स्ट्रिंग में पहले डबल व्हाट्सएप का सूचकांक है i साथ फर्श की शुरुआत तक , इस मामले के लिए कवर करने के लिए एक व्हाट्सएप द्वारा जोड़ा जाता है कि कमरा पहली इमारत में है।

कोड:

def r(l):
 l=h.split(",")
 a,w,s="*","  ",str
 t=l.index(filter(lambda c:a in c,l)[0])
 i=l[t].find(a)
 return s(l[-1][:i].count(w)+1)+s(len(l)-t)+s((l[t][i::-1]+w).find(w))

परीक्षण सूट:

cases = [
         (["*"], 111),
         (["#  #  *  #  #"], 311),
         (["#####","#####","####*","#####","#####"], 135),
         (["         #####","         #####           ######","         #####           ######","#  #  #  #####  #  #  #  ######  *"], 911),
         (["#","#  #","#  #  ##","#  #  ##  ###","#  #  ##  ###  #####","#  #  ##  ###  ##*##  ########","#  #  ##  ###  #####  ########"], 523),
         (["           #","           *","           #","           #","           #","           #","           #","           #","#########  #  #"], 281),
         (["                        ########*","                        #########","                        #########","                        #########","                        #########","                        #########","                        #########","                        #########","#  #  #  #  #  #  #  #  #########"], 999)
        ]

for idx,(hotel,roomnr) in enumerate(cases):
    output=r(hotel)
    if str(output)==str(roomnr):
        result="SUCCESS"
    else:
        result="FAILURE!!!"
    print "Case {} gives output: {}. Correct output is: {}. Result: {}".format(idx,output,roomnr,result)

Answer 10

घोंघे , 32 बाइट्स

A
\*{l\#,|r,9d.,{|=~r,9{|l.,\ \#

Comments

इसे पहले कभी नहीं देखा; प्रभावशाली। अफसोस, 1 अब CJam ... से बाइट

— दरवाज़े

@Doorknob codegolf.stackexchange.com/a/47495/8478

— मार्टिन

Answer 11

सी, 142 138 137 बाइट्स

#include <stdio.h>
f,b,x,p=110;main(c){while(~(c=getchar()))c<11?f+=c,b=x=0:x++<p?++b,c&2?c&8?f=p,p=x:0:(b+=50-b%50):0;printf("%d",b+f);}

( 123 119 118 बाइट्स + 19 #includeलाइन के लिए)

मैंने एक्स्ट्रीमर से वैल्यू मर्जिंग आइडिया चुरा लिया है, लेकिन मैंने उन्हें काफी अलग तरीके से मर्ज किया है ( अंत में 8 बाइट्स बचाता है) )। इससे भी वही धारणा बनती है EOF == -1।

इनपुट स्टड से लिया गया है, और अंतिम पंक्ति पर अंतिम इमारत के बाद व्हाट्सएप या नईलाइन नहीं होनी चाहिए, इसलिए एक उदाहरण इनपुट होगा:

printf "##\n##       #\n##  ##*  #\n##  ###  #" | ./hotel
# or for better visualisation:
printf "##\n##       #\n##  ##*  #\n##  ###  #" | tee /dev/fd/2 | ./hotel;echo ""

टूट - फूट:

// Globals initialise to 0
f,     // floor number * 10 + shift
b,     // building number * 100 + room number
x,     // current column
p=110; // will store column of * (must start >= 11*9-2, and 110 will be used later)
main(c){
    while(~(c=getchar()))              // For each character until EOF
        c<11                           //  Is \n? (10)
            ?f+=c,                     //   Add 10 to floor number
             b=x=0                     //   Reset building, room, column
            :x++<p                     //  Else, is column <= *?
                  ?++b,                //   Add to room number
                   c&2                 //   Is # or *?
                      ?c&8             //   If *:
                          ?f=p,p=x:0   //    Set floor to 110, set p to column
                      :(b+=50-b%50)    //   If ' ': go to next building
                  :0;
    printf("%d",b+f);                  // Result is building+room+floor+shift
}

Comments

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

— परमानंद

आप को बदलने के द्वारा एक बाइट को बचाने के लिए सक्षम हो सकता है &&(f=p,p=x)करने के लिए ?f=p,p=x:0- एक त्रिगुट सशर्त के दूसरे संकार्य निहित कोष्ठक हैं।

— १/१६ बजे ०५

@ecatmur अच्छा बिंदु; धन्यवाद!

— डेव

Answer 12

हास्केल, 128 125 बाइट्स

l=length
f h|b<-snd$break(elem '*')$lines h,q<-fst(span(<'*')$b!!0)++"*"=l(last$words$q)+10*l b+l(words$take(l q)$last b)*100

प्रयोग उदाहरण: f "# # * # #"-> 311।

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

b<-snd$break(elem '*')$lines h      -- split the input into a list of lines
                                    -- and assign b to the lines starting with
                                    -- the one that includes * up to the end,
                                    -- i.e. drop leading lines without the *
q<-fst(span(<'*')$b!!0)++"*"        -- assign q to the line with the *, but strip
                                    -- off all chars after the *

l(last$words$q)                     -- the room on floor number is the length of
                                    -- the last word of q
10*l b                              -- the floor number is 10 times the length of b
l(words$take(l q)$last b)*100       -- the hotel number is 100 times the number of
                                    -- words in the last line cut down to the
                                    -- length of q

                                    -- add for final room number

Answer 13

लुआ, 165 बाइट्स

l={}i=1while(l[i-1]~="")do l[i]=io.read()o=l[i]:find"%*"x=o or x y=o and i or y i=i+1 end print(#l[i-2]:sub(1,x):gsub("%S+%s*","#")*100+(i-y-1)*10+#l[y]:match"#-%*")

Ungolfed

l={}
i=1
while(l[i-1]~="")do
    l[i]=io.read()
    o=l[i]:find"%*" --find "*", and record:
    x=o or x        --position and
    y=o and i or y  --current floor
    i=i+1
end
print(#l[i-2]:sub(1,x):gsub("%S+%s*","#")*100 --[[Take last string of list, and then
                                                  take the substring up until the 
                                                  asterisk. Substitute any substrings
                                                  that include nonspace characters 
                                                  (%S+) followed by a minimum of 0 space 
                                                  characters (%s*) with one character
                                                  (in this code snippet I chose # for no 
                                                  particular reason.) Then take the length 
                                                  of this string, with the # operator. 
                                                  The %S+%s* regex and gsub do the bulk 
                                                  of the magic.
                                                ]]
      +(i-y-1)*10                             --[[Total number of lines minus '*' floor 
                                                  minus one.
                                                ]]
      +#l[y]:match"#-%*")                     --[[Find the substring on the asterisk floor
                                                  with '#' symbols preceding an asterisk.
                                                ]]

Answer 14

कॉफीस्क्रिप्ट, 110 बाइट्स और जावास्क्रिप्ट, 121 बाइट्स

(s)->s.split('\n').reverse().map((f,g)->f.split('  ').map((h,i)->r=h.indexOf('*');s=''+i+g+r if r>-1));111+1*s

पठनीय

(s)->
    s.split '\n' 
        .reverse()
        .map (f,fi)->
            f.split('  ')
                .map (h,hi)->
                    ri = h.indexOf('*')
                    s = ''+hi+fi+ri if ri>-1
    111+1*s

मूल रूप से जावास्क्रिप्ट में एक ही बात:

(s)=>{s.split('\n').reverse().map((f,g)=>f.split('  ').map((h,i)=>{r=h.indexOf('*');r>-1?s=''+i+g+r:''}));return 111+1*s}

Answer 15

जावा, 231 बाइट्स

String a(String a){String[]b=a.split("\n");int i=0,c=b.length,m;String x,k=" ";for(;i<c;i++){x=b[c-1].substring(0,b[i].indexOf("*")+1);m=x.length();a=m>0?""+(m-x.replace(k+k,k).length()+1)+(c-i)+(m-x.lastIndexOf(k)-1):a;}return a;}

डी-golfed

 String a(String a) {
     String[] b = a.split("\n");                                // Split the input into floor lines
     int i = 0, c = b.length, m;                                // i=floor line counter c= number of floor lines
     String x, k = " ";
     for (; i < c; i++) {                                       // Loop through floor lines
        x = b[c - 1].substring(0, b[i].indexOf("*") + 1);       // x = part of bottom floor line up to '*' position in current line (Empty string when no '*')
        m = x.length();                                         // m = length of floor line part
        a = m > 0 ? "" + (m - x.replace(k + k, k).length() + 1) // if m>0 ('*' is on this line) set a=building no+floor no+room no.   building no calculated by replacing double space in x with single space and compare length to x (+1) 
              + (c - i)                                         // floor number is total floor lines (c) - floor line loop counter (i)
              + (m - x.lastIndexOf(k) - 1) : a;                 // room number is m ('*' position in x) - position of last space in x (-1)
     }
     return a;                                                  // return the result at the end.
  }

Answer 16

पॉवर्सशेल, 154 बाइट्स

param($s)filter s{$s|sls $_ -a|% M*|% Le*}(($s-split'
')[-1]|% s*g 0('(?m)^.*\*'|s)|sls '^|  '-a|% M*).Count,('(?ms)(?<=\*.*)$'|s).Count,('#*\*'|s)-join''

कम गोल्फ परीक्षण स्क्रिप्ट:

$f = {

param($s)

filter s{
    $s|sls $_ -AllMatches|% Matches|% Length
}                                   # select an array of lengths of all matches of the string $s by pattern $_

$hpos='(?m)^.*\*'|s                 # horizontal position of the room in the source string
$basement=($s-split"`n")[-1]        # basement floor string

$building=($basement|% substring 0 $hpos|sls '^|  ' -AllMatches|% Matches).Count
                                    # truncate the basement to the position of the room
                                    # and count all double spaces or a 'start of string'
$floor=('(?ms)(?<=\*.*)$'|s).Count  # count all 'end of line' after the room
$room='#*\*'|s                      # count all #, preceding the room, and room itself

$building,$floor,$room-join''


}

@(

,(@"
*
"@, 111)

,(@"
#  #  *  #  #
"@,311)

,(@"
#####
#####
####*
#####
#####
"@, 135)

,(@"
        #####
        #####           ######
        #####           ######
#  #  #  #####  #  #  #  ######  *
"@, 911)

,(@"
#
#  #
#  #  ##
#  #  ##  ###
#  #  ##  ###  #####
#  #  ##  ###  ##*##  ########
#  #  ##  ###  #####  ########
"@, 523)

,(@"
        #
        *
        #
        #
        #
        #
        #
        #
#########  #  #
"@, 281)

,(@"
                        ########*
                        #########
                        #########
                        #########
                        #########
                        #########
                        #########
                        #########
#  #  #  #  #  #  #  #  #########
"@, 999)

) | % {
    $n,$expected = $_
    $result = &$f $n
    "$($result-eq$expected): $result"
}

आउटपुट:

True: 111
True: 311
True: 135
True: 911
True: 523
True: 281
True: 999

Answer 17

05AB1E , 34 बाइट्स

|€SζJðмõ¡εεR'*k>]DOZ©k>;ò®«sĀ€ƶ˜à«

स्ट्रिंग-सूचियों के साथ ज़िप वर्तमान में खराब है। €SζJयह सिर्फ ζ05AB1E के पुराने पायथन विरासत संस्करण में हो सकता था, लेकिन किसी कारण से अब एलिक्जिर रीराइट संस्करण में काम नहीं करता है।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

|                    # Take the input split by newlines
                     #  i.e. "   ###\n#  ###\n#  ###  ##\n#  ##*  ##"
                     #   → ["   ###","#  ###","#  ###  ##","#  ##*  ##"]
 €S                  # Convert each to a list of characters
   ζ                 # Zip, swapping rows and column
    J                # Join them together to a string again
                     #  → [" ###","    ","    ","####","####","###*","    ","    ","  ##","  ##"]
     ðм              # Remove all spaces
                     #  → ["###","","","####","####","###*","","","##","##"]
       õ¡            # Split on empty strings
                     #  → [["###"],[],["####","####","###*"],[],["##","##"]]
ε                    # Map each building to:
 ε                   #  Map each column of the building to:
  R                  #   Reverse the column
   '*k              '#   Get the 0-indexed index of "*"
      >              #   Increase it by 1 to make it 1-indexed
]                    # Close both maps
                     #  → [[0],[],[0,0,1],[],[0,0]]
 D                   # Duplicate the resulting list
  O                  # Sum each building
                     #  → [0,0,1,0,0]
   Z                 # Get the max (without popping)
                     #  → 1
    ©                # Store this max in the register (without popping)
     k>              # Get the index (+ 1) of this max in the sum-list
                     #  → 3
       ;             # Halve it
                     #  → 1.5
        ò            # Round it up to the nearest integer (bankers rounding)
                     #  → 2
         ®           # Retrieve the value from the register again
          «          # Merge the two digits together
                     #  → 21
           s         # Swap so the duplicate list is at the top again
            Ā        # Trutify (0 remains 0, every other integer becomes 1)
                     #  → [[0],[],[0,0,1],[],[0,0]]
             €       # For each building:
              ƶ      #  Multiply the integer with the 1-indexed index
                     #  → [[0],[],[0,0,3],[],[0,0]]
               ˜     # Flatten the list
                     #  → [0,0,0,3,0,0]
                à    # Pop the list, and get the max
                     #  → 3
                 «   # Merge it with the other two digits (and output implicitly)
                     #  → 213

Answer 18

डार्ट , 165 बाइट्स

F(List s)=>s.indexWhere((a)=>a.contains('*'));f(String s){var b=s.split('\n'),v=F(b),c=b[v].split('  '),w=F(c),x=c[w].indexOf('*')+1;return '${w+1}${b.length-v}$x';}

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