टॉयलेट में सम्मानजनक रहें

Question

बेशक, टॉयलेट में सम्मानजनक कैसे होना है, इसके बारे में एसई नेटवर्क बहुत ही जानकार है, लेकिन आप में से उन लोगों के लिए जिन्हें रीमैप की जरूरत है, इज्जतदार होने का मतलब है कि टॉयलेट को फ्लश करना, आदि। सबसे महत्वपूर्ण, हालांकि, इसका मतलब है कि स्टाल का उपयोग करना। जितना संभव हो दूसरों से।

चुनौती

स्टालों के एक सेट के ब्लूप्रिंट को देखते हुए, जिनके संकेत स्ट्रिंग के रूप में उपयोग किए जाते हैं, आपको एक फ़ंक्शन या प्रोग्राम से वापस लौटना चाहिए या प्रिंट करना चाहिए जहां आपके व्यवसाय करने के लिए सबसे सम्मानजनक स्थान है।

इनपुट

 0 1 2 3 4 5    <- The stall number which is not actually visible in the input. 
| | |-| |-|-|   <- the stalls

स्टॉल को बाएं से दाएं बढ़ते हुए क्रम में क्रमांकित किया गया है। हमेशा कम से कम एक खाली स्टाल होगा। एक इनपुट में 50 स्टॉल हो सकते हैं। यदि आप ऐसा करना चाहते हैं, तो आप इनपुट को 0एस और 1एस या बूलियन के एक सरणी या स्ट्रिंग के रूप में भी ले सकते हैं ।

उपयोग में स्टाल -उन में (पाइप के बीच में) है।

उत्पादन

सबसे अधिक सम्मानजनक स्टाल वह है जो उपयोग में आने वाले लोगों से सबसे दूर है। दो स्टालों के बीच की दूरी उनके ऊपर की संख्या के अंतर का पूर्ण मूल्य है।

बस स्पष्ट होने के लिए: आप सभी स्टालों से औसत दूरी पा रहे हैं - न केवल पड़ोसी।

खाली होने के लिए आपको सबसे सम्मानजनक स्टाल की सबसे कम संख्या का उत्पादन करना होगा ।

उदाहरण

Input:
|-| |-| OR 101
Output:
1

Input:
| | |-| |-|-| OR 001011
Output:
0

Input:
|-| |-| | | | |-|-| OR 101000011
Output:
1

Input: 
|-| | | | | |-|-| | | | | OR 100000110000
Output:
11

Input:
|-|-|-|-| | | | | | |-| OR 11110000001
Output:
9

Input:
|-| | OR 10
Output:
1

Input:
|-| | |-| OR 1001
Output:
1

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

आप अपने उत्तर में 0 या 1 आधारित अनुक्रमणिका का उपयोग कर सकते हैं - जो भी आप चाहें; यदि आप 1 आधारित अनुक्रमण का उपयोग करते हैं, तो आपको अपने उत्तर में स्पष्ट रूप से कहना चाहिए।

Comments

" बेशक, एसई नेटवर्क टॉयलेट में सम्मानजनक होने के बारे में बहुत ही जानकार है " [उद्धरण वांछित]

— एलेक्स ए।

@ एलेक्सा।: एसई नेटवर्क की शिक्षा के स्तर (या खुद को शिक्षित करने के लिए) का आकलन करने के लिए यात्रा पर जाने वाले शौचालय के सवालों और जवाबों पर एक नज़र डालें ।

— जोनास

लेकिन हर कोई जानता है कि सम्मान मानदंड न्यूनतम दूरी को अधिकतम करने के लिए है , न कि औसत :-)

— लुइस मेंडू

@ डोप्प्प आपको [1,0,0,1]एक परीक्षण मामले के रूप में जोड़ना चाहिए । वर्तमान परीक्षण मामलों में से कोई भी पुष्टि करता है कि क्या संबंध सही ढंग से टूटे हुए हैं।

