打印所有字母数字字符加下划线

37

编写一个程序或函数，该程序或函数以任意顺序打印或返回字母数字字符和下划线的字符串。准确地说，以下字符需要输出，并没有更多：

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_

打印到标准输出时，允许在输出后添加可选的尾随换行符。

不允许包含9个或更多上述字符的内置常量。

以字节为单位的最短代码获胜。

这是一个非常简单的挑战，尽管如此，我相信它将产生一些有趣的答案。

排行榜

这是一个堆栈片段，用于按语言生成常规排行榜和获胜者概述。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以将旧分数保留在标题中，方法是将它们打掉。例如：

# Ruby, <s>104</s> <s>101</s> 96 bytes

如果要在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

# Perl, 43 + 2 (-p flag) = 45 bytes

您还可以将语言名称设置为链接，然后该链接将显示在页首横幅代码段中：

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

显示代码段

code-golf  kolmogorov-complexity 
— 奥尔普
source
2
评论不作进一步讨论；此对话已转移至聊天。
— 丹尼斯

Answers:

11

凸，9个字节

新方法！另外，我意识到这与Luis的答案几乎完全相同，但在Convex中却是这样，但我是独立提出的。

'{,®\W"Oò

在线尝试！

说明：

'{,           Array of chars from NUL to 'z
   ®\W"       Regex to match non-word characters
       Oò     Replace all matches with emtpy string

旧解决方案，10个字节：

A,'[,_¬^'_

在线尝试！

说明：

A,          0-9
'[,_¬^      A-Za-z
'_          _
— GamrCorps
source
1
@ mbomb007是的，它等效于CJam代码A,'[,_el^'_
— GamrCorps
这是哪种编码？
— 科纳·奥布莱恩
@CᴏɴᴏʀO'BʀɪᴇɴCP-1252或Windows-1252
— GamrCorps
12

Perl，20个字节

需要-E在不增加成本。

say+a.._,A.._,_..9,_

因此，我的原始答案（如下）有点无聊。我唯一想出的就是上面的内容，虽然完全相同，但是看起来有些混乱……它几乎等同于下面的内容：

say a..z,A..Z,0..9,_

我喜欢评论中@ msh210的建议，但它们太长了！

— 唐·黑斯廷斯
source
1
+1。稍微更有趣，但不再是任何这些，所有的27个字节：say grep/\w/,map chr,1..122|| say map{chr=~/\w/;$&}1..122|| say map{chr=~s/\W//r}1..122
— msh210 '16
1
@ msh210仍然无法减少更多内容……尽管管理了25：say chr=~/\w/g for 1..255...
— Dom Hastings
10

切达（Cheddar），31 27字节

->97@"123+65@"91+48@"58+"_"

这@"很好地展示了操作员

无法完成，因为我终于知道要修复该@"运算符了。错误是它生成的是Cheddar范围而不是JS范围，因此无法正常工作

说明

该@"操作是由@CᴏɴᴏʀO'Bʀɪᴇɴ设计的，它的作用是产生从LHS到RHS字符串范围。当用作一元运算符时，它将在给定的代码点（如python chr）返回char。

不打高尔夫球

->
  97 @" 123 +
  65 @" 91  +
  48 @" 58  +
  "_"
— 下山羊
source
10

Brainfuck，58个字节

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

在线尝试。

将磁带初始化为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 |
                                                                        ^
<<-.+<<++           ouput '_'; 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
9

JavaScript（ES6），62个字节

_=>String.fromCharCode(...Array(123).keys()).replace(/\W/g,'')

返回0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz，因此仅比返回字符串文字的函数短6个字节。是的，很烂。

— 尼尔
source
您可以尝试查找btoa返回所需输出的字符串。
— gcampbell '16
@gcampbell 60！（60个阶乘）字符串可能需要一些时间来搜索...
— Neil
您可以使用atob。
— gcampbell '16
@gcampbell我必须以某种方式排除无法代表的字符串。
— 尼尔
@gcampbell事实证明，btoa版本无论如何都要占用62个字节：45可以编码60个字母数字，3个未编码的字符（包括_）和14个用于_=>atob("")+""。
— 尼尔
9

Haskell，38个字节

'_':['a'..'z']++['A'..'Z']++['0'..'9']

这里没什么可解释的。

— 妮米
source
2
问题：:和之间有什么区别++？
— Downgoat
3
@Downgoat：++接受两个字符串并将它们连接起来。:接受一个char和一个字符串，并将char放在字符串前面。"_"++['a'..'z']...也可以，但是要长一个字节。
— nimi
8

PowerShell v3 +，35 33字节

-join([char[]](1..127)-match'\w')

构造一个动态数组1..127，将其强制转换为char数组。这将馈给-match正则表达式上的运算符，该运算符\w将返回所有匹配的元素（即，精确的字母数字和下划线）。我们将这些数组元素封装在中，以-join将其捆绑为一个字符串。这留在管道上，输出是隐式的。

— AdmBorkBork
source
1
嘿，这不公平。我自己的解决方案是相同的，除了我始于0...
— Joey
@Joey Gotta快点。：D
— AdmBorkBork '16
我猜想尤其是对于琐碎而明显的解决方案；-)
— Joey
7

