Nhiệm vụ của bạn là tạo chương trình thực hiện như sau:

1. Bạn nên lấy số. (Tích cực, tiêu cực, phân số là đầu vào có thể)
2. Nếu nó là âm, bạn đảo ngược quine. và phủ nhận số đó (Trở nên tích cực)
3. Sau đó, bạn lặp lại <phần nguyên của số đầu vào> lần và in <tầng đầu tiên (phần phân số của số đầu vào * chiều dài)> từ chương trình nguồn của bạn. Nếu nó là số nguyên, thì phần phân số bằng không.

-10% tiền thưởng nếu chương trình của bạn không nhạt màu.

Thí dụ

Nếu chương trình của bạn là "ABCDEFG", thì

1.

5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFG

Giải trình

ABCDEFG năm lần

2.

-2
GFEDCBAGFEDCBA

Giải trình

GFEDCBA (đảo ngược ABCDEFG) 2 lần

3.

7.5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABC

Giải trình

ABCDEFG 7 lần theo sau là ABC (3 chữ cái đầu tiên (tầng (0,5 * 7) = tầng (3,5) = 3) trên ABCDEFG)

4.

-0.3
GF

Giải trình

GFEDCBA (đảo ngược ABCDEFG) 0 lần theo sau là chữ cái GF (2 đầu tiên (sàn (0,3 * 7) = sàn (2.1) = 2) trên GFEDCBA (ABCDEFG đảo ngược))

5.

0
<empty>

Giải trình:

<blank> ở đây có nghĩa là chương trình của bạn không xuất ra. Đó là số lần 0 ABCDEFG được định nghĩa là chuỗi rỗng.

CJam, 28 26 byte * 0.9 = 23.4

Cảm ơn Sp3000 đã lưu 2 byte.

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

Kiểm tra nó ở đây.

Giải trình

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

Cảm ơn @ Sp3000 vì đã chỉ ra một lỗ hổng trong mã của tôi!

Woo. Giáo viên Vật lý của tôi nhắc nhở tôi rằng tôi có chức năng sức mạnh để giúp tôi điều này. Đi hình.

'r (; Vd3 * V2 ^ 12 / ^ DVV / 1 + (rvl1 - * \ [DO {]
'Bắt đầu ghi dưới dạng chuỗi - điều này lấy tất cả mọi thứ và đẩy nó vào ngăn xếp dưới dạng chuỗi.
 r Đảo ngược thứ tự ngăn xếp.
  (; Nếu mục trên cùng bằng 0, thoát khỏi chương trình.
    V Lấy đầu vào là biến toàn cục cuối cùng.
     d3 * Đẩy nhân vật 'vào ngăn xếp.
        V2 ^ 12 / ^ Nhận giá trị tuyệt đối của giá trị đầu vào.
               DV Sao chép và lưu trong một biến tạm thời.
                 V Đẩy biến toàn cục vào ngăn xếp.
                  / Chia hai mục trên cùng - mục này được -1 hoặc 1 tùy thuộc vào độ phân cực của đầu vào.
                   1+ (Nếu là -1, hãy thực hiện hướng dẫn tiếp theo. Nếu không, đừng.
                      r Đảo ngược ngăn xếp
                       v Đẩy biến tạm thời vào ngăn xếp.
                        l1- * Nhân với chiều dài của ngăn xếp trừ đi 1.
                            \ [] Lặp lại mọi thứ trong ngoặc mục hàng đầu của thời gian xếp chồng.
                              DO {Sao chép một mục, bật nó ra khỏi ngăn xếp và xuất nó, sau đó di chuyển một mục trong ngăn xếp.

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 cho -i- 10% vì không phải là một bảng màu. Đầu vào được truyền dưới dạng đối số -i(ví dụ -0.3ở trên).

Làm thế nào nó hoạt động

Giải pháp này dựa trên quine sau:

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

Điều này hoạt động như sau. Đầu tiên, đặt thành $_chuỗi:

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

Tiếp theo, gọi eval, hoạt động $_theo mặc định. Cuộc gọi này printvới một đối số, một chuỗi bằng chữ:

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

Vì chuỗi này được trích dẫn kép, các biến được nội suy. Sau khi nội suy $_, giá trị của chuỗi là:

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

Khi được in, kết quả này xuất ra:

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

đó là mã nguồn của chính chương trình.

Điều thú vị về câu hỏi này là bạn có thể nhúng mã tùy ý bên trong chuỗi thành eval'd.

Đây là một sự cố của giải pháp đầy đủ:

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 $_
'

Toán học, 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]]] & 

Lưu ý không gian dấu. Khoảng trắng, ký hiệu chuẩn, v.v. là kết quả của 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="

Một hàm 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 _

Lỗi trên 0, nhưng, bỏ qua STDERR, bạn vẫn nhận được đầu ra trống.