谈话翻译

10

“ Talk”是基于baroquified的基于累加器的语言，是为响应Dennis 在talk.tryitonline.net上的报价而创建的。

Waiting for someone to create an esolang called talk.

。“对话”语言具有4个命令：

  • 00 如果累加器为0，则将累加器设置为0。
  • 01 如果累加器为0，则将累加器设置为1。
  • 10 如果累加器为1，则将累加器设置为0。
  • 11 如果累加器为1，则将累加器设置为1。

输入：

  • 根据我们的标准I / O规则，可以通过任何可接受的输入方法进行输入。

  • 有两个输入，初始累加器值和程序。您可以根据需要将这两个输入合并为一个输入，或将输入拆分为有效命令（例如，将它们作为列表；例如[00, 01, 00]）。

输出：

  • 在命令执行结束时，累加器将隐式输出。

规则：

  • 输入可以是单个字符串或字符列表。
  • 因为这是 代码高尔夫球，最短答案（以字节为单位）获胜。
  • 我们采用数字或字符串/字符。

    测试用例：

0 0001111101 -> 1
0 000100 -> 1
0 11001000 -> 0

排行榜

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

为确保您的答案显示出来，请使用以下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  interpreter 
3
那么有两个输入，命令序列和初始累加器值？
— xnor19
4
一些不更改累加器，以累加器中的1开头或没有指令的测试用例会很好
— Jo King
8
能否谈谈真的算是一个编程语言？
— Luis Mendo
8
@A_该评论可能只是个玩笑。过去，一种名为Lang的语言将具有一个URL lang.tryitonline.net（现在是tio.run/#lang）。所以，一个叫做语言通话将引起的URL，然后，最近创建的聊天室，这是困惑talk.tryitonline.net
— 路易斯Mendo
7
将来，在发布了许多答案之后，请不要更改I / O。我今天回来了，允许输入映射信息，这与我回答的挑战完全不同。
— GammaFunction

Answers:

21

果冻，3个字节

y@/

输入是一个列表：累加器，然后是对。

在线尝试！

怎么运行的

的y原子进行音译; [A，B] yÇ内容替换一个与b，所以它返回b如果一个= C和C ^如果一个≠Ç。

y@/通过y交换参数折叠/减少输入，每对执行一次音译。

— 丹尼斯
source
14
这是我迄今为止看到的唯一一个仅使用ASCII字符的果冻答案。
2
— 丹尼斯，
21

Python 3，43个字节

lambda s:re.sub("00|11","",s)[-1]
import re

在线尝试！

该函数采用单个字符串作为输入，其中第一个字符是初始状态，其余字符串代表命令。此解决方案可以轻松移植到对正则表达式有更好支持的其他语言。

困难的部分是证明解决方案会产生正确的结果。要看到这一点，我们需要对命令进行深入分析。首先，我们可以看到命令具有以下属性：

  • 属性（1）：命令00并11保留累加器状态。
  • 属性（2） ：命令01和10使储能器状态一样的第二位的不管其原始状态。

因此，最终的累加器状态为：

  • 情况1：如果不存在01或没有10命令，则最终状态与初始状态相同。
  • 情况2：否则，为last 10或01command 的最后一位。

接下来，我们将显示在两种情况下解决方案都能产生正确的结果。我们将证明对最终状态的陈述，0并且1可以类似地证明的最终状态。如果最终状态为0输入，则采用以下两种形式之一：

  • ^0{2k+1}11(11|00)*

    对于情况1，输入字符串s必须以2k+10 开头，后跟11and 00命令。消除00s和11s会产生一个0，这是最终状态。

  • .+10{2k+1}11(11|00)*

    对于情况2，输入字符串以10命令结尾，后跟零个或多个00和11s。此模式等效于a，1后跟2k+10，然后是零个或多个11s和00s。消除00s和11s会在2k+1字符串末尾留下最后一个0，这代表了最终状态。

基于上述所有内容，在从输入中一次消除00s和11s的同时（01001如果00是先消除一次，然后11又消除另一次的情况，则是反例）s，最后一个字符是最终状态。因此证明了该解决方案的正确性。

— 乔尔
source
欢迎来到PPCG！出色的答案，以及很好的正式证明！
— GammaFunction
3
谢谢。我觉得人们可能会怀疑这样一个简单的解决方案乍看之下是否会得出正确的结果。因此，有必要为此提供证明。
— 乔尔
9

