打印所有ASCII字母数字字符而不使用它们

51

挑战

打印以下字符：

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

要注意的是，您不得在代码中使用其中任何一个。

您可以按任意顺序打印它们，带有或不带有开头或结尾的换行符，但不能打印任何其他字符。

规则

  • 您不得使用上述集合中的任何字符
  • 您可以使用其他任何字符
  • 别作弊
  • 禁止标准漏洞
  • 这是代码高尔夫球，最短答案胜出。

澄清说明

  • 如果您的语言使用其他字符集，则不得在该字符集中使用与字母数字字符相对应的代码点。
  • 从函数返回字符串被认为是有效的输出形式。
  • 您可以返回一个char数组。
code-golf  string  kolmogorov-complexity  restricted-source 
— 德库德里阿夫采夫
source
8
这有点模棱两可。如果要输出的是这些原始字节，而在代码中没有这些字节，则应指定即使这些字符映射到您语言的代码页中的其他字符，也不能使用这些字符的代码点。
— FlipTack
11
因此，这意味着我不能在源代码中使用任何字母或数字。好吧，这几乎消除了任何非深奥的语言。
— 卡普
2
如果语言只是没有表示形式的原始字节（作为操作码）怎么办？我可以随意使用任何字符吗？
— FlipTack
1
@briantist，如果它们在内部由int表示是很好的，但是字符本身必须打印出来。
— dkudriavtsev
3
@ R.Kap Javascript可以正常工作，只要您不认为它是eso
— Destructible Lemon

Answers:

19

V，8 7字节

@DJMcMayhem通过将它们全部放在一个regex语句中节省了1个字节

