Un Quat est une combinaison d'une quine et du programme de chat esolang populaire .

Défi

Le défi est d'écrire un programme de chat standard. Quelles que soient les entrées utilisateur, le programme fera écho à l'entrée de stdout.
Cependant, lorsque la longueur de l'entrée est supérieure à 0 et un multiple de 4, le programme doit sortir son propre code source. Quat vient du quatro portugais , qui se traduit par «quatre».

Règles

• Des échappatoires standard s'appliquent
• Vous ne pouvez pas lire le code source d'un fichier
• Une entrée vide doit produire une sortie vide

Prime

Si votre longueur d'entrée est un multiple de 4, vous pouvez gagner un bonus de 25% en imprimant les length/4temps de quine . Un autre bonus de 5% si vous séparez la sortie par des espaces (aucun espace de fin autorisé).

Cas de test

Les cas de test suivants s'appliquent au programme in%4=0?cat:self(pas une vraie langue).

<empty input> -> <empty output>
input -> input
1234 -> in%4=0?cat:self
12345678 -> in%4=0?cat:self 0% de bonus
12345678 -> in%4=0?cat:selfin%4=0?cat:self 25% de bonus
12345678 -> in%4=0?cat:self in%4=0?cat:self 30% de bonus

Notation

C'est du code-golf . Le code le plus court en octets gagne.

CJam, 23 * 0,75 = 17,25 octets

Quine généralisée standard ...

{`"_~"+q:Q,4md@@*Q\?}_~

ou

{`"_~"+q_,4md@@]:\*?}_~

Testez-le ici.

Explication