Perl 6、17个字节

{m/.)>[(.)$0]*$/}

在线尝试！

通过将输入作为与命令（例如1,[00,11]is）连接的累加器值，利用“您可以根据需要将这两个输入合并为一个输入”的优势10011。如果这样做不行，那么将其视为仅多余5个字节f(accumulator, commands)。返回可以强制转换为字符串的匹配对象。

说明：

{                }  # Anonymous code block
 m/             /   # Find the first match from the input
   .)>              # Capture a number
      [     ]*      # Followed by any number of
       (.)$0        # Pairs of identical characters
              $     # Ending the string

基本上这是可行的，因为00and 11命令实际上不执行任何操作，而01and 10命令只是将累加器设置为命令的第二位。如果没有命令，则它将取累加器的初始值。

— 乔·金
source
6

Zsh，33个字节

字符列表作为参数传递，累加器的初始值作为stdin传递。

read a
for x y;a=$[x^a?a:y]
<<<$a

在线尝试！

39个字节：如果命令必须为单个字符串

输入accumulator commands作为参数。 

for x y (${(s::)2})1=$[x^$1?$1:y]
<<<$1

在线尝试！

有趣的是，这里有一个50字节的递归单行代码（TIO）：

<<<${${2+`f $[$1^${2[1]}?$1:${2[2]}] ${2:2}`}:-$1}
— 伽玛功能
source
6

Python 3，52字节

f=lambda a,s:s and f([s[1],a][s[0]==s[1]],s[2:])or a

在线尝试！

修复了Chas Brown导致返回类型不一致的问题

将输入作为两个字符串；累加器和代码。

— 负七
source
哦，不，那太快了。
— 放射性
1
不错，但是它有潜在的问题- f(1,'11')==f(1,'01')是False；它有时返回int，有时一个str。因此，也许指定将acc输入作为字符串？
— Chas Brown
@ChasBrown好电话，这比我想的要简单得多。
— 负
很好，但是由于您的函数是递归的，因此不能匿名。它应该是52个字节。
— 吉特（Jitse）
5

Brachylog，11个 9字节

tġ₂≠ˢtt|h

在线尝试！

由于已经足够长的时间，我已经忘记了在每个命令之后打印累加器的概念，因此我从Jo King的Perl答案中得到了一些启发，提出了一个天真的解决方案。

       |     The output is
     tt      the last element of the last element of
t            the last element of the input
 ġ₂          split into length-2 slices
   ≠ˢ        with equal pairs removed.
       |     If there is no such element, the input
        h    's first element is the output.

旧解决方案：

Brachylog，18 16字节

ġ₂ᵗc{th~h?tt|h}ˡ

在线尝试！

-2个字节（更改输入格式）。

— 不相关的字符串
source
5

JavaScript（ES6），27个字节

将输入作为(a)(code)，其中代码是2位整数的列表。

a=>c=>c.map(x=>a^=x==a+1)|a

在线尝试！

JavaScript（ES6）， 47个  40字节

将输入作为(a)(code)，其中code是字符串。

a=>c=>c.replace(/../g,x=>a^=x%4==a+1)&&a

在线尝试！

怎么样？

下面总结了所有可能的情况。我们唯一需要切换累加器的情况是(a=0,x=012) 和 (a=1,x=102)。

  a | x (bin) | int(x) % 4 | a + 1 | equal?
----+---------+------------+-------+--------
  0 |   "00"  |  0 % 4 = 0 |   1   |   N
  1 |   "00"  |  0 % 4 = 0 |   2   |   N
  0 |   "01"  |  1 % 4 = 1 |   1   |   Y
  1 |   "01"  |  1 % 4 = 1 |   2   |   N
  0 |   "10"  | 10 % 4 = 2 |   1   |   N
  1 |   "10"  | 10 % 4 = 2 |   2   |   Y
  0 |   "11"  | 11 % 4 = 3 |   1   |   N
  1 |   "11"  | 11 % 4 = 3 |   2   |   N
— Arnauld
source
4

sed -E，26 19字节

一个高达-7字节通过实现消除所有对作品以及来自@Cowsquack。

s/(.)\1//g
s/.*\B//

接受在stdin上串联在一起的输入。受到Jo King的Perl答案的启发。 删除尾随的对，删除所有对，然后得到最后一位。