¬/{Ó×ü_

在线尝试！

输出：

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

注：×是不是 x还是X，它是0xd7

十六进制转储：

00000000: ac2f 7bd3 d7fc 5f                        ./{..._

说明

¬/{            " inserts every character in the range / to {

现在输出如下：

/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{

我们必须删除所有非字母数字字符和_（因为它不包含在其中\W），所以让我们使用正则表达式进行操作

Ó×ü_           " removes every character that is non-alphanumeric or an underscore _ 
               " vim equivalent of :s/\W\|_//g
— 克里特希·里索斯（Kritixi Lithos）
source
惊人！+1击败我。:)另外，如果您这样做的话，可以将其简化为一个正则表达式Ó×ü_（相当于:s/\W\|_//g）
— DJMcMayhem
50

八度，52 46 40字节

['['-('"':'+'),'{'-(_='!':':'),_+'@','']

这评估为

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

说明

在这里，我们使用了这样的事实，即当应用算术运算（例如+-或range函数）时，字符会隐式转换为整数:。与空字符串（[...,'']）串联时，数字再次转换为字符。

在线尝试！

— 瑕疵
source
7
+1在挑战中非常适合使用esolangs 作为第一种非神秘的语言。
— DJMcMayhem
4
很大+1，不是为了使用Octave（这很简单），而是为了很好地打高尔夫球并将其_用作变量！我不知道有没有可能……不错！
— Stewie Griffin
1
当与空字符串（[...，'']）连接时，数字再次转换为字符。...非常好
— rahnema1
29

Brainfuck，77 76 75 72字节

++++++++[>+>++++++>++++>-<<<<-]>++[>.+<-]>>[>+>++>+++<<<-]>++[>+.>+.<<-]

在线尝试！

这个怎么运作

解释器从0个单元格的磁带开始。

++++++++

这会将第一个单元格设置为8，使磁带处于以下状态。

   8
   ^

[>+>++++++>++++>-<<<<-]

这使第二个单元格增加一次，第三个单元格增加6次，第四个单元格增加4次，第五个单元格减少一次，然后返回到磁带的开头并减少第一个单元格。经过8次迭代，磁带看起来如下。

  0   8  48  32  -8
  ^

>++

我们前进到第二个单元格，并将其递增两次，以准备打印数字。

  0  10  48  32  -8
      ^

[>.+<-]

这将打印第三个单元格，将其递增，然后返回第二个单元格并对其递减。经过10次迭代，我们已经打印0123456789了，磁带看起来如下。

  0   0  58  32  -8
      ^

>>

是时候准备信件用胶带了！我们从推进两个单元开始。

  0   0  58  32  -8   0   0
              ^

[>+>++>+++<<<-]

这会使第五个单元格增加一次，第六个单元格增加两次，第七个单元格增加三次，然后返回第四个单元格并将其递减。经过32次迭代后，磁带如下所示。

  0   0  58   0  24  64  96
              ^

>++

作为打印字母之前的最后一步，我们前进到第五个单元格并将其递增两次。

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

最后，我们前进到第六个单元格以递增并打印它，对第七个单元格执行相同的操作，然后返回第五个单元格并递减它。经过26次迭代，我们打印了Aa...Zz。

— 丹尼斯
source
高尔夫不错！我将链接到您的答案
— FlipTack
25

Ruby，42个字节

->{[*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`]}

返回char数组的函数。仅输出字符的程序为49字节：

$><<([*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`])*''

这只是使用相关范围两侧的ascii字符来定义范围。例如，?/...?:表示正斜杠和冒号之间的字符（不包括结尾）。为了摆脱开头，我们减去包含三个开头字符的数组。

— 历史学家
source
辛苦了 我看到了这一点，就像我使用相同的想法发布60字节的版本一样。
— AShelly
3
您可以保存一个字节，其范围略有不同：$> <<（[ （？/ ...？{）]-[*（？：..？@@），*（？[..？`）），？/ ]） ''
— AShelly
真的很漂亮 好吧，丑陋。你知道我的意思。做得很好。
— 韦恩·康拉德
22

6502机器语言，74 70 68字节

十六进制转储（一般无法重定位6502程序；此处的代码存储在$ 0603处）：

0600:          a9 24 0a 8d 20 06 8d 21 06 8d 23 06 8d 
0610: 25 06 09 20 8d 1a 06 8d 1c 06 ea aa ea a8 a9 00 
0620: ea ea 98 ea 8a ea a2 ff a9 7b a0 60 20 3a 06 a9 
0630: 5b a0 40 20 3a 06 a9 3a a0 2f 85 80 c8 e8 98 95 
0640: 00 c8 c4 80 d0 f7 60

您会看到它没有使用任何禁止的字节：$ 41到$ 5a，$ 61到$ 7a或$ 30到$ 39。

这是一个不带参数的函数，根据标准6502调用约定，该函数在调用时将返回指向堆栈顶部的字符数组“ abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”的指针。

作为解释，这里是反汇编：

解决六角转储拆卸
-------------------------------
$ 0603 a9 24 LDA＃$ 24
$ 0605 0a ASL A
$ 0606 8d 20 06 STA $ 0620
$ 0609 8d 21 06 STA $ 0621
$ 060c 8d 23 06 STA $ 0623
$ 060f 8d 25 06 STA $ 0625
$ 0612 09 20 ORA＃$ 20
$ 0614 8d 1a 06 STA $ 061a
$ 0617 8d 1c 06 STA $ 061c
$ 061a ea NOP 
$ 061b aa税 
$ 061c ea NOP 
$ 061d a8 TAY 
$ 061e a9 00 LDA＃$ 00
$ 0620一个NOP 
$ 0621一个NOP 
$ 0622 98 TYA 
$ 0623一个NOP 
$ 0624 8a TXA 
$ 0625一个NOP 
$ 0626 a2 ff LDX＃$ ff
$ 0628 a9 7b LDA＃$ 7b
$ 062a a0 60 LDY＃$ 60
$ 062c 20 3a 06 JSR $ 063a
$ 062f a9 5b LDA＃$ 5b
$ 0631 a0 40 LDY＃$ 40
$ 0633 20 3a 06 JSR $ 063a
$ 0636 a9 3a LDA＃$ 3a
$ 0638 a0 2f LDY＃$ 2f
$ 063a 85 80 STA $ 80
$ 063c c8 INY 
$ 063d e8 INX 
$ 063e 98泰雅 
$ 063f 95 00 STA $ 00，X
$ 0641 c8 INY 
$ 0642 c4 80 CPY 80美元
$ 0644 d0 f7 BNE $ 063d
$ 0646 60 RTS

机器语言代码是自我修改的。对于堆栈操作，我需要使用PHA和PLA来推动和弹出累加器，但这些指令的操作码分别为$ 48和$ 68，这是禁止的（它们是字母'H'和'h'的ASCII码）。因此，对于PHA，我将数字$ 24进行算术左移（ASL），并将结果$ 48存储在需要执行的代码的四个位置。然后，对于PLA而言，我对累加器中的$ 48使用按位“或”运算来计算$ 68，并将其存储在代码中需要的两个位置。

除了PHA和PLA以外，还有其他一些我无法使用的指令，因为它们的操作码恰好与ASCII字母或数字相同，但是我发现了其他指令的直接解决方法。

所需的字符数组是从位置0开始计算和存储的（它的存储位置并不重要，因为我们只需要确保指向它的指针返回到堆栈的顶部即可）。

您可以在Nick Morgan的6502汇编器和仿真器中进行尝试。这是屏幕截图；程序运行后，底部的监视器框显示输出字符串（在$ 00到$ 3D位置）。

— 米切尔·史派克
source
16

Haskell，75 72 63 58 56字节

__=[__|[_',ä]<-["/:","@[","`{"],__<-[_'..],_'<__,__<ä]

在线尝试！致电__。输出：

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

感谢xnor的建议，__并_'用两个字节的变量名代替了(!)或类似的变量，节省了9个字节。我特别喜欢如何_'破坏语法突出显示。再次感谢xnor概括了范围，又节省了4个字节。
编辑：我发现的Unicode字符都可以作为在Haskell标识符，因此例如ä，ö，...也可以作为两个字节标识符。由于程序中还剩下一个三字节的标识符，因此我将其替换为ä，从而节省了另外两个字节。

说明：

__并且_'是有效的变量名。根据语言规范：

标识符包含一个字母，后跟零个或多个字母，数字，下划线和单引号。[...]下划线（_）被视为小写字母，并且可以在任何小写字母可以出现的地方出现。但是，_它们本身就是一个保留标识符，用作模式中的通配符。

所以代码等同于

s = [x|[a,b]<-["/:", "@[", "`{"], x<-[a..], a<x, x<b]

列表中的理解a被绑定到'/'和b到':'（"/:"相当于['/',':']，所以模式匹配成功）。然后，范围[a..]将构建所有等于更大的字符的字符串'/'：

"/0123456789:;<=>?@ABCDE ... \1114110\1114111"

对于x此字符串中的每个字符，然后检查是否'/'<x和x<':'，从而得出chars 0123456789。然后将a和b绑定到@ 和[，生成字符ABCDEFGHIJKLMNOPQRSTUVWXYZ，依此类推。

— 莱科尼
source
3
您可以使用__和_'作为变量。
— xnor
@xnor谢谢，我不知道这条Underscore is treated as a lower-case letter规则。
— Laikoni'1
1
您可以通过概括范围来节省一些字节：（_'_=[__|[_',__']<-["`{","@[","/:"],__<-[_'..],_'<__,__<__']在普通变量中z=[x|[a,b]<-["`{","@[","/:"],x<-[a..],a<x,x<b]）。
— xnor
@xnor再次感谢！将范围的开始和结束组合成字符串的好主意。我也尝试对范围进行概括，但总是在没有这个想法的情况下更长。通过将字符串绑定到可以节省一个额外的字节__，_'_ 即使它__被用作列表推导中的标识符也是如此。
— Laikoni'1
13

Perl（5.10或5.12），30 29字节

该程序主要由不可打印的字符组成，因此这是一个十六进制转储：

00000000: 5f 3d 7e 7e 22 d7 c0 84 8c 9e 86 df 9e d1 d1 85 _=~~"...........
00000010: d3 be d1 d1 a5 d3 cf d1 d1 c6 82 d6 22          ............"

这个程序非常简单：我们针对正则表达式对（=~）下划线（_；感谢@Dennis指出此功能有效）。正则表达式被指定为表达式，而不是字面意义。具体来说，我们采用~字符串的按位补码（）。反转按位补码以获取基础字符串，我们将获得以下正在执行的正则表达式：

(?{say a..z,A..Z,0..9})

在Perl版本5.10和5.12中，该(?{…})语法是实验性语法，用于允许正则表达式在运行时运行任意代码。在这种情况下，我们使用它运行一个简单的Perl程序以打印所需的输出。（由于版本号低于5.10，因此无法使用say。）

(?{…})由于安全原因，默认情况下，现代版本的Perl已默认禁用，但如果您具有这样的Perl版本，则可以通过-Mre=eval作为命令行参数（连同-M5.010指定版本的标准）来禁用检查（从而运行此程序）所要实现的语言类型，并且不计入字节数）。

13

实际上是8 5 4个字节

'>┘▀

这个怎么运作：

 '>    Pushes > onto the stack as a string
           STACK: [>]
    ┘  Converts the top item of the stack to it's ordinal
           STACK: [62]
     ▀ Push all digits from base n(top item of the stack)
           STACK: [012...xyz]

在程序结束时隐式打印。

编辑1：取而代之的是将字母放在小写/大写形式，然后将数字范围（10）改为只获得基数62的可打印字符。

编辑2：感谢Mego :)将“>”更改为'>，节省了1个字节。

在线尝试！

— 蓝绿色鹈鹕
source
'>是一个字节短于">"。
— Mego
@Mego是的，已编辑:)谢谢。
— 青色鹈鹕
11

PHP，69字节

<?=~"ÏÎÍÌËÊÉÈÇƾ½¼»º¹¸·¶µ´³²±°¯®­¬«ª©¨§¦¥žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…";

此处的代码使用Windows-1252进行了样式化。以下是可逆的xxd十六进制转储。

00000000: 3c 3f 3d 7e 22 cf ce cd cc cb ca c9 c8 c7 c6 be  <?=~"...........
00000010: bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae  ................
00000020: ad ac ab aa a9 a8 a7 a6 a5 9e 9d 9c 9b 9a 99 98  ................
00000030: 97 96 95 94 93 92 91 90 8f 8e 8d 8c 8b 8a 89 88  ................
00000040: 87 86 85 22 3b                                   ...";

在线尝试！

— 丹尼斯
source
10

Java（OpenJDK 9），277字节

是的，Java，您读得很好！

$->""+($='='+'=')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='-'+'-')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='_'-'&')+--$+--$+--$+--$+--$+--$+--$+--$+--$

在线尝试！

由于顺序不重要，因此将打印范围，但将其反转。

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

我在没有“无输入”规则的情况下进行游戏，以隐式定义一个 char使整个组件正常工作所必需的。如果那是作弊，请这样说。

脱胶和测试

public class PCG105781 {
  interface X { String apply(char x); }

  public static void main(String[] args) {
    X x = $
        -> "" // Force the result as a String.
        // The line below appends "zyxwvutsrqponmlkjihgfedcba"
        // '=' + '=' is 122 as int. $=122 casts 122 as a char, 'z'
        + ($ = '=' + '=') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "ZYXWVUTSRQPONMLKJIHGFEDCBA"
        // '-' + '-' is 90 as int. $=90 casts 90 as a char, 'Z'
        + ($ = '-' + '-') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "9876543210"
        // '_' - '&' is 57 as int. $=57 casts 57 as a char, '9'
        + ($ = '_' - '&') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
      ;

    System.out.println(x.apply('_'));
  }
}
— 奥利维尔·格雷戈尔（OlivierGrégoire）
source
3
等等，什么？我比所有的JavaScript解决方案都矮吗？o_O
— OlivierGrégoire17年
那是因为JavaScript没有char，否则就很容易了。公平地说，我的答案比您的最初答案短。看看我对所有必须处理的开销的解释。
— 帕特里克·罗伯茨
2
@PatrickRoberts公平地说，我们应该将初始编辑与初始编辑或最后编辑与最后编辑进行比较，而不是将初始编辑与最后编辑进行比较；;）我仔细阅读了对JavaScript所做的操作，尤其是因为我不知道该怎么做得到的答案比所有JS答案都要短。
— 奥利维尔·格雷戈尔
9

Brainfuck，89 85字节

因为无论如何Brainfuck都会忽略字母数字字符，所以这只是一个不断输出的挑战……（编辑：请参见Dennis的解决方案以获取短10字节的版本）

+[-[--<]>>--]++++++++++[<+.>-]<++++++++>+[-[---<]>>-]<-<<+++++[>+++++<-]>+[>.+<<<.+>>-]

在线尝试！

这段代码是Brainfuck中基本计数循环的一个很好的例子：

+[-[--<]>>--]   Create value 47: char just before '0'
++++++++++      Set adjacent cell to 10: to be used as a counter

[               While the counter is not 0:
 <+.              Increment and print the char
    >-            Decrement the counter
       ]        (End loop: Exits when all digits have been printed)


<++++++++>           The char is now at '9' so add 8 to make it 'A'
+[-[---<]>>-]<-      In another cell create lowercase 'a'
<<+++++[>+++++<-]>+  Create 26: the number of times to loop

[                While the counter is not 0:
 >.+               Print and increment the lowercase char
    <<<.+          Print and increment the uppercase char
         >>-       Decrement the counter
            ]    (End loop: Exits when all letters have been printed)

请注意，这使用包装快捷方式生成数字，这意味着解释器需要具有8位包装单元（例如我链接到的单元）。

— FlipTack
source
5
Brainfuck是我想到的第一门语言。可惜我不知道。好答案。
— ElPedro
7

JavaScript（ES6），983个字节

事实证明，在ES6中，可以在JavaScript变量名称中使用很多字符！用$和耗尽六个1-2个字节的变量名后，效果很好_。

_=~[]
$={}
Á=++_
À=![]+""
Â=À[_]
Ã=++_
Ä=À[_]
Å=++_
Æ=($+"")[_]
Ç=(_[_]+"")[_]
È=++_
É=(!""+"")[_]
Ë=++_
Ì=++_
Ê=($+"")[_]
Í=++_
µ=++_
Î=++_
Ï=++_
_="\\"
Ð=$.$
È_=(!""+"")[Ã]
Å_=$+""
Ñ=Å_[Ã]
Ò=(Ð+"")[Ã]
__=Å_[Í]
Ó=(!""+"")[Å]
$_=Å_[Ì]+Ñ+Ò+(!$+"")[È]+__+È_+Ó+Å_[Ì]+__+Ñ+È_
$$=È_+(!""+"")[È]+__+Ó+È_+Ò
$=Á[$_][$_]
$($($$+"\""+Ê+Ñ+_+Ã+Ì+Í+_+Ã+Í+È+Ñ+À[Å]+É+"."+À[Å]+Ñ+_+Ã+Ë+µ+"('"+Ä+Æ+Ê+Ç+É+Â+_+Ã+Ë+µ+_+Ã+Ì+Á+_+Ã+Ì+Ã+_+Ã+Ì+Å+_+Ã+Ì+È+À[Å]+_+Ã+Ì+Ì+_+Ã+Ì+Í+Ñ+_+Ã+Í+Á+_+Ã+Í+Ã+_+Ã+Í+Å+_+Ã+Í+È+__+Ó+_+Ã+Í+Í+_+Ã+Í+µ+_+Ã+µ+Á+_+Ã+µ+Ã+_+Ã+µ+Å+_+Ã+Á+Ã+_+Ã+Á+Å+_+Ã+Á+È+_+Ã+Á+Ë+_+Ã+Á+Ì+_+Ã+Á+Í+_+Ã+Á+µ+_+Ã+Ã+Á+_+Ã+Ã+Ã+_+Ã+Ã+Å+_+Ã+Ã+È+_+Ã+Ã+Ë+_+Ã+Ã+Ì+_+Ã+Ã+Í+_+Ã+Ã+µ+_+Ã+Å+Á+_+Ã+Å+Ã+_+Ã+Å+Å+_+Ã+Å+È+_+Ã+Å+Ë+_+Ã+Å+Ì+_+Ã+Å+Í+_+Ã+Å+µ+_+Ã+È+Á+_+Ã+È+Ã+_+Ã+È+Å+Ã+Å+È+Ë+Ì+Í+µ+Î+Ï+Á+"')\"")())()

JavaScript，1223个字节

这是我了解上述内容之前的答案。

_=~[]
$={}
___=++_
____=![]+""
$$$$=____[_]
__$=++_
$_$_=____[_]
_$_=++_
$_$$=($+"")[_]
$$_$=(_[_]+"")[_]
_$$=++_
$$$_=(!""+"")[_]
$__=++_
$_$=++_
$$__=($+"")[_]
$$_=++_
$$$=++_
$___=++_
$__$=++_
_="\\"
_$_$=$.$
_$$_=(!""+"")[__$]
_$__=$+""
_$=_$__[__$]
__$_=(_$_$+"")[__$]
__=_$__[$$_]
___$=(!""+"")[_$_]
$_=_$__[$_$]+_$+__$_+(!$+"")[_$$]+__+_$$_+___$+_$__[$_$]+__+_$+_$$_
$$=_$$_+(!""+"")[_$$]+__+___$+_$$_+__$_
$=___[$_][$_]
$($($$+"\""+$$__+_$+_+__$+$_$+$$_+_+__$+$$_+_$$+_$+____[_$_]+$$$_+"."+____[_$_]+_$+_+__$+$__+$$$+"('"+$_$_+$_$$+$$__+$$_$+$$$_+$$$$+_+__$+$__+$$$+_+__$+$_$+___+_+__$+$_$+__$+_+__$+$_$+_$_+_+__$+$_$+_$$+____[_$_]+_+__$+$_$+$_$+_+__$+$_$+$$_+_$+_+__$+$$_+___+_+__$+$$_+__$+_+__$+$$_+_$_+_+__$+$$_+_$$+__+___$+_+__$+$$_+$$_+_+__$+$$_+$$$+_+__$+$$$+___+_+__$+$$$+__$+_+__$+$$$+_$_+_+__$+___+__$+_+__$+___+_$_+_+__$+___+_$$+_+__$+___+$__+_+__$+___+$_$+_+__$+___+$$_+_+__$+___+$$$+_+__$+__$+___+_+__$+__$+__$+_+__$+__$+_$_+_+__$+__$+_$$+_+__$+__$+$__+_+__$+__$+$_$+_+__$+__$+$$_+_+__$+__$+$$$+_+__$+_$_+___+_+__$+_$_+__$+_+__$+_$_+_$_+_+__$+_$_+_$$+_+__$+_$_+$__+_+__$+_$_+$_$+_+__$+_$_+$$_+_+__$+_$_+$$$+_+__$+_$$+___+_+__$+_$$+__$+_+__$+_$$+_$_+__$+_$_+_$$+$__+$_$+$$_+$$$+$___+$__$+___+"')\"")())()

我console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')浏览了jjencode并手动打出了结果。肯定还有更多的优化可以完成。

— 达里里奥
source
嘿，仅供参考，我发布了codegolf.stackexchange.com/a/105854/42091，因为我在其中做了很多工作，并且认为与您的回答有很大不同。
— Patrick Roberts
没问题，看起来不错！
— darrylyeo
真好！最后的更新帮助我脱离了我的100多个字节！
— 帕特里克·罗伯茨
1
如果将编码更改为ISO8859-1，并保持完全像这样，它将为769个字节。
— 帕特里克·罗伯茨
7

Befunge，73 72 59 57 55 53字节

"{"< ^+`"`"\+*`\":"\`"/":\*`\"["\`"@":::::-!!
#@_^,_!

在线尝试！

这是一个从向下倒数{（即，后一个字符z）的循环。在第一次迭代中，该"{"<序列将的两个副本压{入堆栈-一个是初始循环计数器，另一个用于使用该序列递减该计数器!!-（两个NOTs make 1，然后将其相减）。在随后的迭代中，循环计数器已经在堆栈上，因此只{需要一个计数器就可以设置递减序列。

代码的其余部分只是一个长布尔表达式，用于计算字符是否在范围内。如果是这样，第二行上的分支将向左拆分以写出该值。如果不是，则右分支将环绕以测试我们是否已达到零并应终止。两个分支在中间合并以向上并重复循环。请注意，所有垂直方向命令都向上移动，因为我们不能使用v，但这很好，因为指令指针会自动环绕在运动场的顶部。

感谢Mistah Figgins最初提出了一种更好的循环增量技术。

但是特别要感谢Jo King提供了一种更好的方法，即倒数而不是递增，以及更紧凑的分支布局。

— 詹姆斯·霍尔德尼斯
source
1
如果除堆栈上的计数器外没有其他任何内容，则可以将增量部分更改为\！+如果存在，则可以执行：!! +。非零值
— MildlyMilquetoast'1
-2字节，通过在行首重新排列检查
— Jo
@JoKing好被发现。v由于这是受限制的源代码，因此我们无法使用，但它仍然可以与一起使用^。谢谢。
— James Holderness
-2个字节（通过递减而不是递增计数），并使用第二行的计数器的额外副本检查循环是否结束（这次记住受限源；））
— Jo King
@JoKing Wow，您在打高尔夫球方面确实比我更好！再次感谢。
— James Holderness
6

果冻，17 16字节

“:[{“/@`‘Ḷḟ"/ỌḊ€

在线尝试！

这个怎么运作

“:[{“/@`‘Ḷḟ"/ỌḊ€  Main link. No arguments.

“:[{“/@`‘         Yield [[58, 91, 123], [47, 64, 96]].
         Ḷ        Unlength; map each n to [0, ..., n-1].
          ḟ"/     Reduce by vectorizing filter-false.
                  This yields [[47, ..., 57], [64, ..., 90], [96, ..., 122]].
             Ọ    Unordinal; replace each n with the corr. Unicode character.
              Ḋ€  Deqeue each; remove the first character of each of the three
                  generated strings ('/', '@', and '`').
— 丹尼斯
source
由于果冻具有自己的代码页，因此如果您附加了
— 十六进制转储
@FlipTack IIRC Jelly的代码页与可打印的ASCII兼容。
— PurkkaKoodari
@FlipTack Pietu1998是正确的。即使他不是，该规范也禁止使用字符，而不是字节。
— 丹尼斯，
@Dennis实际上，尽管它仍然有效（与ASCII兼容），但它禁止每个注释使用字节。
— 大公埃里克（Erik the Outgolfer）'17年
6

自我修改Brainfuck，32位元组

<[-<+.>]<<[-<+.>]<<[-<+.>]`@/

在线尝试！

xxd -r-可逆的十六进制转储（包含不可打印的内容）：

00000000: 3c5b 2d3c 2b2e 3e5d 3c3c 5b2d 3c2b 2e3e  <[-<+.>]<<[-<+.>
00000010: 5d3c 3c5b 2d3c 2b2e 3e5d 601a 401a 2f0a  ]<<[-<+.>]`.@./.
— 暴民埃里克
source
怎么@/办？
— Yytsi'1
@TuukkaX最后6个字符`\x1a@\x1a/\n在那里，因为它们的代码点在打高尔夫球中非常有用。您无法删除它们。
— 暴民埃里克（Erik the Outgolfer）'17年
@downvoter：如果您偶然发现此帖子，请删除您的downvote。此后已修复。
— 暴民埃里克（Erik the Outgolfer）'17年
很高兴我不是唯一使用SMBF的人。:)
— mbomb007'1
@ mbomb007实用性:)我在考虑BF，并且想到了SMBF，因此我已经准备好了代码点。限制没有花费我多少字节，就像我以前使用的+.那样.+。
— 暴民埃里克（Erik the Outgolfer）'17年
6

C，128字节

是的，C。它甚至比一些深奥的要短。

__($$,_,$,_$,$_){$>_$?_$=_$?!$:$,$=*(""-_+$_++)&*"{":_;_$?*(""-_+$$++)=$++:_;$&&__($$,_,$,_$,$_);}_(_){__(_,"",_,!!_,"½´ÞÅþå");}

调用_足够大的空char *缓冲区。

可能与编译器有关。使用GCC测试；文件已保存在代码页1252中。

— 匿名
source
6

的JavaScript（ES6），812 745 657 650个 536 520 416字节

(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))

编辑：使用ISO8859-1编码，此解决方案是416字节而不是520字节。完整的程序为432字节，其中考虑了

f=\r\n
416 byte submission here\r\n
alert(f())

这是功能提交，而不是完整程序。我花了很长时间打高尔夫球JJEncode（为此向darrylyeo致敬），但没有打高尔夫球

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

我打高尔夫球

for($ of[[48,58],[65,91],[97,123]])for(_=$[0];_<$[1];)Ø+=String.fromCharCode(_++);return Ø

在开销中Ø初始化到""的位置。

改用逗号运算符转换为换行符：

À=(Á=!($={})+(Ø=""))[Â=_=+[]]
Ã=(Ä=!_+Ø)[Å=++_]
Æ=(Ç=$+Ø)[_]
È=(É=$.$+Ø)[_]
Ê=Ä[Ë=++_]
Ì=Ä[Í=++_]
Î=++_
Ï=Ç[Ð=++_]
Ñ=Ç[Ò=++_]
Ó=++_
$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô]
// function that returns string
$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)())

说明

该脚本首先初始化一些内置类型并将其强制为字符串。我们不用字母数字字符就能得到的字符串是：

{}+""     -> "[object Object]"
!{}+""    -> "false"
!+[]+""   -> "true"
{}[{}]+"" -> "undefined"

从这些字符串以及引用单个字符所需的数字，我们可以获得字符串return和constructor，它们可以像以下方式使用：

$={}[Ô="constructor"][Ô]
$(("return"+`"encoded script"`)())

对象的构造函数为Object()，而其构造函数为Function()，我们可以本质上使用like eval()。

在这种情况下，要执行的编码脚本是嵌套for循环，使用它们的代码点将所有字母数字字符连接到字符串并将其返回。

对于无法使用内置函数访问的编码脚本中的字母字符，JJEncode使用八进制转义符来表示它们，然后通过从内部函数返回它来解码整个字符串。然后可以调用外部函数来执行源代码。

演示版

f=
(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))
console.log(f())
展开摘要

— 帕特里克·罗伯茨
source
5

Brain-Flak，171字节

包括+3 -A

(((((()()()){}){}){}){})(((()()())){}{}){({}[()]<(({})())>)}{}(({})(()()()()){})(((((()()()){}){}){}())<{({}[()]<(({})())>)}{}(({})(()()()){}())>){({}[()]<(({})())>)}{}

在线尝试！

(((((()()()){}){}){}){}) # push 48
(((()()())){}{})         # push 9
{({}[()]<                # for 9..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()()){})       # pop a, push a, push a + 8
(((((()()()){}){}){}())< # push 26 and save a 26 for later
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()){}())       # pop a, push a, push a + 7
>)                       # push that 26 that we held
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for

可能有一种方法可以执行此操作而不必重复添加1“功能”。

— 莱利
source
5

J，171字节

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

哎呀，我的大脑好痛... 在线尝试！

这样一来，您就可以在一行中看到所有内容（尽管有换行符，但它不会运行）。

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*
_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

仅保证按此j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52顺序与J版本一起使用。（仅前12个字符很重要。）

说明

该程序的大部分致力于不断生成。将这些常量替换为其值，该程序如下所示：

(62){.".(':',~(12){(9)!:(14)''),',',(":(65),(97),48),'+/',('.',~(10){(9)!:(14)''),":26

删除一些括号，并增加一些数字：

62{.".(':',~12{9!:14''),',',(":65 97 48),'+/',('.',~10{9!:14''),":26

这是由一堆,和组成,~的，它们在参数的前面和后面附加。以下是单独的值：

  1. ":26
  2. ('.',~10{9!:14'')
  3. '+/'
  4. (":65 97 48)
  5. ','
  6. (':',~12{9!:14'')

1是26字符串。

9!:14'' 在TIO上生成以下字符串：

j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52

与一起2，我们获得第10个字符（ifrom linux），并.在其末尾添加a ，产生i.。

3并且5是不言自明的。

4 是数字列表 65 97 48作为字符串。

6与相似2，除了它是第12个字符（ufrom linux）并添加一个:在末尾，产生u:。

总的来说，这产生了u:,65 97 48+/i.26。".对此进行评估，得出以下结论：

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

（注意： +/是列表形式的加法。）

然后，使用62{.，我们从中得到第一个62字符，并赋予我们ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789。

— 科纳·奥布莱恩
source
您可以使用常数14来<:<.^^*_节省一个字节。另外，我尝试生成整个范围并删除符号以获取':;<=>?@[\]^_`'-.~".(':',~(+:+:>.^*_){(*:>.^*_)!:(<:<.^^*_)''),":(#@}.@}.@}.@,~(+#\)],,~)(*:@#$])'+++++'104个字节。我敢肯定它会变得更短
— 英里
5

05AB1E，18 15 11字节

-4感谢Adnan，因为如果输入大小为1，则05AB1E将在第一个命令中将0用作b。

•£•Ýç©á®þ«˜

在线尝试！

•£•Ÿ            # Push [0..122] using implicit 0 and the base-214 of `£`.
    ç           # Convert to ASCII chars.
     ©          # Store full array in register.
      á         # Push the same array with ONLY letters.
       ®        # Push contents of register (char)[0..122].
        þ       # Push only the digits.
         «˜     # Concat to list, flatten it.

我尝试了许多不同的方法，但是这里的要点使它变得困难：

- Basic commands will not work, only extended and a select few of the basics.
- Extended commands are pretty complex.
- Eval (.V) will not work.
- To push numbers you can do a base 214 compression.
- ALL sequence pushes (E.G. žK) won't work.
- ALL number pushes won't work, except for compression and the -1 an empty register pushes.
— 魔术章鱼缸
source
1
You may print them in arbitrary order说挑战。
— AdmBorkBork
1
是否 •£•Ýç©á®þ«˜还工作吗？
— 阿德南（Adnan）
@Adnan不错，没有b时不知道它使用0。
— Magic Octopus Urn'1
5

Brainfuck，55个字节

+++[[<+>->++<]>]<<[-<->]<<<<++[->>+.>+.<<<]<--[->>.+<<]

输出：

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

在线尝试！

将磁带初始化为3·2 n，然后从那里开始工作。

+++[[<+>->++<]>]    initialize the tape
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 | 192 | 128 |   0 |   0 |
                                                                                    ^
<<[-<->]            subract 128 from 192
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                                        ^
<<<<++              increment 24 twice
                    |   0 |   3 |   6 |  12 |  26 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                ^
[->>+.>+.<<<]       output aAbBcC ~ zZ
                    |   0 |   3 |   6 |  12 |   0 |  48 | 122 |  90 |   0 |   0 |   0 |
                                                ^
<--[->>.+<<]        decrement 12 twice; output 0 ~ 9
                    |   0 |   3 |   6 |   0 |   0 |  58 | 122 |  90 |   0 |   0 |   0 |
                                          ^
— 原始
source
5

Perl 6，43个字节-无竞争

{|('`'^..^'{'),|('@'^..^'['),|('/'^..^':')}

返回一个字符列表的lambda。
说明：

   '`'                                       # The character before "a" (in Unicode order)
          '{'                                # The character after "z"
      ^..^                                   # Endpoint-exclusive range between them
 |(          )                               # Slip the range into the outer list
               |('@'^..^'[')                 # Same thing for "A" to "Z"
                             |('/'^..^':')}  # Same thing for "0" to "9"

依赖于Rakudo Perl 6解释器的错误修正，该错误修正仅在今天才提交给git repo，并且还不是Rakudo官方发行版的一部分。实际上，我在回答此挑战时遇到了该错误，并在Perl 6核心开发人员之一的帮助下得以解决。据我了解，该网站的规则不允许答案在这种情况下竞争，因此我将其标记为不竞争。

— 短信
source
— Jo King
4

PHP 7.0 +，110字节

愿上帝保佑位弦！

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^_,'%'^_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^_));

用\n真实的* NIX风格的换行符代替。
它存在于代码中，以避免换行符出现问题，但不计入分数。

这引发了一堆警告，但是可以通过@在每个流浪者的前面附加一个警告来消除这些警告_。

无警告，113字节

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^@_,'%'^@_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^@_));
— 伊斯梅尔·米格尔（Ismael Miguel）
source
3

