你好，世界！带有半普通字符

28

你们中的一些人可能知道，将一种语言融入Dennis的精彩在线尝试中！，您好，世界！程序是必需的。最近，丹尼斯提出了一种从网站上加载这些程序的方法。截至2017年7月27日，这是这些程序中使用的字符的JSON pastebin（按频率）。

这些角色中的一些需要爱，因此您的挑战是输出Hello，World！（最好是与此过程有关的语言），仅使用以下指定的字符。这些字符是在10和99（含）时间之间使用的所有字符，以及两个最常见的字符0和，因为我感觉很好。

0 $&*?ABCDEFGIJKLNPQRSTUXYZ\`gjkqwxyz{}÷≤≥=║_

字符的使用应基于其在常规程序中的外观，而不是基于其代码点或字节值。

您必须使用该集合中的至少一个字符，因此长度为0的程序无效。

这是代码高尔夫球，因此最短答案以字节为单位。

JSFiddle检查您的答案是否有效

code-golf  restricted-source  hello-world 
— 史提芬
source
我可以在下一行输出空格吗？
— dzaima
@dzaima如果没有空格就无法输出，请执行。如果要删除空间仅使用更多字节，请删除空间
— Stephen于2008年
对于非印刷字符进入输出（STDOUT）时是否达成了社区共识（或在此处有特定的禁止/允许）？不知道我以前看过它吗（它很容易被人们忽略），但是它在这里极大地改变了我的策略……
— brhfl
@brhfl我不知道-唯一的规范是通常允许尾随换行符，您可以在聊天中提问
— Stephen

Answers:

6

SOGL V0.12，89个 75 68 字节

z{}xxxx≥x≥x≥xXUqXxq≤qq≤q *R_IIRq  q *R_I0II*IRqxXq≤qxqxq CR_0II÷Rq0*

在这里尝试！
请注意：无论何时q此处引用或输出，它都不会弹出，因为弹出输出（oOpP）中的任何一个都不可用或不会输出前置换行符。

说明（已过时，更改之处在于使用字母“ H”打印）：

 $             push "$"
  R_           convert to an array of ordinals, then push all the contents to the stack
    0II        push 0+1+1 = 2
       *       multiply by that
        R      convert to character
         q     output
          z    push the lowercase alphabet
           {}  iterate over it, pushing each char, and do nothing. Stack: ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
stack manipulation:
 xxxx ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r"]
 ≥    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q"]
 x    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o"]
 ≥    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n"]
 x    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l"]
 ≥    ["l","o","r","H","a","b","c","d","e","f","g","h","i","j","k"]
 xxx  ["l","o","r","H","a","b","c","d","e"]
 q    output the "e"
 ≤    ["o","r","H","a","b","c","d","e","l"]
 qq   output the "l" twice
 ≤    ["r","H","a","b","c","d","e","l","o"]
 q    output the "o"

*                       push "*",
 R_                     convert to an array of ordinals, then push all to stack
   II                   increase by 2
     R                  convert back to character
      q                 output
         q              push a space, then output
           *            push "*"
            R_          convert to an array of ordinals, then push all to stack
              I         increase that
               0II      push 0+1+1 = 2
                  *     multiply
                   I    increase
                    Rq  output as character
stack manipulation: (starting stack: ["r","H","a","b","c","d","e","l","o",","," ","W"])
 x  ["r","H","a","b","c","d","e","l","o",","]
 X  ["r","H","a","b","c","d","e","l","o"]
 q  output the "o"
 ≤  ["H","a","b","c","d","e","l","o","r"]
 q  output the "r"
 x  ["H","a","b","c","d","e","l"]
 q  output the "l"
 x  ["H","a","b","c","d"]
 q  output the "d"

C            push "C"
 R_          convert to ordinal as before
   0II÷      floor divide by 2
       Rq    output as character
         0*  multiply by 0 so nothing extra would be outputted

有趣的事实：允许的字符中的所有字符都在SOGL代码页中：D

— 宰马
source
所以...作为专业开发人员，您的工作稳定吗？因为dang，这是一种很酷的语言...也是不错的JS解释器，您昨晚完成了:)？您可以开始发布某些语言的文档吗？还是私人聊天向我发送此类文档的位置？SOGL杀死了它。
— 魔术章鱼缸
@MagicOctopusUrn 1）不，哈哈，我15岁2）我个人不喜欢它，因为它的制作方式是我制作的最笨拙的东西3）JS解释器已经存在了一段时间4）最新的文档SOGL（如果可以叫他们的话）在这里，一些东西（如palenChars.txt）在这里
— dzaima
恭喜您再次减少了字节数！老实说，我认为我不能再降低我的了！
— Dom Hastings'3
23

Perl 5，76个字节

}{${$_=$`x?B?}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}=$_=\*G

