Muitas pessoas sabem o que é uma máquina da verdade na programação. Mas é hora de aumentarmos as coisas um pouco. Apresentando, a máquina da verdade estendida! Uma máquina de verdade estendida aceita duas coisas como entrada, um número inteiro ne uma sequência não vazia s. Ele gera s ntempos com espaço em branco à direita opcional. No entanto, se nfor igual a 0, você deve produzir saté o programa ser parado manualmente, ou seja, nunca deve terminar.

Além disso, se nfor um número negativo, a sequência precisará ser revertida. Por exemplo, com s=helloe n=-1, a saída seria olleh.

Métodos padrão de entrada, qualquer tipo de saída, desde que possa lidar com infinito. Se você tiver uma resposta que não lida com infinito, sinta-se à vontade para publicá-la se for interessante ou em um idioma que não possa lidar com saída infinita.

Casos de teste

n, s, output

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

Isso é código-golfe , então o código mais curto vence!

_{Aqui está a postagem original da Sandbox. Foram feitas edições nele. Obrigado a @ComradeSparklePony por criar a ideia deste desafio}

Haskell, 57 54 bytes

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

Explicação:

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 bytes graças a @nimi

PHP> = 7.1, 67 bytes

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

Versão com em list(,$x,$y)vez de [,$x,$y] Experimente online!

MATL , 37 bytes

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

Experimente online!

Explicação:

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 bytes

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

Experimente online!

A variável kgarante que o loop seja sempre executado pelo menos uma vez. Isso significa que se n=0, então, nserá negativo na próxima iteração do loop, portanto o loop continuará sendo executado para sempre.

Matlab, 87 bytes

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

Minha primeira tentativa no código-golfe! Todas as sugestões de golfe são bem-vindas.

05AB1E , 17 16 14 bytes

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

Experimente online!

Explicação:

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.

Guardado 2 bytes graças a @EriktheOutgolfer

Cubix , 41 Quarenta e quatro 45 bytes

Aceita entrada como <N> <String>

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

Experimente online!

Cubificado:

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

Assista a corrida

Ainda há uma quantidade de no-ops no código das quais eu poderia obter mais alguns bytes, mas queria resolver isso antes que eu o quebre.

Procedimento básico é

• I obter contador de entrada
• A receba o restante da entrada como caracteres
• ;p? remova o espaço, traga o número e teste-o
  • psuqB$)se o contador for negativo, inverta a pilha. Isso envolve manipular o número de entrada e o marcador EOI (-1). Incremente o contador.
  • ;p;ouqu se o contador for zero, remova o contador e o marcador EOI e inicie o loop de saída permanente.
  • ( se positivo diminuir o contador
• <<q?/o()uo loop de saída. Isso produzirá cada caractere da pilha até que o marcador EOI (-1) seja atingido.
• ... _ ... ?wq!no marcador EOI final, contorne o cubo e reflita de volta para a ?faixa de mudança, coloque o marcador EOI na parte inferior e teste o contador.
• @ se zero, pare
• ?u( se inversão de marcha e decréscimo positivos, isso acaba atingindo o início do loop
• ? ... <) se negativo, contorne o cubo para o outro lado, redirecione para o início do loop enquanto passa por um incremento.
• /)< se incremento negativo e continuar no loop de saída

JavaScript (ES6), 79 bytes

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

Snippet:

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 bytes

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

-4, -5 bytes graças a Arjun

-3 bytes graças a Rick Hitchcock

Começou diferente da resposta do Java , mas rapidamente se tornou muito semelhante após o golfe. O alerta é infinito, mas se você deseja que ele fique bonito, mude para console.log. l=alert;e escrever alertsão do mesmo tamanho, mas se você alternar para console.logmenos, será redefinido.

QBIC , 36 bytes

Muito aqui, e o QBIC / QBasic simplesmente não tem a sintaxe para lidar com essas condições de maneira elegante.

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

Explicação:

~:<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 bytes

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]);}

Experimente online!

str , 30 bytes

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

Experimente online!

Explicação

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 bytes

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));}

Experimente online!

Quem disse que precisamos strlen?

C (gcc) , 115 bytes (134 com #include<string.h>na frente)

#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));}

Experimente online!

Sem #include<string.h> obtermos um protótipo implícito para strlenesses retornos int, mas strlené size_t(pelo menos hoje em dia, não tenho muita certeza sobre k & r ou c89, mas acredito que ele retornou intnos velhos tempos).

A falta #include <stdio.h>não é um problema, porque devido à promoção de número inteiro, o protótipo padrão seráint putchar(int) exatamente o que queremos.

Retina , 49 bytes

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

Formato de entrada: recebe a sequência, seguida por uma nova linha, seguida pelo número.

Experimente online!

Explicação:

/¶-/&V`^.+

A /¶-/&linha é executada apenas se o número for negativo. Vé o estágio reverso e inverte ^.+, que corresponde à sequência ( .corresponde a todos os caracteres, exceto as novas linhas).

/¶0/&//+>G0`

A /¶0/&linha é executada apenas se o número for 0. //+>inicia um loop infinito, que imprime a sequência de trabalho após cada iteração. G0pega a corda e descarta o número; faz isso infinitamente, imprimindo sempre.

~`...

Isso marca o código que irá gerar uma string; o programa avalia a sequência como código Retina depois.

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

(.+)¶-*(\d+)corresponde à cadeia inteira e coloca a cadeia no grupo de captura 1 e o número no grupo de captura 2. .-$2+>K` $1gera o código Retina a ser executado: . desativa a saída implícita (caso contrário, a cadeia seria impressa n + 1 vezes), -$2+define um loop de repetição que se repete por {capture group 2} vezes. O sinal de menos no início transforma o número em um número negativo, pois isso desativa a funcionalidade de convergência no loop, que o interrompe após a 1ª iteração.>define esse loop para imprimir após cada iteração. O restante do código é apenas para imprimir a sequência.

Perl 6 , 44 bytes

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

Experimente online!

Bloco de código anônimo que pega um número e uma string e retorna uma lista (possivelmente infinita)