मैथपैक संख्यात्मक शाब्दिक

Question

प्रस्तावना

बहुत गर्म स्थिति में आपको गोल्फ के साथ और भी आगे जाना होगा।
(उदाहरण के लिए एक चुनौती में, जहां आपका उत्तर 100 वर्ण लंबा है और यह केवल शर्मनाक है कि आप इसे 99 में नहीं बना सकते हैं)
उस स्थिति में, अब से आप इस चुनौती के विजेता के एल्गोरिथ्म का उपयोग करते हैं :)

लक्ष्य

आपको एक प्रोग्राम लिखना होगा जो एक uint32 लेता है और सबसे संकुचित रूप देता है।

$ mathpack 147456
9<<14

• एक संख्या के लिए कई समाधान होंगे। सबसे छोटा उठाओ
• यदि संपीड़ित फ़ॉर्म मूल संख्या के बराबर या अधिक है, तो मूल संख्या लौटाएं

नियम

• किसी भी भाषा में लिखें - किसी भी भाषा में आउटपुट
• मुझे पता है कि सी में 'abc'है 6382179और आप इस रूपांतरण के साथ बहुत अच्छे परिणाम प्राप्त कर सकते हैं। लेकिन इस चुनौती में भाषाएं अलग हो जाती हैं, इसलिए हिम्मत न हारें
• यह बाहरी चर का उपयोग करने के लिए निषिद्ध है। केवल ऑपरेटरों और शाब्दिक और गणित से संबंधित कार्य!

स्कोरिंग

यहां परीक्षण के मामले हैं: pastebin.com/0bYPzUhX
आपका स्कोर (प्रतिशत)
byte_size_of_your_output / byte_size_of_the_list बिना लाइन ब्रेक के अनुपात होगा ।
(आपको यह अपने आप से करना होगा क्योंकि मैं सिर्फ मामले में सबसे अच्छा कोड सत्यापित करूँगा)
विजेताओं को स्कोर और आउटपुट की भाषा द्वारा चुना जाएगा !

उदाहरण:

$ mathpack 147456 | mathpack 97787584 |  mathpack 387420489
            9<<14 |           9e7^9e6 |            pow(9,9)

Comments

लवली चुनौती, लेकिन आपको हार्ड कोडिंग के खिलाफ एक नियम में जोड़ना चाहिए।

— atı

y- आप 10k मामलों हार्डकोडिंग का मतलब है? हालांकि मैं कैसे इस चुनौती को परिष्कृत करने पर कुछ सहायता प्राप्त करने के खुशी होगी

— bebe

संपादित (बार-बार ...) स्पष्टता के लिए। सलाह के लिए धन्यवाद।

— बेबे

यह भी [rosetta-stone] नहीं होगा? भी: write in any language - output in any language- दोनों भाषाएँ अलग-अलग हो सकती हैं, है ना?

— atı 19:uʎs

@ -ı stoneuʎs [rosetta-stone] वास्तव में आप इसे संभव के रूप में कई भाषाओं में हल करने के बारे में है। और आपके बाद के प्रश्न के लिए हाँ - कि मुझे उसी प्रश्न के उत्तर में संपादित किया गया है।

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

Answer 1

कोड: गणितज्ञ, आउटपुट: C, ~ 62.1518% (12674/20392)

मैंने सोचा कि मैं उन अजीब चरित्र शाब्दिकों के कारण C को एक कोशिश दूंगा। वर्तमान में यह एकमात्र ऐसी चीज़ है जिसका उत्तर देने की कोशिश की जा रही है, और यह काफी अच्छी तरह से काम कर रही है।