这使用的功能已被弃用，但可以在我的终端中本地使用（如所述，版本为5.18.2）。在旧版本的Perl ?\w?中，/\w/它是一个同义词，它使我可以访问regexp匹配，并且我有足够的字符用于$&（最后匹配）和$`（最后匹配之前的文本）。我需要这些才能得到O。我通过创建一个glob引用来生成它（将$_=\*G其转换为标量，类似于GLOB(0x7ffb728028d0)）。一旦这是在$_，?B?将匹配B和$`包含GLO，然后我就可以对阵\w$这将存储O在$&将其插入我正在以字符串方式运行的字符串中，并创建其余文本，使用将该字符串的主体小写\L。

在线尝试！-用于/\w/代替?\w?TIO上的Perl版本太新。

Perl 5、65个字节

由于它依赖TIO上的文件名（这是.code.tio），因此更具欺骗性，因此我并不认为这很竞争，但我对结果感到满意！

}{${$_=$0}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}

在线尝试！

— 唐·黑斯廷斯
source
我没有对标志的内容说什么，所以-p很好。干得好，这就是我问这个时所希望的：)
— Stephen
1
怎么...什么...的...
— Okx
@StepHen我很高兴有义务！老实说，我真的很喜欢这个。我很高兴您也不会处罚该标志，我将更新我的帖子。谢谢！
— Dom Hastings
@Okx我很高兴能产生这种效果！
— Dom Hastings
您确定不需要添加15个字节<3吗？
— 魔术章鱼缸
10

一元，7 * 10 182字节

一元被Brainfuck转换为二进制，并0用作计数器。本质上，它将Brainfuck程序压缩为一个数字，并且输出为该数字0s。它们通常是非常大的程序。

我不会在这里粘贴程序，因为我不知道SE允许多少文本，但我敢打赌它要少于这个。相反，我将在此答案中粘贴精确的零：

708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556

由于这是一个相当便宜的答案，保证不是最短的答案，我只是复制了它，因此我将其发布为Wiki。

— 工程师吐司
source
2
“我不知道SE多少文本允许”至少这不是7 *10¹⁸²这是waaaaaay比65536更大
— 埃里克Outgolfer
9

05AB1E，137个 106 95字节

X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B

在线尝试！

-31感谢@Adnan指出我可以使用base 108。

-?? 感谢@Riley指出一些错误。

旧版本（不同方法）：

05AB1E，211个 186 166字节

0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B

在线尝试！

哈哈！在这里我想避免出现任何可能的机会！

首先，我们将255存储在X中：

00g               # Push 2 (length of 00).
   00000g         # Push 5 (length of 00000).
         00000g   # Push 5.
               JU # Join to 255 and store in X.

然后，使用相同的长度技巧，我们推入： 1296995323340359595058728869715

0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ

在这里我们只使用0<space>零而不是长度技巧。

然后，最后，我们推送存储的255，并将其从255转换为以10为基数：

X  # Push stored 255.
 B # Convert to base 255.

仍然使用其他允许的字符打高尔夫球，并且重复，这将是一分钟。

— 魔术章鱼缸
source
8

Beatnik，148字节

