कई बार शांत

Question

आपका कार्य कार्यक्रम है जो निम्नलिखित है:

1. आपको नंबर लेना चाहिए। (सकारात्मक, नकारात्मक, अंश संभव इनपुट है)
2. यदि यह नकारात्मक है, तो आप रानी को उल्टा करते हैं। और उस संख्या को नकारें (सकारात्मक बनें)
3. फिर आप इनपुट नंबर> बार के <पूर्णांक भाग को दोहराते हैं और अपने स्रोत कार्यक्रम से पहली <मंजिल (इनपुट संख्या * लंबाई का अंश भाग) को प्रिंट करते हैं। यदि यह पूर्णांक है, तो अंश भाग शून्य है।

-10% बोनस अगर आपका प्रोग्राम पैलिंड्रोम नहीं है।

उदाहरण

यदि आपका कार्यक्रम "ABCDEFG" है, तो

1।

5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFG

व्याख्या

ABCDEFG पांच बार

2।

-2
GFEDCBAGFEDCBA

व्याख्या

GFEDCBA (ABCDEFG से उलट) 2 बार

3।

7.5
ABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABCDEFGABC

व्याख्या

ABCDEFG 7 बार एबीसी (पहले 3 (0.5 * 7) = तल (3.5) = 3) ABCDEFG) के बाद ABCDEFG

4।

-0.3
GF

व्याख्या

GFEDCBA (रिवर्स ABCDEFG) 0 बार GF (पहले 2 (0.3 * 7) = फ्लोर (2.1) = 2) GFEDCBA (ABCDEFG से उलट) पर अक्षर

5।

0
<empty>

स्पष्टीकरण:

<खाली> यहाँ का अर्थ है कि आपका प्रोग्राम आउटपुट नहीं करता है। यह ABCDEFG शून्य समय है जिसे खाली स्ट्रिंग के रूप में परिभाषित किया गया है।

Comments

क्या आप कृपया निर्देशों पर स्पष्ट कर सकते हैं?

— लीजनमोनमल 978

सम्बंधित।

— मार्टिन एंडर

@ LegionMammal978 मैं वास्तव में बात व्यक्त करने में बुरा हूँ, लेकिन मुझे आशा है कि यह स्पष्ट हो जाएगा।

— आकांक्षा

@ mbomb007 मुझे लगता है कि आप स्ट्रिंग को खुद को संभाल सकते हैं -और .मैन्युअल रूप से (सकारात्मक पूर्णांक के रूप में अंश का प्रतिनिधित्व करते हुए) कर सकते हैं। या आप अपना ध्यान अगली चुनौती की ओर मोड़ सकते हैं। ;) (हर भाषा हर चुनौती में भाग नहीं ले सकती है, लेकिन जब तक चुनौती जानबूझकर अलग-अलग भाषाओं पर शासन नहीं करती है, यह पूरी तरह से ठीक है। बस ऑडियो / इमेज प्रोसेसिंग या फाइल सिस्टम चुनौतियों के बारे में सोचें।)

— मार्टिन Ender

यह प्रोग्राम जो करने के लिए एक 10% बोनस देने के लिए अधिक तार्किक महसूस किया होगा रहे हैं खोल देना

— Bassdrop Cumberwubwubwub

Answer 1

CJam, 28 26 बाइट्स * 0.9 = 23.4

2 बाइट बचाने के लिए Sp3000 के लिए धन्यवाद।

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

Answer 2

विटसी, 34 * 0.9 = 30.6 बाइट्स

मेरे कोड में दोष बताने के लिए @ Sp3000 को धन्यवाद!

वू। मेरे भौतिकी के शिक्षक ने मुझे याद दिलाया कि इसके साथ मेरी मदद करने के लिए मेरे पास शक्ति कार्य हैं। जाओ पता लगाओ।

'आर (; Vd3 * V2 ^ 12 / ^ DVV / 1 + (rvl1 - * \ [डीओ {]
'एक स्ट्रिंग के रूप में रिकॉर्डिंग शुरू करें - यह सब कुछ पकड़ लेता है और इसे स्ट्रिंग के रूप में स्टैक पर धकेल देता है।
 Rev स्टैक ऑर्डर को उल्टा करें।
  (), यदि शीर्ष आइटम शून्य है, तो प्रोग्राम से बाहर निकलें।
    V इनपुट को अंतिम वैश्विक चर के रूप में पकड़ो।
     d3 * पात्र को 'स्टैक' पर रखें।
        V2 ^ 12 / ^ इनपुट मूल्य का पूर्ण मूल्य प्राप्त करें।
               Dv डुप्लिकेट और एक अस्थायी चर में बचाने के लिए।
                 V वैश्विक वैरिएबल को स्टैक पर रखें।
                  / शीर्ष दो आइटम विभाजित करें - यह इनपुट की ध्रुवीयता के आधार पर -1 या 1 प्राप्त करता है।
                   1+ (यदि यह -1 है, तो अगला निर्देश करें। अन्यथा, नहीं।
                      stack स्टैक को उल्टा करें
                       v स्टैक के लिए अस्थायी चर धक्का।
                        l1- * स्टैक माइनस 1 की लंबाई से गुणा करें।
                            \ [] स्टैक समय के शीर्ष आइटम कोष्ठक में सब कुछ दोहराएं।
                              DO {एक आइटम डुप्लिकेट करें, इसे स्टैक से पॉप करें और इसे आउटपुट करें, फिर स्टैक में एक आइटम को स्थानांतरित करें।

Answer 3

पर्ल, 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

जो प्रोग्राम का सोर्स कोड है।

इस क्वीन के बारे में अच्छी बात यह है कि आप स्ट्रिंग के अंदर मनमाने कोड एम्बेड कर सकते हैं eval।

---

यहाँ पूर्ण समाधान का टूटना है:

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

Answer 4

गणितज्ञ, १३ ९ - १०% = १२५.१ बाइट्स

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

ट्रेलिंग स्थान पर ध्यान दें। व्हाट्सएप, स्टैंडर्ड नोटेशन आदि के परिणाम हैं ToString[#0, InputForm]।

Answer 5

हास्केल, 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

Answer 6

पायथन 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 को अनदेखा करते हुए, आप अभी भी खाली आउटपुट प्राप्त करते हैं।

Comments

अभी यह सबसे लंबा समाधान है, लेकिन कोशिश करें कि कोई छोटा मिल जाए, और यदि आप कर सकते हैं तो उत्तर दें।

— एरिक Outgolfer