Su tarea es hacer un programa que haga lo siguiente:

1. Deberías tomar el número. (Positivo, negativo, fracción es posible entrada)
2. Si es negativo, invierte la quine. y negar ese número (Ser positivo)
3. Luego repite <parte entera del número de entrada> veces e imprime primero <piso (parte de fracción del número de entrada * longitud)> desde su programa fuente. Si es entero, entonces la parte de fracción es cero.

-10% de bonificación si su programa no es palíndromo.

Ejemplo

Si su programa es "ABCDEFG", entonces

1)

5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFG

Explicación

ABCDEFG cinco veces

2)

-2
GFEDCBAGFEDCBA

Explicación

GFEDCBA (ABCDEFG invertido) 2 veces

3)

7.5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABC

Explicación

ABCDEFG 7 veces seguido de ABC (primeras 3 (piso (0.5 * 7) = piso (3.5) = 3) letra en ABCDEFG)

4)

-0.3
GF

Explicación

GFEDCBA (ABCDEFG invertido) 0 veces seguido de GF (primer 2 (piso (0.3 * 7) = piso (2.1) = 2) letra en GFEDCBA (ABCDEFG invertido))

5)

0
<empty>

Explicación:

<vacío> aquí significa que su programa no sale. Es ABCDEFG cero veces que se define como una cadena vacía.

CJam, 28 26 bytes * 0.9 = 23.4

Gracias a Sp3000 por guardar 2 bytes.

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

Pruébalo aquí.

Explicación

{`"_~"+ 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 Bytes

¡Gracias a @ Sp3000 por señalar una falla en mi código!

Cortejar. Mi profesor de física me recordó que tenía funciones de poder para ayudarme con esto. Imagínate.

'r (; Vd3 * V2 ^ 12 / ^ DvV / 1 + (rvl1 - * \ [DO {]
'Comience a grabar como una cadena: esto lo agarra todo y lo empuja a la pila como una cadena.
 r Invierta el orden de la pila.
  (; Si el elemento superior es cero, salga del programa.
    V Tome la entrada como una variable global final.
     d3 * Empuja el personaje 'a la pila.
        V2 ^ 12 / ^ Obtenga el valor absoluto del valor de entrada.
               Dv Duplicar y guardar en una variable temporal.
                 V Empuje la variable global a la pila.
                  / Divida los dos elementos principales: obtiene -1 o 1 según la polaridad de la entrada.
                   1+ (Si es -1, realice la siguiente instrucción. De lo contrario, no lo haga.
                      r Invierta la pila
                       v Empuje la variable temporal a la pila.
                        l1- * Multiplica por la longitud de la pila menos 1.
                            \ [] Repita todo entre paréntesis el elemento superior de la pila de veces.
                              DO {Duplicar un elemento, sacarlo de la pila y sacarlo, luego mover un elemento sobre la pila.

Perl, 104 bytes - 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 bytes + 2 bytes para -i- 10% por no ser un palíndromo. La entrada se pasa como argumento a -i(por ejemplo, -0.3arriba).

Cómo funciona

Esta solución se basa en la siguiente quine:

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

Esto funciona de la siguiente manera. Primero, establezca $_la cadena:

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

A continuación, llame eval, que funciona $_de manera predeterminada. Esto llama printcon un argumento, un literal de cadena:

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

Como esta cadena tiene comillas dobles, las variables se interpolan. Después de interpolar $_, el valor de la cadena es:

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

Cuando se imprime, esto genera:

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

cuál es el código fuente del programa en sí.

Lo bueno de este quine es que puede incrustar código arbitrario dentro de la cadena para que sea eval'd.

Aquí hay un desglose de la solución completa:

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 bytes

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

Tenga en cuenta el espacio final. El espacio en blanco, la notación estándar, etc. son el resultado de ToString[#0, InputForm].

Haskell, 158 * 0.9 = 142.2 bytes

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="

Una función 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 bytes - 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 _

Errores en 0, pero, ignorando STDERR, aún obtienes resultados vacíos.