V，27个字节

i1122ñYpñvHgJ|éidd@"Í×

在线尝试！

这个答案是可怕的令人费解。稍后再发表解释。

十六进制转储：

00000000: 6916 1631 1b31 3232 f159 7001 f176 4867  i..1.122.Yp..vHg
00000010: 4a7c e969 6464 4022 1bcd d7              J|.idd@"...

说明：

可读性：

i<C-v><C-v>1<esc>                                   "Insert the text "<C-v>1"
                                                    "<C-v> means "literal"
                 122ñ       ñ                       "122 times,
                     Yp                             "Duplicate this line
                       <C-a>                        "And increment the first number on this line
                             vHgJ                   "Join every line together
                                 |éi                "Insert an 'i' at the beginning of this line
                                    dd              "Delete this line
                                      @"<esc>       "And execute it as V code.
                                                    "That will generate every ascii value from 1-123
                                             Í×     "Now remove every non-word character.
— DJMcMayhem
source
5
：D：D：D切达（Cheddar）与高尔夫球郎并列！
— Downgoat
7

J，30 29 28字节

感谢randomra，节省了一个字节！

~.u:95,;48 65 97+i."*10,,~26

输出：

   ~.u:95,;48 65 97+i."*10,,~26
_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

说明

我本身不会提供解释，但是会提供中间结果。

   10,,~26
10 26 26
   i. b. 0
1 _ _
   *  b. 0
0 0 0
   i."* b. 0
   i."*2 3 4
0 1 0 0
0 1 2 0
0 1 2 3
   i. 2
0 1
   i. 3
0 1 2
   i. 4
0 1 2 3
   i."*10,,~26
0 1 2 3 4 5 6 7 8 9  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
   0 1 2 + i."*10,,~26
0 1 2 3 4 5 6 7  8  9  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
1 2 3 4 5 6 7 8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
   48 65 97+i."*10,,~26
48 49 50  51  52  53  54  55  56  57  48  48  48  48  48  48  48  48  48  48  48  48  48  48  48  48
65 66 67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
   ;48 65 97+i."*10,,~26
48 49 50 51 52 53 54 55 56 57 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
   95,;48 65 97+i."*10,,~26
95 48 49 50 51 52 53 54 55 56 57 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 48 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 ...
   u:95,;48 65 97+i."*10,,~26
_01234567890000000000000000ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
   ~.u:95,;48 65 97+i."*10,,~26
_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
— 科纳·奥布莱恩
source
6

Haskell，31个字节

do(x,y)<-zip"aA0_""zZ9_";[x..y]

该表达式zip "aA0_" "zZ9_"给出了端点列表[('a','z'),('A','Z'),('0','9'),('_','_')]。该do符号将每个符号都(x,y)包含在内\(x,y)->[x..y]，并将结果连接起来。感谢Anders Kaseorg用do代替的两个字节>>=。