65c02机器语言+ Apple] [ROM，25字节

A9 E0 20 0F 80 A9 C0 20 0F 80 A2 0A A9 AF 2C A2 1A 1A 20 ED FD CA D0 F9 60

版画 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789。

应该从 $8000。

拆卸

8000-   A9 E1       LDA   #$E0
8002-   20 0F 80    JSR   $800F
8005-   A9 C1       LDA   #$C0
8007-   20 0F 80    JSR   $800F
800A-   A2 0A       LDX   #$0A
800C-   A9 B0       LDA   #$AF
800E-   2C          HEX   2C     ; SKIPS NEXT 2 BYTES
800F-   A2 1A       LDX   #$1A
8011    1A          INC   
8012-   20 ED FD    JSR   $FDED
8015-   CA          DEX   
8016-   D0 F9       BNE   $8011
8018-   60          RTS
— insert_name_here
source
这违反了代码点规则-您只是在使用不同字符集中的字符。字节是可以的，只要它们不是迭代或不被代码读取即可。
— dkudriavtsev
@wat啊，好的。我已经对代码进行了编辑，以使其不使用任何映射到“正常”（正）ASCII字母数字字符的机器代码字节，并且不使用任何正或负ASCII字母数字文字；现在有效吗？
— insert_name_here
大概吧... 。_。
— dkudriavtsev
@wat目前使用的以升序的码点10, 15, 26, 32, 44, 96, 128, 162, 169, 175, 192, 202, 208, 224, 237, 249, 253，其映射到字符↵.. ,`.¢©¯ÀÊÐàíùý，其中.s为不可打印的字符。有效
— Patrick Roberts
3

bash的（在Linux），507 493 490 485字节

这将字符数组存储在全局变量中 __

: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
__=(/????/????/??/??)
___=${__%??}
__=(${__[@]#$___?})
____=${___#/*/?}
____=${____%?/*/}
_____=${____%?}
____=${____#?}
___=${___%??/}
______=($___*_??)
______=${______#$___???????}
______=${______%??_*}
_______=($___$_____???*)
_______=${_______#$___??}
_______=${_______%????}
___=$#
___=$((++___))$((___+++++___+___--))$___
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
__=(${__[@]} ${___[@]} ${___[@]^})

它需要在新启动的Linux机器上执行 /proc或类似pid名称空间

说明：

# {var}>file opens a file descriptor >= 10 to that file
: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
# at startup no pid is > 999 so there's no other /proc/pid/fd/??
__=(/????/????/??/??)                                 # /proc/self/fd/1[0-9]
___=${__%??}                                          # /proc/self/fd/
__=(${__[@]#$___?})                                   # {0..9}
____=${___#/*/?}                                      # elf/fd/
____=${____%?/*/}                                     # el
_____=${____%?}                                       # e
____=${____#?}                                        # l
___=${___%??/}                                        # /proc/self/
______=($___*_??)                                     # /proc/self/timerslack_ns
______=${______#$___???????}                          # ack_ns
______=${______%??_*}                                 # a
_______=($___$_____???*)                              # /proc/self/environ
_______=${_______#$___??}                             # viron
_______=${_______%????}                               # v

___=$#                                                # 0
___=$((++___))$((___+++++___+___--))$___              # 172 (z in octal)

# eval eval                   ___="\({a..$'\172'}\)"
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
#   {0..9}   {a..z}    {A..Z}
__=(${__[@]} ${___[@]} ${___[@]^})

尝试一下，我们可以declare -p __在最后添加以显示结果

$ sudo unshare --fork --pid --mount-proc bash golf
declare -a __=([0]="0" [1]="1" [2]="2" [3]="3" [4]="4" [5]="5" [6]="6" [7]="7" [8]="8" [9]="9" [10]="a" [11]="b" [12]="c" [13]="d" [14]="e" [15]="f" [16]="g" [17]="h" [18]="i" [19]="j" [20]="k" [21]="l" [22]="m" [23]="n" [24]="o" [25]="p" [26]="q" [27]="r" [28]="s" [29]="t" [30]="u" [31]="v" [32]="w" [33]="x" [34]="y" [35]="z" [36]="A" [37]="B" [38]="C" [39]="D" [40]="E" [41]="F" [42]="G" [43]="H" [44]="I" [45]="J" [46]="K" [47]="L" [48]="M" [49]="N" [50]="O" [51]="P" [52]="Q" [53]="R" [54]="S" [55]="T" [56]="U" [57]="V" [58]="W" [59]="X" [60]="Y" [61]="Z")
— izabera
source
+1。我认为您应该将此声明为Linux上的Bash，因为其他操作系统（例如MacOS）没有/proc。实际上，/proc在Linux上并不是绝对必要的，尽管没有它可能很难找到现代发行版。
— Digital Trauma
3

JavaScript，1273年 1351 1610 个字节

该解决方案的工作原理基本相同的方式在此线程的其他两个答案在这里，并在这里，它使用字母从true，false，undefined，和[object Object]字符串来构建它需要生成其他字母的功能。

由于对象中已经放入了大量字母，因此我尝试将所有剩余的小写字母和数字添加到对象中，然后将其应用于对象toUpperCase中的所有值以生成缺失的伪字母。

更新：

我可以改进八进制值的设置方式，但是它们仍然占用13 x 30字节（或者在我将数字更改为不同的键后，它们将分别为30字节），现在每个值都遵循此常规模式：$.ž=\'\\'+$.一+$.七+$.二+'\';。

通过将数字的键切换为2个字节的字符，可以轻松取出另外49个字节。

当前提交： 

$=~[];_={ť:!""+"",ň:![]+"",û:$._+'',ô:{}+"",ø:''};$={零:++$,ƒ:_.ň[$],ť:_.ť[$],一:++$,â:_.ň[$],ř:_.ť[$],ô:_.ô[$],ň:_.û[$],二:++$,ľ:_.ň[$],û:_.ť[$],ƅ:_.ô[$],ď:_.û[$],三:++$,ŝ:_.ň[$],ĵ:_.ô[$],四:++$,ě:_.ň[$],五:++$,ĉ:_.ô[$],î:_.û[$],六:++$,七:++$,八:++$,Ô:_.ô[$],九:++$};_.ĉ=$.ĉ+$.ô+$.ň+$.ŝ+$.ť+$.ř+$.û+$.ĉ+$.ť+$.ô+$.ř;_.ř=$.ř+$.ě+$.ť+$.û+$.ř+$.ň;_.ƒ=(0)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()
— 马丁
source
1
这似乎很有趣，但实际上它不是很打高尔夫球。仅删除空白将节省74个字节，单引号可用于包含双引号的字符串，而3字节Unicode字符可替换为较便宜的字符。
— 丹尼斯，
@Dennis是的，尽管我认为此方法目前最大的问题是使用八进制代码设置的字符太多。
— 马丁
3

C（clang），164字节

é,ú,í,ó;_(*$){ú-=ú;ú++;í=ú+ú;ó=í<<í*í<<ú;!é?é++,é<<=í*í+ú,é+=í<<í+ú:é;*$++=é++;é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú;é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú;é<í*ó-(í*í)-ú?_($):ú;}

在线尝试！

这是一个递归函数，它以1开头（减去self并递增）来获取字符，并从中创建所有其他数字。

退货/解释： 

é,ú,í,ó;
_(*$){ //function "_" taking a pointer "$"
	ú-=ú;ú++; //constant ú=1
	í=ú+ú; //constant í=2
	ó=í<<í*í<<ú; //constant ó=64
	!é?é++,é<<=í*í+ú,é+=í<<í+ú:é; //if é isn't initialized, seek to character '0'
	*$++=é++; //write to string and increase string index
	é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú; //skip to 'A'
	é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú; //skip to 'a'
	é<í*ó-(í*í)-ú?_($):ú; //keep recursing until end of alphabet
}
— 洛根
source
2

CJam，15个字节

"{`[@:/"_:,:^\-

在线尝试！

说明

"{`[@:/" e# Push this string. Note that these are the characters just above and
         e# below the a-z, A-Z and 0-9 ranges, respectively.
_        e# Get a copy of the string.
:,       e# Turn each character into a range, i.e. all characters from the null byte
         e# to the the character below the given one. E.g. { is turned into "...xyz".
:^       e# Fold symmetric set difference over the list. Gives us the characters that
         e# appear in an odd number of the strings. Those are the letters, the digits
         e# as well as `, @ and /.
\        e# Pull the other copy of the string on top.
-        e# Remove these characters from the string. That leaves only the alphanumerics.
— 马丁·恩德
source
2

𝔼𝕊𝕄𝕚𝕟，8个字符/ 19个字节

ᶐ+ᶛ+⩥Ⅹă⬯

在这里尝试！

ᶐ是大写字母，ᶛ是小写字母，并且⩥Ⅹă⬯是范围（⩥）从0到10（Ⅹ，Unicode罗马数字）减去1，由（ă）否（⬯）联接。

— 科纳·奥布莱恩
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.