— डेनिस

क्यों 1010000111 लौटता है (4 या 5 के बजाय)?

— अमानी किलुमंगा

Answer 1

जेली , 10 9 बाइट्स

JạþTS׬MḢ

1-आधारित अनुक्रमण का उपयोग करता है। इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

JạþTS׬MḢ  Main link. Argument: A (array of Booleans)

J          Yield all indices of A.
   T       Yield all truthy indices of A.
 ạþ        Compute the table of absolute differences.
    S      Compute the sums of all columns.
           For each index, this yields the sum of all distances to occupied stalls.
     ׬    Multiply each sum by the logical NOT of the corresponding Boolean in A.
           This zeroes sums that correspond to occupied stalls.
       M   Maximal; yield an array of all indices of maximal sums.
        Ḣ  Head; extract the first index.

Comments

मेरा मानना ​​है कि 9 अक्षर हैं, 9 बाइट नहीं।

— रेने न्यफेनेगर

जेली एक कस्टम कोड पेज का उपयोग करता है जो केवल उन पात्रों को एनकोड करता है जिन्हें वह प्रत्येक बाइट के रूप में समझता है। बाइट्स यह करने के लिए शीर्ष लेख अंक में जोड़ देते हैं।

— डेनिस

मैं इस बात से अनजान था ... इसे इंगित करने के लिए धन्यवाद।

— रेने न्यफेनेगर

@ डेनिस क्या आपने एक ऑटो-कमेंट यूजरस्क्रिप्ट बनाया है ताकि आप "जेली बाइट्स कमेंट" पर क्लिक कर सकें और यह पोस्ट हो जाएगा?

— NoOneIsHere 16

@NoOneIsHere मेरे पास वह उपयोगकर्तालेख है ( मेरा नहीं ), लेकिन मैंने इसे अभी तक नहीं जोड़ा है। मुझे शायद हालांकि ...

— डेनिस

Answer 2

स्विफ्ट, 158, 157, 128, 100 बाइट्स

Array<Bool>चर से इनपुट लेता है i, अंतिम अभिव्यक्ति से उत्तर देता है।

let e=i.characters.map{$0>"0"}.enumerate()
e.flatMap{$1 ?nil:$0}.map{a in(a,e.flatMap{$1 ?$0:nil}.map{abs(a-$0)}.reduce(0){$0+$1})}.maxElement{$0.1 < $1.1}!.0

1 संपादित करें:

स्ट्रिंग तुलना के माध्यम से बूल में परिवर्तित करके एक बाइट को बचाया

let e=i.characters.map{$0=="1"}.enumerate()
e.flatMap{$1 ?nil:$0}.map{a in(a,e.flatMap{$1 ?$0:nil}.map{abs(a-$0)}.reduce(0){$0+$1})}.maxElement{$0.1 < $1.1}!.0

2 संपादित करें:

मेरे एल्गोरिथ्म का मूल्यांकन किया:

let e=i.characters.map{$0=="1"}.enumerate()
e.map{x in(x.0,x.1 ?0:e.reduce(0){$1.1 ?$0+abs(x.0-$1.0):$0})}.max{$0.1<$1.1}!.0

3 संपादित करें:

नए नियम का लाभ उठाया जो बूलियन सरणी से सीधे इनपुट लेने की अनुमति देता है।

let e=i.enumerated()
e.map{x in(x.0,x.1 ?0:e.reduce(0){$1.1 ?$0+abs(x.0-$1.0):$0})}.max{$0.1<$1.1}!.0

Ungolfed:

// for the sake of easier copy/pasting of input, take it as string
let s = "100000110000"

// convert input to true for taken, false for free
// this is the input the golfed version actually uses
let input = s.characters.map{$0>"0"}

// Returns an array of tuples storing the array values (vacancy of the stall) and their index (their location)
let valueIndexPairs = bools.enumerated()