与替代品比较：

do(x,y)<-zip"aA0_""zZ9_";[x..y]

zip"aA0_""zZ9_">>= \(x,y)->[x..y]
f(x,y)=[x..y];f=<<zip"aA0_""zZ9_"
id=<<zipWith enumFromTo"aA0_""zZ9_"
[c|(a,b)<-zip"aA0_""zZ9_",c<-[a..b]]
f[x,y]=[x..y];f=<<words"az AZ 09 __"
— 异或
source
2
do表示法保存两个字节：do(x,y)<-zip"aA0_""zZ9_";[x..y]
— Anders Kaseorg '16
4

C，50个字节

调用时f()不带任何参数。

f(n){for(n=128;--n;)isalnum(n)|n==95&&putchar(n);}

版画

zyxwvutsrqponmlkjihgfedcba_ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210
— owacoder
source
1
isalnum(n)|n==95&&putchar(n)
— orlp
那里有UB。您没有传递必需的参数。
— 2016年
@orlp-您使用putc而不是putchar。putc希望流也要写入，但您没有通过。该函数本身可以正常工作（尝试putc完全删除您，它可以正常工作）。
— owacoder
@owacoder糟糕！
— orlp
1
@QPaysTaxes错了。If the number of arguments does not equal the number of parameters, the behavior is undefined.6.5.2.2/6，请参阅N1570。
— 法师
4

///，63字节

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_
— 暴民埃里克
source
有效答案如何？似乎违反了规则。
— nicael
@nicael哪个规则？
— Leaky Nun
“不允许包含9个或更多上述字符的内置常量。” ...我是否缺少明显的东西，@ Leaky？
— nicael
4
是的，它没有使用任何内置常量。
— Leaky Nun
好的，但这至少很奇怪。绝对OP不会要求您复制粘贴该序列，这并不有趣。
— nicael
4

Python 3，58个字节

print('_',*filter(str.isalnum,map(chr,range(123))),sep='')

打印到STDOUT的完整程序。

输出为： _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

这个怎么运作

map(chr,range(123))       Yield an iterator containing all ascii characters with
                          code-points in [0,122]...
*filter(str.isalnum,...)  ...keep characters if alphanumeric and unpack into tuple...
print('_',...,sep='')     ...add underscore and print all characters with no separating
                          space

在Ideone上尝试

如果允许使用字符串常量，则以下内容将为45个字节：

from string import*
print('_'+printable[:62])
— 骑自行车的维京人
source
1
print('_'+*filter(str.isalnum,map(chr,range(123))))
— Leaky Nun
@LeakyNun引发语法错误。我曾想过与做类似的事情print('_',*filter(str.isalnum,map(chr,range(123))))，但是会打印出空格。OP在评论中说，“ ...输出中根本不允许有空格”。
— TheBikingViking
Python 2可以使用这种方法节省一个字节：print''.join(filter(str.isalnum,map(chr,range(123)))),'_'
— 气象学家
4

我第一次尝试codegolf！

C＃，168 152 150 147 130 127 117 116 115 109 106个字节

for(var a='0';a<'~';a++){Console.Write(System.Text.RegularExpressions.Regex.IsMatch(a+"","\\w")?a+"":"");}

非常感谢aloisdg，AstroDan，Leaky Nun和Kevin Lau-不是Kenny在评论中提供的所有帮助。

— 丹尼尔
source
2
欢迎来到PPCG！随意删除所有空间！另请查看有关C＃中打高尔夫球的技巧以获取一些技巧。
— aloisdg说恢复莫妮卡
1
太好了-为我节省了2个字节。我真的很喜欢这个codegolf :)
— Daniel
1
AFAIK，\w正则表达式类涵盖了字母数字和_，这"\\w"对于您的正则表达式匹配功能应足够有效。
— 价值墨水
1
您的代码应该是函数或完整程序，而不是语句。还可以使用.NetFiddle来分享您的代码示例：)
— aloisdg说，莫妮卡（Monica）重启2016年
2
“ C＃并不是最好的代码高尔夫”我发现C＃足够有趣，可以编码高尔夫。我认为这是一种很棒的主流语言。如果您在这里赢了，那您就输了。将您的目标定义为学习和度过美好时光，您将永远赢得胜利。
— aloisdg说恢复莫妮卡
4

