Beaucoup de gens savent ce qu'est une machine à vérité dans la programmation. Mais il est temps que nous accélérions les choses. Présentation, la machine de vérité étendue! Une machine de vérité étendue prend deux choses en entrée, un entier net une chaîne non vide s. Il génère des s nheures avec un espace de fin facultatif. Cependant, si nest égal à 0, vous devez produire sjusqu'à ce que le programme soit arrêté manuellement, c'est-à-dire qu'il ne devrait jamais se terminer.

De plus, si nest un nombre négatif, la chaîne doit être inversée. Par exemple avec s=helloet n=-1, la sortie serait olleh.

Méthodes d'entrée standard, tout type de sortie tant qu'il peut gérer l'infini. Si vous avez une réponse qui ne gère pas l'infini, n'hésitez pas à la publier si elle est intéressante ou dans une langue qui ne peut pas gérer la sortie infinie.

Cas de test

n, s, output

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

C'est le code-golf , donc le code le plus court gagne!

_{Voici la publication Sandbox originale. Des modifications y ont été apportées. Merci à @ComradeSparklePony d'avoir créé l'idée de ce défi}

Haskell, 57 54 octets

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

Explication:

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 octets grâce à @nimi

PHP> = 7.1, 67 octets

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

Version avec list(,$x,$y)au lieu de [,$x,$y] Essayez-le en ligne!

MATL , 37 octets

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

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne!

La variable kgarantit que la boucle est toujours exécutée au moins une fois. Cela signifie que si n=0, alors nsera négatif à la prochaine itération de la boucle, la boucle continuera donc d'être exécutée indéfiniment.

Matlab, 87 octets

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

Ma première tentative de code-golf! Toutes les suggestions pour le golf sont les bienvenues.

05AB1E , 17 16 14 octets

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

Essayez-le en ligne!

Explication:

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.

2 octets enregistrés grâce à @EriktheOutgolfer

Cubix , 41 quarante-quatre 45 octets

Prend l'entrée comme <N> <String>

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

Essayez-le en ligne!

Cubifié:

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

Regardez-le courir

Il y a toujours une quantité de no-ops dans le code dont je pourrais peut-être obtenir quelques octets de plus, mais je voulais le faire avant de le casser.

La procédure de base est

• I obtenir le compteur de l'entrée
• A prendre le reste de l'entrée en tant que caractères
• ;p? supprimer l'espace, augmenter le nombre et le tester
  • psuqB$)si le compteur est négatif, inversez la pile. Cela implique la gestion du numéro d'entrée et du marqueur EOI (-1). Incrémentez le compteur.
  • ;p;ouqu si le compteur est nul, retirez le compteur et le marqueur EOI et démarrez la boucle de sortie perpétuelle.
  • ( si positif décrémenter le compteur
• <<q?/o()ula boucle de sortie. Cela affichera chaque caractère de la pile jusqu'à ce que le marqueur EOI (-1) soit atteint.
• ... _ ... ?wq!à la fin du marqueur EOI, contournez le cube et réfléchissez à nouveau ?, changez de voie, déposez le marqueur EOI au fond et testez le compteur.
• @ si zéro, arrêtez
• ?u( si demi-tour positif et décrémentation, le vol finit par frapper le début de la boucle
• ? ... <) s'il est négatif, faites le tour du cube vers l'autre côté, redirigez-le vers le début de la boucle en passant sur un incrément.
• /)< si incrément négatif et continuer sur la boucle de sortie

JavaScript (ES6), 79 octets

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

Fragment:

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 octets

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

-4, -5 octets grâce à Arjun

-3 octets grâce à Rick Hitchcock

Commencé différemment de la réponse Java , mais est rapidement devenu très similaire après le golf. L'alerte est infinie, mais si vous voulez qu'elle soit belle, passez à console.log. l=alert;et l'écriture alertsont de la même longueur, mais si vous basculez vers console.logc'est plus court pour le redéfinir.

QBIC , 36 octets

Beaucoup de choses ici, et QBIC / QBasic n'a tout simplement pas la syntaxe pour gérer ces conditions avec élégance.

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

Explication:

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

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

Essayez-le en ligne!

str , 30 octets

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

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Qui a dit que nous avions besoin strlen?

C (gcc) , 115 octets (134 avec #include<string.h>devant)

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

Essayez-le en ligne!

Sans #include<string.h>nous obtenons un prototype implicite pour strlence retour int, mais strlenc'est size_t(au moins de nos jours, pas tout à fait sûr de k & r ou c89, mais je crois, il est revenu intdans le bon vieux temps).

Le manquant #include <stdio.h>n'est pas un problème, car en raison de la promotion d'entiers, le prototype par défaut sera int putchar(int)exactement ce que nous voulons.

Rétine , 49 octets

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

Format d'entrée: prend la chaîne, suivie d'une nouvelle ligne, suivie du numéro.

Essayez-le en ligne!

Explication:

/¶-/&V`^.+

Le /¶-/&exécute cette ligne uniquement si le nombre est négatif. Vest l'étape inverse, et elle inverse ^.+, ce qui correspond à la chaîne ( .correspond à chaque caractère à l'exception des sauts de ligne).

/¶0/&//+>G0`

L' /¶0/&exécute cette ligne uniquement si le nombre est 0. //+>démarre une boucle infinie, qui imprime la chaîne de travail après chaque itération. G0prend la chaîne et jette le numéro; il le fait à l'infini, imprimant à chaque fois.

~`...

Cela marque le code qui va générer une chaîne; le programme évalue la chaîne comme code Retina après.

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

(.+)¶-*(\d+)correspond à la chaîne entière et place la chaîne dans le groupe de capture 1 et le numéro dans le groupe de capture 2. .-$2+>K` $1génère le code Retina à exécuter: . désactive la sortie implicite (sinon la chaîne serait imprimée n + 1 fois), -$2+définit une boucle de répétition qui se répète pour {capturing group 2} fois. Le moins au début transforme le nombre en nombre négatif, car cela désactive la fonctionnalité de convergence dans la boucle, ce qui l'arrêterait après la 1ère itération.>définit cette boucle pour imprimer après chaque itération. Le reste du code consiste simplement à imprimer la chaîne.

Perl 6 , 44 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui prend un nombre et une chaîne et renvoie une liste (éventuellement infinie)