Sua tarefa é criar um programa que faça o seguinte:

1. Você deve pegar o número. (Fração positiva, negativa, é possível entrada)
2. Se for negativo, você reverte o quine. e negue esse número (torne-se positivo)
3. Em seguida, você repete <parte inteira do número de entrada> vezes e imprime primeiro <andar (parte da fração do número de entrada * comprimento)> do seu programa de origem. Se for inteiro, a parte da fração é zero.

-10% de bônus se o seu programa não for palíndromo.

Exemplo

Se o seu programa for "ABCDEFG", então

1

5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFG

Explicação

ABCDEFG cinco vezes

2)

-2
GFEDCBAGFEDCBA

Explicação

GFEDCBA (ABCDEFG invertido) 2 vezes

3)

7.5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABC

Explicação

ABCDEFG 7 vezes seguido por ABC (primeira 3 (piso (0,5 * 7) = piso (3,5) = 3) letra no ABCDEFG)

4)

-0.3
GF

Explicação

GFEDCBA (ABCDEFG revertido) 0 vezes seguidas por GF (primeira 2 (piso (0,3 * 7) = piso (2,1) = 2) letra na carta GFEDCBA (ABCDEFG revertido)))

5)

0
<empty>

Explicação:

<vazio> aqui significa que seu programa não é gerado. É zero vezes ABCDEFG definido como sequência vazia.

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

Agradecimentos ao Sp3000 por salvar 2 bytes.

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

Teste aqui.

Explicação

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

Agradeço ao @ Sp3000 por apontar uma falha no meu código!

Woo. Meu professor de física me lembrou que eu tinha funções de poder para me ajudar com isso. Vai saber.

'r (; Vd3 * V2 ^ 12 / ^ DvV / 1 + (rvl1 - * \ [DO {]
'Comece a gravar como uma string - isso agarra tudo e a empurra para a pilha como uma string.
 r Inverta a ordem da pilha.
  (; Se o item principal for zero, saia do programa.
    V Pegue a entrada como uma variável global final.
     d3 * Empurre o caractere 'para a pilha.
        V2 ^ 12 / ^ Obtenha o valor absoluto do valor de entrada.
               Dv Duplique e salve em uma variável temp.
                 V Empurre a variável global para a pilha.
                  / Divida os dois itens principais - obtém -1 ou 1, dependendo da polaridade da entrada.
                   1+ (Se for -1, execute a próxima instrução. Caso contrário, não.
                      r Inverta a pilha
                       v Empurre a variável temporária para a pilha.
                        l1- * Multiplique pelo comprimento da pilha menos 1.
                            \ [] Repita tudo entre parênteses no item superior dos tempos de pilha.
                              FAÇA {Duplique um item, retire-o da pilha e faça a saída e, em seguida, mova um item na pilha.

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 não ser um palíndromo. A entrada é passada como argumento para -i(por exemplo, -0.3acima).

Como funciona

Esta solução é baseada no seguinte quine:

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

Isso funciona da seguinte maneira. Primeiro, defina $_a sequência:

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

Em seguida, chame eval, que funciona $_por padrão. Isso chama printcom um argumento, uma string literal:

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

Como essa sequência é entre aspas duplas, as variáveis ​​são interpoladas. Após a interpolação $_, o valor da sequência é:

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

Quando impresso, isso gera:

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

qual é o código fonte do próprio programa.

O bom desse quine é que você pode incorporar código arbitrário dentro da string para ser eval'd.

Aqui está um detalhamento da solução 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]]] & 

Observe o espaço à direita. O espaço em branco, a notação padrão etc. são o 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="

Uma função 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 _

Erros apagados 0, mas, ignorando STDERR, você ainda obtém saída vazia.