13

आप अपने 2 अन्य सबसे अच्छे दोस्तों के साथ रहने वाले एक युवा प्रोग्रामिंग गीक हैं। हर हफ्ते, आप में से किसी को घर के सभी काम करने होते हैं और आप तय करते हैं कि किसकी बारी है छड़ी लेकर। जो सबसे छोटी छड़ी चुनता है वह खो देता है और सभी काम करता है।

जैसा कि आप सभी प्रोग्रामर हैं और पहेलियां बनाना पसंद करते हैं, आपने "सबसे छोटी छड़ी उठाओ" को कंप्यूटर पहेली में बदल दिया है।

यहाँ पहेली के नियम हैं।

आपको एक 2 डी मैट्रिक्स दिया जाएगा, जहां प्रत्येक स्तंभ एक छड़ी का प्रतिनिधित्व करता है।
प्रत्येक कॉलम में, 1 स्टिक के एक हिस्से का प्रतिनिधित्व करता है और 0 एक खाली जगह है
प्रत्येक स्तंभ में ऊपर से नीचे जाने पर, शुरू में आपके पास है 0और जैसे ही आप एक हिट करते हैं 1, छड़ी शुरू हो गई है और बाकी कॉलम 1केवल भर जाएगा
आप एक कॉलम चुनने के लिए अपना प्रोग्राम लिख सकते हैं। उस कॉलम में छड़ी का आकार विजेता / हारने वाला निर्धारित करता है। छड़ी का आकार == उस कॉलम में 1s की संख्या।
हालाँकि, उस प्रोग्राम में केवल एक रैखिक सबसे खराब समय जटिलता हो सकती है।

जैसा कि आप सभी प्रोग्रामर हैं, आपको पता होगा कि क्या किसी और का कार्यक्रम समय जटिलता सीमा की शूटिंग कर रहा है।

आपका काम है:

एक प्रोग्राम या फ़ंक्शन लिखें जो इनपुट को या तो 2 डी प्रारूप या स्ट्रिंग के सरणी में स्वीकार करता है।
इनपुट STDIN / प्रॉम्प्ट / कंसोल या एक फ़ंक्शन तर्क से लिया जा सकता है।
यदि आप STDIN / प्रॉम्प्ट से इनपुट पढ़ रहे हैं तो आप मान सकते हैं कि इनपुट को पढ़ने और इसे किसी अरै में परिवर्तित करने में 0 समय लगता है (भले ही ऐसा करने के लिए कोड आपके उत्तर में हो)
इसमें सबसे लंबी छड़ी के साथ कॉलम का निर्धारण करें।
आउटपुट फ़ंक्शन का रिटर्न मान या STDOUT / कंसोल / अलर्ट हो सकता है।
कार्यक्रम / फ़ंक्शन में रैखिक सबसे खराब स्थिति वाला समय जटिलता होना चाहिए, O(m+n)जहां mपंक्तियों nकी संख्या और स्तंभों की संख्या है।

इनपुट निम्नलिखित स्वरूपों में से एक हो सकता है:

2D सरणी:

[ [0, 0, 0, 0],
  [1, 0, 0, 0],
  [1, 1, 0, 1],
  [1, 1, 1, 1] ]

स्ट्रिंग्स की सरणी:

[ "0000", "1000", "1101", "1111" ]

इनपुट में निम्नलिखित गुण होंगे:

सरणी का आकार अज्ञात है, किसी भी आकार की आयत मान लें
किसी भी कॉलम में, नीचे की ओर आते हुए, यदि आपको 1 दिखाई देता है, तो नीचे सब कुछ एक होगा
खाली-कॉलम (यानी 0-लंबाई) स्टिक की अनुमति है।

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

कृपया अपने कोड की व्याख्या करें, या अनगुल्ड संस्करण (समय जटिलता को सत्यापित करने के लिए) के साथ दो इनपुट स्वरूपों की अपेक्षा करें।

UPDATE रैखिक समय की जटिलता का अर्थ है O (n + m) जहां n स्तंभ आकार है और m पंक्ति आकार है। (उन लोगों के लिए जो अस्पष्ट थे)

अद्यतन 2 यह निश्चित रूप से रैखिक समय में किया जा सकता है। और यदि आप एक उत्तर पोस्ट कर रहे हैं, तो एक निष्पक्ष लड़ाई के लिए कुछ दिनों तक तर्क / एल्गोरिथ्म पोस्ट करने में देरी महसूस करें :)

