अंधविश्वासी होटल लिफ्ट

Question

विवरण

यहाँ शंघाई में एक बहुत ही अंधविश्वासी होटल लिफ्ट है:

               

यह संख्या 13 से बचा जाता है, क्योंकि तेरह पश्चिमी दुनिया में अशुभ है, और यह अंक 4 से बचा जाता है, क्योंकि चार एशिया के कुछ हिस्सों में अशुभ है। अगर यह होटल लंबा होता तो क्या होता?

nSTDIN से एक धनात्मक पूर्णांक भी पढ़ें , जो मंजिलों की संख्या का प्रतिनिधित्व करता है, और प्रिंट करें कि बटन लेआउट STDOUT की तरह दिखाई देगा: -1इसके बाद अगला n-1सकारात्मक पूर्णांक जो 13 के बराबर नहीं है और इसमें अंक 4 नहीं हैं। इन्हें व्यवस्थित करें उपरोक्त छवि में दो स्तंभों में संख्याएँ: प्रति पंक्ति दो मंजिल संख्याएँ मुद्रित करें, एक क्षैतिज टैब द्वारा अलग, ताकि बाएं से दाएं से रिवर्स ऑर्डर में पंक्तियों को पढ़ने से आरोही क्रम में अनुक्रम उत्पन्न हो। (आप वैकल्पिक रूप से एक अनुगामी न्यूलाइन वर्ण भी प्रिंट कर सकते हैं।)

परीक्षण के मामलों

इनपुट के लिए 14, आउटपुट उपरोक्त छवि के अनुसार होना चाहिए:

15  16
11  12
9   10
7   8
5   6
2   3
-1  1

जहां प्रत्येक पंक्ति में व्हॉट्सएप एक एकल क्षैतिज टैब वर्ण है।

इनपुट के लिए 2, आपको प्रिंट करना चाहिए -1 1।

इनपुट के लिए 100, आपको प्रिंट करना चाहिए:

120 121
118 119
116 117
113 115
111 112
109 110
107 108
105 106
102 103
100 101
98  99
96  97
93  95
91  92
89  90
87  88
85  86
82  83
80  81
78  79
76  77
73  75
71  72
69  70
67  68
65  66
62  63
60  61
58  59
56  57
53  55
51  52
39  50
37  38
35  36
32  33
30  31
28  29
26  27
23  25
21  22
19  20
17  18
15  16
11  12
9   10
7   8
5   6
2   3
-1  1

लक्ष्य

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

Comments

@ मोरिस 6138, शायद नहीं, लेकिन 113? मुझे लगता है कि जब आप संख्या को जोर से पढ़ेंगे तो कुंजी "तेरह" कहेगी ।

— रैंडम 832

@ Random832 आप जो सुझाव देते हैं, वह प्रभावी रूप से युक्ति के लिए मनमाना परिवर्तन है। PPCG शिष्टाचार उत्तर दिए जाने के बाद इस तरह के बदलावों को हतोत्साहित करता है, खासकर यदि मौजूदा उत्तरों को प्रभावी रूप से अमान्य कर दिया जाता है, जो वे इस मामले में होंगे

— डिजिटल ट्रामा

FWIW, 4 अशुभ नहीं है। 4 बस विभिन्न चीनी बोलियों / भाषाओं में "मर" या "मृत्यु" के समान लगता है।

— स्लीपबेटमैन

@ स्लेबेटमैन: ठीक है, हाँ, इसीलिए 4 अशुभ है। यह अभी भी अंधविश्वास है, जो भी मूल है! लेकिन यह थोड़ा बंद विषय है।

— लिन

रुको! बटन गिनते हुए मैं देखता हूं कि होटल में 13 मंजिल हैं (तहखाने को छोड़कर।) कोई रास्ता नहीं है कि मैं वहां

— लेवल रिवर सेंट

Answer 1

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