K QQQQQQQG ZD XA K QQJA KD ZD XA K KG KD ZD ZD ZD XA XA K B KD ZD XA K QQQQF ZD ZD XA K QQQD XA K A Z KD XA ZD XA K B KD XA ZD XA K J Z XA K QQQB XA

在线尝试！

说明

Beatnik会根据单词的拼字游戏分数来执行所执行的指令。这里是一个简短的解释：

Code         Scrabble Score   Explanation

K            5                push the scrabble score of the next word
QQQQQQQG     72               72 ['H']
ZD           12               pop a value; push it back twice
XA           9                pop a value; print its ASCII character
KD           7                pop two values; push their sum
Z            10               pop two values; push their difference
— 全人类
source
8

Moorhens（v2.0），3423 983 923 866 749 716字节

我认为这可以打一点，Moorhens不是一种容易使用的语言。

xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU KA AA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU KA KA xU xU xU AA AA AA AA AA KA xU AA KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU KA XI XI XI XI XI XI KA XI XI XI XI XI XI XI XI AA AA AA AA AA AA AA AA AA AA AA AA

说明

Moorhens是一种基于词典单词的语言。每个单词都基于其哈希值对应于一个操作。这里所用的五种操作是xU，ER，XI，KA，和AA

  • xU 增加TOS
  • ER 在堆栈上放置一个新的零。
  • XI 降低TOS
  • KA 复制TOS
  • AA 将TOS滚动到底部

我们会在成功应用这些操作后再推每个字母。

— 小麦巫师
source
5
“这两个操作”-我不太熟悉esolang，但是肯定是五个操作吗？
— boboquack
@boboquack固定
— 小麦巫师
1
链接到语言？
— Leaky Nun
我觉得这就是。 github.com/Wheatwizard/Moorhen
— 递归
5

Glypho，480字节

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

在线尝试！

— 奥克斯
source
4

头颈，78字节