{`"_~"+  e# Generalised quine framework. Leaves the source code on the stack.
  q:Q    e# Read input and store it in Q.
  ,      e# Get its length.
  4md    e# Divmod 4.
  @      e# Pull up the source code.
  @      e# Pull up the div.
  *      e# Repeat the source code that many times.
  Q\     e# Push the input and swap it below the repeated source.
  ?      e# Pick the right output based on the modulo.
}_~

L'autre version évite l'utilisation d'une variable en utilisant l'astuce de rotation de pile ]:\.

Sérieusement, 8 9 octets

Q,ó;l4@%I

Essayez-le en ligne

(Appuyez une fois sur Entrée dans la zone de saisie pour tester l'entrée vide.)

Le premier bonus peut être fait en 12 octets (16 * 0,75):

Q,ó;l;4@\(*)4@%I

Explication:

Q                   Push program source to stack
 ,ó                 Push input string, and terminate if it's empty
   ;l               Push length of input
     4@%            Take the length mod 4.
        I           Pick the next stack element (input) if nonzero,
                    else the next next (program source)

Étant donné que certaines personnes n'aiment pas l'utilisation du quining intégré de Serious, je fournis cette version de 22 octets qui ne sert pas Qde référence:

`è";ƒ"(+,ó;l4@%I`;ƒ

Si vous êtes une de ces personnes, considérez-la comme la version définitive (pour l'instant), puis lancez un méta-fil sur l'utilisation des intégrés dans les quines.

Pyth, 33 * 0,75 = 24,75

?%lz4z*/lz4jN*2]"?%lz4z*/lz4jN*2]

Suite de tests

Quine Pyth standard utilisant join. Ce n'est qu'une vraie quine sur l'interpréteur en ligne, qui n'ajoute pas de dernière ligne finale.

Obtenir le bonus final avec un score de 39 * .7 = 27.3:

?%lz4zjd*/lz4]jN*2]"?%lz4zjd*/lz4]jN*2]

Vitsy , 18 17 octets

Si proche . Oui. Je gagne maintenant parmi les quintres non construits! regarde sérieusement

zl4M([&'rd3*8\}]Z
z                 Grab ALL THE INPUT! :D
 l4M([         ]  If the input is a multiple of four, do the stuff in brackets.
      &           Generate a new stack and move to it.
       'rd3*      Standard quine.
            8\}   Push the bottom 8 items of the stack to the top.
                Z Output the current stack.

Il n'y a aucune raison pour moi d'aller après les bonus - ils jetteraient beaucoup plus d'octets.

Version quine triche, 12 octets:

zl4M([&iG`]Z
zl4M([&   ]Z  Same as above.
       i      Push -1.
        G     Get the name of the file with this index of use (-1 is self)
         `    Read the file with the given name and push its contents to the stack.

Emacs Lisp (323 * 0,75 = 242,25)

((lambda (s) (let* ((a (read-string "")) (l (string-bytes a))) (if (> (% l 4) 0) (message a) (dotimes (v (/ l 4)) (prin1 (list s (list (quote quote) s))))))) (quote (lambda (s) (let* ((a (read-string "")) (l (string-bytes a))) (if (> (% l 4) 0) (message a) (dotimes (v (/ l 4)) (prin1 (list s (list (quote quote) s)))))))))

Cela utilise le mécanisme de citation de Lisp pour donner le code source comme entrée pour lui-même.

Ancienne version de triche

:; exec emacs -Q -script $0
(find-file(nth 2 command-line-args))(set'b(buffer-string))(set's(read-string""))(set'l(string-bytes s))(if(>(% l 4)0)(message s)(dotimes(v(/ l 4))(message"%s"b)))

Non golfé:

:; exec emacs -Q -script $0
(find-file(nth 2 command-line-args)) ; open self
(set'b(buffer-string))               ; read own code to string
(set's(read-string""))               ; read input
(set'l(string-bytes s))              ; length of input
(if(>(% l 4)0)                       ; l % 4 > 0 ?
    (message s)                      ; output input
  (dotimes(v(/ l 4))                 ; (implicit else) repeat l/4 times
    (message"%s"b)))                 ; output own code

JavaScript, 57 56 72 octets * 0,75 = 54

Merci à @Neil pour une économie d'un octet!

(f=_=>alert(!(p=prompt())||(l=p.length)%4?p:`(f=${f})()`.repeat(l/4)))()

La solution la plus courte que j'ai pu trouver était assez simple.

Voici donc quelques solutions bonus (plus intéressantes):

JavaScript, 82 81 octets * 0,75 = 60,75

f=_=>{try{p=prompt();a=`f=${f};f()`.repeat(p.length/4)}catch(e){a=p}alert(a)};f()

Celui-ci abuse de repeatla fonctionnalité de levée d'une exception si passé un non-entier.

JavaScript, 83 octets * 0,70 = 58,1

(f=_=>alert((a=(p=prompt()).split(/.{4}/)).pop()?p:a.fill(`(f=${f})()`).join` `))()

Ce dernier est définitivement mon préféré, divisant l'entrée sur tous les quatre caractères à l'aide de l'expression régulière /.{4}/. S'il reste des caractères à la fin de la chaîne lorsque nous le faisons pop, il n'est pas divisible par 4, alors alertez l'entrée. Sinon, la poplongueur du tableau a été réduite de un, donc à ce stade, la longueur du tableau est égale à la longueur d'entrée / 4. Dans ce cas, juste fillavec la quine et les joinespaces.

Perl, 68 65 * 0,75 = 48,75 octets

perl -e'$_=q{print+($l=($~=<>)=~y///c)%4?$~:"\$_=q{$_};eval"x($l/4)};eval'

Voir la suite de tests en ligne ici.

En panne

perl -e'
    $_=q{                      # store source code in $_
        print+(
            $l=($~=<>)=~ y///c # read STDIN into $~, assign length to $l
        )%4 ?                  # if length is a multiple of 4
             $~ :              # print $~
             "\$_=q{$_};eval"  # otherwise, print source code
             x($l/4)           # length/4 times
    };
    eval'                      # eval $_ to execute its contents

Mathematica, 229 octets

($RecursionLimit = Infinity; WriteString[$Output, If[Mod[StringLength[a = (If[(a = InputString[]) === EndOfFile, "", StringJoin["\n", a, #0[]]] & )[]], 4] == 1, ToString[#0, InputForm][], If[a == "", "", StringDrop[a, 1]]]]) & []

Tous les espaces sont réservés InputFormau programme pour correspondre à son code réel.

Javascript ES6, 45 octets

$=(_=prompt())=>_.length%4?_:`$=${$};$()`;$()

Extension de ma Bling Quine de 21 octets. J'espère que le mixage promptet la sortie de fonction sont autorisés.

JavaScript, 33 octets

f=(i,l=i.length)=>l%4?i:("f="+f).repeat(l/4)

• +44 octets
• -25% de bonus

Autres solutions:

44 36 octets

f=(i,l=i.length)=>l%4?i:("f="+f).repeat(!!l)

f=(i,l=i.length)=>l%4?i:l?("f="+f):i

38,5 octets

f=(i,l=i.length)=>l%4?i:Array(l/4).fill("f="+f).join` `

• +55 octets
• -25% de bonus
• -5% de bonus