Göreviniz aşağıdakileri yapan bir program yapmak:

1. Sayı almalısın. (Pozitif, negatif, kesir girilebilir)
2. Negatifse, kınayı ters çevirirsiniz. ve bu sayıyı reddetmek (Olumlu olmak)
3. Sonra <giriş numarasının tamsayı kısmı> kez tekrarlayın ve kaynak programınızdan ilk <katı (giriş numarasının * uzunluğunun kesir kısmı)> yazdırın. Tamsayı ise, kesir kısmı sıfırdır.

Programınız palindrom değilse% -10 bonus.

Misal

Programınız "ABCDEFG" ise,

1.

5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFG

açıklama

ABCDEFG beş kez

2.

-2
GFEDCBAGFEDCBA

açıklama

GFEDCBA (ters ABCDEFG) 2 kez

3.

7.5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABC

açıklama

ABCDEFG 7 kez ardından ABC (ilk 3 (kat (0,5 * 7) = kat (3,5) = 3) ABCDEFG'deki mektup)

4.

-0.3
GF

açıklama

GFEDCBA (ters ABCDEFG) 0 kez ardından GF (ilk 2 (zemin (0,3 * 7) = zemin (2,1) = 2) GFEDCBA (ters ABCDEFG)) harfi

5.

0
<empty>

Açıklama:

<empty> burada programınızın çıktısı olmadığı anlamına gelir. Boş dize olarak tanımlanan sıfır ABCDEFG'dir.

CJam, 28 26 bayt * 0.9 = 23.4

2 bayt tasarruf için Sp3000'e teşekkürler.

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

Burada test edin.

açıklama

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

Kodumdaki bir kusuru işaret ettiği için @ Sp3000'e teşekkürler!

Woo. Fizik öğretmenim bana bu konuda yardımcı olacak güç fonksiyonlarım olduğunu hatırlattı. Git şekil.

'R (, VD3 * V2 ^ 12 / ^ DVV / 1 + (rvl1 - * \ [DO {]
'Bir dize olarak kaydetmeye başlayın - bu her şeyi alır ve dizeye yığına iter.
 r Yığın sırasını ters çevirin.
  (; En üstteki öğe sıfırsa, programdan çıkın.
    V Girdiyi nihai bir global değişken olarak alın.
     d3 * 'karakterini yığına doğru itin.
        V2 ^ 12 / ^ Giriş değerinin mutlak değerini alın.
               Dv Çoğaltma ve temp değişkeninde kaydetme.
                 V Global değişkeni yığına doğru itin.
                  / En üstteki iki öğeyi bölün - girişin polaritesine bağlı olarak -1 veya 1 olur.
                   1+ (-1 ise, bir sonraki talimatı uygulayın. Aksi takdirde yapma.
                      r Yığını ters çevirin
                       v Geçici değişkeni yığına doğru itin.
                        l1- * Yığın uzunluğunun eksi 1 ile çarpın.
                            \ [] Yığın zamanlarının üst köşesinde parantez içindeki her şeyi tekrarla.
                              DO {Bir öğeyi çoğaltın, yığının dışına çıkarın ve çıktısını alın, ardından bir öğeyi yığının üzerinde hareket ettirin.

Perl, 104 bayt -% 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 bayt + 2 bayt -i- palindrom olmadığından% 10. Girdi, argüman olarak -i(örn. -0.3Yukarıda) geçirilir .

Nasıl çalışır

Bu çözüm aşağıdaki kine dayanmaktadır:

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

Bu aşağıdaki gibi çalışır. İlk $_olarak, dizeye ayarlayın :

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

Ardından, varsayılan olarak evalçalışan arama $_. Bu print, bir bağımsız değişkeni, bir dize değişmezini çağırır :

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

Bu dize çift tırnaklı olduğu için değişkenler enterpole edilir. Enterpolasyondan sonra $_dizenin değeri:

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

Yazdırıldığında, bu çıktı:

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

bu da programın kaynak kodudur.

Bu alıntı ile ilgili güzel bir şey, eval'd olmak üzere dizenin içine rastgele kod gömebilirsiniz .

İşte tam çözümün dökümü:

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 bayt

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

Sondaki boşluğa dikkat edin. Boşluk, standart gösterim vb ToString[#0, InputForm].

Haskell, 158 * 0.9 = 142.2 bayt

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

Bir quine işlevi.

*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 bayt -% 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 _

Hatalar açık 0, ancak STDERR'ı yok sayarak yine de boş çıktı alıyorsunuz.