Ваша задача - создать программу, которая делает следующее:

1. Вы должны взять номер. (Положительный, отрицательный, возможен ввод дроби)
2. Если оно отрицательное, вы меняете квинну. и отрицать это число (стать положительным)
3. Затем вы повторяете <целую часть входного числа> и печатаете сначала <пол (дробная часть входного числа * длина)> из исходной программы. Если это целое число, то дробная часть равна нулю.

Бонус -10%, если ваша программа не палиндром.

пример

Если ваша программа "ABCDEFG", то

1.

5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFG

объяснение

ABCDEFG пять раз

2.

-2
GFEDCBAGFEDCBA

объяснение

GFEDCBA (в обратном порядке ABCDEFG) 2 раза

3.

7.5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABC

объяснение

ABCDEFG 7 раз, за ​​которыми следует ABC (первые 3 (пол (0,5 * 7) = пол (3,5) = 3) буквы на ABCDEFG)

4.

-0.3
GF

объяснение

GFEDCBA (обратный ABCDEFG) 0 раз, за ​​которым следует GF (первые 2 (пол (0,3 * 7) = нижний (2,1) = 2) буквы на GFEDCBA (обратный ABCDEFG))

5.

0
<empty>

Объяснение:

<пустой> здесь означает, что ваша программа не выводит. Это ABCDEFG ноль раз, который определяется как пустая строка.

CJam, 28 26 байтов * 0,9 = 23,4

Спасибо Sp3000 за сохранение 2 байта.

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

Проверьте это здесь.

объяснение

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

Витси, 34 * 0,9 = 30,6 Байт

Спасибо @ Sp3000 за указание на недостаток в моем коде!

Woo. Мой учитель физики напомнил мне, что у меня есть силовые функции, чтобы помочь мне с этим. Пойди разберись.

«Г (; VD3 * V2 ^ 12 / ^ DVV / 1 + (rvl1 - * \ [DO {]
«Начать запись в виде строки - это все захватывает и помещает в стек как строку.
 r Обратный порядок в стеке.
  (; Если верхний элемент равен нулю, выйдите из программы.
    V Получите ввод как окончательную глобальную переменную.
     d3 * Вставить символ 'в стек.
        V2 ^ 12 / ^ Получить абсолютное значение входного значения.
               Dv Дублируйте и сохраните во временной переменной.
                 V Вставьте глобальную переменную в стек.
                  / Разделите два верхних элемента - получится -1 или 1 в зависимости от полярности входа.
                   1+ (Если это -1, выполните следующую инструкцию. В противном случае, нет.
                      г Перевернуть стек
                       v Перенесите временную переменную в стек.
                        l1- * Умножьте на длину стека минус 1.
                            \ [] Повторите все в скобках верхний элемент стека раз.
                              DO {Дублируйте элемент, вытолкните его из стека и выведите его, затем переместите один элемент в стек.

Perl, 104 байта - 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 байта + 2 байта за -i- 10% за отсутствие палиндрома. Ввод передается в качестве аргумента-i (например, -0.3выше).

Как это устроено

Это решение основано на следующей сущности:

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

Это работает следующим образом. Сначала установите $_строку:

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

Далее вызов eval, который работает $_по умолчанию. Это вызывает printс одним аргументом, строковым литералом:

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

Поскольку эта строка в двойных кавычках, переменные интерполируются. После интерполяции $_значение строки:

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

При печати это выводит:

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

который является исходным кодом самой программы.

Хорошая вещь в этом quine заключается в том, что вы можете встроить произвольный код в строку eval'd.

Вот разбивка полного решения:

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 байта

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

Обратите внимание на завершающий пробел. Пробелы, стандартные обозначения и т. Д. Являются результатом ToString[#0, InputForm].

Haskell, 158 * 0,9 = 142,2 байта

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

Функция Квина.

*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 байта - 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 _

Ошибки включены 0, но, игнорируя STDERR, вы все равно получаете пустой вывод.