पॉल के साथ चिकन खाने के लिए पांच दोस्तों का पता लगाएं

Question

पॉल आपके बेल्जियम के परिचितों में से एक है, और वह आपको एक ऐसा प्रोग्राम बनाना चाहेगा, जो निम्न पांच स्ट्रैंथ में से कम से कम एक आउटपुट दे :

12496=>14288=>15472=>14536=>14264

14264=>12496=>14288=>15472=>14536

14536=>14264=>12496=>14288=>15472

15472=>14536=>14264=>12496=>14288

14288=>15472=>14536=>14264=>12496

यह उन दोस्तों का प्रतिनिधित्व करता है जिन पर उन्हें सबसे अधिक गर्व है, और वह उनके साथ भोजन करना चाहते हैं। पॉल यह भी सोचते हैं कि नंबर 6 सही है, और यह एकमात्र नंबर का उपयोग करने लायक है। इसलिए आप अपने कोड में "6" के अलावा किसी अन्य अंक का उपयोग नहीं कर सकते (0 से 5 और 7 से 9 निषिद्ध हैं)। आपका प्रोग्राम कोई इनपुट नहीं ले सकता। आउटपुट में स्ट्रिंग से पहले और / या बाद में कचरा हो सकता है लेकिन इसमें उपरोक्त स्ट्रिंग्स में से कम से कम एक होना चाहिए।

उदाहरण के लिए यह एक मान्य आउटपुट है:

220frefze
f**14288=>15472=>14536=>14264=>12496**fczfe fz**15472=>14536=>14264=>12496=>14288**zfe
fzehth

मैंने "ligthly" सवाल में संकेत दिया कि कैसे मैं यह हल करने की उम्मीद करता हूं, लेकिन कैसे जानता है? शायद एक बेहतर तरीका है ... आशा है कि आप मज़े करेंगे।

यह कोड-गोल्फ है: बाइट्स जीत में सबसे कम स्कोर।

Comments

संबंधित OEIS अनुक्रम।

— एमिगा

मैं यह पता नहीं लगा सकता कि पॉल या मुर्गियों का इससे क्या लेना-देना है।

— मैजिक ऑक्टोपस Urn

@carusocomputing: मिलनसार श्रृंखला '12496 => 14288 => 15472 => 14536 => 14264 " पॉल पॉलेट द्वारा 1918 में (एक बेल्जियम के गणितज्ञ) और" पौलेट "का अर्थ फ्रेंच में" चिकन "मिला। 6 भी एक है। इस अर्थ में सही संख्या कि उसके भाजक का योग 6. है

— जाइलो

रुको, तो एक मैन्केन ने 1918 में संख्याओं का एक क्रम पाया ... और हम पॉल नाम के गणितीय मैन्केन की तुलना में संख्या अनुक्रम के बारे में अधिक परवाह करते हैं?

— मैजिक ऑक्टोपस Urn

@ डेनिस, अच्छी तरह से यह सच है, मैं एक शानदार 4 बाइट के जवाब की उम्मीद नहीं कर रहा था, आप हमेशा आश्चर्यचकित होते हैं: पी मैंने इस नियम को जोड़ा क्योंकि मुझे उम्मीद थी कि अगर कोई पूर्णांक से अधिक पुनरावृत्ति कर रहा था और सभी पाया विश्वसनीय आउटपुट कर रहा था पहले एक जटिल संख्या को हार्ड कोडिंग के बिना चेन। लेकिन अंत में यह बहुत ही बेस रूपांतरण, और गैर गोल्फ भाषा में भी चरित्र रूपांतरण का पक्ष लेता है। मुझे लगता है कि डिजाइनिंग प्रश्न वास्तव में कठिन है! फिर भी, एनिग्मा ने आउटपुट की संपत्ति का इस्तेमाल किया और उसका अब तक का उच्च स्कोर है :)

— ज्योलो

Answer 1

05AB1E , 18 17 बाइट्स

•w[•Y·FDѨO})„=>ý

इसे ऑनलाइन आज़माएं!

व्याख्या

•w[•                # base 214 encoding of 12496
    Y·F             # loop 2*2 times
       D            # duplicate top of stack
        Ñ           # push divisors
         ¨          # remove the last element (itself)
          O         # sum
           }        # end loop
            )       # wrap in list
             „=>ý   # join list on "=>"

संक्षेप में, हम प्रत्येक संख्या की गणना करते हैं f(n+1) = sum(divisors(f(n)) - f(n)

Answer 2

पाइके, 16 बाइट्स

wヰw$VDlsh)J"=>

यहाँ यह कोशिश करो!