// Returns an array of pairs of locations and their avg distance to others
let locationDistancePairs = valueIndexPairs.map{(valueIndexPair: (Int, Bool)) -> (Int, Int) in

    let averageDistance = valueIndexPairs.reduce(0) {partialSum, otherStall in

        let otherStallIsTaken = otherStall.1

        if otherStallIsTaken {
            //don't let other stalls effect average if they're taken
            return partialSum
        }
        else {
            let thisStallLocation = valueIndexPair.0
            let otherStallLocation = otherStall.0
            let distanceToOtherStall = abs(thisStallLocation - otherStallLocation)
            return partialSum + distanceToOtherStall 
        }       
    }

    //if this stall is taken, treat its average distance to others as 0
    let thisStallsLocation = valueIndexPair.0
    let isThisStallTaken = valueIndexPair.1
    return (thisStallsLocation, isThisStallTaken ? 0 : averageDistance)
}

//find location where average distance is maxiumum
let bestLocationIndexPair = locationDistancePairs.max{$0.1 < $1.1}!

let bestLocation = bestLocationIndexPair.0

print(bestLocation)

Comments

मुझे स्विफ्ट उत्तर पसंद है

— downrep_nation

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

— अलेक्जेंडर - मोनिका

मुझे शायद समझाना चाहिए कि यह कोड कैसे काम करता है

— अलेक्जेंडर - मोनिका

@downrep_nation मैंने आपकी रुचि के मामले में अस्वास्थ्यकर बरामदे को जोड़ा,

— अलेक्जेंडर - बहाल मोनिका

शायद "आइड" को हटाकर 3 बाइट्स बचाएं यदि आपको इसकी आवश्यकता है या नहीं, लेकिन जो मैं समझता हूं कि आपको "लेट" की आवश्यकता नहीं है, जो केवल एक निरंतर मूल्य के संकेतक के रूप में कार्य करता है

— रोहन झुनझुनवाला

Answer 3

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

1 अनुक्रमित।

³Tạ⁸S
JUÇÞḟTṪ

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

कलन विधि

प्रश्न का Naive कार्यान्वयन।

Comments

मेरे उत्तर + 1 से लगभग 16 गुना छोटा है! (1! == 1)

— रोहन झुनझुनवाला

@ रोहन झुनझुनवाला ने क्या कहा?

— लीक

अनिवार्य रूप से जावा कभी भी जेली को देखकर जवाब नहीं दे सकता है कि 12 बाइट्स लंबे (किसी भी संभव जावा प्रोग्राम से कम) के उत्तर उल्लसित हैं। तो एक उत्थान है ..

— रोहन झुनझुनवाला

@LeakyNun ने गोल्फ से चूक की: D

— रोहन झुनझुनवाला

1001 आउटपुट 3 जब इसे 2 लौटना चाहिए

— डैनियल

Answer 4

जावा "केवल" 270 200 196 187 196 138 148 146 बाइट्स!

लीकी नन की बदौलत 4 13 अनगिनत बाइट्स बचाए ! मिशेल बेलीड को 1 बाइट धन्यवाद

int m(boolean[]b){int r=0,l=b.length,i,j,k=0,z=r;for(i=0;i<l;i++){if(b[i])for(j=0,k=0;j<l;j++)if(!b[j])k+=i>j?i-j:j-i;if(k>z){r=i;z=k;}}return r;}

Ungolfed

int m(int[] s) {
        int l=s.length,i,j=0,k=0;
    boolean[] b = new boolean[l];
    int[] a = new int[l];
    //see what stalls are open
    for (i = 0; i < s.length; i++) {
        if (s[i] == 0){
            b[i] = true;
        }
    }
    //assign the sum of distance to the a[]
    for (i = 0; i < l; i++) {
        if (b[i]) {
            for (j = 0; j < l; j++) {
                if (!b[j]) {
                    a[i]+= Math.abs(i - j);
                }
            }
        }
    }
    //find the stall the greatest distance away breaking ties based on the furthest left
    for (i = 0; i < l; i++) {
        if (b[i] && (a[i] > k || k == 0)) {
            k = a[i];
            j=i;
        }
    }
    //return the index
    return j;
}