अद्यतन 3 मैं समय की जटिलता और कार्यक्रम को मान्य करने के लिए कुछ घंटों में सभी उत्तरों पर जाऊंगा :)

code-golf restricted-complexity

— अनुकूलक
स्रोत

2

मेरा तर्क है कि यह O (n + m) में नहीं किया जा सकता है, क्योंकि प्रत्येक सेल में महत्वपूर्ण मान (यानी सबसे लंबी छड़ी / स्तंभ का पहला "1") हो सकता है। तो आपको प्रत्येक सेल को देखना होगा, जो O (n * m) लेता है।

— फाल्को

क्या खाली कॉलम हो सकते हैं?

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

@Optimizer: ओह, मैं देख रहा हूँ। आप सही हे। :)

— फाल्को

11

यह O (n + m) में नहीं किया जा सकता है। एक बार जब इनपुट को एक प्रारूप में परिवर्तित कर दिया जाता है, जो यादृच्छिक अभिगम की अनुमति देता है तो शेष प्रसंस्करण O (n + m) हो सकता है, लेकिन आपको एक प्रोग्राम लिखने की आवश्यकता होती है, और सबसे खराब स्थिति में कि 1इनपुट में एकमात्र अंतिम सेल है संपूर्ण इनपुट को पढ़ना आवश्यक है। भले ही भाषा का मानक पुस्तकालय स्टड के लिए यादृच्छिक अभिगम करता हो, दृश्यों के तहत यह इसे बफर कर रहा है और इसलिए लिया गया समय ओमेगा (n * m) है।

— पीटर टेलर

2

यदि आप लोगों को " बस एक फ़ंक्शन बनाने की अनुमति देना चाहते हैं जो एक सरणी को स्वीकार करता है ", तो सवाल यह नहीं होना चाहिए कि उन्हें एक कार्यक्रम लिखना चाहिए। और अगर आपको ऐसे समाधान की आवश्यकता है जो O (N ^ 0.5) में हों जहां N इनपुट का आकार है, तो आपको रैखिक समय के समाधान के लिए नहीं पूछना चाहिए। एक रैखिक समय समाधान पूरे इनपुट को पढ़ सकता है।

— पीटर टेलर

4

GolfScript, 45 वर्ण

