Twoim zadaniem jest stworzenie programu, który wykona następujące czynności:

1. Powinieneś wziąć numer. (Dodatni, ujemny, możliwy jest ułamek)
2. Jeśli jest ujemny, odwracasz quine. i zaneguj tę liczbę (zostań dodatnia)
3. Następnie powtarzasz <część całkowitą numeru wejścia> i drukujesz pierwsze <piętro (część ułamka liczby wejścia * długość)> ze swojego programu źródłowego. Jeśli jest liczbą całkowitą, część ułamkowa ma wartość zero.

-10% bonusu, jeśli twój program nie jest palindromem.

Przykład

Jeśli twój program to „ABCDEFG”, to

1.

5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFG

Wyjaśnienie

ABCDEFG pięć razy

2)

-2
GFEDCBAGFEDCBA

Wyjaśnienie

GFEDCBA (odwrócona ABCDEFG) 2 razy

3)

7.5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABC

Wyjaśnienie

ABCDEFG 7 razy, a następnie ABC (pierwsze 3 (piętro (0,5 * 7) = piętro (3.5) = 3) litera na ABCDEFG)

4

-0.3
GF

Wyjaśnienie

GFEDCBA (odwrócona ABCDEFG) 0 razy, a następnie GF (pierwsze 2 (podłoga (0,3 * 7) = podłoga (2,1) = 2) litera na GFEDCBA (odwrócona ABCDEFG))

5

0
<empty>

Wyjaśnienie:

<pusty> tutaj oznacza, że ​​twój program się nie wyświetla. Jest to zero razy ABCDEFG, który jest zdefiniowany jako pusty ciąg.

CJam, 28 26 bajtów * 0,9 = 23,4

Dzięki Sp3000 za oszczędność 2 bajtów.

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

Sprawdź to tutaj.

Wyjaśnienie

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

Dzięki @ Sp3000 za wskazanie błędu w moim kodzie!

Zabiegać. Mój nauczyciel fizyki przypomniał mi, że mam funkcje mocy, które mi w tym pomogą. Domyśl.

'r (; Vd3 * V2 ^ 12 / ^ DvV / 1 + (rvl1 - * \ [DO {]
„Rozpocznij nagrywanie jako ciąg - chwyta to wszystko i odkłada na stos jako ciąg.
 r Odwróć kolejność stosów.
  (; Jeśli najwyższa pozycja to zero, zamknij program.
    V Złap dane wejściowe jako końcową zmienną globalną.
     d3 * Wciśnij znak „na stos.
        V2 ^ 12 / ^ Uzyskaj wartość bezwzględną wartości wejściowej.
               DV Powiel i zapisz w zmiennej temp.
                 V Wciśnij zmienną globalną do stosu.
                  / Podziel dwa górne elementy - otrzyma -1 lub 1 w zależności od polaryzacji wejścia.
                   1+ (Jeśli to -1, wykonaj następną instrukcję. W przeciwnym razie nie.
                      r Odwróć stos
                       v Wciśnij zmienną tymczasową na stos.
                        l1- * Pomnóż przez długość stosu minus 1.
                            \ [] Powtórz wszystko w nawiasach najwyższy element stosu.
                              DO {Duplikuj element, zdejmij go ze stosu i wyślij go, a następnie przesuń jeden element na stosie.

Perl, 104 bajty - 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 bajty + 2 bajty dla -i- 10% za brak bycia palindromem. Dane wejściowe są przekazywane jako argument do -i(np. -0.3Powyżej).

Jak to działa

To rozwiązanie opiera się na następującej quine:

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

Działa to w następujący sposób. Najpierw ustaw $_ciąg:

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

Następnie zadzwoń eval, który $_domyślnie działa . Wywołuje to printz jednym argumentem, dosłownym ciągiem:

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

Ponieważ ten ciąg jest podwójny, zmienne są interpolowane. Po interpolacji $_wartość ciągu wynosi:

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

Po wydrukowaniu powoduje to:

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

który jest kodem źródłowym samego programu.

Zaletą tego quine jest to, że możesz osadzić dowolny kod wewnątrz łańcucha, aby był eval„d.

Oto podział pełnego rozwiązania:

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 bajtów

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

Zwróć uwagę na spację końcową. Białe znaki, standardowa notacja itp. Są wynikiem ToString[#0, InputForm].

Haskell, 158 * 0,9 = 142,2 bajtów

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

Funkcja 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 bajty - 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 _

Wystąpiły błędy 0, ale ignorując STDERR, nadal otrzymujesz puste dane wyjściowe.