एक बूलियन सरणी के रूप में इनपुट जहां सच्चे एक खुले स्टाल का अर्थ है।

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— एलेक्स ए।

आपको सरणी की आवश्यकता नहीं है a।

— लीक नून

@LeakyNun मैं इसे कैसे निकालूं?

— रोहन झुनझुनवाला

एक पुनरावृति में न्यूनतम को खोजने से (छोरों के लिए बाहरी को मिलाएं)

— लीक नून

ओह @LeakyNun आज जब मैं वापस आऊंगा

— रोहन झुनझुनवाला

Answer 5

रूबी, 79 78 76 + nध्वज = 77 बाइट्स

आउटपुट 0-आधारित अनुक्रमण है। इनपुट 0 और 1 के एसटीडीआई लाइन है।

p (r=0...~/$/).max_by{|i|k=0;$_[i]>?0?0:r.map{|j|k+=$_[j]<?1?0:(j-i).abs};k}

Comments

0...~/$/एक अच्छी चाल है। 👍🏻

— जॉर्डन

Answer 6

MATL , 14 बाइट्स

~ftGf!-|Xs&X>)

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

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

व्याख्या

~f     % Implicitly take input. Compute row vector with indices of zeros
t      % Duplicate that
Gf!    % Push input again. Compute column vector of indices of ones
-|     % Absolute differences with broadcast. Gives 2D array with all combinations
Xs     % Sum of each column
&X>    % Arg max. Gives the index of the first maximizer if there are several
)      % Index into row vector of indices of zeros. Implictly display

Answer 7

पर्ल 84 + 3 ( -alpझंडे) = 87 बाइट्स

