Il tuo compito è creare un programma che procede come segue:

1. Dovresti prendere il numero. (È possibile input positivo, negativo, frazione)
2. Se è negativo, inverti il ​​quine. e annulla quel numero (diventa positivo)
3. Quindi ripetere <parte intera del numero di input> volte e stampare prima <piano (parte della frazione del numero di input * lunghezza)> dal programma sorgente. Se è intero, la parte della frazione è zero.

-10% di bonus se il tuo programma non è palindromo.

Esempio

Se il tuo programma è "ABCDEFG", allora

1.

5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFG

Spiegazione

ABCDEFG cinque volte

2.

-2
GFEDCBAGFEDCBA

Spiegazione

GFEDCBA (ABCDEFG invertito) 2 volte

3.

7.5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABC

Spiegazione

ABCDEFG 7 volte seguito da ABC (primi 3 (piano (0,5 * 7) = piano (3,5) = 3) lettera su ABCDEFG)

4.

-0.3
GF

Spiegazione

GFEDCBA (ABCDEFG invertito) 0 volte seguito da GF (primi 2 (piano (0.3 * 7) = piano (2.1) = 2) lettera su GFEDCBA (ABCDEFG invertito))

5.

0
<empty>

Spiegazione:

<empty> qui significa che il tuo programma non viene emesso. È ABCDEFG zero volte che viene definita come stringa vuota.

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

Grazie a Sp3000 per aver salvato 2 byte.

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

Provalo qui.

Spiegazione

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

Grazie a @ Sp3000 per aver segnalato un difetto nel mio codice!

Corteggiare. Il mio insegnante di fisica mi ha ricordato che avevo funzioni di potere per aiutarmi in questo. Vai a capire.

'R (; VD3 * V2 ^ 12 / ^ DVV / 1 + (rvl1 - * \ [DO {]
'Inizia a registrare come una stringa: questo prende tutto e lo spinge nello stack come una stringa.
 r Invertire l'ordine dello stack.
  (; Se la prima voce è zero, esci dal programma.
    V Prendi l'input come variabile globale finale.
     d3 * Spingi il personaggio 'in pila.
        V2 ^ 12 / ^ Ottieni il valore assoluto del valore di input.
               Dv Duplica e salva in una variabile temporanea.
                 V Spingere la variabile globale nello stack.
                  / Dividi i primi due elementi: si ottiene -1 o 1 a seconda della polarità dell'ingresso.
                   1+ (Se è -1, segui le istruzioni successive. Altrimenti, no.
                      r Invertire la pila
                       v Spingere la variabile temporanea nello stack.
                        l1- * Moltiplica per la lunghezza della pila meno 1.
                            \ [] Ripeti tutto tra parentesi nella parte superiore dei tempi dello stack.
                              DO {Duplica un oggetto, estrailo dalla pila e lo manda in uscita, quindi sposta un oggetto nella pila.

Perl, 104 byte - 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 byte + 2 byte per -i- 10% per non essere un palindromo. L'input viene passato come argomento a -i(ad es. -0.3Sopra).

Come funziona

Questa soluzione si basa sul seguente quine:

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

Funziona come segue. Innanzitutto, imposta $_la stringa:

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

Quindi, chiama eval, che funziona $_per impostazione predefinita. Questo chiama printcon un argomento, una stringa letterale:

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

Poiché questa stringa è racchiusa tra virgolette doppie, le variabili vengono interpolate. Dopo l'interpolazione $_, il valore della stringa è:

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

Quando viene stampato, questo produce:

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

che è il codice sorgente del programma stesso.

La cosa bella di questo quine è che puoi inserire codice arbitrario all'interno della stringa per essere eval'd.

Ecco una ripartizione della soluzione 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 byte

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

Nota lo spazio finale. Lo spazio bianco, la notazione standard, ecc. Sono il risultato di ToString[#0, InputForm].

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

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 funzione 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 byte - 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 _

Errori in corso 0, ma, ignorando STDERR, si ottiene ancora un output vuoto.