描述

这是上海一个非常迷信的酒店电梯：

它避免使用数字13，因为在西方世界中有13位不幸，而避免使用数字4，因为在亚洲部分地区，有4位不幸。如果这家酒店更高，该怎么办？

n从STDIN 读取一个代表楼层数的正整数，并打印按钮布局到STDOUT：的样子-1，然后是下一个n-1不等于13并且不包含数字4的正整数。两列中的数字，如上图所示：每行打印两个楼层号，并由水平制表符分隔，以便从左到右以相反的顺序读取行会产生升序的序列。（您也可以选择打印尾随换行符。）

测试用例

对于input 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

目标

这是代码高尔夫球。以字节为单位的最短答案将获胜。

Pyth，27个字节

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

在这里在线尝试。

获取.fIRST Q-1符合筛选条件的号码!=13，并4没有在数字的字符串表示。然后将其准备好-1，切成两半，通过tabs（C9）进行联接，并通过换行进行联接。

Bash +通用工具，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 在N / 2行之后停止
• tac 反转输出线顺序

JavaScript的ES6，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`
`

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

特征 ：

它最多可以计算2095984层，如果每层都19.5m高（包括天花板），则该建筑物足够长，可以包裹在赤道周围！2095984*19.5=40871688m=~40000km=one 'lap' around the planet。

朱莉娅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

里面的那个有趣的空白是一个文字标签。正如Conor O'Brien所指出的，这比doing短了一​​个字节\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

Python 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

JavaScript中，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>

Python 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达到楼层配额为止。对于每个楼层，测试其是否不包含4nor等于0或13。如果是这样，请将其添加到升降机串上s并减少配额n。

使用字符串格式的技巧可以使每列的两层楼在添加时以正确的顺序显示。每行的新行都准备为'%d\t%%d\n'，因此当按顺序替换两层时，第一层位于左侧，第二层位于右侧。例如，

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

高尔夫技巧：

• i（运行中的计数器）和j（正在考虑的当前数字）分别在循环体内的表达式内（而不是正常情况下的for语句）减少/增加
• 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

Ruby，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

Lua，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

坦率地说，我们首先组装一个包含所有按钮值的表。然后我们向后迭代，一次打印两个值，如果第二个值不存在，则不打印任何值。

Mathematica，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，并包括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();
    }
}

讲解

我创建了两个列表，并在推入它们，反转它们，循环浏览其中一个和按索引获取另一个之间进行切换。

Python 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)

Japt，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

Lua，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

在线尝试（您需要单击顶部的“执行”，然后单击底部的终端，然后键入输入；我正在寻找一种更好的方法来使用stdin和stdout在线测试lua）

05AB1E，25 23 22字节

-1字节感谢@ ASCII-only

·Ý<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：由ceilingcat提供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;
}

Java，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))}

Python 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 2 post的修改版本以适合python 3规范。

PowerShell，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

不打高尔夫球

# 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

Haskell 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

我是Haskell初学者...

• 首先创建无限值列表。（吨清单）
• function by2将一个列表分组为2个元素的子列表。
• 主要取值。
  • 取t列表的值元素
  • 反转列表以首先具有更大的元素
  • map show函数将int列表转换为字符串列表
  • 使用by2函数将元素2 2分组
  • 我们有一个像[[“” 4“，” 5“]，[” 6“，” 7“]]这样的列表，转换成[[4 5”，“ 6 7”]，并在列表上映射了unwords函数
  • 取消列表的顺序（列表的每个元素以“ \ n”分隔）
  • 用putStrLn完成以在终端上写入字符串。

Javascript 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）；

Perl 6，73个字节

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

假设楼层数为偶数，因为问题陈述似乎也假定为楼层数，并且至少有另外一个为奇数层数提供了解决方案中断。只需,:partial在的第二个参数中rotor增加9个字节，即可支持奇数层数。

果冻，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

JavaScript的（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,⍳⍵×⍵}

在线尝试！