jjLC9_c+_1.f&!@\4`ZnZ13tQ)2

इसे यहाँ ऑनलाइन आज़माएँ ।

हो जाता है .first Q-1संख्या कि फिल्टर से मेल खाते !=13और 4संख्या की स्ट्रिंग प्रतिनिधित्व में नहीं है। फिर यह -1आधा भाग में चॉप करता है, प्रत्येक को टैब से जोड़ता है ( C9) और नए सिरे से जुड़ता है।

Answer 2

बैश + आम बर्तन, 51

seq 9$1|sed 13d\;/4/d\;1i-1|rs 0 2|sed $[$1/2]q|tac

• seq 1 से N तक आरोही पूर्णांक बनाता है, जो सामने 9 अतिरिक्त अंक के साथ है - 64 बिट पूर्णांक इनपुट के लिए पर्याप्त से अधिक
• sed-1लाइन 1 से पहले अशुभ फर्श और आवेषण को फ़िल्टर करता है
• rs दो टैब से अलग किए गए कॉलमों में फेरबदल करें
• sed एन / 2 लाइनों के बाद बंद हो जाता है
• tac आउटपुट लाइन क्रम को उलट देता है

Comments

मैं आपके लिए 5 बाइट्स शेव कर सकता हूं - उसके sed $[$1/2]qबाद rsसे sed $1qपहले से बदल दें। मुझे लगता है कि यह POSIX- शेल को भी संगत बनाता है।

— टोबे स्पाइट

अंततः, पूर्ववर्ती 1इनपुट के माध्यम से केवल 0.9 ^ n पास करने के लिए क्षतिपूर्ति करने के लिए पर्याप्त नहीं होगा ( 4अंकों की संख्या बढ़ने पर स्पैसर और स्पैसर युक्त नंबर नहीं )। लेकिन एक बार जब आप अपने होटल में कुछ सौ मिलियन से अधिक फर्श रखते हैं, तो आपको संभवतः अन्य समस्याएं भी होती हैं, जैसे कि प्लंबिंग को काम पर रखना, और कर्मचारियों की रोटियां व्यवस्थित करना।

— टोबे स्पाइट

@TobySpeight आपके पास स्पेस एलेवेटर भी हो सकता है :)

— डिजिटल ट्रॉमा

@TobySpeight यहां तक ​​कि इनपुट (922337203685474780807) के रूप में अधिकतम हस्ताक्षरित 64 बिट पूर्णांक के साथ, बस एक 1 पूर्वसर्ग (बस के बारे में) पर्याप्त है - कम से कम मेरे अल्पविकसित आधार 9 गणना के साथ। बाकी उत्तर शेल $[]अंकगणित के कारण वैसे भी इस सीमा तक सीमित है । मुझे लगता है कि यह सवाल में मनमाने ढंग से सटीक अंकगणित के स्पष्ट उल्लेख के अभाव में एक उचित सीमा है। भले ही, मैं अब के 9बजाय एक उपसर्ग कर रहा हूँ 1, बस सुरक्षित पक्ष पर होने के लिए।

— डिजिटल ट्रामा

Answer 3

जावास्क्रिप्ट ईएस 6, 236 234 233 210 195 188 बाइट्स

एक पूरे झुंड को बचा लिया।

function*जनरेटर के लिए उपयोग करता है । शायद ऐसा करने का एक छोटा तरीका है, लेकिन यह मजेदार था। रास्ता मजेदार। मैं शर्त लगा सकता हूँ कुछ गोल्फिंग किया जा सकता है। वे अजीब व्हाट्सएप चीजें टैब हैं।

z=prompt(i=x=0,l=[]);y=(function*(){while(i<z-x)yield(i?(/4/.test(i)||i==13?--x&&".":i):-1)+(0*++i)})();while(a=y.next().value)+a&&l.push(a);l.join`    `.match(/-?\d+  \d+/g).reverse().join`
`

Comments

z=+prompt(i=x=0,l=[]);==> z=prompt(i=x=0,l=[]);(-1 बाइट)

— usandfriends

@usandfriends धन्यवाद! मैं स्वचालित प्रकार के रूपांतरण के बारे में भूल गया।

— कॉनर ओ'ब्रायन 3

.joinटैब के साथ और टैब के साथ जगह को /-?\d+ \d+/gहटा दें, .map(x=>x.replace(/ /,"\t"))(23 बाइट्स

— बचाएं

.filter(x=>x!=".0")==> .filter(x=>+x), (-5 बाइट्स)

— usandfriends

^ स्क्रैच कि , बस पूरे .filter(..)हिस्से को हटा दें ! कोशिश l.push(a);==> +a&&l.push(a);(-15 बाइट्स)

— usandfriends

Answer 4

सी, 282 बाइट्स

int main(int r,char*v[]){int c=atoi(v[1]),a[c],b,E=1E9,g,i,t,o=t=g=(E)-2;while(i++<c){while(t>0){r=t%10;t=t/10;if(r==4||g==(E)+13||g<=o||g==E)t=++g;}a[i-1]=o=t=g;}for(c-=3;c>=0;c-=2){printf("%d\t",a[c+1]-E);printf("%d\n",a[c+2]-E);}printf("%d\t",a[0]-E);if(i%2)printf("%d",a[1]-E);}

प्रारूपित:

int main ( int r , char * v[] ) {
    int c = atoi ( v[ 1 ] ) , a[c] , b , E = 1E9 , g , i , t , o = t = g = ( E ) - 2;
    while ( i ++ < c ) {
        while ( t > 0 ) {
            r = t % 10;
            t = t / 10;
            if ( r == 4 || g == ( E ) + 13 || g <= o || g == E )t = ++ g;
        }
        a[ i - 1 ] = o = t = g;
    }
    for ( c -= 3 ; c >= 0 ; c -= 2 ) {
        printf ( "%d\t" , a[ c + 1 ] - E );
        printf ( "%d\n" , a[ c + 2 ] - E );
    }
    printf ( "%d\t" , a[ 0 ] - E );
    if ( i % 2 )printf ( "%d" , a[ 1 ] - E );
}

विशेषताएं :

यह 2095984 मंजिलों तक की गणना कर सकता है, अगर प्रत्येक मंजिल 19.5mऊंची (incl। छत) है तो यह इमारत भूमध्य रेखा के चारों ओर लिपटे रहने के लिए पर्याप्त है! 2095984*19.5=40871688m=~40000km=one 'lap' around the planet।

Comments

अच्छा जवाब है, लेकिन आपका भूगोल थोड़ा हटकर है। भूमध्य रेखा से उत्तरी ध्रुव की दूरी परिभाषा en.wikipedia.org/wiki/Metre द्वारा 10000 किमी है, जिसका अर्थ है कि भूमध्य रेखा की परिधि 40000 किमी से थोड़ी अधिक है।

— स्तर नदी सेंट

अच्छी टिप्पणी है, लेकिन मीटर की आपकी परिभाषा थोड़ी पुरानी है। ;-)

— मर्फी

@steveverrill मैंने अभी पहले नंबर का उपयोग किया है जो मुझे Google से मिला, मैं गणना को अपडेट करूंगा।

— x13

आप मुख्य से "int" छोड़ कर कुछ बाइट्स बचा सकते हैं। ई के आसपास ब्रेसिज़ वास्तव में आवश्यक हैं? पहले में whileपरिवर्तित किया जा सकता है forऔर यह आपको कुछ घुंघराले ब्रेसिज़ को छोड़ने की अनुमति देता है। t/=10से एक बाइट कम है t=t/10। forएक जोड़े बाइट को बचाने के लिए आप लूप में 1 से c जोड़ें -> a[c+1]बन जाता है a[c], जबकि अन्य सभी नंबरों की लंबाई समान होती है। मैं भी दो printfs को एक साथ लूप में मिलाता हूँ, और घुंघराले ब्रेस को फिर से गिराता हूँ।

— 14

मुझे लगता है कि "मंजिल ऊंचाई" की आपकी परिभाषा थोड़ी दूर हो सकती है - एक विशिष्ट मंजिल लगभग 3 मीटर लंबा है, न कि 19.5 मीटर लंबा।

— nnonneo

Answer 5

जूलिया, 134 132 बाइट्स

x=[-1;filter(i->i!=13&&'4'∉"$i",1:2(n=parse(readline())))][1:n]
for i=2:2:endof(x) println(join((r=reverse)(r(x)[i-1:i]),"  "))end

उस मजेदार व्हाट्सएप में एक शाब्दिक टैब है। जैसा कि कॉनर ओ'ब्रायन ने कहा, यह एक बाइट करने की तुलना में कम है \t।

Ungolfed:

# Read an integer from STDIN
n = parse(readline())

# Generate all numbers from 1 to 2n, exclude 0, 13, and all numbers containing 4,
# prepend -1, then take the first n
x = [-1; filter(i -> i != 13 && '4' ∉ "$i", 1:2n)][1:n]

# Loop over pairs, print tab-separated
for i = 2:2:endof(x)
    println(join(reverse(reverse(x)[i-1:i]), "  "))
end

Answer 6

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

N=input()
n=['-1']+[`i`for i in range(N*2)if i!=13and'4'not in`i`][1:N]
while n:x=n.pop();print n.pop()+'\t'+x

Comments

मुझे लगता है कि आप i-13इसके बजाय का उपयोग कर सकते हैंi!=13

— 12M2121

Answer 7

जावास्क्रिप्ट, ११६ १२२

सहेजे गए 6 बाइट्स thx @Neil को संपादित करें

सरल सरणी समाधान - ES6 का उपयोग भी नहीं

किसी भी ब्राउज़र के साथ प्रयास करें

/* test */ console.log=function(x){ O.innerHTML+=x+'\n'; }

n=prompt();for(r=[-1],v=1;n;v++)v!=13&!/4/.test(v)&&--n&&r.push(v);for(;r[0];)console.log(a=r.pop(b=r.pop())+'\t'+b)

<pre id=O></pre>

Comments

आप 6 बाइट्स का उपयोग करके बचा सकते हैं !/4/.test(v)।

— नील

आप (शाब्दिक टैब) के ' 'बजाय एक सिंगल बाइट बचा सकते हैं'\t'

— Mwr247

Answer 8

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

n=input();c=-1;s=''
while n:
 if('4'in`c`)==0!=c!=13:n-=1;s=(n%2*'%d	%%d\n'+s)%c
 c+=1
print s

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

स्ट्रिंग में एक टैब कैरेक्टर है जो एसई रेंडर नहीं करता है (इसे इस्तेमाल करने के लिए सुझाए गए Sp3000 के लिए धन्यवाद, एक बाइट की बचत)।

जब तक मंजिलों का कोटा नहीं मिल जाता तब तक cफ्लोर से शुरू होने वाले टेस्ट फ्लोर । प्रत्येक मंजिल के लिए, परीक्षण कि यह एक न के बराबर होता है या नहीं । यदि ऐसा है, तो यह एलेवेटर स्ट्रिंग के लिए प्रस्तुत करता है और कोटा को घटाता है ।-1n4013sn

स्ट्रिंग स्वरूपण के साथ एक चाल का उपयोग दो स्तंभ प्रति स्तंभ को उचित क्रम में प्रकट होने के लिए किया जाता है। प्रत्येक नई लाइन को इस प्रकार तैयार किया जाता है '%d\t%%d\n', ताकि जब दो मंजिलों को क्रम में प्रतिस्थापित किया जाए, तो पहली बाईं तरफ और दूसरी दाईं ओर हो। उदाहरण के लिए,

('%d\t%%d\n'%2)%3 == ('2\t%d\n')%3 == '2\t3\n'  

Comments

बहुत अच्छा है, लेकिन यह वास्तव में 96 बाइट्स है । शायद ट्रेलिंग कॉमा को हटा दें?

— २०:०४ पर मूवमेंट

@movatica अनुगामी अल्पविराम पर अच्छी पकड़ है, क्योंकि चुनौती निर्दिष्ट करती है अनुगामी न्यूलाइन ठीक है। 1 बाइट अंतर इसलिए था क्योंकि एसई कोड ब्लॉक टैब प्रदर्शित नहीं कर सकता है, इसलिए मैंने एक में डाल दिया \t। आह, TIO से पहले के दिन।

— xnor

Answer 9

सी #, 296 बाइट्स

namespace System.Collections.Generic{using Linq;class X{static void Main(){var a=new List<int>();var b=new List<int>();for(int i=int.Parse(Console.ReadLine()),j=-2;i>0;)if(++j!=13&&j!=0&&!(j+"").Contains("4"))(i--%2<1?a:b).Insert(0,j);Console.Write(string.Join("\n",a.Zip(b,(x,y)=>x+"\t"+y)));}}}

Ungolfed:

namespace System.Collections.Generic
{
    using Linq;
    class X
    {
        static void Main()
        {
            var a = new List<int>();
            var b = new List<int>();
            for (int i = int.Parse(Console.ReadLine()), j = -2; i > 0;)
                if (++j != 13 && j != 0 && !(j + "").Contains("4"))
                    (i-- % 2 < 1 ? a : b).Insert(0, j);
            Console.Write(string.Join("\n", a.Zip(b, (x, y) => x + "\t" + y)));
        }
    }
}

गोल्फ चाल का इस्तेमाल किया:

• i (रनिंग काउंटर) और j (विचाराधीन वर्तमान संख्या) क्रमशः सामान्य के रूप में लूप बॉडी में अभिव्यक्ति के अंदर, क्रमशः घट / बढ़े हुए हैं।
• j+"" के बजाय j.ToString()
• हर चीज को namespace System.Collections.Genericन केवल अंदर रखें ताकि हम पहुंच सकें List<T>, बल्कि Systemबिना किसी योग्यता के नाम स्थान का भी उपयोग कर सकें
• usingनाम स्थान के अंदर रखें ताकि हम using Linq;इसके बजाय लिख सकेंusing System.Linq;
• .Insert(0,j)उपयोग करने .Add(j)और बाद में आवेदन करने से कम है.Reverse()

यह दुर्भाग्यपूर्ण है कि using Linq;यह आवश्यक है, क्योंकि इसकी आवश्यकता केवल इसके लिए है .Zip, लेकिन इसे लिखना उतना Linq.Enumerable.Zip()ही लंबा है।

Answer 10

रूबी 2.3, 84 83 वर्ण

(82 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प)

puts (["-1",*?1..?1+$_].grep_v(/^13$|4/)[0..$_.to_i]*?\t).scan(/\S+\t\d+/).reverse

नमूना रन:

bash-4.3$ ruby -ne 'puts (["-1",*?1..?1+$_].grep_v(/^13$|4/)[0..$_.to_i]*?\t).scan(/\S+\t\d+/).reverse' <<< '14'
15      16
11      12
9       10
7       8
5       6
2       3
-1      1

रूबी, ९ ३ ९ अक्षर

(91 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प)

puts ([-1,*1..2*n=$_.to_i].reject{|i|i==13||i.to_s[?4]}[0..n]*?\t).scan(/\S+\t\d+/).reverse

नमूना रन:

bash-4.3$ ruby -ne 'puts ([-1,*1..2*n=$_.to_i].reject{|i|i==13||i.to_s[?4]}[0..n]*?\t).scan(/\S+\t\d+/).reverse' <<< '14'
15      16
11      12
9       10
7       8
5       6
2       3
-1      1

Answer 11

लुआ, 169 बाइट्स

t={-1}i=1 repeat if(i..""):find("4")or i==13 then else table.insert(t,i)end i=i+1 until #t==arg[1] for i=#t%2==0 and#t-1 or#t,1,-2 do print(t[i],t[i+1]and t[i+1]or"")end

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

Answer 12

गणितज्ञ, १०५ बाइट्स

StringRiffle[Reverse[Select[Range[2#]-2,#!=13&&#!=0&&DigitCount[#,10,4]<1&][[;;#]]~Partition~2],"
","\t"]&

\tएक वास्तविक टैब वर्ण के साथ बदलें ।

Answer 13

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

,Ll?,Lbb:1{h_.|[L:I]hhH,I+1=J((13;J:Zm4),L:J:1&.;Lb:J:1&:[J]c.)}:[1:-1]c{_|hJ,?bhw,[9:J]:"~c~w
"w,?bb:2&}

सीएलपीएफडी समर्थन के साथ बहुत कम होगा, यहां मुझे पहले उप-विधेय में पुनरावृत्त करने की कोशिश करनी होगी।

पहले नई लाइन "w,?bb:2&}अनिवार्य है, यह नई पंक्ति है जो हर पंक्ति के बीच मुद्रित होती है।

Comments

अच्छा! एक प्रश्न: क्यों नहीं Brachylog में सभी पूर्णांक अंकगणितीय सीएलपी (एफडी) का उपयोग करके स्वचालित रूप से बाधाएं बनती हैं? यह एक स्वाभाविक तार्किक विस्तार होगा।

— चटाई

@mat क्योंकि मैं आलसी हूं और मैंने ऐसा नहीं किया। लेकिन मुझे करना चाहिए!

— घातक

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

— मैट

@ इस चर्चा के लिए क्या आप मुझे इस चैट रूम में शामिल कर सकते हैं ? मुझे किसी से सलाह की जरूरत है जाहिर है कि मेरे साथ प्रोलॉग के साथ अधिक अनुभवी हैं।

— घातक

Answer 14

सी #, 277 343

using System;using System.Collections.Generic;static void f(int v){List<int>a=new List<int>();List<int>b=new List<int>();int s=1;for(int i=-1;i<v-1;i++){if(i==13||i.ToString().Contains("4")||i==0){ v++;continue;}if(s==1){s=2;a.Add(i);}else{s=1;b.Add(i);}}a.Reverse();b.Reverse();int l=0;foreach(int y in a){Console.WriteLine(y+" "+b[l]);l++;}}

यह केवल एक फ़ंक्शन के रूप में है। मैं C # नया हूं। वृद्धि 40-49 के लिए वैध बनाने के लिए थी, और usingएस सहित के लिए

पूर्ण चलने वाले कार्यक्रम के रूप में अनगुल्फेड:

using System;
using System.Collections.Generic;

class P {
    static void Main()
    {
        List<int> a = new List<int>();
        List<int> b = new List<int>();
        int v = Int32.Parse(Console.ReadLine());
        int s = 1;
        for (int i = -1; i < v - 1; i++)
        {
            if (i == 13 || i.ToString().Contains("4") || i == 0)
            {
                v++;
                continue;
            }
            if (s == 1)
            {
                s = 2;
                a.Add(i);
            }
            else {
                s = 1;
                b.Add(i);
            }
        }
        a.Reverse();
        b.Reverse();
        int l = 0;
        foreach (int y in a)
        {
            Console.WriteLine(y + " " + b[l]);
            l++;
        }
        Console.ReadLine();
    }
}

व्याख्या की

मैं दो सूचियां बनाता हूं, और उन्हें धकेलने के बीच वैकल्पिक करता हूं, उन्हें उल्टा करता हूं, एक के माध्यम से लूप करता हूं, और दूसरे को इंडेक्स द्वारा पकड़ता हूं।

Comments

मैं के बारे में सी # में ज्यादा पता नहीं है, लेकिन नहीं आप की जगह ले सकता if(s==1)द्वारा if(s)(बूलियन के पूर्णांक से स्वत: डाली?)

— Fatalize

नाह, क्योंकि दूसरा s == 2 के लिए है, हालांकि मैं 1 और 2 के बजाय ध्वज 0 और 1 बना सकता था। मैं कोशिश करूँगा।

— हंस

Answer 15

पायथन 3, 155 बाइट्स

मुझे लगता है कि फ्लोर-नंबर जनरेटर s()को सूचीबद्ध करना, उलटना, और स्वयं-ज़िप करना अपने स्वयं के अच्छे के लिए बहुत चालाक हो सकता है, लेकिन दूसरों ने पहले से ही विकल्प किया है (एक समय में दो आइटमों को पॉप करना), पायथन 2 का उपयोग करने का उल्लेख नहीं करना जो बाइट्स को बचाता है कुछ प्रमुख बिंदुओं पर।

def s(m,n=-1):
 while m:
  if not(n in(0,13)or'4'in str(n)):yield n;m-=1
  n+=1
*f,=s(int(input()))
g=iter(f[::-1])
h=zip(g,g)
for a,b in h:print(b,'\t',a)

छोटा, लेकिन पहले से बेहतर विकल्प 140 बाइट्स लेता है।

def s(m,n=-1):
 while m:
  if not(n in(0,13)or'4'in str(n)):yield n;m-=1
  n+=1
*f,=s(int(input()))
while f:a=f.pop();print(f.pop(),'\t',a)

Comments

दूसरे विकल्प के लिए, (0!=n!=13)!=('4'in str(n))5 बाइट्स से कम है not(n in(0,13)or'4'in str(n))।

— रात २१

Answer 16

जाप, 42 बाइट्स

JoU*2 k0 kD f@!Xs f4} ¯U ã f@Yv} w ®q'    } ·

चार रिक्त स्थान एक वास्तविक टैब चार होना चाहिए। इसे ऑनलाइन आज़माएं!

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

          // Implicit: U = input integer, D = 13
JoU*2     // Create the range of integers [-1,U*2).
k0 kD     // Remove 0 and 13.
f@!Xs f4} // Filter out the items X where X.toString().match(/4/g) is not null, i.e. the numbers that contain a 4.
¯U ã      // Slice to the first U items, and generate all adjacent pairs of items.
f@Yv}     // Filter out the items where the index Y is odd. This discards every other pair.
w         // Reverse.
®q'\t}    // Join each item with tabs.
·         // Join the whole list with newlines.
          // Implicit: output last expression

Answer 17

लूआ, 141 बाइट्स

n,s=1,'-1 1'function g()repeat n=n+1 until s.find(n,4)==z and n~=13 return n end for i=4,io.read(),2 do s=g()..' '..g().."\n"..s end print(s)

Ungolfed

n,s = 1,'-1'1' --n is the current floor number, S is the string to be printed
function g() --This function raises n to the next valid floor
    repeat --Same as while loop except it runs the following block before checking the expression
        n = n + 1 --Self-explanatory, increases n by one
    until --Checks the expression, if it is true, it breaks out of the loop
        s.find(n,4) == z --[[Strings have a member :find(X) where it finds the position of
                             X in the string (X can also be a pattern). However, calling it 
                             by .find(S,X) executes find on S with argument X. I can't 
                             directly do n:find(4) because n is a number. This is a "hack" 
                             (sort of) to cut down some bytes. Also, if X is not a string,
                             lua tries to (in this case, succeeds) cast X to a
                             string and then look for it. I check if this is equal to z
                             because z is nil (because it is undefined), and find returns
                             nil if X is not found in S.
                             TL;DR: Checks if 4 is not the last digit.]]
        and n ~= 13 --Self-explanatory, checks if n is not 13
        return n --Self-explanatory, returns n
end
for i = 4, io.read(), 2 do --[[Start at floor 3 (shows 4 because we're going by target
                               floor, not by starting floor), continue until we reach
                               floor io.read() (io.read returns user input), increment by
                               2 floors per iteration)]]
    s = g() .. ' ' .. g() .. "\n" .. s --[[Prepend the next floor, a space, the next floor,
                               and a newline to s]]
end
print(s) --Self-explanatory, output the string

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

Answer 18

05AB1E , 25 23 22 बाइट्स

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

·Ý<0K13Kʒ4å_}s£2ôR9çý»

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

व्याख्या

                           # Implicit input: integer n
·Ý<                        # Push list [-1,0,1,...,2n-1]
   0K                      # Remove 0 from [-1,0,1,...,2n-1]
     13K                   # Remove 13 from [-1,1,...,2n-1]
        ʒ4å_}              # Filter out every number containing a 4 from the list
             s£            # Pick out the n first element in the list
               2ôR         # Splice list into parts of length 2
                  9çý      # Join with tab character (ascii value 9)
                     »     # Join with newlines

Comments

22?

— ASCII- केवल

आह। मुझे पता था कि उस बदसूरत 0 13ªहिस्से को थोड़ा बेहतर बनाने का एक तरीका था । धन्यवाद!

— विस्लोव

रुको। कोई तार्किक नहीं है और 05AB1E में है? O_o

— केवल

यदि 1 सत्य है और 0 असत्य है तो गुणन तर्क के रूप में कार्य करता है और

— विस्लोव

बदलकर -1 बाइट ʒ4å_}के लिए 4мïê। पुनश्च: आपके पहले की टिप्पणी के आधार पर: जैसा भी 0 13ªहो सकता था ¾13ª।

— केविन क्रूज़सेन

Answer 19

सी ++ 11, 259 258 203 202 195 194 बाइट्स

1 बाइट से फिसल गया, इसके बजाय शाब्दिक टैब का उपयोग करने के लिए कॉनर ओ'ब्रायन के विचार के लिए धन्यवाद \t।

UPD 2: बेहतर तर्क और अल्पविराम के दुरुपयोग के साथ 55 बाइट्स फिसले।

UPD 3: सीलिंग की बदौलत एक और बाइट।

UPD 4: 7 सीट्स ऑफ सीलिंगसीट के सौजन्य से।

UPD 5: और सीलिंग द्वारा एक और बाइट।

खुश है कि सभी जगह शामिल हैं और अभी भी सी और सी # समाधान को हराते हैं।

#include<iostream>
#include<string>
int main(){std::string o="-1    1",c,b;int n,i=2,s=2;for(std::cin>>n;s<n;o=i==14|~c.find(52)?o:(++s&1?b=c,"":b+'    '+c+'\n')+o)c=std::to_string(i++);std::cout<<o;}

Ungolfed:

#include <iostream>
#include <string>

int main()
{
    std::string o = "-1 1", c, b;
    int n, i = 2, s = 2;
    for (std::cin >> n;
         s < n;
         o = i == 14 | ~c.find(52) ? o : (++s & 1 ? b = c, "" : b + '   ' + c + '\n') + o
    )
        c = std::to_string(i++);
    std::cout << o;
}

Comments

iostreamशामिल है string, इसलिए आप बायटेकाउंट में एक बड़ी कमी के लिए दूसरे को शामिल कर सकते हैं :)

— चल

@ movatica cppreference.com के अनुसार नहीं है, और VS2019 में संकलन इसके बिना विफल हो जाता है। तो अगर यह कहीं और संकलित करता है तो यह उस मानक मानक कार्यान्वयन के लिए विशिष्ट है।

— अलेक्जेंडर रेवो

ठीक है, एक gcc बात लगती है।

— movatica

191 बाइट्स

— सीलिंगकैट

Answer 20

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

import java.util.*;interface E{static void main(String[]a){byte i=-1;Stack<Byte>s=new Stack<>();while(s.size()<Byte.valueOf(a[0])){if(i==13|i==0|String.valueOf(i).contains("4")){i++;continue;}s.add(i);i++;}if(s.size()%2!=0){System.out.println(s.pop());}while(!s.isEmpty()){int r=s.pop();int l=s.pop();System.out.println(l+"\t"+r);}}}

एक स्टैक पर फ़्लोर नंबर्स की अनुमति देता है फिर उन्हें प्रिंट करने के लिए उन्हें वापस पॉप करता है।

मैं एक IntStream का उपयोग कर के चारों ओर खेला, लेकिन सभी आयातों के साथ यह एक छोटे से समाप्त हो गया।

Answer 21

स्केला 147

val n=io.StdIn.readInt;(-1 to 4*n).filter(i=>i!=0&&i!=13&&(!(i+"").contains(52))).take(n).reverse.grouped(2).toList.map{i=>println(i(1)+"\t"+i(0))}

Comments

यह स्पष्ट रूप से स्काला डाउन संस्करण है।

— सीजे डेनिस

Answer 22

पायथन 3, 117 बाइट्स

n=int(input())
l=[-1]+[i for i in range(n*2)if(i!=13)*(not'4'in str(i))][1:n]
while l:x=l.pop();print(l.pop(),'\t',x)

अजगर 3 विनिर्देश फिट करने के लिए अजगर 2 पोस्ट का संशोधित संस्करण।

Answer 23

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

$c=,-1+$(while($i+1-lt"$args"){if(++$c-notmatch'^13$|4'){$c;++$i}})
while($c){$a,$b,$c=$c;$s="$a    $b
$s"}$s

Ungolfed

# Calculate floors:
$c=,-1 # Array with one element
  +
  $( # Result of subexpression
    while($i+1-lt"$args"){ # Uninitialized $i is 0, +1 ensures loop start from 1
      if(
        ++$c-match'^13$|4' # Expression increments uninitialized $c (i.e. start from 1)
                           # and matches resulting number to regex.
      ){
        $c;++$i # Return $c and increment $i counter 
      }
    }
  )

# Print floors:
while($c){ # Loop until no more elements in $c
  $a,$b,$c=$c # Use PS's multiple assignment feature
              # $a - first element of $c array
              # $b - second element of $c array
              # $c - the rest of elements of $c array
  $s="$a    $b
$s" # Create string with tabs and newlines,
    # literal characters are used
}
$s # Output resulting string

उदाहरण

PS > .\Elevator.ps1 14
15  16
11  12
9   10
7   8
5   6
2   3
-1  1

Answer 24

हास्केल 202 बाइट्स

t=(-1):[x|x<-[1..],x/=13,all (/='4')(show x)]
by2 []=[[]]
by2 [a]=[[a]]
by2 [a,b]=[[a,b]]
by2 (a:b:xs)=[a,b]:(by2 xs)
main=do
 n<-getLine
 putStr$unlines$map unwords$by2$map show$reverse$take(read n) t

हैम हैस्केल शुरुआत ...

• पहले मूल्यों की अनंत सूची बनाएं। (टी सूची)
• फ़ंक्शन 2 से 2 तत्वों के उप सूची में समूह की सूची बनाएं।
• मुख्य मूल्य लेते हैं।
  • टी सूची के मूल्य तत्व लें
  • सूची में पहले महान तत्वों को उल्टा करें
  • इंट शो को स्ट्रिंग लिस्ट में बदलने के लिए मैप शो फंक्शन
  • समूह तत्व 2 बाय 2 फ़ंक्शन के साथ 2
  • हमारे पास एक सूची है [["4", "5"], ["6", "7"]] जैसे कि ["4 5", "6 7"] की तरह बदल दिया गया है, सूची में अनएप्ड फ़ंक्शन मैप किया गया है
  • सूची को सूचीबद्ध करता है (सूची का प्रत्येक तत्व '\ n' द्वारा अलग होता है)
  • टर्मिनल पर स्ट्रिंग लिखने के लिए putStrLn के साथ समाप्त करें।

Comments

आप by21 वर्ण नाम और पुन: आदेश का उपयोग करके परिभाषित करने में कई बाइट्स बचा सकते हैं : अपनी अंतिम पंक्ति का उपयोग करें, फिर b x = [x]बाद में।

— बॉलस्टास्ट 25

Answer 25

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

n=>[...Array(n)].map(_=>{while(/^13$|4|^0/.test(++i));return i;},i=-2).join`    `.match(/-?\d+  \d+/g).reverse().join`\n`

प्रयोग

f=n=>[...Array(n)].map(_=>{while(/^13$|4|^0/.test(++i));return i;},i=-2).join`  `.match(/-?\d+  \d+/g).reverse().join`\n`

च (100);

Answer 26

पर्ल 6 , 73 बाइट्स

{.join("    ").say for (-1,|grep {$_-13&!/4/},1..Inf)[^$_].rotor(2).reverse}

फर्श की एक समान संख्या मान लेता है, क्योंकि समस्या कथन इसे मान लेता है और कम से कम एक अन्य प्रदान किया गया समाधान विषम संख्या वाली मंजिलों के लिए टूट जाता है। फर्श की विषम संख्याओं का समर्थन करने के ,:partialलिए rotor, नौ और बाइट्स के लिए बस एक दूसरे तर्क के रूप में जोड़ें ।

Comments

55 बाइट्स

— जो किंग

Answer 27

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

ḟ13D_4Ȧµ#o-s2Ṛj€9Ọ¤Y

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

कैसे?

ḟ13D_4Ȧµ#o-s2Ṛj€9Ọ¤Y - Main Link: no arguments
        #            - start at n=0 and collect the first INPUT values which are truthy under:
       µ             -   the monad (i.e. f(n)):        e.g.:    0      3      4      13     42        813
ḟ13                  -     filter out thirteens                 [0]    [3]    [4]    []     [42]      [813]
   D                 -     convert to decimal lists             [[0]]  [[3]]  [[4]]  []     [[4,2]]   [[8,1,3]]
    _4               -     subtract four (vectorises)           [[-4]] [[-1]] [[0]]  []     [[0,-2]]  [[4,-3,-1]
      Ȧ              -     any & all?                           1      1      0      0      0         1
         o-          - logical OR with -1 (replace floor 0 with floor -1)
           s2        - split into twos
             Ṛ       - reverse
                  ¤  - nilad followed by link(s) as a nilad:
                9    -   literal nine
                 Ọ   -   to character (a tab)
              j€     - join €ach
                   Y - join with newlines
                     - implicit print

Answer 28

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

alert([for(a of Array((n=+prompt(i=0))*2).keys())if((i+=t=/4/.test(a)||a==13,!t&&a<n+i))a].reduce((a,b,j,r)=>j%2-1?(b||-1)+`  ${r[j+1]}
`+a:a,''))

इससे पहले कि मुझे पता चलता edc65 पहले से ही एक छोटा बना दिया था। ओह अच्छा!

Answer 29

आर , 106 बाइट्स

n=scan();x=-1:n^2;x=x[-grep(4,x)][-14][-2][n:1];cat(paste0(matrix(x,2,n/2)[2:1,],c("	","\n"),collapse=""))

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

$-1$$n^2$$n^3$$n^9$c("\t","\n")\t

n=scan();                                        # read number of floors n
x=-1:n^2;                                        # initial vector of numbers
x=x[-grep(4,x)]                                  # remove floors with a 4
               [-14]                             # remove floor 13
                    [-2]                         # remove floor 0
                        [n:1];                   # keep lowest n remaining floors, highest to lowest
cat(paste0( 
  matrix(x,2,n/2)                                # split vector of floors into 2 rows
                 [2:1,],                         # take row 2 then row 1
                        c("   ","\n"),           # separate integers with alternating tabs and newlines (uses recycling)
                                    collapse=""))

Answer 30

APL (Dyalog) , 34 बाइट्स

{⊖(⍵÷2)2⍴o/⍨~'4'∊¨⍕¨o←13~⍨¯1,⍳⍵×⍵}

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