对象Pascal，85 83 73字节

只是使用一组字符的普通对象pascal。编写完整的程序而不是过程将节省2个字节。删除program关键字可以再节省10个字节。

var c:char;begin for c in['a'..'z','A'..'Z','0'..'9','_']do write(c);end.
— hdrz
source
我过去曾经并且可能永远会被Object Pascal的确切分类所迷惑。如果没有无用的program关键字，Turbo / Borland Pascal和FreePascal肯定很高兴。
— manatwork '16
@manatwork我不知道。奇怪的是，它现在使帕斯卡在这里更具竞争力……
— hdrz
我长大的语言。我知道还没有死……
— rexkogitans '16
@rexkogitans是的，我是在学校学习的，但是从那时起就已经不记得了...我现在又在玩一些编程
— hdrz
4

bash – 47 37字节

man sh|egrep -o \\w|sort -u|tr -d \\n

我的系统上的输出是：

_0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ

感谢Digital Trauma的有用建议。

在某些系统上，您可能可以使用ascii而不是man sh保存字节。

1
man sh|egrep -io _\|\\w|sort -u|tr -d \\n
— Digital Trauma
1
@DigitalTrauma谢谢！经过实验发现\w匹配_已经不区分大小写，因此可以缩短更多时间。
env而不是man sh在大多数环境下都可以使用。它在我身上。$ env|egrep -o \\w|sort -u|tr -d \\n-> 0123456789ABCDEFGHIKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz。
— YSC
没有J。我的错。
— YSC
4

PHP，40个字节

_0<?for(;$a++^9?$a^q:$a=A;)echo" $a"|$a;

在线演示。

