기술

상하이의 매우 미신적 인 호텔 엘리베이터는 다음과 같습니다.

서구에서는 13 개가 운이 아니기 때문에 숫자 13을 피하고 아시아의 일부에서는 4 개가 운이 좋지 않기 때문에 숫자 4를 피합니다. 이 호텔이 키가 크면 어떻게 되나요?

nSTDIN에서 양의 짝수 정수 를 읽고 층 수를 표시하고 버튼 레이아웃이 STDOUT : -1에 표시되는 형식을 인쇄 한 다음 n-113과 같지 않고 숫자 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

골

이것은 code-golf 입니다. 바이트 단위의 최단 답변이 이깁니다.

Pyth, 27 바이트

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

여기에서 온라인으로 사용해보십시오 .

필터 와 일치하며 숫자 의 문자열 표현에없는 .first Q-1숫자를 가져 옵니다. 그런 다음 접두사 를 반으로 자르고 각각 탭 ( )으로 결합하고 개행으로 결합합니다.!=134-1C9

배쉬 + 공용 유틸리티, 51

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

• seq 64 비트 정수 입력에 충분한 것보다 앞에 9 자리가 추가되어 1에서 N까지 오름차순 정수를 생성합니다.
• sed-11 행 전에 불행한 바닥과 인서트 를 걸러냅니다.
• rs 두 개의 탭으로 구분 된 열로 재구성
• sed N / 2 라인 후 정지
• tac 출력 라인 순서를 반대로 바꿉니다.

자바 스크립트 ES6, 236 234 233 210 195 188 바이트

usandfriends 덕분에 전체 바이트를 절약했습니다!

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`
`

C, 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 );
}

특징 :

각 층이 19.5m높을 경우 (천장 포함) 최대 2095984 층을 계산할 수 있으며이 건물은 적도를 감쌀 수있을만큼 길다! 2095984*19.5=40871688m=~40000km=one 'lap' around the planet.

줄리아, 134132 바이트

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

거기에있는 재미있는 공백은 리터럴 탭입니다. Conor O'Brien이 지적했듯이, 이것은 바이트보다 짧습니다 \t.

언 골프 드 :

# 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

파이썬 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

자바 스크립트, 116 122

저장된 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>

파이썬 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

온라인으로 사용해보십시오!

문자열에 SE가 렌더링하지 않는 탭 문자가 있습니다 (Sp3000 덕분에 사용을 제안하여 바이트 절약).

c바닥 -1할당량 n에 도달 할 때까지 바닥에서 시작하여 바닥을 테스트 합니다. 각 층의 경우, 그것은을 포함하지 않는 것을 테스트 4도 동일 0또는 13. 그렇다면 엘리베이터 문자열 앞에 추가 s하고 할당량을 줄 n입니다.

문자열 형식의 트릭을 사용하여 열당 두 층을 앞에 추가하면 올바른 순서로 표시됩니다. 각 줄 바꿈은로 '%d\t%%d\n'2 층이 순서대로 대체 될 때 첫 번째 줄이 왼쪽에 있고 두 번째 줄이 오른쪽에 있도록 준비됩니다. 예를 들어

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

C #, 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)));}}}

언 골프 드 :

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)));
        }
    }
}

사용 된 골프 트릭 :

• 평상시처럼 for 문 대신 루프 본문의 표현식에서 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()더 오래 쓸 수 있습니다.

루비 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

루비, 93 92 자

(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

루아, 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

당연히, 우리는 먼저 모든 버튼 값으로 채워진 테이블을 조립합니다. 그런 다음 거꾸로 반복하여 한 번에 두 개의 값을 인쇄하거나 두 번째 값이 없으면 아무것도 인쇄하지 않습니다.

수학, 105 바이트

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

를 \t실제 탭 문자로 바꿉니다 .

Brachylog , 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&}

CLPFD 지원으로 훨씬 짧았을 것입니다. 여기서 첫 번째 하위 조건 자에서 정수를 반복적으로 시도해야합니다.

이전의 새로운 줄 "w,?bb:2&}은 필수이며, 이것은 모든 줄 사이에 인쇄되는 새로운 줄입니다.

C #, 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와 usings 를 포함하여 유효하게 증가

완전한 실행중인 프로그램으로서의 Ungolfed :

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();
    }
}

설명

나는 두 개의 목록을 만들고, 그것들을 밀고, 반대로하고, 하나를 반복하고, 다른 하나를 색인으로 잡습니다.

파이썬 3, 155 바이트

플로어 번호 생성기를 나열, 반전 및 자체 압축하는 s()것은 자체적으로 너무 영리했을 수도 있지만 다른 사람들은 바이트를 절약하는 Python 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)

apt, 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

루아, 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)

언 골프

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

온라인으로 시도하십시오 (상단에서 'execute'를 클릭 한 다음 입력을 입력하기 전에 하단의 터미널을 클릭해야합니다. 나는 stdin 및 stdout으로 온라인으로 lua를 테스트하는 더 좋은 방법을 찾고 있습니다)

05AB1E , 25 23 22 바이트

@ASCII 전용으로 -1 바이트

·Ý<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

C ++ 11 259 258 203 202 195 194 바이트

Conor O'Brien의 아이디어 대신 리터럴 탭을 사용하여 1 바이트가 줄었습니다 \t.

UPD 2 : 향상된 논리 및 쉼표 남용으로 55 바이트가 줄었습니다.

UPD 3 : 상한선 덕분에 또 다른 바이트 오프.

UPD 4 : 상한 고양이에 의한 7 바이트.

UPD 5 : 상한선으로 또 다른 바이트 오프.

모든 포함을 갖추어도 C 및 C # 솔루션을 능가하는 것이 행복합니다.

#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;}

언 골프 드 :

#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;
}

자바, 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을 사용하여 놀았지만 모든 가져 오기 로이 작은 것이 끝났습니다.

스칼라 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))}

파이썬 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)

python 3 사양에 맞게 python 2 post의 수정 된 버전.

PowerShell, 106107 바이트

$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

언 골프

# 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

하스켈 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

저는 하스켈 초보자입니다…

• 먼저 무한한 값 목록을 만듭니다. (t리스트)
• function by2리스트를 2 개의 요소로 구성된 서브리스트로 그룹화합니다.
• main 값을 가져옵니다.
  • t list의 가치 요소를 취 하십시오
  • 더 큰 요소를 먼저 갖도록 목록을 뒤집습니다.
  • int 목록을 문자열 목록으로 변환하는 map show 함수
  • by2 함수를 사용하여 요소 2를 2로 그룹화
  • [[ "4", "5"], [ "6", "7"]]과 같은 목록이 있습니다. unwords 함수를 사용하여 목록에 매핑 된 [ "4 5", "6 7"]
  • 목록을 해제합니다 ( '\ n'으로 구분 된 목록의 각 요소)
  • 터미널에 문자열을 쓰려면 putStrLn으로 마무리하십시오.

자바 스크립트 ES6 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`

f (100);

펄 6 , 73 바이트

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

짝수의 층을 가정합니다. 문제 진술은 그것을 가정하는 것으로 보이고 적어도 하나의 다른 층은 홀수 층에 대한 해결책을 제공했습니다. 홀수의 층을 지원하기 위해 9 바이트 ,:partial를 더하기 위해 두 번째 인수로 추가하십시오 rotor.

젤리 , 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

자바 스크립트 (ES6) 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가 이미 더 짧아 졌다는 것을 깨달았습니다. 오 잘!

R , 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=""))

APL (Dyalog) , 34 바이트

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

온라인으로 사용해보십시오!