:^,:y;0:x{^y(=x=2%y*{y(:y;x\}{x):x}if^0=,<}do

इनपुट को स्ट्रिंग्स की एक सरणी के रूप में लेता है, सबसे लंबे कॉलम का रिटर्न (0-आधारित) सूचकांक। यह ओ ( पंक्तियों + स्तंभों ) पुनरावृत्तियों में चलता है , और प्रत्येक पुनरावृत्ति को अनिवार्य रूप से निरंतर समय (कम से कम निरंतर-समय अंकगणित) लेना चाहिए। लूप के भीतर किए गए एकमात्र सरणी / स्ट्रिंग संचालन तत्व लुकअप ( =) और एक स्ट्रिंग की लंबाई ( ,) ले रहे हैं, जो दोनों गोल्फस्क्रिप्ट में निरंतर समय लेते हैं।

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

स्पष्टीकरण:

यहां अधिकांश समाधानों की तरह, यह कोड मैट्रिक्स के निचले बाएं कोने पर शुरू करके काम करता है, इस आधार पर कि मैट्रिक्स का वर्तमान तत्व 1 या 0 है, और यह उस स्थान के आधार पर स्तंभ का ट्रैक रखता है, जहां वह अंतिम बार उठा था। ।

कार्यक्रम की शुरुआत में, मैं चर को इनपुट सरणी ^, इसकी लंबाई (यानी पंक्तियों की संख्या) y, और 0 से 0 असाइन करता हूं x। स्टैक पर मान 0 भी छोड़ दिया जाता है; निम्नलिखित लूप के दौरान, इसे सबसे लंबे कॉलम के सूचकांक से बदल दिया जाएगा।

मुख्य लूप के भीतर, -th रो ^y(=x=के x-th कैरेक्टर को अर्क करता y-1है ^। यह वास्तव में चरित्र के ASCII कोड को वापस करता है, इसलिए 2%सभी को छोड़ने की जरूरत है लेकिन अंतिम बिट। एक विशेष मामले के रूप में, यदि y0 समतुल्य है (जो तब तक हो सकता है जब पाया गया सबसे लंबा स्तंभ शीर्ष पंक्ति के सभी तरह से पहुंचता है), बिट देखा गया वास्तव में मैट्रिक्स (इंडेक्स -1) में अंतिम पंक्ति से आएगा , लेकिन निम्नलिखित y*इसे शून्य करने के लिए मजबूर करता है, इस प्रकार प्रभावी रूप से मैट्रिक्स के शीर्ष पर एक वर्चुअल ऑल-ज़ीरोस पंक्ति बनाता है।

इसके बाद निम्नलिखित ifदो कोड ब्लॉक में से एक को निष्पादित करेगा, जो इस बात पर निर्भर करता है कि देखा गया बिट गैर-शून्य (सत्य) या शून्य (गलत) है या नहीं। यदि गैर-शून्य, yएक से घटाया जाता है, और xस्टैक पर सबसे लंबा कॉलम इंडेक्स को बदलता है (पुराने मूल्य के साथ अस्थायी रूप से इसके शीर्ष पर छोड़ दिया जाता है)। यदि शून्य है, xतो बस एक (और अस्थायी रूप से स्टैक पर, सबसे ऊँचे कॉलम इंडेक्स के ऊपर) से बढ़ा हुआ है।

अंत में, ^0=मैट्रिक्स की पहली पंक्ति को निकालता है, ,इसकी लंबाई लौटाता है, और इसकी <तुलना स्टैक पर अस्थायी रूप से छोड़े गए कॉलम इंडेक्स के साथ करता है (जो बराबर होगा xअगर यह सिर्फ इंक्रीमेंट हुआ हो) यदि इंडेक्स कम है तो पंक्ति की लंबाई, लूप दोहराता है।

Ps। मेरे परीक्षण के आधार पर, ,<लूप के अंत में स्ट्रिंग लंबाई परीक्षण को बदलकर इस प्रोग्राम को एक वर्ण से छोटा करना संभव है >, जो दिए गए इंडेक्स में स्ट्रिंग को काटता है और अंतिम भाग को वापस करता है (जो खाली होगा, और इस प्रकार झूठे, लूप के अंत में)। हालाँकि, जैसे कि एक स्ट्रिंग काटते समय ऐसा प्रतीत होता है कि गोल्फस्क्रिप्ट (या, बल्कि रूबी में, जिसे गोल्फस्क्रिप्ट शीर्ष पर चलता है) के निरंतर संचालन के रूप में लागू किया जाता है, मुझे ऐसा कहते हुए कोई आधिकारिक दस्तावेज नहीं मिला है। बस सुरक्षित होने के लिए, मैंने थोड़ी देर की सुविधा के लिए चुना है, लेकिन निश्चित रूप से O (1), उपरोक्त संस्करण।

— इल्मरी करोनें
स्रोत

6

रूबी, 83 75 68 66 63 बाइट्स

f=->m{m[b=c=i=0].map{(c=i;b-=1)while(r=m[b-2])&&r[i]>0;i+=1};c}

एक फ़ंक्शन को परिभाषित करता है fजो इनपुट के रूप में 2D सरणी फॉर्म लेता है।

मैं नीचे बाईं ओर शुरू कर रहा हूं, अधिकतम छड़ी की लंबाई (वास्तव में, शून्य से) और इसी कॉलम का ध्यान रख रहा हूं। प्रत्येक कॉलम में, यदि 1पिछली अधिकतम स्टिक लंबाई के ऊपर अभी भी एस है, तो मैं स्टिक को अंत तक चलता हूं और नई अधिकतम लंबाई और कॉलम को याद करता हूं। इसका मतलब है कि मैं स्तंभों के साथ और पंक्तियों के साथ एक बार सबसे अधिक पुनरावृत्ति कर रहा हूं (विशेष रूप से मैं अधिकतम छड़ी की लंबाई के रूप में जहां तक इसे पुनरावृत्त कर रहा हूं), जो ठीक है O(m+n)।

— मार्टिन एंडर
स्रोत

@ ओप्टिमाइज़र मैंने आपके पोस्ट को संपादित करने के बाद तक नहीं देखा था, इसलिए यह वैसे भी संपादन इतिहास में था। इसलिए मैं इसे सिर्फ उन लोगों के लिए एक बिगाड़ने में लगा देता हूं जो इसे खुद समझ लेना चाहते हैं।

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

4

पायथन 2 - 71, 69, 73, 75 81

j=i=-1
M=input()
for m in M[0]:
 j+=1
 while-i<len(M)and M[i][j]:i-=1;J=j
print J

— फ़ाल्को
स्रोत

क्या यह पायथन 2 या 3 में चलाने का इरादा है? इनपुट कैसा दिखना चाहिए?

— feersum

1

@ फैर्सम पायथन 2, सरणियों का सरणी।

— जस्टिन

@ फ़ेर्सम: क्विनकुंक्स सही है। जैसा कि आपने सुझाव दिया था इनपुट इनपुट की एक 2 डी सरणी है।

— फाल्को

iयदि एक छड़ी एक पूरे स्तंभ को उठा ले तो सीमा से बाहर नहीं जाएंगे?

— xnor

1

क्षमा करें, लेकिन यह लूप की स्थिति jको 0तोड़ने से गिनती में बदलने जैसा दिखता है i*j।

— xnor

2

सी, 64 बाइट्स

संपादित करें: मैंने जाना कि सवाल सबसे लंबे कॉलम का स्थान पूछता है और इसकी लंबाई नहीं।

पहली पंक्ति गोल्फ कोड है और बाकी नमूना मंगलाचरण है।

g(int m,int n,int**a,int*r){for(*r=n;n*m;a[m][n]?m--,*r=n:--n);}

/* usage:
    m = number of rows
    n = number of columns
    a = 1-based 2D array such that a[i][j] gives the value at the ith row and jth column
    r = address of return value 
    Returns (to r) the 1-indexed location of a column with the longest length, or 0 if n=0
    */

int main()
{
    int flat[4*4] = {1, 0, 0, 0,
                     1, 0, 0, 1,
                     1, 1, 0, 1,
                     1, 1, 1, 1};
    int*twoD[4] = {flat-1,flat+3,flat+7,flat+11};
    int ret;
    g(4,4,twoD-1,&ret);
    printf("%d", ret);
    return 0;
}

// old function which determines longest length (65 bytes)
f(int m,int n,int**a,int*r){for(*r=m;n*m;a[m][n]?m--:--n);*r-=m;}

— feersum
स्रोत

प्रभावशाली! क्या आप intकिसी भी संयोग से फंक्शन सिग्नेचर में सेंध लगा सकते हैं या वहाँ के पॉइंटर्स के कारण काम नहीं करते हैं?

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

1

इनपुट में केवल सरणी होनी चाहिए। आप सरणी के आकार के बारे में कार्यक्रम नहीं बता सकते।

— अनुकूलक

रुको, क्या यह वास्तव में काम करता है? यह सबसे लंबी छड़ी की लंबाई लौटाता है और इसकी स्थिति नहीं है: ideone.com/YEzqzl

— मार्टिन

2

@ ऑप्टिमाइज़र जो मूल रूप से सी में असंभव है

— मार्टिन

हो सकता है, लेकिन यह सवाल है :)

— अनुकूलक

2

सी #: 236 शुल्क

int p(int[,] a){int y=0,s=0,i=0,x;for(;++y<=a.GetUpperBound(0);)for(x=i;x<=a.GetUpperBound(1);){if(a[y,x++]==0)break;s=y;i++;}return s;}

ungolfed:

int p(int[,] a)
{
    int selectedRow=0;
    int maxLength=0;
    for(var y = 0; y<=a.GetUpperBound(0); y++)
        for(var x=maxLength; x<=a.GetUpperBound(1); x++)
        {
            if(a[y,x++]==0)
                break;
            selectedRow=y;
            maxLength++;
        }
    return selectedRow;
}

— स्टेफ़न शिंकेल
स्रोत

2

PHP 5.4 - 108 बाइट्स

(113 यदि आप शामिल हैं <?php)

इनपुट प्रारूप: ऐरे को JSON स्ट्रिंग के रूप में पढ़ा जाएगा।

php longest_stick.php "[[0, 0, 0, 0],[1, 0, 0, 0],[1, 1, 0, 1],[1, 1, 1, 1]]"

व्हाट्सएप ने पठनीयता के लिए जोड़ा - सभी नए समाचार और प्रमुख स्थान हटाए जा सकते हैं।

<?php
$t=count($s=json_decode($argv[1]))-1;
foreach($s[0] as $k=>$_)
    while($s[$t][$k]) {
        $t--;
        $l = $k;
    }
echo $l?:0;

न्यूनतम संस्करण:

<?php $t=count($s=json_decode($argv[1]))-1;foreach($s[0] as $k=>$_)while($s[$t][$k]){$t--;$l=$k;}echo $l?:0;

यहां मार्टिन से एल्गोरिथ्म चुराने की तरह, लेकिन उन भाषाओं के साथ खेलना अच्छा लगता है जिन्हें अक्सर यहां XD के रूप में नहीं देखा जाता है

— नीट द डार्क एबसोल
स्रोत

@ MartinBüttner मैंने आपके एल्गोरिथ्म को "चोरी" कर लिया है, इसलिए यह अब O (n + m) होना चाहिए। मुझे लगता है कि यह सही है XD

— नीट द डार्क एबोल

आप बदल सकते हैं $s=json_decode($argv[1]);$t=count($s)-1;के साथ $t=count($s=json_decode($argv[1]))-1;(-3 बाइट्स)।

— ब्लैकहोल

@ ब्लेकहोल वास्तव में आप कर सकते हैं। धन्यवाद!

— रात

@ ब्लेकहोल मुझे लगता है कि कार्यक्षमता टूट जाएगी। यह शर्त पूरी न होने पर भी कार्य करेगा।

— नीट द डार्क एबोल

@ ब्लेकहोल अभी भी इसे तोड़ता है, मुझे डर है $t--कि शर्त पूरी होने पर ही XD होना चाहिए।

— रात

2

कोबरा - 98

def f(a)
    s,x,y=0,0,a.count-1
    while y+1and x<a[0].count
        while a[y][x],y,s=y-1,x
        x+=1
    print s

— Οurous
स्रोत

2

C ++ :: 78

अन्य सी समाधान के विपरीत, यह पूरा कार्यक्रम है। (कोई आह्वान की जरूरत नहीं है, फ़ंक्शन को सरणी का आकार बताने की आवश्यकता नहीं है)। दुर्भाग्य से इसका मतलब यह है कि यह mainएकल चरित्र फ़ंक्शन नाम के बजाय उपयोग किया जाना चाहिए, मुझे इनपुट की व्याख्या करनी होगी और फिर उत्तर को आउटपुट करना होगा, जहां दूसरा समाधान "अन्यत्र" संभालता है। इसके अलावा मेरा पहला कोड गोल्फ।
के साथ संकलित g++ file.cpp -include iostream, ./a 000 010 110 111(उदाहरण के लिए) == तार के साथ चलाएं (मुझे विश्वास है कि यह प्रश्न युक्ति में अनुमति है)

int c;main(int r,char**v){for(r--;r*v[r][c];v[r][c]-48?std::cout<<c,r--:++c);}

उपरोक्त संस्करण प्रत्येक पुनरावृत्ति पर अब तक मिले सबसे अच्छे वर्तमान आउटपुट का उत्पादन करता है। अंतिम आउटपुट अंक का उत्तर है। नीचे दाईं ओर के बजाय बाईं ओर से प्रसंस्करण से स्विचिंग और 0अनुक्रमण ने इस समाधान को 10 (!) वर्णों से कम कर दिया।
c ++ पर स्विच करने से एक से अधिक वर्णों की std::cout<<तुलना में प्रस्तुत करना कम होता है putchar(-48)और इसे उचित आउटपुट के साथ स्पष्ट रूप से 9 से अधिक छड़ें का समर्थन करना चाहिए (हालांकि यह प्रत्येक आउटपुट को अलग करने के लिए कठिन हो सकता है)
उत्तर क्षेत्र को हटाते हुए और इसे अन्य पात्रों को भयंकर रूप से काट देता है। यह अब केवल सबसे अच्छा आउटपुट देता है जब यह ऊपर जाता है जो कुछ आउटपुट को कम से कम काट देता है।
संपूर्ण फ़ाइल अब केवल 78 बाइट्स आकार में है - फ़ंक्शन के पास केवल समाधान जो अन्य हैCप्रस्तुत उपयोग (कहा समारोह का समर्थन करने के लिए अतिरिक्त कोड के साथ)।

जैसा कि नीचे दिया गया विवरण पुराना है:

cवैश्विक है इसलिए इसके साथ इनिशियलाइज़ किया गया 0
rहै इनपुट्स (पंक्तियों) की संख्या +1 (प्रोग्राम का नाम) अमान्य होने के
vसाथ स्ट्रिंग्स का सरणी है v[0](प्रोग्राम का नाम)
जैसा कि यह 0 अनुक्रमित है, rसीमा से बाहर है, इसलिए अपघटन।
जबकि r!=0(मान्य स्ट्रिंग पर इशारा करते हुए) और चरित्र cस्ट्रिंग में अशक्त टर्मिनेटर नहीं है '\0'
अगर चरित्र नहीं '0' है
एक पंक्ति (ऊपर जाना r) और आउटपुट स्तंभ ( c)
अगले स्तंभ के लिए और जाने ( c)

किया

क्या मैं इसे और भी आगे बढ़ा सकता हूँ?

अ-कोड कोड (अतिरिक्त आउटपुट के साथ):

#include <stdio.h>
#include <string.h>

int main(int argc, char* argv[])
{
  int rows = argc-1;
  int cols = strlen(argv[1]);
  int ans;

  printf("rows: %d, cols: %d\n",rows, cols);

  while((rows)&&cols)
  {
    if (argv[rows][cols-1]-'0')
    {
      printf("stick @%d,%d\n",cols,rows);
      ans = cols;
      rows--;
    }
    else
    {
      printf("no stick @%d,%d\n",cols,rows);
      cols--;
    }
  }
  printf("%d",ans);
}
यह पंक्तियों की संख्या का पता लगाने के लिए तार की लंबाई का उपयोग करता है और पंक्तियों की संख्या को खोजने के लिए argc करता है। निचले दाएं कोने में शुरू करना, यह इन सरल नियमों का पालन करता है: यदि सेल एक छड़ी है, तो वर्तमान कॉलम पर उत्तर सेट करें, ऊपर जाएं। यदि सेल छड़ी नहीं है, तो बाईं ओर जाएं। O (n + m): जैसा कि यह केवल ऊपर और बाएं चलता है, इसमें केवल अधिकतम n + m रीड हो सकते हैं। यह जल्दी बाहर निकलता है अगर यह सरणी के ऊपर या बाईं ओर गिरता है।

— Baldrickk
स्रोत

1

OCaml - 144 अक्षर

let s a=Array.(let rec f i j m=if i=0then m else if a.(i).(j)=0then if j=length a.(i)-1then m else f i(j+1)m else f(i-1)j j in f(length a-1)0 0)

एक int array arrayइनपुट के रूप में लेता है , और अगर यह एक 1या एक को देखता है, तो नीचे या बाएँ से शुरू होता है 0। कॉलम की गिनती शुरू होती है 0।

प्रयोग

 s [| [| 0; 0; 0; 0 |]; [| 0; 0; 1; 0|]; [| 1; 0; 1; 0 |]; [| 1; 1; 1; 0 |]; [| 1; 1; 1; 1 |] |];;
 - : int = 2

Ungolfed

let s a = Array.(
  let rec f i j m = (* m is the longest stick seen so far *)
    if i=0 then m (* A column is full: this is the longest possible stick and j=m anyway *)
    else if a.(i).(j)=0 then (* current column is shorter than a previously seen stick *)
      if j=length a.(i)-1 then m (* we have examined all columns, just return m *)
      else f i(j+1) m (* start examining next column *)
    else f (i-1) j j (* current column is longer than all the ones previously seen. Check how long the stick is *)
  in
  f (length a-1) 0 0)

— Virgile
स्रोत

0

टी-एसक्यूएल - 71 64

इनपुट के रूप में तालिका A लेता है

SELECT IDENTITY(INT, 1, 1) R, A INTO A
FROM (VALUES
 ('0000')
,('1000')
,('1101')
,('1111')
) AS A(A)

और क्वेरी है

SELECT TOP(1)CHARINDEX('1',A)FROM A WHERE A LIKE'%1%' ORDER BY R

SQLFiddle

यह तालिका द्वारा पहली पंक्ति को आर द्वारा आदेशित करता है जहां स्ट्रिंग 1 में 1 है।

TOP(1) पहली पंक्ति में परिणाम को प्रतिबंधित करता है।

CHARINDEX('1',A) यदि यह नहीं मिला है तो पहले 1 की स्थिति स्ट्रिंग या शून्य में देता है।

WHERE A LIKE'%1%' पंक्तियों को फ़िल्टर करता है जहाँ A में 1 होता है

ORDER BY R यह सुनिश्चित करता है कि तालिका ऊपर से नीचे पढ़ी जाए

— MickyT
स्रोत

क्या आप बता सकते हैं कि उस कोड में क्या चल रहा है? : टी-एसक्यूएल के साथ कोई अनुभव नहीं

— ऑप्टिमाइज़र

मैं देख रहा हूं, इसलिए प्रत्येक पंक्ति भाग O (n * m) ऑपरेशन पर फ़िल्टरिंग नहीं है? अर्थात् रैखिक समय जटिलता नहीं।

— ऑप्टिमाइज़र

कहना मुश्किल है। SQL इंजन कॉलम में 1 के लिए सभी पंक्तियों की जाँच करेगा। यह केवल ऊपर से नीचे की पहली पंक्ति को ही लौटाएगा जो क्वालीफाई करता है। तो इस स्थिति में यह पूरी तालिका को स्कैन करता है। कॉलम वाली पंक्तियों को फिल्टर करता है। पहचान कॉलम पर परिणामों को सॉर्ट करता है और पहला परिणाम देता है।

— मिकी

इसे इस तरह देखें: क्या होगा यदि आपकी पंक्तियाँ "0000", "0000", "0000", "0001" जैसी हैं। इस मामले में, इसे अंतिम पंक्ति तक और पंक्ति के अंतिम चरित्र तक 1 की उपस्थिति का पता लगाना होगा

— अनुकूलक

1

तो हाँ, यह O (m * n) है तब :)