for$i(0..$#F){$t=0;map{$t+=abs($i-$_)*$F[$_]}0..$#F;($m,$_)=($t,$i)if$m<$t&&!$F[$i]}

जरूरत -alpको चलाने के लिए झंडे। इनपुट के रूप में रिक्त स्थान द्वारा अलग किए गए 1 और 0 की स्ट्रिंग लेता है। उदाहरण के लिए :

perl -alpe '$m=0;for$i(0..$#F){$t=0;map{$t+=abs($i-$_)*$F[$_]}0..$#F;($m,$_)=($t,$i)if$m<$t&&!$F[$i]}' <<< "1 0 1
0 0 1 0 1 1
1 0 1 0 0 0 0 1 1
1 0 0 0 0 0 1 1 0 0 0 0
1 1 1 1 0 0 0 0 0 0 1
1 0"

ध्यान दें कि मैंने $m=0भीख मांगने के लिए जोड़ा था, लेकिन यह केवल कई प्रविष्टियों पर परीक्षण करने के लिए है।

Comments

मैं गिनती +7: F'' alp। -गिने नहीं जाते।

— NoOneIsHere 17

@NoOneIsHere Hum, वास्तव में, यह मेरा बुरा होगा। धन्यवाद

— दादा

Answer 8

मतलाब, 87 बाइट्स

n=input('');k=numel(n);[a b]=ndgrid(1:k);[x y]=max(sum(abs(a-b).*repmat(n,k,1)').*~n);y

उनकी और शून्य की सरणी लेता है; 1-आधारित अनुक्रमण का उपयोग करता है।
कुछ अन्य जवाबों की तरह, अधिकतम औसत दूरी नहीं।
संभवत: कुछ और गोल्फिंग संभव है ...

Answer 9

जावास्क्रिप्ट (ईएस 6), 87 86 82 75 बाइट्स

a=>a.map((u,i)=>u||(a.map((v,j)=>u+=v*(i>j?i-j:j-i)),u>x&&(x=d,r=i)),x=0)|r

एक बूलियन सरणी लेता है (सच / गलत या 1/0)। औसत दूरी की गणना करने का कोई मतलब नहीं है क्योंकि वे सभी एक ही समान कारक का उपयोग कर रहे हैं, इसलिए प्रत्येक स्टाल के लिए कुल दूरी की गणना करें और उच्चतम का पहला सूचकांक ढूंढें। संपादित करें: के *बजाय का उपयोग करके 1 बाइट सहेजा गया &&। मैन्युअल रूप से @Dendrobium द्वारा एक टिप्पणी के आधार पर उच्चतम दूरी पाकर 5 बाइट्स सहेजे गए। u@ Edc65 द्वारा एक टिप्पणी के आधार पर छद्म कम संचायक के रूप में पुन: उपयोग करके 7 बाइट्स सहेजे गए।

Comments

79 बाइट्स:a=>(x=0,a.map((o,i)=>x<(t=a.reduce((r,u,j)=>r+(b=i-j)*b*u*!o,0))&&(x=t,r=i)),r)

— डेंड्रोबियम

@ डेंड्रोबियम प्रश्न पूर्ण दूरी के लिए पूछता है; आप RMS दूरी की गणना करने लगते हैं।

— नील

इनपुट के रूप में एक सरणी का उपयोग करना - अच्छा विचार है। औसत के बजाय कुल गणना - अच्छा विचार। के reduceबजाय का उपयोग करना map- mmmm

— edc65

75:s=>s.map((u,i)=>u||(s.map((w,j)=>u-=w*Math.abs(j-i)),u<x&&(x=u,r=i)),x=0)|r

— edc65

@ नहीं काफी RMS नहीं, बस वर्ग दूरी, जो समाधान के परिणाम को प्रभावित नहीं करना चाहिए जब तक कि nonsymmetric आदानों की कुल दूरी (उदाहरण के 1100011101संबंध में 2और 8जब पूर्ण 8का उपयोग करते समय , का उपयोग करते हुए) में संबंध नहीं हैं , तब से यह मायने नहीं रखता है ऐसा लगता है कि नियमों को स्पष्ट कर दिया गया है और संबंधों को अब बाएं-सबसे स्टॉल के साथ सुलझाया गया है ...

— डेंड्रोबियम

Answer 10

जे, 27 बाइट्स

(#{:@-.~]/:[:+/]|@-/~#)i.@#

ऑनलाइन दुभाषिया ।

Answer 11

रूबी, 87 76 बाइट्स

इस पहले ड्राफ्ट को जल्दी से एक साथ फेंक दिया, लेकिन इस बीच वैल्यू इंक ने पहले ही एक 80 बाइट रूबी जवाब पोस्ट किया था ...

संपादित करें: वैल्यू इंक की मदद से कुछ बाइट्स निकाले:

->a{(r=0...a.size).max_by{|i|a[i]?0:r.map{|j|a[j]?(i-j).abs: 0}.reduce(:+)}}

यह एक अनाम फ़ंक्शन है जो उदाहरण के लिए, सत्य / मिथ्या मूल्यों की एक सरणी लेता है:

f=->->a{(r=0...a.size).max_by{|i|a[i]?0:r.map{|j|a[j]?(i-j).abs: 0}.reduce(:+)}}
# Test case number 5:
p f[[1, 1, 1, 1, nil, nil, nil, nil, nil, nil, 1]] # => 9

Comments

एक चर के लिए प्रारंभिक सीमा निरुपित (r=0...a.size)और फिर उस के बजाय का उपयोग करने पर नक्शा with_index: r.map{|j|a[j]?(i-j).abs: 0}। यह आपको 78 बाइट्स मिलना चाहिए।

— इंक पर वैल्यू इंक

@ValueInk बहुत बढ़िया, धन्यवाद! केवल फ़ंक्शन के साथ, कोई असाइनमेंट नहीं है, मुझे 76 बाइट्स

— मिलते हैं

Answer 12

मैथेमेटिका, 53 बाइट्स

MaximalBy[a=PositionIndex@#;a@0,Tr@Abs[#-a@1]&][[1]]&

1-आधारित इंडेक्सिंग का उपयोग करता है और 0 और 1s की सूची के रूप में इनपुट लेता है।

Answer 13

जावास्क्रिप्ट ईएस 6 - 98 95 91 86 84 88 बाइट्स

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

(r,x=0,f=g=>r.reduce(g,0))=>f((p,o,i)=>x<(o=f((p,c,j)=>p+c*!o*Math.abs(i-j)))?(x=o,i):p)

Ungolfed:

(r,                            // string input
 x=0,                          // current max distance
 f=g=>r.reduce(g,0))=>         // iterator function
   f((p,o,i)=>                 // for each stall
     x<(o=f((p,c,j)=>          // iterate through all stalls and
       p+c*!o*Math.abs(i-j)))? //   calculate sum of distances from current stall
     (x=o,i):                  // if total dist is greater than x, update x, return index
     p)                        //   else return previous max index

टेस्ट रन:

f=(r,x=0,f=g=>r.reduce(g,0))=>f((p,c,i)=>x<(c=+c?0:f((p,c,j)=>p+c*Math.abs(i-j)))?(x=c,i):p)
f([1,0,1])                   // 1
f([0,0,1,0,1,1])             // 0
f([1,0,1,0,0,0,0,1,1])       // 1
f([1,0,0,0,0,0,1,1,0,0,0,0]) // 11
f([1,1,1,1,0,0,0,0,0,0,1])   // 9
f([1,0])                     // 1

Answer 14

लूआ , 165 150 बाय

n=arg[1]n=n:gsub("%|%-","1"):gsub("%| ","0")i=0 for s in n:gmatch("0+")do i=(i<#s)and(#s)or(i)end n,l=n:find(("0"):rep(i))print(n+math.floor((l-n)/2))

यह इस तथ्य का उपयोग करते हुए थोड़ा धोखा देता है कि आम तौर पर, लुआ एक तालिका पारित करता है जिसे arg कहा जाता है जिसमें कोई भी कमांड लाइन इनपुट होता है।

मैं थोड़ा निराश हूं कि मैंने लूप के लिए उपयोग किया है, लेकिन मैं इसे खींचने के लिए एक छोटा तरीका नहीं सोच सकता।

इसके अलावा, क्योंकि लुआ, 1 आधारित अनुक्रमण का उपयोग किया गया था।

एक बेकार gsub से स्निप 15 बाइट्स संपादित करें।

Answer 15

सी #, 127 बाइट्स

public int G(char[]s){int i=0;var l=s.ToLookup(b=>b,b=>i++);return l['0'].OrderBy(j=>l['1'].Average(p=>Math.Abs(p-j))).Last();}

परीक्षण बिस्तर

public static void Main() {
    var respectful = new Respectful();
    foreach (var kvp in testCases) {
        $"{kvp.Key}: Expected {kvp.Value} Actual {respectful.G(kvp.Key.ToCharArray())}".Dump();
    }
}

public static readonly List<KeyValuePair<string, int>> testCases = new List<KeyValuePair<string, int>> {
    new KeyValuePair<string, int>("101", 1),
    new KeyValuePair<string, int>("001011", 0),
    new KeyValuePair<string, int>("101000011", 1),
    new KeyValuePair<string, int>("100000110000", 11),
    new KeyValuePair<string, int>("11110000001", 9),
    new KeyValuePair<string, int>("10", 1),
    new KeyValuePair<string, int>("1001", 1),
};

public class Respectful {
    public int G(char[]s){int i=0;var l=s.ToLookup(b=>b,b=>i++);return l['0'].OrderBy(j=>l['1'].Average(p=>Math.Abs(p-j))).Last();}
}