mathpack[n_] := Module[{versions, charLiteral},
   charLiteral = "'" <> StringReplace[Map[
        Switch[#,
          (*d_ /; d < 32,
          "\\" <> IntegerString[#, 8],*)
          10,
          "\\n",
          13,
          "\\r"
          39,
          "\\'",
          92 ,
          "\\\\",
          _,
          FromCharacterCode@#] &,
        FromDigits[#, 
           2] & /@ (Partition[PadLeft[IntegerDigits[n, 2], 32], 
            8] //. {{0 ..} .., x__} :> {x})
        ] <> "",
      {(*"\\10" -> "\\b",
       "\\11" -> "\\t",
       "\\13" -> "\\v",
       "\\14" -> "\\f",*)
       RegularExpression["(?!<=\?)\?\?(?=[=/()!<>-]|$)"] -> "?\\?"
       }
      ] <> "'";
   versions = {ToString@n, charLiteral};
   SortBy[versions, StringLength][[1]]
 ];

मुझे आशा है कि मैं कुछ भी याद नहीं करता था, लेकिन यह उत्तर बैकस्लैश, एकल उद्धरण चिह्नों और ट्रिग्राफ से बचना सुनिश्चित करता है। गैर-मुद्रण योग्य वर्णों के लिए ऑक्टल या अन्य एस्केप अनुक्रमों का उपयोग करने वाले कुछ कोड आउट किए गए हैं, लेकिन मुझे नहीं लगता कि यह वास्तव में आवश्यक है, क्योंकि सी को चरित्र शाब्दिक, afaik में किसी भी बाइट से निपटने में सक्षम होना चाहिए (कृपया मुझे सही करें 'मैं गलत हूं)।

अन्य सबमिशन के साथ, इस के साथ परीक्षण करें

input = StringSplit[Import["path/to/benchmark.txt"]];
numbers = ToExpression /@ input;
output = mathpack /@ numbers;
N[StringLength[output <> ""]/StringLength[input <> ""]]

Comments

(कम से कम मेरे सिस्टम पर) जीसीसी 10 ( \n) और 13 ( \r) को छोड़कर सिंगल कोट्स में किसी भी बाइट को स्वीकार करेगा । एक शून्य बाइट ठीक संकलित करेगा, लेकिन त्रुटि संदेश के साथ warning: null character(s) preserved in literal।

— r3mainer

@squeamishossifrage धन्यवाद, निश्चित!

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

Answer 2

कोड: गणितज्ञ, आउटपुट: जूलिया, ~ 98.9457% (20177/20392 बाइट्स)

optimise[n_] := 
  Module[{bits, trimmedBits, shift, unshifted, nString, versions, 
    inverted, factorised, digits, trimmedDigits, exponent, base, 
    xored, ored, anded},
   nString = ToString@n;
   versions = {nString};

   (* Try bitshifting *)
   bits = IntegerDigits[n, 2];
   trimmedBits = bits /. {x___, 1, 0 ..} :> {x, 1};
   shift = ToString[Length[bits] - Length[trimmedBits]];
   unshifted = ToString@FromDigits[trimmedBits, 2];
   AppendTo[versions, unshifted <> "<<" <> shift];

   (* Try inverting *)
   inverted = ToString@FromDigits[1 - PadLeft[bits, 32], 2];
   AppendTo[versions, "~" <> inverted];

   (* Try invert/shift/invert *)
   trimmedBits = bits /. {x___, 0, 1 ..} :> {x, 1};
   shift = ToString[Length[bits] - Length[trimmedBits]];
   unshifted = ToString@FromDigits[trimmedBits, 2];
   AppendTo[versions, "~(~" <> unshifted <> "<<" <> shift <> ")"];

   (* Try factoring *)
   factorised = Riffle[
      FactorInteger[n]
        /. {a_, 1} :> ToString@a
       /. {a_Integer, b_Integer} :> ToString[a] <> "^" <> ToString[b]
      , "+"] <> "";
   AppendTo[versions, factorised];

   (* Try scientific notation *)
   digits = IntegerDigits[n, 10];
   trimmedDigits = digits /. {x___, d_ /; d > 0, 0 ..} :> {x, d};
   exponent = ToString[Length[digits] - Length[trimmedDigits]];
   base = ToString@FromDigits[trimmedDigits, 10];
   AppendTo[versions, base <> "e" <> exponent];

   (* Don't try hexadecimal notation. It's never shorter for 32-bit uints. *)
   (* Don't try base-36 or base-62, because parsing those requires 12 characters for
      parseint("...") *)

   SortBy[versions, StringLength][[1]]
  ];

mathpack[n_] := 
 Module[{versions, increments},
  increments = Range@9;
  versions = Join[
    optimise[#2] <> "+" <> ToString@# & @@@ ({#, n - #} &) /@ 
      Reverse@increments,
    {optimise@n},
    optimise[#2] <> "-" <> ToString@# & @@@ ({#, n + #} &) /@ 
      increments,
    optimise[#2] <> "*" <> ToString@# & @@@ 
      Cases[({#, n / #} &) /@ increments, {_, _Integer}],
    optimise[#2] <> "/" <> ToString@# & @@@ ({#, n * #} &) /@ 
      increments
    ];
  SortBy[versions, StringLength][[1]]
 ];

फ़ंक्शन एक संख्या लेता है और सबसे छोटी स्ट्रिंग पाता है। वर्तमान में यह चार सरल अनुकूलन लागू होता है (मैं और अधिक कल जोड़ सकता हूं)।

आप इसे पूरी फाइल पर लागू कर सकते हैं (इसके स्कोर को मापने के लिए) इस प्रकार है:

input = StringSplit[Import["path/to/benchmark.txt"]];
numbers = ToExpression /@ input;
output = mathpack /@ numbers;
N[StringLength[output <> ""]/StringLength[input <> ""]]

ध्यान दें कि इनमें से कुछ अनुकूलन यह मानते हैं कि आप 64-बिट जूलिया पर हैं, जैसे कि पूर्णांक शाब्दिक int64रूप से आपको डिफ़ॉल्ट रूप से देते हैं। अन्यथा, आप 2 ³¹ से अधिक पूर्णांकों के लिए वैसे भी अतिप्रवाहित होंगे । उस धारणा का उपयोग करके हम कुछ अनुकूलन लागू कर सकते हैं जिनके मध्यवर्ती चरण वास्तव में 2 ³² से भी बड़े हैं ।

संपादित करें: मैं अनुकूलन ओपी के उदाहरण में सुझाव दिया बिटवाइज़ को जोड़ा गया XOR वैज्ञानिक अंकन में दो बड़ी संख्या (वास्तव में, सभी के लिए XOR , या और और )। ध्यान दें कि विस्तार xormap, ormapऔर andmap2 परे ऑपरेंड शामिल करने के लिए ³² हो सकता है मदद अतिरिक्त अनुकूलन की खोज है, लेकिन यह देखते हुए परीक्षण मामलों लिए काम नहीं करता और केवल 10 का एक पहलू की तरह कुछ द्वारा चलाए जा रहे समय बढ़ जाती है।

संपादित करें: मैंने अन्य 16 बाइट्स को काट दिया, सभी के n-9, n-8, ..., n+8, n+9लिए जाँच करके कि क्या उनमें से किसी को छोटा किया जा सकता है, इस मामले में मैंने उस संख्या के आधार पर प्रतिनिधित्व किया, जो अंतर को जोड़ या घटाता है। कुछ मामले हैं, जहां उन 18 नंबरों में से एक का प्रतिनिधित्व 3 या उससे अधिक वर्णों के साथ किया जा सकता nहै, जिस स्थिति में मैं अतिरिक्त अतिरिक्त बचत कर सकता हूं। सभी परीक्षण मामलों में इसे चलाने के लिए अब लगभग 30 सेकंड लगते हैं, लेकिन निश्चित रूप से, अगर कोई वास्तव में इस फ़ंक्शन का "उपयोग" करता है, तो वह इसे केवल एक ही नंबर पर चलाएगा, इसलिए यह अभी भी एक सेकंड के तहत अच्छी तरह से है।

संपादित करें: गुणा और भाग के लिए एक ही करके एक और अविश्वसनीय 4 बाइट्स। 50 सेकंड अब (विभाजित लोगों को उतना समय नहीं लगता है, क्योंकि मैं केवल इनकी जांच कर रहा हूं कि क्या संख्या वास्तव में ब्याज के कारक से विभाज्य है)।

संपादित करें: एक और अनुकूलन जो वास्तव में दिए गए परीक्षण सेट के साथ मदद नहीं करता है। यह एक बाइट को 2 ³⁰ या 2 ³¹ जैसी चीजों के लिए बचा सकता है । अगर हमारे पास इसके बजाय uint64s होते, तो बहुत सारी संख्याएँ होतीं जहाँ यह बहुत बड़ी बचत हो सकती है (मूल रूप से, जब भी बिट प्रतिनिधित्व 1s के बहुत में समाप्त होता है)।

संपादित करें: पूरी तरह से xor , या , और अनुकूलन को हटा दिया। मैंने अभी देखा कि वे जूलिया में भी काम नहीं करते हैं, क्योंकि (स्पष्ट रूप से) वैज्ञानिक संकेतन आपको एक फ्लोट देता है जहां बिट-वार ऑपरेटरों को भी परिभाषित नहीं किया जाता है। दिलचस्प बात यह है कि एक या एक से अधिक नए ऑप्टिमाइज़ेशन उन सभी मामलों को पकड़ने लगते हैं, जिन्हें इन ऑप्टिमाइज़ेशनों द्वारा छोटा किया गया था, क्योंकि स्कोर बिल्कुल भी नहीं बदला था।

Answer 3

J से C (अप्रयुक्त, लेकिन अधिकांश मामलों में काम करता है, एक आधारभूत उत्तर की तरह।)

    f=:(,~ (($&0) @: (8&-) @: (8&|) @: #)) @: #:
    g=:($~ ((,&8) @: (%&8) @: #))@:f
    toCString=:({&a.)@:#.@:g
    toCString 6382179
abc    

एक स्ट्रिंग शाब्दिक आउटपुट, जो यदि C में दर्ज किया गया है, संख्या का प्रतिनिधित्व करता है (जैसा कि ओपी में उल्लेख किया गया है)। यह एक गंभीर सबमिशन नहीं है, बल्कि अपने जे कौशल को मजबूत करने के लिए कुछ है, जो मुझे लगा कि मैं साझा करूंगा।

वैकल्पिक एक-लाइनर:

toCString=:({&a.) @: #. @: ($~ ((,&8) @: (%&8) @: #))@: (,~ (($&0) @: (8&-) @: (8&|) @: #)) @: #:

जब आप इसे इनपुट करते हैं तो J इसे बनाने की कोशिश करता है:

{&a.@:#.@:($~ ,&8@:(%&8)@:#)@:(,~ $&0@:(8&-)@:(8&|)@:#)@:#:

धन्यवाद एक गुच्छा, जे। इसके अलावा, जे के बारे में 'पता' में उन लोगों के लिए, अधिक जटिल कार्यों को बनाने के लिए विज़ियो चट्टानें:

Comments

चूँकि मैं इसमें से कोई भी नहीं पढ़ सकता हूँ: अगर चरित्र गैर-मुद्रण योग्य है, या यदि चरित्र है \ , ?या यह क्या करता है '?

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

@ m.buettner कुछ भी नहीं (अभी तक), मुझे अभी भी उसके लिए कुछ बनाना है

— buıʇǝɥʇuʎs

इसके बजाय m&u@:v, m u vकीमती पात्रों को बचाने और पठनीयता बढ़ाने के लिए उपयोग करें। अपने कोड को यह लागू करने पर हम पाते हैं f =: [: (,~ 0 $~ 8 - 8 | #) #:और g =: [: ($~ 8 ,~ # % 8:) fऔर अंत में toCString =: a. {~ [: #. g। सभी संयुक्त हम प्राप्त करते हैं a. {~ [: #. [: ($~ 8 ,~ # % 8:) [: (,~ 0 $~ 8 - 8 | #) #:, जो वास्तव में पढ़ना आसान है।

— FUZxxl