— अनुकूलक

0

डेल्फी 122 वर्ण

उच्छ्वास ... यह एक ऐसी स्वैच्छिक भाषा है।

अद्यतन: बदलने के समारोह में 6 अक्षर जोड़ने के लिए मैं से पूर्णांक के लिए वापसी प्रकार है। फ़ंक्शन को अभी भी संकलित किया गया है क्योंकि परीक्षण कार्यक्रम में "टाइप I = पूर्णांक" था; कार्यक्रम के पुराने संस्करण से बचे हुए कथन।

function S(A:array of string):integer;var n,c:integer;begin n:=0; repeat c:=Pos('1',A[n]);inc(n) until c>0; result:=c;end;

— Penguino
स्रोत

क्या आप Array की प्रत्येक पंक्ति (आपके मामले में, स्ट्रिंग) पर Pos () कॉल कर रहे हैं?

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र हाँ, प्रोग्राम ऐरे में प्रत्येक स्ट्रिंग ('इंक' (n) 'का उपयोग करके) को तब तक खोजता है जब तक कि वह' 1 'न मिल जाए। पाया गया पहला '1' उच्चतम (या बराबर उच्चतम) '1' होगा, इसलिए स्ट्रिंग में इसकी स्थिति (स्ट्रिंग 1-ndexed में डेल्फी) सबसे लंबे स्तंभ की स्थिति होगी। यदि रूट में कोई '1' नहीं है, तो रूटीन विफल हो जाता है, लेकिन मेरा मानना है कि यह टूटा हुआ इनपुट होगा, क्योंकि तब "सबसे लंबी छड़ी" नहीं मिलेगी।

— पेंगुइन

1

तो सबसे पहले, यह एक वैध इनपुट है: "0000", "0010", "1111"दूसरी बात, आपका जवाब रैखिक समय जटिलता आवश्यकता को पूरा नहीं कर रहा है

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र हाँ, यह मान्य इनपुट होगा और 3 जी स्टिक की सही पहचान करेगा। लेकिन मुझे एहसास हुआ कि पोस्ट बनाने के बाद मैंने अपने वैध आदेश एन प्रोग्राम को परिवर्तित कर दिया था, जो सरणियों का उपयोग करता था, एक अमान्य आदेश एन ^ 2 प्रोग्राम में जो स्ट्रिंग्स का उपयोग करता था (~ 160 अक्षरों से कमी का पीछा करते हुए)।

— पेंगुइन

0

योजना - 236 चार्ट

डेल्फी संस्करण की तुलना में अधिक समय तक ... योजना के साथ इसे और अधिक कुशलता से करने का एक तरीका है। और इससे भी बदतर - मैंने अभी देखा कि यह ऑर्डर m * n है।

(define (s l) (cond ((eq? (cdr l) '()) (car l)) (else (map + (car l) (s (cdr l)))))) (define (u l) (define (t n p q l) (cond ((eq? l '()) p) ((< n (car l)) (t (car l) q (+ 1 q) (cdr l))) (else (t n p (+ 1 q) (cdr l))))) (t 0 0 1 (s l)))

