许多人知道编程中的真机。但是现在是时候让我们努力了。介绍，扩展的真机！扩展的真理机器将两件事作为输入，一个整数n和一个非空字符串s。输出s n带有可选尾随空格的时间。但是，如果n等于0，则必须输出，s直到手动停止程序为止，即永远不要终止它。

另外，如果n为负数，则字符串需要颠倒。例如，使用s=helloand n=-1，输出将为olleh。

输入的标准方法，任何种类的输出，只要可以处理无限。如果您的答案不能处理无限大，请在有趣的情况下或以无法处理无限大输出的语言随意发布。

测试用例

n, s, output

5, "hello world", "hello worldhello worldhello worldhello worldhello world"
0, "PPCG", "PPCGPPCGPPCGPPCG..."
-2, "truThY", "YhTurtYhTurt"
2000, "o", "oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo"

这是代码高尔夫球，所以最短的代码获胜！

_{这是原始的沙盒帖子。已对其进行了编辑。感谢@ComradeSparklePony创建了这个挑战的想法}

Haskell，57 54字节

f 0=cycle
f n|n<0=f(-n).reverse|n>0=concat.replicate n

说明：

f 0           -- If n=0 ..
 =cycle       -- infinitely repeat the input
f n|n<0       -- Otherwise, if n<0 ..
 =f(-n)       -- call f with the negative of n ..
 .reverse     -- and the reverse of the input
 |n>0         -- Finally, if n>0 ..
 concat       -- concatenate the result of ..
 .replicate n -- repeating the input n times

-3个字节，感谢@nimi

PHP> = 7.1，67字节

for([,$x,$y]=$argv,$z=$x<=>0;!$z||$x;$x-=$z)echo$x<0?strrev($y):$y;

与版本一起使用，list(,$x,$y)而不是[,$x,$y] 在线尝试！

MATL，37字节

jXJiXI0=?`1wtwDw]}I0>?I:"t]x}PI|:"t]x

在线尝试！

说明：

j            % input string
XJ           % copy to clipboard J
i            % input
XI           % copy to clipboard I
0            % number literal
=            % is equal? (element-wise, singleton expansion)
?            % if
  `          % do...while
    1        % number literal
    w        % swap elements in stack
    t        % duplicate elements
    w        % swap elements in stack
    D        % convert to string and display / string representation
    w        % swap elements in stack
  ]          % end
}            % else
  I          % paste from clipboard I
  0          % number literal
  >          % is greater than? (element-wise, singleton expansion)
  ?          % if
    I        % paste from clipboard I
    :        % range; vector of equally spaced values
    "        % for
      t      % duplicate elements
    ]        % end
    x        % delete
  }          % else
    P        % flip the order of elements
    I        % paste from clipboard I
    |        % absolute value / norm / determinant
    :        % range; vector of equally spaced values
    "        % for
      t      % duplicate elements
    ]        % end
    x        % delete
             % (implicit) end
             % (implicit) end
             % (implicit) convert to string and display

Python 3，71个字节

def f(n,s,k=1):
 if n<0:s=s[::-1];n=-n
 while n|k:print(end=s);n-=1;k=0

在线尝试！

该变量k确保循环始终至少运行一次。这意味着，如果n=0，则n在循环的下一次迭代中为负，因此循环将永远继续运行。

Matlab，87个字节

n=input('')
s=input('','s')
a=repmat(s,1,abs(n))
while~n s=[s s]
end
if n<0,flip(a)
end

我第一次尝试代码高尔夫球！欢迎打高尔夫球。

05AB1E，17 16 14字节

0‹iR}¹Ä×¹_i[²?

在线尝试！

说明：

0‹iR}¹Ä×¹_i[²?
0‹             Is the input negative?
  iR}          If so, reverse the second input.
     ¹Ä        Get the absolute value of the first input.
       ×       Repeat the string that many times.
        ¹_     Boolean NOT the first input. (Is the first input 0?)
          i    If so...
           [   Do forever...
            ²? Print the second input without a newline.

@EriktheOutgolfer节省了2个字节

Cubix 41 四十四 45字节

输入为 <N> <String>

.uq.sB.p$IA;p?;ouu(..!q/o()uq?..@<w?q<<_)

在线尝试！

总结：

      . u q
      . s B
      . p $
I A ; p ? ; o u u ( . .
! q / o ( ) u q ? . . @
< w ? q < < _ ) . . . .
      . . .
      . . .
      . . .

观看它运行

代码中仍然有一些空操作，我可能可以从中得到更多的字节，但是我想在打破它之前先弄清它。

基本程序是

• I 从输入获取计数器
• A 将其余输入作为字符
• ;p? 删除空间，调高数字并进行测试
  • psuqB$)如果计数器为负，则反转堆栈。这涉及处理输入数字和EOI标记（-1）。递增计数器。
  • ;p;ouqu 如果计数器为零，请删除计数器和EOI标记并开始永久输出循环。
  • ( 如果正值递减计数器
• <<q?/o()u输出回路。这将输出堆栈中的每个字符，直到到达EOI标记（-1）。
• ... _ ... ?wq!在末端EOI标记上，绕过立方体并反射回?，更改车道，将EOI标记放到底部并测试计数器。
• @ 如果为零，则停止
• ?u( 如果正掉头和递减，则小偷最终会碰到循环的开始
• ? ... <) 如果为负，则将多维数据集绕到另一边，并在经过增量时重定向到循环的开始。
• /)< 如果为负增量并继续到输出回路