wヰ             -  12496
  w$            -   4
    V    )      -  repeat ^:
     D          -   duplicate(^)
      l         -     factors(^)
       s        -    sum(^)
        h       -   ^ + 1
          J     - v.join(^)
           "=>  -  "=>"

कभी भी एक स्ट्रिंग शाब्दिक एक कार्यक्रम के अंत में होता है, इसे टोकन से स्वैप करता है इसके ठीक पहले, इस तरह के मामलों में 1 बाइट की बचत होती है। Pyke के factorsसमारोह संख्या में ही है और न ही शामिल नहीं है 1. यदि संख्या की अनुमति दी गई, 1 बाइट की जगह द्वारा बचाया जा सकता है w$के साथ4

पाइके, 21 बाइट्स

uバ㟐㱰㣈㞸J"=>

यहाँ यह कोशिश करो!

आवश्यक संख्याओं की एक सूची बनाएं और उनमें शामिल हों। तार के साथ चाल के अलावा बहुत दिलचस्प नहीं है।

Answer 3

MATLAB, 44 बाइट्स

['','=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@'-6-6]

इसे ऑनलाइन आज़माएं!

मुझे संख्याओं में एक पैटर्न नहीं मिला है (और वैसे भी पैटर्न का उपयोग करना कठिन होगा, क्योंकि मैं संख्याओं का उपयोग नहीं कर सकता), इसलिए मैं सिर्फ भोले दृष्टिकोण के लिए जाऊंगा।

'=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@'वह स्ट्रिंग है '12496=>14288=>15472=>14536=>14264'जब 12 ASCII-मानों में जोड़ा जाता है। अब, उस स्ट्रिंग को इनपुट करें, घटाएं 6+6, और खाली स्ट्रिंग के साथ ''उसे वर्ण सरणी में बदलने के लिए संक्षिप्त करें।

Comments

हाँ, क्षमा करें, मैं संख्या की हार्ड कोडिंग को रोकना चाहता था, लेकिन यह निश्चित रूप से 'गोल्फ' भाषा को बढ़त देता है। कोई भी पैटर्न नहीं है, हालांकि प्रत्येक संख्या पिछले एक के भाजक का योग है।

— 15

मैं जिस तरह से कोडित स्ट्रिंग अभी भी शामिल है =>।

— नील

Answer 4

जावास्क्रिप्ट (ES6), 57 बाइट्स / 47 (UTF-8) अक्षर

10 बी सेव के लिए user5090812 का धन्यवाद

_=>[...'バ㟐㱰㣈㞸'].map(a=>a.charCodeAt()).join`=>`

व्याख्या

पहले हम एक सरणी बनाते हैं और इसे स्ट्रिंग में वर्णों के साथ भरते हैं バ㟐㱰㣈㞸। फिर हम स्ट्रिंग पर लूप करते हैं ( aवर्तमान तत्व का मूल्य है) और हम चरित्र को इसके चरित्र कोड में बदलते हैं। फिर हम सरणी में सभी मानों को जोड़ते हैं=> ।

पुराना: 67 बाइट्स

_=>[6,6,6,6,6].map((_,a)=>`バ㟐㱰㣈㞸`.charCodeAt(a)).join`=>`

व्याख्या

पहले हम लंबाई की एक सरणी बनाते हैं। 5. फिर हम स्ट्रिंग में उसी सूचकांक पर वर्ण के वर्ण कोड के लिए प्रत्येक सूचकांक में सरणी के मूल्यों को बदलते バ㟐㱰㣈㞸हैं, जो क्रम में पॉल के सभी दोस्तों की संख्या है। जब हमें वह मिल गया, तो हम सरणी को एक साथ जोड़ते हैं, और हम =>विभाजक के रूप में उपयोग करते हैं ।

प्रयोग

इसका उपयोग करने के लिए, बस इसे चलाएं:

f=_=>[...'バ㟐㱰㣈㞸'].map(a=>a.charCodeAt()).join`=>`;alert(f())

उत्पादन

12496=>14288=>15472=>14536=>14264

Comments