l फॉर्म की एक सूची है '((0 0 0 0) (1 0 0 0) (1 1 0 1) (1 1 1 1))। मुझे लगता है कि यह योजना के लिए 2 डी सरणी इनपुट का एक उचित प्रतिनिधित्व है।

(एसएल) nuimbers की सूची की सूची के उप-सूचियों में से प्रत्येक के एन-वें तत्वों को, इसलिए (एस (0 0 0 0)) (1 0 0 0) (1 1 0 1) (1) 1 1))) वापस आएगा (3 2 1 2)।

(उल) संख्याओं की सूची की सबसे बड़ी प्रविष्टि (हेल्पर फ़ंक्शन टी का उपयोग करके) का 'इंडेक्स ’लौटाता है, इसलिए (u' (3 2 1 2)) 1 (सूची में सबसे बड़ा तत्व '3 के रूप में) लौटेगा (३ २ १ २) १ स्थान पर है)।

— Penguino
स्रोत

सभी उपविदों को सारांशित करना एक O (m * n) ऑपरेशन है।

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

0

रैकेट 70

golfed:

(define(h m)(for/last([r m]#:final(memv 1 r))(length(takef r even?))))

माना जाता है कि इनपुट एक द्वि-आयामी सरणी है, जो रैकेट में सूचियों की सूची होगी:

(define m 
  '((0 0 0 0)
    (1 0 0 0)
    (1 1 0 1)
    (1 1 1 1)))

Ungolfed:

(define (h m)
  ;; step through rows, stopping at the first that contains a 1
  (for/last ([r m] #:final (memv 1 r)) 
    (length (takef r even?)))) ; pop off the leading zeroes to get the column index

सबसे लंबे समय तक छड़ी के साथ कॉलम इंडेक्स लौटाता है।

— मैथ्यू बटरिक
स्रोत

तो मूल रूप से आप प्रत्येक कॉलम के माध्यम से जा रहे हैं और संख्या की गिनती कर रहे हैं 1?

— ऑप्टिमाइज़र

में तुम्हारी बात समझ रहा हूँ। एल्गोरिथम अपडेट किया गया।

— मैथ्यू बटरिक

इसमें अभी भी O (m * n) की सबसे खराब स्थिति है (उस मामले के लिए जिसमें 1मैट्रिक्स में नहीं है, या केवल नीचे की पंक्ति में है)।

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

0

जावास्क्रिप्ट, ईएस 6, 76 वर्ण

W=a=>(j=>{for(k=i=a.length-1;~i&~j;)a[i][j]?(k=j,i--):j--})(a[0].length-1)|k

सरणी इनपुट की सारणी लेता है।

— अनुकूलक
स्रोत

0

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

दोनों इनपुट प्रारूप लेता है

f=(a,t)=>a.reduceRight((p,c)=>t+1?t:(x=c.indexOf(1,p))+1?x:t=p,0)

व्याख्या की:

नीचे से ऊपर तक Iterates। प्रत्येक मूल्य पर इनपुट के आधार पर उपयोग String.prototype.indexOf()या Array.prototype.indexOf()निर्भर करता है। पिछले ऑफसेट से 1 के साथ प्रत्येक पंक्ति के पहले सूचकांक को ढूँढता है, अगर यह कोई नहीं पाता है तो यह tचर को अंतिम ऑफसेट में सेट करता है और अब indexOfकॉल नहीं करता है।

— जॉर्ज रीथ
स्रोत

indexOfO(log n)या तो में काम करता है O(n), तो समग्र एल्गोरिथ्म में कभी नहीं होगाO(m + n)

— अनुकूलक

@ ऑप्टीमाइज़र हाँ को एहसास हुआ कि इसका O (m * n) सीधा नहीं सोच रहा था।

— जॉर्ज रीथ

@ ऑप्टिमाइज़र अपडेट किया गयाO(m+n)

— जॉर्ज रीथ

सबसे लंबी छड़ी उठाओ

GolfScript, 45 वर्ण

स्पष्टीकरण:

रूबी, 83 75 68 66 63 बाइट्स

पायथन 2 - 71, 69, 73, 75 81

सी, 64 बाइट्स

PHP 5.4 - 108 बाइट्स

कोबरा - 98

OCaml - 144 अक्षर

प्रयोग

Ungolfed

टी-एसक्यूएल - 71 64

डेल्फी 122 वर्ण

योजना - 236 चार्ट

रैकेट 70

जावास्क्रिप्ट, ईएस 6, 76 वर्ण

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