JavaScript（ES6），79个字节

 f=(n,s)=>n<0?f(-n,[...s].reverse().join``):(alert(!n?s:s.repeat(n)),!n&&f(n,s))

片段：

f=(n,s)=>n<0?f(-n,[...s].reverse().join``):(alert(!n?s:s.repeat(n)),!n&&f(n,s))

f(5, "hello world")
//f(0, "PPCG")  //uncomment this at your peril!!!
f(-2, "truThY")
f(2000, "o")

JavaScript（ES6）， 98 94 91 83字节

n=>s=>{s=n<0?[...s].reverse().join``:s;while(!n)l(s);l(s.repeat(n<0?-n:n))}

-4，-5个字节，感谢Arjun

-3个字节，感谢Rick Hitchcock

最初与Java答案有所不同，但打高尔夫球后很快变得非常相似。警报是无限的，但是如果您希望它看起来不错，请切换到console.log。l=alert;和写入alert的长度相同，但是如果您切换到console.log它，则重新定义它的长度会更短。

QBIC，36个字节

这里有很多内容，而QBIC / QBasic只是没有语法来优雅地处理这种情况。

~:<0|;=_fA}[abs(a)|Z=Z+A]~a|_X}{?A';

说明：

~:<0|       IF cmd line arg 'a' is negative
  ;=_fA         Make cmd line arg A$ into its reverse
}           Close the IF (this eliminates the need for a | fuction terminator on _f)
[abs(a)|    FOR b = 1 to (abs(a) (hammering out negatives)
  Z=Z+A         Add A$ to Z$ (on exit, Z$ is printed explicitly)
]           NEXT
~a|_X       IF a is non-zero, terminate the program
}           END IF
{?A';       If we're here, just start a DO-loop and keep on printing the input.

Java（OpenJDK 8），137字节

void f(String[] a){for(long n=Long.valueOf(a[0]),i=0;n==0|i++<Math.abs(n);)System.out.print(n<0?new StringBuilder(a[1]).reverse():a[1]);}

在线尝试！

str，30个字节

I#Lbd0<[_u_][d0='e'u#?]#?xo;db

在线尝试！

说明

I#Lbd0<[_u_][d0='e'u#?]#?xo;db
...........................;      preamble
I                                 read number
 #L                               read rest of STDIN
   b                              buffer the STDIN
    d                             duplicate number
     0<[   ]           #?         if the number is less than zero
        _                         negate that number
         u_                       and reverse STDIN from buffer
            [         ]           otherwise
             d0='e  #?            if its 0, push the empty string
                  'u              otherwise, push the unbuffered STDIN untouched
                         x        repeat STDIN by the TOS
                          o       and output
                           ;..    main program (only activates when input = 0)
                            d     duplicate the implicitly unbuffered STDIN
                             b    and rebuffer it
                                  implicitly displayed

C（GCC） ，115个 112 109 107 104字节

f(n,s,l,p,d)char*s;{d=n<0?-1:1;do for(l=1,p=0;p>=0;p+=l)s[p]?d==l&&putchar(s[p]):l--;while(!n||(n-=d));}

在线尝试！

谁说我们需要strlen？

C（gcc），115个字节（#include<string.h>前面有134个字节）

#include<string.h>
f(n,s)char*s;{int l=strlen(s),d=n<0?0:2,m=d--,p;do for(p=m?0:l-1;p!=(m?l:-1);p+=d)putchar(s[p]);while(!n||(n-=d));}

在线尝试！

没有#include<string.h>我们，我们将得到一个隐式原型，strlen用于返回int，但是strlen是size_t（至少在今天，对k＆r或c89尚不完全确定，但我相信，它int是在过去返回的）。

丢失#include <stdio.h>不是问题，因为由于整数提升，默认原型int putchar(int)正是我们想要的。

视网膜，49字节

/¶-/&V`^.+
/¶0/&//+>G0`
~`(.+)¶-*(\d+)
.-$2+>K`$1

输入格式：接受字符串，后跟换行符，再跟数字。

在线尝试！

说明：

/¶-/&V`^.+

将/¶-/&只运行，如果数字为负这一行。V是相反的阶段，它反转^.+，它匹配字符串（.匹配换行符的每个字符）。

/¶0/&//+>G0`

在/¶0/&仅当数为0运行此线//+>开始的无限循环，它打印在每次迭代之后所述工作串。G0接受字符串并丢弃数字；它无限执行此操作，每次都打印。

~`...

这标记了将生成字符串的代码；程序之后将字符串评估为Retina代码。

(.+)¶-*(\d+)
.-$2+>K`$1

(.+)¶-*(\d+)匹配整个字符串，并将字符串放入捕获组1，将数字放入捕获组.-$2+>K2。` $1生成要运行的Retina代码：. 关闭隐式输出（否则该字符串将被打印n + 1次），-$2+设置重复循环重复{捕获组2}次。开头的减号将数字变为负数，因为这将禁用循环中的收敛功能，这将在第一次迭代后停止它。>将此循环设置为在每次迭代后打印。其余代码仅用于打印字符串。

Perl 6，44个字节

{[$^s.flip,$s,$s Zxx-$^n,Inf,$n][$n.sign+1]}

在线尝试！

匿名代码块，它包含一个数字和一个字符串并返回一个（可能是无限的）列表