कैसे के बारे में _ => [... 'バ _ 㣈 㞸]']] .map (s => s.charCodeAt ())। Join करें = = - `

— user5090812

@ user5090812 सुझाव के लिए धन्यवाद!

— ल्यूक

Answer 5

रूबी, 36 बाइट्स (26 अक्षर)

p"バ㟐㱰㣈㞸".unpack("U*")*"=>"

क्योंकि, क्यों नहीं। नरक के रूप में बोरिंग।

पुराने संस्करण - 53 बाइट्स

p %w(jol mld oim n6b mke).map{|x|x.to_i ~-6*~-6}*'=>'

स्पष्टीकरण: संख्याओं को आधार २५ में समाहित करने से ५ छह-मुक्त तार मिलते हैं, उन्हें डिकोड करने के लिए मुझे केवल २५ का प्रतिनिधित्व करते हुए केवल ६: (६-१) (६-१) => ~ -६ ~ -६ का उपयोग करना होगा

Comments

मैं यूटीएफ 8 के साथ 36 बाइट्स गिनता हूं, 26 नहीं।

— स्मेल करता है

मुझे लगता है कि उसने पात्रों को गिना है, न कि बाइट्स। मैं हमेशा बाइट काउंट के लिए इस साइट का उपयोग करता हूं ।

— ल्यूक

अब गिनती सही।

— जीबी

Answer 6

पर्ल 6 , 63 59 बाइट्स

{$/=6;$/--;join "=>",<JOL MLD OIM N6B MKE>».parse-base($/*$/)}

{join "=>",<JOL MLD OIM N6B MKE>».parse-base(--($_=6)*$_)}

आधार संख्या को 25 से घटाता है, क्योंकि यह एकमात्र आधार है जो .parse-base(2 से 36) द्वारा समर्थित है, जहाँ उनमें से किसी के भी अवैध अंक नहीं हैं।

-3 बाइट्स के लिए नील को धन्यवाद।

पर्ल 6 , 82 75 बाइट्स

{my \a="BXS".parse-base(6*6);join "=>",(a,{sum grep $_%%*,^$_}...^{$_==a if $++})}

{my \a="BXS".parse-base(6*6);join "=>",({$/=$_//a;sum grep $/%%*,^$/}...a)}

15472बेस 36 में संख्या को घटाता है , और फिर प्रत्येक संख्या को पिछली संख्या के उचित विभाजक के योग के रूप में गणना करके अनुक्रम उत्पन्न करता है।

पर्ल 6 , 69 बाइट्स (47 अक्षर) - नॉनकमेटिंग

{"{١٢۴۹6}=>{١۴۲۸۸}=>{١۵۴۷۲}=>{١۴۵۳6}=>{١۴۲6۴}"}

किसी भी निषिद्ध ASCII अंकों का उपयोग नहीं करता है, इसके बजाय अरबी-इंडिक ब्लॉक से यूनिकोड अंकों का उपयोग करता है (प्रत्येक 2 बाइट्स)! { }स्ट्रिंग छेड़छाड़ सुनिश्चित करें कि वे पर्ल 6 नंबर शाब्दिक रूप में पार्स कर रहे हैं, और उसके बाद उनके ASCII अभ्यावेदन के लिए stringified बनाते हैं।

ठीक है, यह धोखा है - यही कारण है कि मैंने इसे अपने मुख्य उत्तर के रूप में उपयोग नहीं किया ... :)

Comments

चूँकि मैं आसानी से एक पर्ल 6 दुभाषिया तक नहीं पहुँच पाता, क्या यह लिखने का काम करता है --$/*$/?

— नील

@ नील: यह करता है। धन्यवाद! वास्तव में, यह काम भी करता है अगर मैं असाइनमेंट को इनलाइन करता हूं, जैसे --($/=6)*$/)।

— 17:00

Answer 7

जेली , 5 4 बाइट्स

ȷṗȷỌ

सभी पाँच तार प्रिंट करता है। इस तथ्य का लाभ उठाता है कि "कचरा" आउटपुट की अनुमति है और आउटपुट के 10 ³⁰⁰³ वर्णों में पांच तारों को दबा देता है ।

यह काम किस प्रकार करता है

ȷṗȷỌ  Main link. No arguments.

ȷ     Set the return value to 1000.
 ṗȷ   Cartesian power; form all arrays of length 1000 that consist of integers in
      [1, ..., 1000].
   Ọ  Unordinal; convert all integers to characters.

Comments

आउटपुट के भीतर आवश्यक स्ट्रिंग की बाइट ऑफसेट क्या है?

— नील

क्या किसी भी आवश्यक तार का समर्थन करने के लिए कोई सबूत है जो वास्तव में मुद्रित है?

— को आउटगोल्फ

@Neil चरित्र ऑफसेट 48049051056053060061048051049055055060061048052051054049060061048051052050053060061048051049053051000 होना चाहिए । बाइट्स के बारे में निश्चित नहीं है।

— डेनिस

@EriktheOutgolfer अगर वास्तव में आप उचित समय और स्मृति बाधाओं के साथ मतलब है, तो नहीं। चुनौती हालांकि किसी भी सीमा को निर्दिष्ट नहीं करती है, और वे डिफ़ॉल्ट रूप से असीमित हैं।

— डेनिस

@ डेनिस नहीं, मेरा मतलब है। बेशक यह निहित है कि यह जल्द ही कभी भी अपना काम खत्म नहीं करेगा। कोड को देखते हुए, हालांकि, मुझे लगता है कि यह वास्तव में उन तार में से किसी को भी प्रिंट करने की संभावना नहीं है। तब, फिर से, मैंने कुछ उचित प्रमाण के बारे में सोचा ...

— एरिक आउटगॉल्फर

Answer 8

सी, 94 84 77 बाइट्स

मूर्ख सरल। विशेष धन्यवाद @ नील

g(){char*m="!mnpuryzmpnttyzmqpsnyzmpqoryzmpnrp";for(;*++m;)putchar(*m-66+6);}

f () {प्रिंटफ ("% d =>% d =>% d =>% d =>% d", '~' 'r' - 'd', '~' 'd' - 'h', ' ~ ~ ' र ’-' ल’, ’~’ + z ’+ 'd’, ~ ~ ’* t t’ -} P ’);};

Comments

कम से कम विचारधारा पर, आप एक बाइट को बचाने char*mके for()लिए अंदर ले जा सकते हैं , और यह फ़ंक्शन को पुन: प्रयोज्य (कार्यों की आवश्यक स्थिति) भी बनाता है। इसके अलावा, आप एक अनुगामी नल का उत्पादन करते हैं; *++mउसे ठीक कर देंगे। इसके अलावा, आप 66 के बजाय 60 घटाकर कुछ बाइट्स बचा सकते हैं g(){for(char*m="!mnpuryzmpnttyzmqpsnyzmpqoryzmpnrp";*++m;)putchar(*m-66+6);}:।

— नील

या आप MATLAB उत्तर से दृष्टिकोण की प्रतिलिपि बना सकते हैं, जो उस के शीर्ष पर एक और बाइट को बचाएगा।

— नील

@ मेरे संकलक मुझे लूप के अंदर की घोषणा नहीं करने देंगे initial declaration used outside C99 modeलेकिन मैं पुचर को सरल बनाने के लिए खुश हूं। धन्यवाद!

— क्लेब्लांक

Answer 9

PHP, 73 63 60 बाइट्स

for(;$c="|`*X6H-$*@"[$i];)echo!!$i&++$i?"=>".!!6:"",ord($c);