在线尝试！ 在线尝试！

— 伽玛功能
source
1
最后一行可以很简单s/.*\B//，但是无论如何稍微改变方法都会得到更短的19个字节。请在线尝试！
— user41805
1
didn，我认为这s/(.)\1//g行不通，因为它可以消除一对的结尾和下一对的开始，但是仍然可以解决。优秀的！
— GammaFunction
@GammaFunction s/(.)\1//g等效s/00|11//g于我的解决方案中所示。
— 乔尔
4

视网膜0.8.2，18 11个字节

(.)\1

!`.$

在线尝试！链接包括测试用例。将输入串联。由于@CowsQuack指出删除所有加倍的字符然后取最后一个剩余的字符有效，因此节省了6个字节，尽管实际上@JoKing原始答案的端口即使没有该技巧也可以被占用3个字节。

— 尼尔
source
12个字节在线尝试！
— user41805
@Cowsquack D'oh，一旦您考虑分离阶段，就已经节省了2个字节，然后又保存了一个字节，因为可以使用!`.$，然后再节省了4个字节，因为您不必限制尾随对...
— 尼尔，
4

Python 3，38个字节

lambda l:[y for*x,y in l if[y]!=x][-1]

在线尝试！

基于Joel的解决方案。将输入作为初始累加器值（长度为一的字符串）和命令（长度为二的字符串）的列表。查找带有两个不相等值的最后一个命令，并输出第二个字符。

为了在没有这样的命令时将其累加到初始累加器值，我们进行了设置，以使单字符初始值字符串通过测试。我们通过检查具有最后一个字符的单例列表是否不等于所有先前字符的列表来完成此操作，该列表由任何长度为一的字符串或长度为二的带有两个不同字符的字符串传递。

— 异或
source
3

果冻，8 6字节

EÐḟṪṪo

在线尝试！

多亏了尼克·肯尼迪（Nick Kennedy）通知我规则更改，所以-2个字节。（他提出的golf EÐḟFȯṪ似乎更聪明，但长度与我以前的解决方案相同，但减去了s2。）现在，输入格式将命令作为两个字符字符串的列表，但是为了方便起见，测试页脚从旧格式转换而来。

翻译自我较新的Brachylog解决方案。

旧版：

果冻，13个字节

ḢẎ⁼⁹a⁸o
s2ç@ƒ

在线尝试！

我不是100％肯定这是正确的，但是在所有三个测试用例中都成功。将命令作为左参数，并将初始累加器作为右参数。

— 不相关的字符串
source
1
允许将输入拆分为一个列表，因此您可以EÐḟFȯṪ将输入作为例如[[0,0],[0,1],[1,1],[1,1],[0,1]]。
— 尼克·肯尼迪
哇，对规范的更改确实很大……
— 不相关的字符串
3

Haskell，29个字节

在类型为的第一行定义一个未命名的函数(Foldable t, Eq b) => b -> t [b] -> b。出于此代码高尔夫的目的，我们可以将其实例化为Char -> [String] -> Char第一个参数是累加器，第二个参数是字符串列表，每个字符串都是单个命令。

