Votre tâche est de créer un programme qui fait ce qui suit:

1. Vous devriez prendre le numéro. (Positif, négatif, la fraction est une entrée possible)
2. S'il est négatif, vous inversez le quine. et nier ce nombre (devenir positif)
3. Ensuite, vous répétez <partie entière du numéro d'entrée> fois et imprimez d'abord <étage (partie fractionnaire du numéro d'entrée * longueur)> à partir de votre programme source. S'il est entier, alors la partie fractionnaire est nulle.

-10% de bonus si votre programme n'est pas palindrome.

Exemple

Si votre programme est "ABCDEFG", alors

1.

5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFG

Explication

ABCDEFG cinq fois

2.

-2
GFEDCBAGFEDCBA

Explication

GFEDCBA (inversé ABCDEFG) 2 fois

3.

7.5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABC

Explication

ABCDEFG 7 fois suivi de ABC (3 premières (étage (0,5 * 7) = étage (3,5) = 3) lettre sur ABCDEFG)

4.

-0.3
GF

Explication

GFEDCBA (inversé ABCDEFG) 0 fois suivi de GF (2 premières (étage (0.3 * 7) = étage (2.1) = 2) lettre sur GFEDCBA (inversé ABCDEFG))

5.

0
<empty>

Explication:

<empty> signifie ici que votre programme ne sort pas. C'est ABCDEFG zéro fois qui est défini comme une chaîne vide.

CJam, 28 26 octets * 0,9 = 23,4

Merci à Sp3000 pour avoir économisé 2 octets.

{`"_~"+rd_z26*,\g1|@%f=}_~

Testez-le ici.

Explication

{`"_~"+ e# Generalised quine framework. Leaves the source code on the stack.
  rd    e# Read input and parse as double.
  _z    e# Copy and get absolute value.
  26*   e# Multiply by 26, the length of the quine to get length N of the output.
  ,     e# Get a range [0 1 ... floor(N-1)].
  \g    e# Swap with other copy and computer signum to determine direction of string.
  1|    e# This might be zero though, so take bitwise OR with 1 to avoid an error.
  @%    e# Pull up source string. Reverse it if the signum was -1 (no-op otherwise).
  f=    e# The range we pushed earlier corresponds to the (cyclic) indices of the source
        e# which make up the desired result, so we map each index to the corresponding
        e# character to get the final result.
}_~

Vitsy, 34 * 0,9 = 30,6 octets

Merci à @ Sp3000 d'avoir signalé une faille dans mon code!

Courtiser. Mon professeur de physique m'a rappelé que j'avais des fonctions de puissance pour m'aider. Allez comprendre.

'r (; Vd3 * V2 ^ 12 / ^ DvV / 1 + (rvl1 - * \ [DO {]
'Commencez à enregistrer sous forme de chaîne - cela saisit tout et le pousse dans la pile sous forme de chaîne.
 Inversez l'ordre des piles.
  (; Si l'élément supérieur est zéro, quittez le programme.
    V Saisissez l'entrée en tant que variable globale finale.
     d3 * Poussez le caractère 'dans la pile.
        V2 ^ 12 / ^ Récupère la valeur absolue de la valeur d'entrée.
               Dv Dupliquez et enregistrez dans une variable temporaire.
                 V Poussez la variable globale dans la pile.
                  / Divisez les deux éléments supérieurs - cela obtient -1 ou 1 selon la polarité de l'entrée.
                   1+ (Si c'est -1, faites l'instruction suivante. Sinon, ne le faites pas.
                      r Inverser la pile
                       v Poussez la variable temporaire dans la pile.
                        l1- * Multipliez par la longueur de la pile moins 1.
                            \ [] Répéter tout entre parenthèses l'élément supérieur des temps de pile.
                              FAIRE {Dupliquer un élément, le retirer de la pile et le sortir, puis déplacer un élément dans la pile.

Perl, 104 octets - 10% = 93,6

perl -i-0.3 -e '$_=q{$_="\$_=q{$_};eval";$_=reverse if$^I<0;$n=abs$^I;print+($_ x$n).substr$_,0,y///c*($n-int$n)};eval'

102 octets + 2 octets pour -i- 10% pour ne pas être un palindrome. L'entrée est passée comme argument à -i(par exemple -0.3ci-dessus).

Comment ça fonctionne

Cette solution est basée sur le quine suivant:

$_=q{print"\$_=q{$_};eval"};eval

Cela fonctionne comme suit. Tout d'abord, définissez $_la chaîne:

print"\$_=q{$_};eval"

Ensuite, appelez eval, qui fonctionne $_par défaut. Cela appelle printavec un argument, un littéral de chaîne:

"\$_=q{$_};eval"

Comme cette chaîne est entre guillemets, les variables sont interpolées. Après interpolation $_, la valeur de la chaîne est:

\$_=q{print"\$_=q{$_};eval"};eval

Une fois imprimé, il affiche:

$_=q{print"\$_=q{$_};eval"};eval

qui est le code source du programme lui-même.

La bonne chose à propos de cette quine est que vous pouvez incorporer du code arbitraire dans la chaîne pour être eval'd.

Voici une ventilation de la solution complète:

perl -i-0.3 -e'
    $_=q{                     # string to be eval'd
        $_="\$_=q{$_};eval";  # append beginning and end of quine so the
                              #  entire thing can be reversed if necessary
        $_=reverse if $^I<0;  # reverse if input < 0
        $n=abs $^I;           # set $n to absolute value of input
        print                 # print
            +($_ x $n)        # $_ repeated $n times
            .                 # concatenated with
            substr $_,        # substring of $_
                   0,         # starting at the beginning
                   y///c      # having length x, where x is length of $_
                   *          # multiplied by
                   ($n-int$n) # fractional part of $n
    };
    eval                      # eval $_
'

Mathematica, 139-10% = 125,1 octets

StringJoin[Table[s = If[#1 > 0, #1 & , StringReverse][ToString[#0, InputForm]], {Abs[Floor[#1]]}], StringTake[s, Floor[Mod[#1, 1]*139]]] & 

Notez l'espace de fin. Les espaces, la notation standard, etc. sont le résultat du ToString[#0, InputForm].

Haskell, 158 * 0,9 = 142,2 octets

c i|i<0=reverse|1<2=id;f i=putStr$take(floor$abs i*158)$cycle$c i$s++show s;s="c i|i<0=reverse|1<2=id;f i=putStr$take(floor$abs i*158)$cycle$c i$s++show s;s="

Une fonction quine.

*Main> f (-0.3)
"=s;s wohs++s$i c$elcyc$)851*i sba$roolf(ekat$r

*Main> f 1.1
c i|i<0=reverse|1<2=id;f i=putStr$take(floor$abs i*158)$cycle$c i$s++show s;s="c i|i<0=reverse|1<2=id;f i=putStr$take(floor$abs i*158)$cycle$c i$s++show s;s="c i|i<0=reverse

*Main> f 0
              <-- empty

Python 2, 193 octets - 10% = 173,7

x=input();y=int(x);_='x=input();y=int(x);_=%r;_=(_%%_)[::y/abs(y)];x,y=abs(x),abs(y);_=_*y+_[:int(y*(x-y)*193)];print _';_=(_%_)[::y/abs(y)];x,y=abs(x),abs(y);_=_*y+_[:int(y*(x-y)*193)];print _

Erreurs sur 0, mais, en ignorant STDERR, vous obtenez toujours une sortie vide.