के साथ चला -nr।

थोड़ा कम आलसी: की सूची के रूप में स्ट्रिंग ले लिया =>1(ascii)(ascii)
अर्थात्: 124, 96, =>1, 42, 88, =>1, 54, 72, =>1, 45, 36, =>1, 42, 64, स्ट्रिंग इंडेक्स द्वारा
प्रिंट करें =>1, एएससीआई कोड जोड़ें

टूट - फूट

            # loop through string with index $i
for(;$c="|`*X6H-$*@"[$i];)echo
            # string ascii values: 124,96,42,88,54,72,45,36,42,64
    !!$i        # true if $i>0
    &++$i       # odd if (old) $i is 0,2,4,6,8
                # -> true for 2,4,6,8
        ?"=>".!!6   # if true, print "=>1"
        :"",        # else print nothing
    ord($c);    # print ascii value

Answer 10

सी ++, 92 बाइट्स

#include <cstdio>
int main(){for(char c:"UVX]ZabUXV\\abUYX[VabUXYWZabUXVZX")putchar(c-6*6);}

Answer 11

PHP, 53 बाइट्स

<?=join('=>',unpack('v*',gzinflate('�`p������s')));

हेक्स डंप:

00000000: 3c3f 3d6a 6f69 6e28 273d 3e27 2c75 6e70  <?=join('=>',unp
00000010: 6163 6b28 2776 2a27 2c67 7a69 6e66 6c61  ack('v*',gzinfla
00000020: 7465 2827 bb60 70c1 bcc0 e684 c50e 7300  te('.`p.......s.
00000030: 2729 2929 3b                             ')));

आउटपुट:

12496=>14288=>15472=>14536=>14264

स्पष्टीकरण:

पाँच-अंकीय पूर्णांक वर्गों में से प्रत्येक को एक अहस्ताक्षरित छोटे से छोटे अंतिका के रूप में एन्कोड किया गया है, फिर एक साथ सम्‍मिलित किया गया है और परिणाम gzipped है। यह एक बाइट स्टीम का उत्पादन करने के लिए होता है, जिसमें कोई अपमानजनक अंक वर्ण नहीं होता है, जो तब एक स्ट्रिंग में हार्ड-कोडित होता है। निकालने के लिए, स्ट्रीम को अन-गज़िप करें, दो-बाइट शॉर्ट्स को अनपैक करें, प्रत्येक को एक स्ट्रिंग के रूप में व्याख्या करें और साथ जुड़ें >=।

Comments

कैसे टूटने के बारे में?

— टाइटस

Answer 12

जावा 8, 134 बाइट्स

golfed:

()->{String s="";for(String a:new String[]{"JOL","MLD","OIM","N6B","MKE"}){if(!s.isEmpty())s+=("=>");s+=Long.valueOf(a,25);}return s;}

Ungolfed, पूरा कार्यक्रम:

import java.util.function.*;

public class FindFiveFriendsToEatChickenWithPaul {

  public static void main(String[] args) {
    System.out.println(toString(() -> {
      String s = "";
      for (String a : new String[] { "JOL", "MLD", "OIM", "N6B", "MKE" }) {
        if (!s.isEmpty()) s += ("=>");
        s += Long.valueOf(a, 25);
      }
      return s;
    }));

  }

  private static String toString(Supplier<String> s) {
    return s.get();
  }

}

Answer 13

बैच, 191 बाइट्स

@set/as=n=66*(66+66+66+6*6)+66/6+66/6+6,u=6/6
@call:t
@call:t
@echo %s: ==^>%
@exit/b
:t
@call:c
:c
@for /l %%i in (%u%,%u%,%n%)do @set/an-=%%i*!(%n%%%%%i)
@set/an=-n
@set s=%s% %n%

मेरा अनुमान है कि 6इन सभी को प्रिंट करने के लिए केवल एस प्लस एक और 32 का उपयोग करके प्रत्येक संख्या की गणना करने में न्यूनतम 32 बाइट्स लगेंगे , जो कि पहले से ही 192 बाइट्स हैं, इसलिए मैं एमिकेबल चेन की गणना करके जीत रहा हूं। इसके अलावा, मुझे लगता है कि %एक पंक्ति में पाँच एस मेरे लिए एक रिकॉर्ड है। इसके अलावा, स्वच्छ बैच चाल: लूप का मूल्यांकन करने %n%से पहले प्रतिस्थापित forकिया जाता है, इसलिए लूप सभी कारकों की गणना करता है n, और उन्हें इससे घटाता है n, जिसके परिणामस्वरूप वांछित परिणाम की उपेक्षा होती है।

Answer 14

जेली , 12 बाइट्स

“<ọ’ÆṣÐĿj“=>

चौथी स्ट्रिंग प्रिंट करता है और कुछ नहीं।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

“<ọ’ÆṣÐĿj“=>  Main link. No arguments.

“<ọ’          Yield the 1-based indices of '<' and 'ọ' in Jelly's code page, i.e.,
              [61, 222], and convert the array from base 250 to integer.
              This yields 15472.
      ÐĿ      Iteratively call the link to the left until the results are no longer
              unique and return the array of all unique results.
    Æṣ        Compute the proper digit sum of the previous value (initially 15472).
        j“=>  Join, separating by the string "=>".

Answer 15

पायथन 2, 78 72 बाइट्स

print''.join(chr(ord(x)-6-6)for x in'=@>DDIJ=A@C>IJ=@A?BIJ=@>B@IJ=>@EB')

संपादित करें - स्टेवी ग्रिफिन के लिए धन्यवाद 6 बाइट्स बचाने लिए !

इसके अलावा, एक अन्य समाधान सभी संभव क्रमपरिवर्तन का उत्पादन करना होगा। ओपी कहते हैं कि कचरा ठीक है।

from itertools import permutations
print str(list(permutations(''.join(str(x)+'.'for x in range(int('9'*5)).replace(',','').replace('\'','') 
# also 9 and 5 need to be converted using ord and chr

से intया में परिवर्तित करने में बहुत अधिक अतिरेक listहै str। मुझे लगता है कि यह कुछ गूढ़ भाषाओं में आसान होगा, लेकिन मुझे पता है कि उनमें से कोई भी नहीं है।

Comments

क्या आप 12 के बजाय 66 जोड़ सकते हैं? इससे एक और बाइट बच जाएगी।

— जीबी

यह सामान्य ASCII- श्रेणी @GB से बाहर चला जाएगा, जिसका अर्थ है कि आपको प्रति वर्ण दो बाइट्स गिनना होगा।

— स्टीवी ग्रिफिन

मैं देखता हूं, मैंने '=>' वर्णों की गणना नहीं की है।

— जीबी