foldl(#)
a#[x,y]|a==x=y|1>0=a

在线尝试！

— Ankh-Morpork
source
1
如果使用前缀表示法定义字节数，则该字节数相同。我不敢相信我几乎在同一时间写了几乎完全相同的答案，甚至包括类型签名说明……
— 科尔
2

Python，111个字节

def f(a,b):
    c=a
    for i in range(0,len(b)-1,2):
        c=(not b[i])*(c or b[i] or b[i+1]) or c*b[i]*b[i+1]
    return c

松了口气。编辑：啊，有人击败了我！

— 高放射性
source
2

桶，-ir16个字节

"(!;½|':"=['_"|_

在线尝试！

解释：

  1. 接受隐式输入，然后将累加器值右移至底部

  2. 重复以下（堆栈长度-1除以2）次

2.1。将累加器移回顶部

2.2。与命令的第一部分进行相等性比较

2.2.1。如果为true，则更换蓄电池，否则弹出更换件

输入作为与源串联的初始acc值。例如

010011000
  • 第一个字符为acc值
  • 休息就是程序
— lyxal
source
1

Bash，58 40字节

为完整程序添加一个字节：更改f为$0。

(($1=$2-a?a:$3,1))&&f $1 ${@:4}||echo $1

58个字节 在线尝试！

当$1设置为时，三进制将返回false 0，但,1最后确保整个语法((expression))将返回true，语法错误除外。

使用完所有参数后，将发生语法错误，并且递归结束。

— 伽玛功能
source
1

木炭，16字节

Ｆ⪪η²Ｆ⁼θ§ι⁰≔§ι¹θθ

在线尝试！链接是详细版本的代码。采用不同的参数。说明：

Ｆ⪪η²

将指令分成几对数字并在其上循环。

Ｆ⁼θ§ι⁰

如果累加器等于第一个数字...

≔§ι¹θ

...然后分配第二个数字。

θ

在循环结束时打印累加器。

— 尼尔
source
1

果冻，7 个字节

fؽḂ⁹;Ṫ

双向链接，该程序在左侧接受程序作为整数列表，在右侧接受初始累加器，产生整数。

在线尝试！或看一个测试套件

— 乔纳森·艾伦
source
我正在删除输入映射，因为@GammaFunction建议我这样做。
@A_啊，好的，无法在手机上删除，因此必须稍后解决
— Jonathan Allan
@A_可以与数字的未映射版本的0、1、2、3一起使用，可以吗？
— 乔纳森·艾伦，
1
是的，没关系。
1

符文附魔，28字节

/~@/i~/i<
/=?/~iR:l}i{l1-=?!

在线尝试！

将输入作为一系列以空格分隔的字节（Runic无法理解列表）。第一个字节是初始状态，其他每个字节是程序。不执行任何验证（即，假定仅给出有效程序作为输入，并且不关心使用什么值表示0和1）。

— Draco18s不再信任SE
source
1

x86汇编，33字节

将初始累加器状态取为CL（整数0或1），并将命令的地址取为零终止的ASCII字符串ESI。将最终的累加器状态保留在中CL。

将呼叫指令指向偏移处0x1B（interpret说明中的标签）。

3C 30 74 03 B0 01 C3 30 C0 C3 E8 F1 FF FF FF 38
C8 AC 75 07 E8 E7 FF FF FF 88 C1 AC 84 C0 75 EA
C3

说明（使用英特尔语法）：

; function to convert ASCII '1'/'0' into 0 or 1 int values (from AL to AL)
ctob:
        CMP AL, 0x30 ; '0'
        JE .zero
        MOV AL, 1
        RET
        .zero:
        XOR AL, AL
        RET

; interpreting function
        interp_lp:
                CALL ctob     ; convert to number
                CMP AL, CL    ; compare to current accumulator
                LODSB         ; read the next character of the string
                              ; this doesn't affect any flags and we need to do
                              ; it in both cases anyway
                JNE interpret ; if AL != CL (from above, not the new value of AL), skip forward
                CALL ctob     ; convert AL to number
                MOV CL, AL    ; store AL in CL
interpret:      LODSB         ; read the next character of the string
                TEST AL, AL   ; check if it is a zero byte
                JNZ interp_lp ; if not, jump back into the loop
        RET
— Fayti1703
source
0

水晶，46字节

中包含命令Array(Tuple(Int32,Int32))，例如[{0,0}, {0,1}, {0,0}]。

def f(s,i);i.map{|c,v|s+=~(s^c)&(s^v)%2};s;end

在线尝试！

以更易读的形式理解非常简单：

def f(state, instructions)
  instructions.map do |check, value|
    state += ~(state ^ check) & (state ^ value) % 2
  end
  state
end

函数遍历每个命令，自动将元组值解包到c和中v。然后state通过公式设置

state = state + NOT(state XOR check) AND (state XOR value) mod 2

我主要是通过反复试验得出的。处理完所有命令后，它将返回状态值。

— 金克斯
source
0

C（clang），68 62字节

t(s,e,a)char*s,*e;{for(;s<e;++s)a=*s++-48^a?a:*s-48;puts(&a);}

在线尝试！

获取指向源字符串开头的指针，指向源字符串结尾的指针（start + strlen（start））以及初始累加器值。

旧版本（为0/1打印ASCII 48/49）：

t(s,e,a)char*s,*e;{for(;s<e;++s)a=*s++-48^a?a:*s-48;putchar(a+48);}
— osuka_
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.