yyzyzzxNxNzx{yyy{y{y{yzzz_{_zzyy\zxxxxxx\zzy\\zz\zx\{{\{{\zzz\xxx\{{\{{y\zzzx\
— 乌列尔
source
4

Double JavaScript，318个字节

我不确定是否允许，我一次无法使用JavaScript解释器来做到这一点。这与使用类似，eval()但是我两次使用了解释器：（在控制台中尝试将结果打印回）

`\`\\x${0xA*0xA&0xC}${0xA&0xC}\\x${0xA*0xF&0xF}${0xB*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}F\\x${0xE*0xF&0xF}C\\x${0xE*0xF&0xF}${0}\\x${0xB*0xF&0xF}${0xB*0xB*0xF&0xF}\\x${0xA*0xF&0xF}F\\x${0xB*0xB*0xF&0xF}${0xE*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}${0xA*0xA&0xC}\\x${0xE*0xF&0xF}${0**0}\``

在线尝试！

评估为：

`\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21`

在线尝试！

哪个评估为 Hello, World!

— 镭8
source
3

Smallf ** k，266个字节：

zJ$NJ`ZZx*gQYQQ{zqyKKUkUR?AS`zB`JB&UCKCIxQ_G0*000FzzJ&?YwkC\qqgZ`xYQyC}DgY_&_S}KPZ\&?SGAE&{Gw_w} GAgA{qT{gC&`qI?xwCNQwgR}?{*QEwQUj&BT&jR__IJJIqUqAPF0yICXESL?AYR QIAFU& yYwE&$\Njj B0T*F j$?kCzQk*}U}UgI$}Ew_yDL`qYI*E_G}SCjXDFNJKGNIGyIwA\BzLP`*zCILGCNqyYZyq? GwN{q{gKSj

实际上，这些字符是无关紧要的。这只是每个字符是否具有偶数代码点或奇数代码点的问题。因此，我已经尽力使用所有可用的字符（多字节字符除外）（尽管由于它是随机的，所以我不做任何保证）。

— 超中微子
source
1
@totallyhuman你是对的；我会改变的。我将删除多字节字符。它实际上没有代码页。它只需要存储为1和0（1表示奇数ord，0表示偶数ord），因此您可以说这是33.25字节xD
— HyperNeutrino
字符的使用应基于其在常规程序中的外观，而不是基于其代码点或字节值。
— KSmarts '17年
@KSmarts我将询问OP。
— HyperNeutrino
@KSmarts的意思是，如果一种语言具有不同的代码页，例如'5'占用常规代码的代码点，则'A'不允许使用'5'。
— HyperNeutrino
@KSmarts只是意味着，如果您使用的是非标准代码页，则这些字符会在该代码页上移动。您仍然可以将它们的代码点用作程序的一部分。
— 斯蒂芬
3

派克，133个 144字节

? BXKKKKRKRKRK\CkJ00q}}}XEjTX}G_E\E\L\LkJjRT}}XRGREkJjR 00q}R? B_RE\ \wkJjRT}}XRGRE\R\L\DkJjRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJjRT}}RG_RE00q}}RAA

在线尝试！

几乎可以肯定会缩短的一堆可怕的代码...一次构造一个字符。 

? BXKKKKRKRKRK\CkJ - ".C" - A string that when evaled, gets the character at the point
00q}}}XEj - Construct 64 by doing `((0==0)*2*2*2)**2` and then eval, getting the "@" character and store it in `j`
TX}G_E - Get "h" using `@` by looking it up in the alphabet
\E\L\LkJ - "hELL"
jRT}}XRGREkJ - "hELLo"
jR 00q}R? B_RE  - ","
\ \wkJ - "hELLo, w"
jRT}}XRGRE\R\L\DkJ - "hELLo, woRLD"
jRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJ - "hELLo, woRLD!"
jRT}}RG_RE00q}}RAA - "Hello, World!"
— 蓝色
source
2

dc，164162字节

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzS zzS?zzzzzzzzzzzzS$zzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzzzzzzzzzzzzzzzSwzzzzzzzzzzzzzzzPzzzzzzzzSLzPzPzzzzPL$PL PLwPzPzzzzPLLPAI*PL?P

在线尝试！

可能有更好/更有趣的方法。我尝试使用ASCII + 256技巧dc，但也会输出其他字符（即使它们是非打印字符也是如此），一旦我将“ o”（即极好的质数111）设置为“ o”，甚至会遇到麻烦值111+（256的倍数）干净利落。因此，这是一个相当简单的解决方案（尽管可能的话也可以打高尔夫球）：

在中dc，z是将堆栈深度推入堆栈的命令。这意味着我们可以将其用作增量。这就是我为此挑战创建大多数ASCII值的方式（打印有P），然后将其压入命名堆栈S然后使用弹出回到主堆栈L。

dc即使输入的基数为十进制（默认），也可以使用十六进制值AF。幸运的是，我们的第一个字母72是12的倍数，因此我在这里通过乘以6 * 12并立即打印来保存一两个字节（zzzzzzzC*P）。我的164字节版本在早期就使用乘法来获得72（'H'），这虽然有点聪明，但由于较早的尝试而保持不变，并且浪费了字节。现在，我首先增加并保存乱序的空间，感叹号和逗号，因此尚无法打印。接下来，我进入立即打印的“ H”，然后再进入“ W”，以后必须保存。

当我按下“ e”时，我只是简单地打印，然后递增到“ l”。我打印其中两个并保存一个。当我将其设置为“ o”时，我首先以为以后必须保存其中一个，但是一切都有点像为了在这一点上。我打印一个“ o”，从前面检索逗号，空格和“ W”，现在我又回到了“ o”。我进行打印，然后递增一些直到最高必要值'r'（114），然后在加载和打印我先前藏匿的'l'之前进行打印。

快完成了！“ d”是ASCII值100，可以通过乘以10 * 10（比早先存储并立即加载少的字节）来轻松地制成。十六进制值A 10，我们的输入基数也可以通过命令检索I。将它们相乘，打印，然后加载并打印之前的感叹号。你好，世界！

— h
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.