— 原始
source
1
+1追求卓越。旁注：PHP 7.2会发出警告，指出将来的版本将为未定义的常量抛出错误。:-(
— Titus
4

视网膜，30 19 16 15 12字节

我为这个最新版本修改了原始字母尝试。每个字符都循环打印。

第一行是空的。


;
+T\`;w`w_

在线尝试

输出：

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

感谢Leaky Nun在我最近的尝试中打了4个字节。

— mbomb007
source
我想说这w是一个包含9个或更多必需字符的常量。您可能需要扩展右侧，并用替换w左侧的o。尽管您可以使用EO代替来保存一个字节，d因为它们每个仅包含5个字符。
— 马丁·恩德
w音译阶段内的@ mbomb007 与正则表达式无关。这是一种简写形式，可扩展为所需的63个字符的列表。至少我会特别询问orlp这种情况，因为它\w与正则表达式中的使用完全不同。
— 马丁·恩德
3

MATL，11个字节

7W:'\W'[]YX

在线尝试！

7W     % Push  2 raised to 7, i.e. 128
:      % Range [1 2 ... 128]
'\W'   % Push string to be used as regex pattern
[]     % Push empty array
YX     % Regex replace. Uses (and consumes) three inputs: source text, regex pattern, 
       % target text. The first input (source text) is implicitly converted to char.
       % So this replaces non-word characters by nothing.
       % Implicitly display
— 路易斯·门多
source
缩短2个字节：8W:'\w'XX
— DJMcMayhem
2
@DrGreenEg​​gsandIronMan谢谢！但我认为不允许将换行符用作分隔符。挑战说：“一串字母数字字符加下划线…………”
— Luis Mendo
1
那么，为什么您不能做8W:'\w'XX!我尝试过但无法工作的事
— DJMcMayhem
@DrGreenEg​​gsandIronMan很好的问题！让我在聊天中回答您，以便我可以使用更多字符
— Luis Mendo
3

Brachylog，25个字节

"_"w9yrcw"A":"Z"ycL@l:Lcw

这会将以下内容打印到STDOUT：

_9876543210abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

说明

"_"w               Write "_"
9y                 Get the list [0:1:2:3:4:5:6:7:8:9]
  rcw              Reverse it, concatenate into one number, write
"A":"Z"y           Get the list of all uppercase letters
        cL         Concatenate into a single string L
          @l:Lcw   Concatenate L to itself lowercased and write
— 致命
source
3

Pyth，13 12字节

s:#"\w"0rk\|

在线尝试！

查找U + 0000到U + 007B中与正则表达式匹配的所有字符/\w/。

输出0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz。

替代方法：15个字节

ssrMc4"0:A[a{_`

在线尝试！

基本上会产生所需的半数范围：0-:, A-[, a-{, _-`。

— 漏尼姑
source
3

CJam，15 14 11字节

感谢@FryAmTheEggman和@Dennis，减少了4个字节！

A,'[,_el^'_

在线尝试！

A,    e# Push range [0 1 ... 9]
'[,   e# Push range of chars from 0 to "Z" ("[" minus 1)
_el   e# Duplicate and convert to lowercase
^     e# Symmetric difference. This keeps letters only, both upper- and lower-case
'_    e# Push "_".
      e# Implicitly display stack contents, without separators
— 路易斯·门多
source
3

Brainfuck，89个字节

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

在这里尝试

细节：

+++++++++[>+++++>+<<-]>+++.  Goes to '0' while remembering a 9 for the 9 other numbers
[<+.>-]                      Simply prints for the next 9 characters
<+++++++>                    Moves it 7 space to the letters
>+++++++++++++               Saves a 13
[<+<+.+.>>-]                 Prints 2 char at a time while making a second '13' space
<<+++++.+>                   Moves 5, prints '_' and moves to the lowercases
[<+.+.>-]                    And again the double print

如果我可以发表评论，我将不得不改善其他答案。但是由于我做不到，所以我最好自己发表。当我开始写这篇文章时，最低的BF是96长。

— 罗比约
source
3

F＃，50 59字节

Seq.iter(printf"%c"<<char)(95::[48..57]@[65..90]@[97..122])

输出：

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

编辑：第一次错过了数字

受此Haskell解决方案启发，Edit2的F＃代码段为67字节。

Seq.zip"aA0_""zZ9_"|>Seq.iter(fun(x,y)->Seq.iter(printf"%c")[x..y])

输出：

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_
— 阿西巴希
source
3

六角形33

"A}_8_47<='>({a/_x.@.9!\356);');

展开：

    " A }
  _ 8 _ 4 7
 < = ' > ( {
a / _ x . @ .
 9 ! \ 3 5 6
  ) ; ' ) ;
   . . . .

输出：

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ1203568479_

在线尝试！

请注意，0x1A程序的第一个字节是不可打印的字符。这也使扩展后的Hexagon的第一行看起来有些偏离。非常感谢Martin给我展示了这个技巧，并建议了打印字母的算法！

这通过在六边形的两个边缘上存储，a并A在与字母之间的接点相触的六边形的边缘上存储数字26来打印字母。看起来像这样：

A \ / a
   |
   26

然后，它进入一个循环，该循环打印字母，然后递增字母，然后递减数字。经过一轮迭代，我们将有：

B \ / b
   |
   25

等等。初始化的线性代码为：0x1A " A } a。控制流更改之外的循环的线性代码为：; ) ' ; ) { ( ' =。

一旦计数器达到零，我们将沿着另一条路径打印数字和下划线。线性写出的是：x 3 5 6 8 4 7 9 ! ; { @。这会将当前内存边沿的值替换为数字1203568479（请注意，其xASCII码为120），其中包含所有十进制数字。我们先打印出该数字，然后使用Hexagony的一个简洁功能：我们将数字mod 256打印为ASCII字符。这恰好是95或下划线。

— 弗莱姆·埃格曼
source
3

Brainfuck，114个 103 98 90 76 71字节

另一个琐碎的（现在不是琐碎的）解决方案，但是这次是BF！

感谢@primo，节省了14（！）个字节。

由于@primo的建议向后生成了范围，因此又节省了4个字节，在打印小写字母之前，我通过递增来保存了另一个字节。

新增功能（重复4，71）：

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

旧的（值114）：

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

旧的（重复1，103）：

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

旧的（重复2、90）：

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

旧的（重复3、76）：

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

假定8位包装单元和包装内存。我用过在线试用。

全部列印 _AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789

首先，这部分

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

使用这些值初始化磁带

[91, 70, 49, 21, 7]
                 ^

之所以有效，是因为我建模的递归关系基本上是f(x) = 7 * (3 * x + 1)向后的。参见@primo的Hello，World！回答有关什么是递归关系的解释。

然后，将这些值更改为有用的值非常简单。（并打印下划线）

Code: +++<--<-<-----<++++.+

Tape: [96, 65, 48, 26, 10]
       ^

然后，简单循环使用这些值来打印其余字符。我通过在打印前增加一个增量来节省1个字节。

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

我真的需要找到一个较短的序列生成。

我发现一种递归关系似乎运作良好，但可能会有一个较短的猎物和啄子。

我使用了线性回归计算器来查找应该是最短的线性递归关系，因此，如果我想进行改进，可能应该找到一些其他公式。

@primo确实大大改善了递归关系，谢谢。

— 蓝色
source
向后构造怎么样？+[--[<+++++++>->+<]>-]
— 2016年
@primo哇！这是如何运作的？
— 蓝色
3是不均匀的，因此将循环播放整整256次。以结束>-]，您可以确定最终的项将是1（x7）。实际上，您可能应该从开始-，它的完成要快得多。
— primo
3

Sesos，17个字节

00000000: a854be 2cbc9e 71d597 14bc56 1ad99e 713b           .T.,..q....V...q;

输出量

0123456789AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz_

在线尝试！选中调试以查看生成的二进制代码。

这个怎么运作

上面的二进制文件是通过组合以下SASM代码生成的。

add 48     ; Set cell 0 to 48 ('0').
fwd 1      ; Advance to cell 1.
add 10     ; Set cell 1 to 10.
jmp        ; Set an entry marker and jump to the jnz instruction.
    rwd 1  ;   Retrocede to cell 0.
    put    ;   Print its content (initially '0').
    add 1  ;   Increment cell 0 ('0' -> '1', etc.).
    fwd 1  ;   Advance to cell 1.
    sub 1  ;   Decrement cell 1.
jnz        ; While cell 1 in non-zero, jump to 'rwd 1'.
           ; This loop will print "0123456789".
rwd 1      ; Retrocede to cell 0, which holds 48 + 10 = 58.
add 7      ; Set cell 0 to 65 ('A').
fwd 1      ; Advance to cell 1.
add 26     ; Set cell 1 to 26.
jmp        ; Set an entry marker and jump to the jnz instruction.
    rwd 1  ; Retrocede to cell 0.
    put    ; Print its content (initially 'A').
    add 32 ; Add 32 to convert to lowercase ('A' -> 'a', etc.).
    put    ; Print the cell's content.
    sub 31 ; Subtract 31 to switch to the next uppercase letter ('a' -> 'B', etc.).
    fwd 1  ; Advance to cell 1.
    sub 1  ;   Decrement cell 1.
jnz        ; While cell 1 in non-zero, jump to 'rwd 1'.
           ; This loop will print "AaBb...YyZz".
rwd 1      ; Retrocede th cell 0, which holds 65 + 26 = 91.
add 4      ; Set cell 0 to 95 ('_').
put        ; Print its content.
— 丹尼斯
source
哇，我正准备发布一个与您非常相似的解决方案。
— Leaky Nun
相同的人认为很棒！
— 丹尼斯
@LeakyNun Hm，有点迟了，但看来您的地址要短3个字节...
— Egg the Outgolfer
过去，@ EriktheOutgolfer Sesos的编码效率较低。这两个程序现在都是17个字节长。
— 丹尼斯
@Dennis嗯，那么，TIO缓存有时会令人困惑。
— 暴民埃里克（Erik the Outgolfer）'18年
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.