Molte persone sanno cos'è una macchina della verità nella programmazione. Ma è tempo di dare una spinta alle cose. Vi presentiamo la macchina della verità estesa! Una macchina per la verità estesa accetta due cose come input, un numero intero ne una stringa non vuota s. Produce s ntempi con spazi vuoti finali opzionali. Tuttavia, se nè uguale a 0, è necessario seseguire l' output fino a quando il programma non viene arrestato manualmente, ovvero non deve mai terminare.

Inoltre, se nè un numero negativo, la stringa deve essere invertita. Ad esempio con s=helloe n=-1, l'output sarebbe olleh.

Metodi standard di input, qualsiasi tipo di output purché sia ​​in grado di gestire infiniti. Se hai una risposta che non gestisce infinito, sentiti libero di pubblicarlo se è interessante o in una lingua che non è in grado di gestire un output infinito.

Casi test

n, s, output

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

Questo è code-golf , quindi vince il codice più corto!

_{Ecco il post originale di Sandbox. Sono state apportate modifiche. Grazie a @ComradeSparklePony per aver creato l'idea di questa sfida}

Haskell, 57 54 byte

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

Spiegazione:

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 byte grazie a @nimi

PHP> = 7,1, 67 byte

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

Versione con list(,$x,$y)invece di [,$x,$y] Provalo online!

MATL , 37 byte

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

Provalo online!

Spiegazione:

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 byte

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

Provalo online!

La variabile kgarantisce che il ciclo sia sempre eseguito almeno una volta. Ciò significa che se n=0, allora nsarà negativo alla successiva iterazione del ciclo, quindi il ciclo continuerà a essere eseguito per sempre.

Matlab, 87 byte

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

Il mio primo tentativo di code-golf! Tutti i suggerimenti per il golf sono i benvenuti.

05AB1E , 17 16 14 byte

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

Provalo online!

Spiegazione:

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.

Salvato 2 byte grazie a @EriktheOutgolfer

Cubix , 41 Quarantaquattro 45 byte

Accetta input come <N> <String>

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

Provalo online!

Cubified:

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

Guarda correre

C'è ancora una quantità di no-op nel codice che potrei essere in grado di ottenere qualche byte in più, ma volevo risolverlo prima di romperlo.

La procedura di base è

• I ottenere il contatore dall'input
• A prendi il resto dell'input come carattere
• ;p? rimuovere lo spazio, aumentare il numero e testarlo
  • psuqB$)se il contatore è negativo, invertire la pila. Ciò comporta la gestione del numero di input e del marker EOI (-1). Incrementa il contatore.
  • ;p;ouqu se il contatore è zero, rimuovere il contatore e il marker EOI e avviare il ciclo di uscita perpetuo.
  • ( se positivo decrementa il contatore
• <<q?/o()uil circuito di uscita. Questo produrrà ogni carattere dello stack fino a raggiungere il marker EOI (-1).
• ... _ ... ?wq!sull'estremità dell'indicatore EOI, gira intorno al cubo e rifletti indietro verso ?, cambia corsia, lascia cadere l'indicatore EOI in basso e prova il contatore.
• @ se zero, fermati
• ?u( se inversione a U positiva e decremento, il ladro finisce col colpire l'inizio del loop
• ? ... <) se negativo, gira intorno al cubo verso l'altro lato, reindirizza all'inizio del ciclo mentre passa sopra un incremento.
• /)< in caso di incremento negativo e passare al loop di uscita

JavaScript (ES6), 79 byte

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

Frammento:

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 byte

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

-4, -5 byte grazie ad Arjun

-3 byte grazie a Rick Hitchcock

Iniziato diversamente dalla risposta Java , ma divenne rapidamente molto simile dopo il golf. L'avviso è infinito, ma se vuoi che sia bello, passa a console.log. l=alert;e la scrittura alertè della stessa lunghezza, ma se si passa a console.logè più breve per ridefinirla.

QBIC , 36 byte

Molto avanti qui, e QBIC / QBasic non ha la sintassi per affrontare tali condizioni con eleganza.

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

Spiegazione:

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

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

Provalo online!

str , 30 byte

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

Provalo online!

Spiegazione

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 byte

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

Provalo online!

Chi l'ha detto, abbiamo bisogno strlen?

C (gcc) , 115 byte (134 con #include<string.h>davanti)

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

Provalo online!

Senza #include<string.h>otteniamo un prototipo implicito per strlenquei ritorni int, ma strlenè size_t(almeno al giorno d'oggi, non perfettamente sicuro di k & r o c89, ma credo che sia tornato intai vecchi tempi).

La mancanza #include <stdio.h>non è un problema, perché a causa della promozione dei numeri interi, il prototipo predefinito sarà int putchar(int)esattamente quello che vogliamo.

Retina , 49 byte

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

Formato di input: accetta la stringa, seguita da una nuova riga, seguita dal numero.

Provalo online!

Spiegazione:

/¶-/&V`^.+

La /¶-/&gestisce questa linea solo se il numero è negativo. Vè lo stadio inverso e si inverte ^.+, che corrisponde alla stringa ( .corrisponde a tutti i caratteri tranne le nuove righe).

/¶0/&//+>G0`

La /¶0/&gestisce questa linea solo se il numero è 0. //+>inizia un ciclo infinito, che consente di stampare la stringa di lavoro dopo ogni iterazione. G0prende la stringa e scarta il numero; lo fa all'infinito, stampando ogni volta.

~`...

Questo segna il codice che genererà una stringa; il programma valuta la stringa come codice Retina dopo.

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

(.+)¶-*(\d+)corrisponde all'intera stringa e inserisce la stringa nel gruppo di acquisizione 1 e il numero nel gruppo di acquisizione 2. .-$2+>K` $1genera il codice Retina da eseguire: . disattiva l'output implicito (altrimenti la stringa verrebbe stampata n + 1 volte), -$2+imposta un ciclo di ripetizione che si ripete per {catturare il gruppo 2} volte. Il meno all'inizio trasforma il numero in un numero negativo, in quanto ciò disabilita la funzionalità di convergenza nel loop, che lo fermerebbe dopo la prima iterazione. >imposta questo ciclo per stampare dopo ogni iterazione. Il resto del codice è solo per stampare la stringa.

Perl 6 , 44 byte

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

Provalo online!

Blocco di codice anonimo che accetta un numero e una stringa e restituisce un elenco (possibilmente infinito)