52

एक संख्या n (0 <= n <= 2642245) को देखते हुए , अगर n और n ³ में अंकों का समान सेट है, और तदनुसार एक सत्य या गलत मान का उत्पादन करें।

उदाहरण के लिए, चलो 100 नंबर की जांच करते हैं।

100 ³ 1000000 है।

100 में अंकों का सेट {0, 1} है।

1000000 में अंकों का सेट {0, 1} है।

इसलिए, 100 को एक सत्य मूल्य देना चाहिए।

परीक्षण के मामलों

0 -> True
1 -> True
10 -> True
107624 -> True
251894 -> True
251895 -> False
102343 -> False

याद रखें, यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स वाला कोड जीत जाता है।

OEIS A029795

code-golf number decision-problem

— ओलिवर नी
स्रोत

28

प्रस्तावित परीक्षण मामला: 106239

— डेनिस

8

टेस्ट मामला: 2103869 -> True। यह (या एक बड़ा) एक longडेटाटाइप के साथ एक भाषा का परीक्षण करने के लिए आवश्यक है ।

— mbomb007

5

बहुत खराब अधिकतम 64 बिट पूर्णांक प्रकार के बिना भाषा के लिए बहुत बड़ा है।

— edc65

17

मुझे लगता है कि आपको आधार के बारे में स्पष्ट होना चाहिए ... द्विआधारी में यह आधा मज़ेदार है :

— वी

7

@ ZoltánSchmidt 106239 सबसे छोटा धनात्मक पूर्णांक n है जो n³ - 1199090390129919 - n के सभी अंकों को समाहित नहीं करता है । अगर कुछ जवाब ही देख रहे हों एन के सभी अंक निहित n³ है और इस तरह के लिए गलत परिणाम मिला 106,239 ।

— डेनिस

28

पायथन 3, 36 32 बाइट्स

lambda x:{*str(x)}=={*str(x**3)}

मुझे लगता है कि यह केवल पायथन 3.5 और बाद में काम करता है। कॉपर के लिए चार बाइट्स चले गए हैं।

— 0WJYxW9FMN
स्रोत

8

अजगर 2 में आप रीपी () के लिए शॉर्टकट के रूप में 6 बाइट्स बचाकर उपयोग कर सकते हैं। set(`x`)

— डेनडेनडो

9

@DenDenDo यदि आप उपयोग करते हैं तो 2097152( sys.maxint**(1/3.)) और उससे कम कोई भी इनपुट sys.maxint+1वापस आ जाएगा । repl.it/EXs2/1 । लोंगों के अंत में होता है। Falserepr()L

— mbomb007

9

अनटाइटेड, लेकिन आप शायद lambda x:{*str(x)}=={*str(x**3)}पायथन 3.5+ में कर सकते हैं ।

— कॉपर

1

@BenHoyt यह प्रिंट (...) और इनपुट () का उपयोग करने की तुलना में अधिक संक्षिप्त है। इसे एक फंक्शन बनाना पूर्ण प्रोग्राम बनाने से कम है।

— 0WJYxW9FMN

1

क्योंकि सवाल लौटने एक truthy या falsy मूल्य के लिए पर्याप्त है कहते हैं, आप की जगह ले सकता ==से ^। दो समान सेट लीड के लिए {}मिथ्या है।

— रेमकोगर्लिच

19

05AB1E , 6 बाइट्स

05AB1E CP-1252 एन्कोडिंग का उपयोग करता है ।

3mê¹êQ

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

व्याख्या

3m       # input^3
  ê      # sorted with duplicates removed
     Q   # is equal to
   ¹ê    # input sorted with duplicates removed

— Emigna
स्रोत

1

@PuzomorCroatia: 05AB1E CP-1252 एन्कोडिंग का उपयोग करता है , इसलिए ये सभी वर्ण 1 बाइट हैं। गोल्फ भाषाओं के लिए यूटीएफ -8 की तुलना में अधिक मुद्रण योग्य पात्रों के साथ कोड पृष्ठों का उपयोग करना या वैकल्पिक रूप से अपना स्वयं का कोड पृष्ठ बनाना काफी आम है।

— एमिगा

7

जवाब के लिए धन्यवाद। दुर्भाग्य से, मेरी टिप्पणी को संपादित करने की कोशिश करते हुए, मैंने इसे हटा दिया। बस हर किसी के लिए चीजों को स्पष्ट करने के लिए, मैंने कोड गोल्फिंग भाषाओं में पात्रों के एन्कोडिंग के बारे में पूछा

— पुजोमोर क्रोएशिया

14

सी, 73 बाइट्स

k;b(i){k=0;while(i)k|=1<<i%10,i/=10;return k;}f(n){return b(n)-b(n*n*n);}

बिट्स के माध्यम से सेट बनाता है। 0एक ही सेट के लिए रिटर्न , अलग सेट के लिए कुछ और।

Ungolfed:

k;
b(i){
  k=0;
  while(i)
    k|=1<<i%10,
    i/=10;
  return k;
}

f(n){
  return b(n)-b(n*n*n);
}

— कार्ल नेफ
स्रोत

1 <<बिट्स को सेट करने के दौरान ungolfed कोड गायब है k |= 1 << i % 10। महान समाधान!

— 1Darco1

1

मैंने 39 बिट बाइट x86-64 मशीन कोड फंक्शन बनाने के लिए इस बिटमैप विचार का उपयोग किया है :)

— पीटर कॉर्डेस

क्या हमें 0सत्य मानने की अनुमति है ? मुझे लगता strcmpहै कि इस तरह से काम करता है, इसलिए यह सी में उचित लगता है

— पीटर कॉर्डेस

1

यह केवल int64-बिट से बड़ा होने पर प्रश्न द्वारा आवश्यक इनपुट की पूरी श्रृंखला के लिए काम करता है । (यहां तक कि हस्ताक्षर किए गए 64-बिट पर्याप्त नहीं है, लेकिन 64-बिट अहस्ताक्षरित है)। इसलिए सी का कोई वास्तविक कार्यान्वयन नहीं है कि मुझे पता है कि यह सवाल की आवश्यकताओं को पूरा करता है। (यह ठीक से काम करता है unsigned long long, या सिर्फ unsigned longकार्यान्वयन में जहां यह 64-बिट प्रकार है)। जीएनयू सी __int128_t64-बिट मशीनों (बिना किसी हेडर के) को परिभाषित करता है ...

— पीटर कॉर्डेस

8

पर्ल, 31 + 2 ( `-pl`ध्वज) = 25 21 18 34 33 बाइट्स

$_=($==$_**3)!~/[^$_]/*!/[^$=]/

का उपयोग करते हुए:

perl -ple '$_=($==$_**3)!~/[^$_]/*!/[^$=]/' <<< 251894

आउटपुट: 1\nया 0\n।

3 बाइट्स के लिए @ दादा से, 1 बाइट के लिए गेब्रियल बेनामी, और बग रिपोर्ट के लिए @ ज़ेडड।

— डेनिस इबाव
स्रोत

1

अच्छा जवाब! आप अभी भी कुछ (3) बाइट्स बचा सकते हैं:perl -pe '$_=$_**3!~/[^$_]/'

— दादा

@ ज़ेड थांक्स। फिक्स्ड।

— डेनिस इबाएव

अब यह झूठा उत्पादन करता है 10:(

— ज़ेड

@ जैद हां। -lझंडा चाहिए।

— डेनिस इबाएव

2

बाइट बचाने के &&लिए ए में बदलें*

— गेब्रियल बेनामी

7

गणितज्ञ, 34 बाइट्स

f=Union@*IntegerDigits;f@#==f[#^3]&

प्रत्यक्ष कार्यान्वयन (एक पूर्णांक तर्क का अनाम कार्य)।

— ग्रेग मार्टिन
स्रोत

7

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

,3*\D‘ṬE

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

,3*\D‘ṬE  Main link. Argument: n

,3        Pair; yield [n, 3].
  *\      Cumulative reduce by exponentation. Yields [n, n³].
    D     Decimal; yield the digit arrays of n and n³.
     ‘    Increment, mapping 0 ... 9 to 1 ... 10.
      Ṭ   Untruth (vectorizes); map digit array [a, b, c, ...] to the smallest
          of zeroes with ones at indices a, b, c, ...
       E  Test the results for equality.

— डेनिस
स्रोत

6

सीजेएम, 8 बाइट्स

l_~3#s^!

परीक्षण सूट।

व्याख्या

l   e# Read input.
_~  e# Duplicate and evaluate.
3#  e# Raise to third power.
s   e# Convert back to string.
^   e# Symmetric set difference. Gives an empty list iff the two sets
    e# are equal.
!   e# Logical NOT.

— मार्टिन एंडर
स्रोत

6

जावास्क्रिप्ट ईएस 6, 55 51 बाइट्स

3 बाइट्स के लिए डाउनगेट का धन्यवाद! आप ईएस 7 को परिवर्तित करके और n**3इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं n*n*n।

n=>(f=s=>[...new Set(s+[])].sort()+[])(n)==f(n*n*n)

काफी सरल।

— कोनोर ओ ब्रायन
स्रोत

यह भयानक है कि तुल्यता के लिए सेट की तुलना करने के लिए एक अच्छा तरीका नहीं है

— njzk2

1

@ njzk2 अच्छा, मैं कहूंगा कि बड़ी त्रासदी यह है कि ==सरणियों पर भी काम नहीं करता है।

— कॉनर ओ'ब्रायन

आप को बदलने के द्वारा एक बाइट बचा सकते हैं n*n*nकरने के लिए n**3है, लेकिन मुझे लगता है कि कि ES7 और नहीं ES6 हो सकता है।

— रॉबर्ट हिकमैन

1

@Downgoat धन्यवाद, जिसने मुझे कुछ और बाइट्स बचाने के लिए प्रेरित किया!

— कॉनर ओ'ब्रायन

3

इसके लिए विफल रहता है 2103869, और समस्या को स्पष्ट रूप से काम करने के लिए समाधान की आवश्यकता होती है 2642245।

— 14:50 बजे user5090812

6

सी #, 241 208 205 201 193 233 222 220 212 203 177 159 बाइट्स (109 वैकल्पिक)

I=>{x=s=>{var a=new int[10];foreach(var h in s+"")a[h-'0']++;return a;};var i=x(I);var j=x(I*I*I);for(var k=0;k<10;)if(i[k]>0^j[k++]>0)return 0>1;return 1>0;};

मेमने को विशेष रूप से ulongप्रकार का उपयोग करना चाहिए :

System.Func<ulong, bool> b; // = I=>{...};
System.Func<ulong, int[]> x; // inner lambda

कुछ मूल बाइट को बचाने के लिए @ कोरक और @ डेनिस_ई, और मेरे मूल समाधान के साथ एक समस्या खोजने के लिए @TimmyD का धन्यवाद। Ulong / long / दशमलव / etc समस्या की ओर इशारा करने के लिए @SaxxonPike (जिसने वास्तव में मुझे कुछ बचे भी बचाया) के लिए धन्यवाद।

जावा के जवाब के समान हैशसेट का उपयोग करते हुए 109 बाइट का समाधान भी है, लेकिन मैं अपने स्कोर के मूल समाधान पर टिकने जा रहा हूं।

using System.Collections.Generic;I=>{return new HashSet<char>(I+"").SetEquals(new HashSet<char>(I*I*I+""));};

— Yodle
स्रोत

क्या आप p<0इसके बजाय जांच कर सकते हैं p==1?

— यति

@TuukkaX ने ऐसा किया होगा, लेकिन जिस तरह से मैं अब सेटों का निर्धारण कर रहा हूं, पूर्णांक की एक ही सरणी का उपयोग कर रहा है, दोनों तारों के लिए उपयुक्त सूचकांक को बढ़ाता है, इसलिए 0 या 2 का मान ठीक है, लेकिन यदि कोई 1 है यह गलत होना चाहिए।

— योडल

रचना को निकालने और एक अलग मेमने में सरणियों को भरने से बहुत कम बचाएं:

n=>{Func<string,int[]>x=s=>{var a=new int[10];foreach(var c in s)a[int.Parse(c+"")]++;return a;};var i=x(n);var j=x((long)Math.Pow(int.Parse(n),3)+"");for(var k=0;k<10;)if(i[k]>0^j[k++]>0)return 0>1;return 1>0;};

— कोरक

आप बदल सकते हैं int.Parse(c+"")के साथc-'0'

— Dennis_E

फेल परीक्षण केस 2103869। मैं एक ही मुद्दे में भाग गया। (कोई बात नहीं, मुझे पता चला कि मैंने ऐसा क्यों किया है। मैं longइसके बजाय ulongएमएसबी का उपयोग करता

— हूं

6

जावा 8, 154 वर्ण

a->java.util.Arrays.equals((a+"").chars().distinct().sorted().toArray(),(new java.math.BigInteger(a+"").pow(3)+"").chars().distinct().sorted().toArray());

इस तरह कहा जाता है:

interface Y {
    boolean n(int x);
}

static Y y = a->java.util.Arrays.equals((a+"").chars().distinct().sorted().toArray(),(new java.math.BigInteger(a+"").pow(3)+"").chars().distinct().sorted().toArray());

public static void main(String[] args) {
    System.out.println(y.n(0));
    System.out.println(y.n(1));
    System.out.println(y.n(10));
    System.out.println(y.n(107624));
    System.out.println(y.n(251894));
    System.out.println(y.n(251895));
    System.out.println(y.n(102343));
}

आउटपुट:

true
true
true
true
true
false
false

एक बहुत ही जावा 8-वाई उत्तर, एक लैम्ब्डा के साथ-साथ कुछ फैंसी नंबर-टू-स्ट्रिंग रूपांतरण सहित धाराओं का उपयोग करता है।

दुर्भाग्य से हमें गैर-सटीक डबल्स का उपयोग करके Math.pow BigInteger.pow(3)के Math.pow(a,3)कारण उपयोग करने की आवश्यकता होती है , जो बड़ी संख्याओं के साथ गलत मान लौटाते हैं (शुरुआत के साथ 2103869)।

— Hypino
स्रोत

यह static Y yबात एक अजीब प्रारंभिक सिंटैक्स है, क्या यह ऑटोइज़ाइन करता है y.nक्योंकि इंटरफ़ेस में बिल्कुल एक सदस्य है?

— बिल्ली

मुझे विश्वास है, हाँ। ईमानदार होने के लिए मैं जावा 8 के लिए नया हूँ क्योंकि मेरा कार्यस्थल अभी भी 7 पर है, लेकिन मुझे लगता है कि मुझे यह काम करना है।

— हाइपिनो

संकलक स्वचालित रूप से @FunctionalInterfaceएनोटेशन (केवल एक विधि के साथ इंटरफ़ेस, जवादॉक देखें) जोड़ता है जो सामान्य अनाम प्रकार के बजाय लैम्बडा को काम करता है।

— दार्को 1

यह अनिवार्य रूप से बराबर है

Y y = new Y() { @Override public boolean n(int x) { return Arrays.equals((a+"").chars().distinct().sorted().toArray(),(new BigInteger(a+"").pow(3)+"").chars().distinct().sorted().toArray()); } }

और staticसंशोधक केवल y.n(int)स्थैतिक मुख्य विधि से कॉल करने की अनुमति देने के लिए है ।

— तारकोल १

1

कोई बात नहीं, बस इस बारे में मेटा पोस्ट पढ़ें और ऐसा लगता है कि समुदाय इससे सहमत है। मुझे लगता है मैं देख सकता हूँ क्यों। मैं अपडेट कर दूंगा।

— हाइपिनो

6

दे घुमा के, 69, 59 बाइट्स

अपडेट करें

बैश में ऐसा करने का एक और अच्छा तरीका है ट्र (62 बाइट्स का उपयोग करना , लेकिन शायद थोड़ा और निचोड़ा जा सकता है)

T() { m=`bc<<<$1^3`;[ -z "`tr -d $m <<<$1;tr -d $1 <<<$m`" ];}

संपादित करें: कुछ और अनुकूलन (Thx! @Manatwork)

golfed

T() { S(){ fold -1|sort -u;};bc<<<$1^3|S|diff - <(S<<<$1);}

परीक्षा

TEST() {
 T $1 >/dev/null; echo $?
}

TEST 0
0
TEST 1
0
TEST 11
1
TEST 10
0
TEST 107624
0
TEST 251894
0
TEST 251895
1
TEST 102343
1
TEST 106239
1

0 - सफलता के लिए (निकास कोड) 1 - विफलता के लिए (बाहर निकलें कोड)

— टसेपेल्लिन
स्रोत

मुझे डर है कि आधार सिद्धांत यहां पूरी तरह से गलत है। कोशिश करो T <<< 11। कहेंगे कि अंक सेट केवल इसलिए हैं क्योंकि 11 ** 3 == 1331 में अंक दो बार मूल संख्या में मौजूद नहीं हैं।

— 11:15

हाँ, आप सही हैं, तय! धन्यवाद !

— टसेपेल्लिन

ठीक है, लेकिन अब कोड में कुछ अतिरिक्त स्थान बचे हैं। सुनिश्चित नहीं हैं कि आपने -wस्पष्ट रूप से क्यों जोड़ा है fold। यदि uniqविकल्प के बिना उपयोग किया जाता है, तो sort -uइसे प्रतिस्थापित कर सकते हैं। और 2-एस कॉल को यहां-स्ट्रिंग के साथ फ़ीड करें। और मुझे लगता है कि पास किए गए फॉर्मूले को उद्धृत करने की कोई आवश्यकता नहीं है bc।

— 13

@manatwork, thx, मैंने तह तर्क को ठीक कर दिया है, रिक्त स्थान हटा दिए हैं, और दूसरे अंतर तर्क को यहाँ-डॉक्टर का उपयोग किया है। मैं अब भी पाइप में पहला तर्क diff , और चारों ओर ज़रूरत से ज़्यादा उद्धरण को हटा दिया है bc अभिव्यक्ति। > यूनीक का उपयोग बिना विकल्पों के किया जाता है, सॉर्ट -यू इसे बदल सकता है। यह पिछले संस्करण के एक अवशेष ( uniq -u ) था । धन्यवाद !

— ज़ेपेलिन

1

@zeppelin: आप cmpइसके बजाय diff1 बाइट का उपयोग कर सकते हैं और बचा सकते हैं ।

— इपोर सिरकार

6

x86-64 मशीन कोड फ़ंक्शन, 40 बाइट्स।

या 37 बाइट्स यदि 0 बनाम गैर-शून्य को "सत्य" के रूप में अनुमति दी जाती है, तो स्ट्रैम्प की तरह।

बिटमैप विचार के लिए कार्ल नेपफ के सी उत्तर के लिए धन्यवाद, जो बी 86 बीटीएस के साथ बहुत कुशलता से कर सकता है ।

फंक्शन सिग्नेचर: _Bool cube_digits_same(uint64_t n);x86-64 सिस्टम V ABI का उपयोग करके। ( nRDI में, बूलियन रिटर्न वैल्यू (0 या 1) AL में)।

_BoolISO C11 द्वारा परिभाषित किया गया है, और आमतौर पर C ++ के समान शब्दार्थ के साथ #include <stdbool.h>परिभाषित करने के लिए उपयोग किया जाता है ।boolbool

संभावित बचत:

3 बाइट्स: उलटा स्थिति (गैर-शून्य अगर कोई अंतर है) लौटना। या इनलाइन एएसएम से: एक फ्लैग कंडीशन लौटाना (जो कि gcc6 के साथ संभव है)
1 बाइट: अगर हम ईबीएक्स को बंद कर सकते हैं (ऐसा करने से यह फ़ंक्शन एक गैर-मानक कॉलिंग सम्मेलन होगा)। (इनलाइन asm से ऐसा कर सकते हैं)
1 बाइट: आरईटी निर्देश (इनलाइन एएसएम से)

ये सभी संभव हैं यदि यह एक फ़ंक्शन के बजाय एक इनलाइन-एएसएम टुकड़ा था, जो इनलाइन-एएसएम के लिए 35 बाइट्स बना देगा ।

0000000000000000 <cube_digits_same>:
   0:   89 f8           mov    eax,edi
   2:   48 f7 e7        mul    rdi          # can't avoid a REX prefix: 2642245^2 doesn't fit in 32 bits
   5:   48 f7 e7        mul    rdi          # rax = n^3, rdx=0
   8:   44 8d 52 0a     lea    r10d,[rdx+0xa]  # EBX would save a REX prefix, but it's call-preserved in this ABI.
   c:   8d 4a 02        lea    ecx,[rdx+0x2]

000000000000000f <cube_digits_same.repeat>:
   f:   31 f6           xor    esi,esi

0000000000000011 <cube_digits_same.cube_digits>:
  11:   31 d2           xor    edx,edx
  13:   49 f7 f2        div    r10         ; rax = quotient.  rdx=LSB digit
  16:   0f ab d6        bts    esi,edx     ; esi |= 1<<edx
  19:   48 85 c0        test   rax,rax     ; Can't skip the REX: (2^16 * 10)^3 / 10 has all-zero in the low 32.
  1c:   75 f3           jne    11 <cube_digits_same.cube_digits>

                                         ; 1st iter:                 2nd iter:                both:
  1e:   96              xchg   esi,eax   ; eax=n^3 bitmap            eax=n bitmap             esi=0
  1f:   97              xchg   edi,eax   ; edi=n^3 bitmap, eax=n     edi=n bmp, eax=n^3 bmp
  20:   e2 ed           loop   f <cube_digits_same.repeat>

  22:   39 f8           cmp    eax,edi
  24:   0f 94 d0        sete   al
                  ;; The ABI says it's legal to leave garbage in the high bytes of RAX for narrow return values
                  ;; so leaving the high 2 bits of the bitmap in AH is fine.
  27:   c3              ret    
0x28: end of function.

LOOP एक बार दोहराने का सबसे छोटा तरीका लगता है। मैंने केवल लूप को दोहराते हुए देखा (REX उपसर्गों के बिना, और एक अलग बिटमैप रजिस्टर), लेकिन यह थोड़ा बड़ा है। मैं भी PUSH RSI उपयोग कर, और उपयोग करने की कोशिश test spl, 0xf/ jzपाश करने के लिए एक बार (के बाद से ABI की आवश्यकता है कि आरएसपी 16B कॉल करने से पहले गठबंधन है, इसलिए एक धक्का यह संरेखित करता है, और एक अन्य इसे फिर से misaligns)। कोई test r32, imm8एन्कोडिंग नहीं है , इसलिए सबसे छोटा तरीका एक 4 बी टेस्ट इंस्ट्रक्शन (एक आरईएक्स प्रीफिक्स सहित) के साथ आरएसपी के कम बाइट को एक इम 8 के खिलाफ परीक्षण करने के लिए था। LEA + LOOP के समान आकार, लेकिन आवश्यक अतिरिक्त PUSH / POP निर्देशों के साथ।

परीक्षण रेंज में सभी एन के लिए परीक्षण किया गया, बनाम स्टेबबॉक्स का सी कार्यान्वयन (क्योंकि यह एक अलग एल्गोरिथ्म का उपयोग करता है)। अलग-अलग परिणामों के दो मामलों में जो मैंने देखा, मेरा कोड सही था और स्टैब्लबॉक्स गलत था। मुझे लगता है कि मेरा कोड सभी n के लिए सही है।

_Bool cube_digits_same(unsigned long long n);

#include <stdio.h>
#include <stdbool.h>
int main()
{
    for(unsigned n=0 ; n<= 2642245 ; n++) {
        bool c = f(n);
        bool asm_result = cube_digits_same(n);
        if (c!=asm_result)
            printf("%u problem: c=%d asm=%d\n", n, (int)c, (int)asm_result);
    }
}

मुद्रित की गई एकमात्र पंक्तियों में c = 1 asm = 0 है: C एल्गोरिथ्म के लिए गलत-सकारात्मक।

एक uint64_tही एल्गोरिथ्म के कार्ल के कार्यान्वयन के एक संस्करण के खिलाफ भी परीक्षण किया गया , और सभी इनपुट के लिए परिणाम मेल खाते हैं।

— पीटर कॉर्डेस
स्रोत

मशीन कोड में कोड गोल्फ ? यही सच्ची महारत है!

— chx

@ एक्सएक्सएक्स: यह वास्तव में विधानसभा भाषा में है, कोड आकार के लिए अनुकूलन। मैं हेक्स बाइट्स को सीधे नहीं लिखता, मुझे बस पता है (या जांचना) कि प्रत्येक निर्देश का आकार क्या है। (मैंने जो पोस्ट किया है वह yasm के साथ कोडांतरण से है और फिर objdump -drwC -Mintelऑब्जेक्ट फ़ाइल पर चल रहा है , और टिप्पणियों की प्रतिलिपि बना रहा है)। यह एक ऐसी भाषा है जहाँ कोड आकार के लिए अनुकूलन वास्तव में वास्तविक जीवन में उपयोगी है। (लेकिन फिर भी, केवल बूटलोडर्स या डेमो जैसे दुर्लभ मामलों में। आमतौर पर यह केवल बचत कोड आकार के लायक होता है जब यह पहले से ही कैश्ड मामले में प्रदर्शन को चोट नहीं पहुंचाता है, लेकिन फिर यह उपयोगी है डिकोड बाधाओं + कैश मिस से बचें)

— पीटर पार्सर्स

@chx: लेकिन हां, asm में गोल्फिंग मुझे बदमाश की तरह लगता है, ध्यान देने के लिए धन्यवाद :) मेरे अन्य उत्तर देखें, यहाँ और इतने पर :)

— पीटर कॉर्डेस

मैं असेंबली में एक बहुत पुरानी टोपी हूं (1987, Z80 पहली बार) लेकिन मैंने कभी भी उसके साथ कोड गोल्फ में प्रवेश करने के बारे में नहीं सोचा होगा। मैंने असंभव सोचा होगा।

— chx

@chx: मैं केवल कभी-कभार ही गोल्फ करता हूं, आमतौर पर केवल जब मैं हॉट नेटवर्क प्रश्नों में से एक को देखता हूं जो asm के लिए उचित लगता है। आमतौर पर संख्याओं के साथ सामान, तार नहीं। कुछ अन्य लोग asm में गोल्फ करते हैं, हालांकि। मैंने खुद ऐसा करने के बारे में तब तक नहीं सोचा था जब तक कि मैंने किसी और के मशीन-कोड गोल्फ का जवाब नहीं देखा। हो सकता है कि यह ऐसा था जिसने मुझे इस तथ्य से रूबरू कराया कि आप asm उत्तर के लिए asm स्रोत वर्णों के बजाय मशीन कोड बाइट्स गिन सकते हैं। anatolyg ने इस प्रश्न पर कुछ पोस्ट किए हैं।

— पीटर कॉर्डेस

5

हास्केल, 47 बाइट्स

n%p=[c|c<-['0'..],elem c$show$n^p]
f n=n%1==n%3

बहुत धीमी गति से। के साथ टेस्ट करें c<-['0'..'9']।

के स्ट्रिंग प्रतिनिधित्व में शामिल करने के लिए हर चरित्र का परीक्षण करता है n, और शामिल लोगों की सूची बनाता है। इसी तरह n^3और सूचियों के बराबर होने पर जांच करता है।

— XNOR
स्रोत

क्या हास्केल में शाब्दिक, या एक फ़ंक्शन नहीं है जो एक सूची से अद्वितीय तत्वों को लौटाता है?

— बिल्ली

2

@cat नहीं। हास्केल nub(अद्वितीय तत्व प्राप्त करें) और sort, लेकिन दोनों को लंबे आयात की आवश्यकता है import Data.List। फिर भी, यह 48 बाइट्स के बहुत करीब आता है import Data.List;q=sort.nub.show;f n=q n==q(n^3):।

— xnor

छांटने की जरूरत क्यों ...?

— बिल्ली

1

@cat nubपहली उपस्थिति द्वारा आदेश को संरक्षित करता है, अर्थात nub [3,1,3,2,1,2] == [3,1,2]। यह एक सेट प्रकार में परिवर्तित नहीं होता है (कोई भी नहीं है), लेकिन एक सूची देता है।

— xnor

ओह, मैंने कभी महसूस नहीं किया कि हास्केल के पास एक आदिम अनियोजित संग्रह प्रकार नहीं है, जो समझ में आता है

— बिल्ली

5

Dyalog एपीएल , 10 बाइट्स

⍕≡⍕∪(⍕*∘3)

⍕≡ तर्क का पाठ प्रतिनिधित्व समान है

⍕∪ तर्क के पाठ प्रतिनिधित्व का संघ और

(⍕*∘3) क्यूब तर्क का पाठ प्रतिनिधित्व?

TryAPL ऑनलाइन!

नोट: बड़ी संख्या के लिए, सेट ⎕PP←34 ⋄ ⎕FR←1287(34 महत्वपूर्ण अंक, 128 बिट फ़्लोट)

— एडम
स्रोत

1

आप मान रहे हैं कि n ^ 3 में अद्वितीय अंक n से कम नहीं हो सकते?

— ngn

क्या आप एक प्रति-उदाहरण के अस्तित्व को साबित कर सकते हैं?

— 20

1

106239, शीर्ष पर टिप्पणियाँ देखें

— ngn 19'16

5

क्लोजर, 35 बाइट्स

#(=(set(str %))(set(str(* % % %))))

— MattPutnam
स्रोत

5

जावा 7, 185 178 अक्षर

import java.util.*;
boolean a(int n){return new HashSet(Arrays.asList((n+"").split(""))).equals(new HashSet(Arrays.asList((new java.math.BigInteger(n+"").pow(3)+"").split(""))));}

इस रूप में कॉल करें:

public static void main(String [] args) {
    System.out.println(0 + " -> " + a(0));
    System.out.println(1 + " -> " + a(1));
    System.out.println(10 + " -> " + a(10));
    System.out.println(107624 + " -> " + a(107624));
    System.out.println(2103869 + " -> " + a(2103869));
    System.out.println(251894 + " -> " + a(251894));
    System.out.println(251895 + " -> " + a(251895));
    System.out.println(102343 + " -> " + a(102343));
    System.out.println(106239 + " -> " + a(106239));
}

आउटपुट:

0 -> true
1 -> true
10 -> true
107624 -> true
2103869 -> true
251894 -> true
251895 -> false
102343 -> false
106239 -> false

(मुझे यकीन नहीं है कि अगर मुझे आयात और विधि परिभाषाओं को भी गिनना है ... तो मैंने भी रास्ता देख लिया है। कोड केवल 141 बाइट्स लंबा होगा हालांकि)।

— QBrute
स्रोत

आयात / उपयोग वास्तव में बाइट-काउंट का हिस्सा हैं। आप static हालांकि निकाल सकते हैं ।

— केविन क्रूज़सेन

ठीक है शुक्रिया। निकाला हुआ static।

— QBrute

4

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

*3ṢQ⁼ṢQ$

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

स्पष्टीकरण:

       $    # As a monadic (single argument) link:
    ⁼       # Return true if the following are equal
     ṢQ     # The unique sorted elements of 'n'
  ṢQ        # and The unique sorted elements
*3          # of 'n^3'

— DJMcMayhem
स्रोत

यह इनपुट 100 के साथ काम नहीं करता है ।

— डेनिस

मैं समझता हूं कि यह क्यों नहीं है, लेकिन यह काम क्यों नहीं करता है ?

— डीजेएमकेम

1

क्योंकि जेली को कड़ाई से दाएं से बाएं छोड़ दिया जाता है, बिना ऑपरेटर की प्राथमिकता के। *3ṢQ⁼ṢQ$त्वरित $समूहों के दो परमाणु परमाणुओं को एक विमुद्रीकरण श्रृंखला में छोड़ देने के बाद से, इरादा के अनुसार काम करता है ।

— डेनिस

4

अजगर, 10 बाइट्स

क्योंकि हमारे पास पाइथ के जवाब के साथ पर्याप्त विविधता नहीं है, चलो एक नहीं, बल्कि दो और जोड़ते हैं! दोनों 10 बाइट्स हैं, और 106239एक नमूना इनपुट के रूप में परीक्षण किया गया है (जो कुछ अन्य उत्तर विफल रहे)।

!s.++Q,`**

स्पष्टीकरण:

!s.++Q,`**QQQQ   Implicit input filling
        **QQQ    Q ^ 3
       `         repr(Q^3)
      ,      Q   [repr(Q^3),Q]
    +Q           [Q,repr(Q^3),Q]
  .+             Deltas ([Digits in Q but not in Q^3, digits in Q^3 but not in Q])
!s               Are both empty?

ऑनलाइन टेस्ट सूट का उपयोग करके पहले उत्तर का प्रयास करें।

दूसरा जवाब:

qFmS{`d,**

स्पष्टीकरण:

qFmS{`d,**QQQQ   Implicit input filling
        **QQQ    Q ^ 3
       ,     Q   [Q^3, Q]
  m              map over each element d of [Q^3, Q]:
     `d           the element's string representation
    {             with duplicates removed
   S              and sorted
qF               Fold over equality (are the two the same?)

ऑनलाइन टेस्ट सूट का उपयोग करके दूसरे उत्तर का प्रयास करें।

— स्टीवन एच।
स्रोत

4

कोटलिन: 46/88/96 बाइट्स

यह सवाल निर्दिष्ट नहीं करता है कि इनपुट कहां से आता है, इसलिए यहां सामान्य 3 इनपुट स्रोत हैं।

समारोह: 46 बाइट्स

fun f(i:Long)="$i".toSet()=="${i*i*i}".toSet()

मुख्य () पहले प्रोग्राम तर्क का उपयोग करते हुए: 88 बाइट्स

fun main(a:Array<String>){val i=a[0].toLong();println("$i".toSet()=="${i*i*i}".toSet())}

मुख्य () मानक इनपुट का उपयोग: 96 बाइट्स

fun main(a:Array<String>){val i=readLine()!!.toLong();println("$i".toSet()=="${i*i*i}".toSet())}

— एफ जॉर्ज
स्रोत

1

PPCG में आपका स्वागत है! इनपुट / आउटपुट कोड-गोल्फ के कारण स्पष्ट रूप से निर्दिष्ट है । आप यहां समुदाय-सर्वसम्मति के मानकों को देख सकते हैं । आपकी फ़ंक्शन संख्या पर्याप्त होनी चाहिए।

— AdmBorkBork

4

हास्केल, 54 52 बाइट्स

धन्यवाद @ लाईकोनी दो बाइट बचाने के लिए।

(%)=all.flip elem
k n|[a,b]<-show<$>[n,n^3]=b%a&&a%b

— Angs
स्रोत

1

एक फ़ंक्शन के रूप में a%b=all(एलएम की घोषणा a)bकरना और फिर कॉल b%a&&a%bकरना दो बाइट्स को सहेजना चाहिए।

— लाकोनी

4

जावास्क्रिप्ट (ईएस 6), 44 बाइट्स

g=n=>n<1?0:g(n/10)|1<<n%10
n=>g(n)==g(n*n*n)

पोर्ट ऑफ @ कार्लप्लाफ का उत्कृष्ट सी उत्तर। ES7 के माध्यम से एक बाइट बचाता है n**3। केवल जावास्क्रिप्ट सीमित संख्यात्मक परिशुद्धता के कारण 208063 तक काम करता है; यदि आपको केवल 1290 तक काम करने की आवश्यकता है, तो आप एक और बाइट बचा सकते हैं।

— नील
स्रोत

4

पर्ल 6 , 22 बाइट्स

{!(.comb⊖$_³.comb)}

विस्तारित:

{ # bare block lambda with implicit parameter ｢$_｣
  !(
    .comb # get a list of the graphemes ( digits )

    ⊖ # Symmetric Set difference

    $_³.comb # cube and get a list of the graphemes
  )
}

सममित सेट अंतर 「⊖」 ऑपरेटर एक खाली रिटर्न सेट करता है, तो दोनों पक्षों के बराबर सेट (स्वचालित रूप से एक सेट में एक सूची बदल जाता है) कर रहे हैं। उस बिंदु पर केवल करने के लिए छोड़ दिया है यह तार्किक रूप से उलटा है।

— ब्रैड गिल्बर्ट b2gills
स्रोत

आप बदल सकते हैं $_बस के साथ.

— जो राजा

4

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

t(int a){int b=a*a*a,c,d;while(a|b)c|=1<<a%10,a/=10,d|=1<<b%10,b/=10;return c==d;}

फ़ंक्शन t (a) उत्तर देता है। सेट के रूप में एक इंट का उपयोग करता है। अच्छी तरह से मुद्रित:

t(int a)
{
    int b = a*a*a, c, d;
    while(a|b) c|=1 << a%10, a/=10, d|=1 << b%10, b/=10;
    return c==d;
}

— जे। एंटोनियो पेरेज़
स्रोत

आपको शामिल करने की आवश्यकता है #include<set>और using namespace std;गोल्फ कोड और बाइट काउंट में

— बिल्ली

@ के #include<set>बजायalgorithm

— कार्ल नेपफ

@ कर्लअनफ ओह, मैंने सोचा कि सभी stdlib कंटेनरों को एल्गोरिथ्म के माध्यम से पहचाना जा सकता था - दिखाता है कि मुझे C ++ के बारे में क्या पता है :)

— cat

यह मुझे लगता है कि फ़ंक्शन "c" के वेरिएबल लोकल को इनिशियलाइज़ नहीं किया गया है, बल्कि c = = 1 का इस्तेमाल किया गया है ...

— RosLuP

4

आर, 65 79 70 बाइट्स

nस्टडिन, स्प्लिट्स nऔर n^3सिंगल डिजिट्स से लेता है , और दो सेटों की तुलना करता है। gmpबड़े पूर्णांक को संभालने के लिए पैकेज का उपयोग करता है (उस कमी को इंगित करने के लिए बिलीवोब के लिए धन्यवाद)। अब substringकट का उपयोग करता है nऔर n^3, सुझाव के लिए @MickyT का धन्यवाद। (पिछले संस्करण इस्तेमाल किए गए scanऔर gsubएक हैकरी तरीके से।)

s=substring
setequal(s(n<-gmp::as.bigz(scan()),p<-1:1e2,p),s(n^3,p,p))

— rturnbull
स्रोत

दुर्भाग्य से यह अभ्यस्त काम (बड़े के लिए n) जब तक आप किसी प्रकार के बिगआईंट पैकेज का उपयोग नहीं करते हैं। देखें ?.Machineसबसे बड़ी पूर्णांक पर जानकारी के लिए और नाव आदि इस जैसे तुलना देखने के लिए 2600001^3आर में करने के लिए वॉलफ्रेम अल्फा

— Billywob

मुझे इसे स्वयं उपयोग करने की आवश्यकता नहीं है, लेकिन ऐसा लगता है कि gmpपैकेज इस समस्या को हल कर सकता है।

— बिल्वोब

आह, अच्छा पकड़! मैंने उत्तर अपडेट कर दिया है, यह अब gmp::as.bigz()बड़े पूर्णांक को संभालने के लिए उपयोग करता है।

— rturnbull

आप संख्या को विभाजित करने के लिए एक s=substring;setequal(s(n<-gmp::as.bigz(scan()),p<-1:1e4,p),s(n^3,p,p))

— पदार्थ

@ मिक्की शानदार सुझाव! मुझे नहीं पता था substringकि इस तरह से इस्तेमाल किया जा सकता है (मैंने केवल कभी इस्तेमाल किया है substr)। अब आपके सुझाव को शामिल करने के लिए उत्तर को संपादित कर दिया गया है।

— rturnbull

4

सी ++ 14, 93 बाइट्स

int b(auto i){int k=0;while(i)k|=1<<i%10,i/=10;return k;}int f(auto n){return b(n)-b(n*n*n);}

मेरे सी उत्तर का पोर्ट , बड़ी संख्या ( Lप्रत्यय के साथ कॉल ) के लिए काम करता है ।

— कार्ल नेफ
स्रोत

3

हास्केल, 47 बाइट्स

import Data.Set
s=fromList.show
f n=s n==s(n^3)

प्रयोग उदाहरण: f 102343-> False।

Data.Setमॉड्यूल से सेट का उपयोग करता है । सहायक फ़ंक्शन sअपने स्ट्रिंग प्रतिनिधित्व में एक संख्या को बदल देता है और वर्णों के बाहर सेट बनाता है।

— nimi
स्रोत

क्या आप यहां एक बाइट का उपयोग करके नहीं बचा सकते हैं s$n^3?

@ ais523: नहीं, क्योंकि यह अनुवाद करता है (s n==s) (n^3)जिससे एक प्रकार की त्रुटि होती है।

— निमि

3

ब्रेकीलॉग , 11 बाइट्स

doI,?:3^doI

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

मेरे मूल उत्तर के साथ किसी समस्या को इंगित करने के लिए @DestructibleWatermelon का धन्यवाद।

व्याख्या

(?)doI,           I is the Input sorted with no duplicates
       ?:3^       Compute Input^3
           doI    Input^3 sorted with no duplicates is I

— Fatalize
स्रोत

मुझे इसमें बिल्ली स्माइली पसंद है: 3

— QBrute 7

3

PowerShell v2 +, 94 93 बाइट्स

filter f($n){-join("$n"[0..99]|sort|select -u)}
(f($x=$args[0]))-eq(f("[bigint]$x*$x*$x"|iex))

(स्पष्टता के लिए नई रूपरेखा, बायटेकाउंट में शामिल नहीं)

पहली पंक्ति fएक के रूप में परिभाषित करती है filter(हमारे उद्देश्यों के लिए एक समान-ईश पर्याप्त है जो हमारे यहाँ विशिष्टताओं में न जाए) जो इनपुट लेता है $nऔर निम्न कार्य करता है:

filter f($n){-join("$n"[0..99]|sort|select -u)}
       f($n)                                    # Input
                   "$n"                         # Cast as string
                       [0..99]                  # Index as char-array
                              |sort             # Sorted alphabetically
                                   |select -u   # Only select the -Unique elements
             -join(                          )  # Join those back together into a string
                                                 # Implicit return

दूसरी पंक्ति इनपुट लेती है $args, fउस पर कार्य करती है, और यह -eqजांचती है कि क्या यह क्यूबेड पर fप्रदर्शन करने के लिए ual है $x। स्पष्ट [bigint]कलाकारों पर ध्यान दें , आवश्यक है कि हम वैज्ञानिक संकेतन में वापस परिणाम प्राप्त करेंगे, जो स्पष्ट रूप से काम नहीं करेगा।

बूलियन परिणाम पाइपलाइन पर छोड़ दिया जाता है, और आउटपुट निहित है।

PS C:\Tools\Scripts\golfing> 0,1,10,107624,251894,251895,102343,106239,2103869|%{"$_ --> "+(.\do-n-n3-same-digits.ps1 $_)}
0 --> True
1 --> True
10 --> True
107624 --> True
251894 --> True
251895 --> False
102343 --> False
106239 --> False
2103869 --> True

@ConnorLSW को एक बाइट धन्यवाद दिया

— AdmBorkBork
स्रोत

आप एक बाइट को बचाने के "$n"[0..99]बजाय उपयोग कर सकते हैं [char[]]"$n", क्योंकि आपको सबसे बड़ी संख्या से निपटने की आवश्यकता होगी, जिसकी लंबाई केवल 20 चार्ट है।

— 15:15 बजे कोल्स

@ConnorLSW वहाँ फिर से अनुक्रमण चाल है। मुझे याद रखने की जरूरत है।

— AdmBorkBork

जब तक आप 100 से कम वर्णों का उपयोग करने की गारंटी देते हैं, तब तक यह सामान्य char[]रूपांतरण पर एक आसान पर्याप्त बचत है , आपके बाकी कोड उतने ही अच्छे हैं जितना कि मैं इसे प्राप्त कर सकता हूं, अगर सरणियों की तुलना करने के लिए शॉर्टहैंड तरीका था, तो आप कर सकते हैं ("$n"[0..99]|group).Nameलोड को बचाने के लिए कुछ का उपयोग करें लेकिन compareगोल्फ के लिए बिल्कुल त्वरित और आसान नहीं है।

— 10

मुझे लगता है कि इसे हल करने के लिए क्या जवाब मिलता है ... बहुत ही एक ही जवाब ;; लेकिन आप कुछ बहुत स्पष्ट अनुकूलन से चूक गए ;-)

— जोए

3

ग्रूवी, 35 51 चार्ट / बाइट्स

मैं ग्रूवी को शामिल नहीं देखकर दुखी था, इसलिए यहां मेरा मूल 51-बाइट का प्रयास है:

def x(def n){"$n".toSet()=="${n.power(3)}".toSet()}

35-बाइट गुमनाम बंद के रूप में और **घातांक के लिए फिर से लिखा गया , मैनटवर्क के लिए धन्यवाद:

{"$it".toSet()=="${it**3}".toSet()}

मूल फ़ंक्शन के लिए कुछ परीक्षण मामले:

println x(0)
println x(1)
println x(10)
println x(107624)
println x(251894)
println x(251895)
println x(102343)

एक नामित बंद cको इस तरह कहा जा सकता है println c.call(107624):। अनाम 35-बाइट को बंद करने को इस तरह कहा जा सकता है:println ({"$it".toSet()=="${it**3}".toSet()}(107624))

आउटपुट:

true
true
true
true
true
false
false

कृपया ध्यान दें: मुझे पता चला कि कोड गोल्फ जैसी कोई चीज अभी मौजूद है, इसलिए उम्मीद है कि मुझे यह अधिकार मिल जाएगा!

— Rado
स्रोत

नमस्कार राडो, और पीपीसीजी में आपका स्वागत है! यह एक महान पहला जवाब है, +1!

— NoOneIsHere

मैं इसे बंद करने के लिए 47 चार्ट्स / बाइट्स के आगे भी निचोड़ने में कामयाब रहा, लेकिन यहाँ नया होने के कारण अपने पिछले उत्तर को संपादित नहीं कर सकता, इसलिए यहाँ यह है:def c={"$it".toSet()=="${it.power(3)}".toSet()}

— Rado

1

अनाम कार्य स्वीकार्य हैं। और **घातांक के लिए ऑपरेटर का उपयोग करें ।

— मैनावर्क

धन्यवाद @NoOneIsHere! इसके अलावा, परीक्षण के मामलों को बंद करने के लिए x(107624)c.call(107624)

— राडो

शुक्रिया @manatwork! एक अनाम बंद का उपयोग करके और **इसे सुंदर 35 चार्ट / बाइट्स के लिए नीचे लाता है:{"$it".toSet()=="${it**3}".toSet()}

— राडो

2

रूबी, 48 बाइट्स

->n{(f=->x{x.to_s.chars.uniq.sort})[n]==f[n**3]}

— ली डब्ल्यू
स्रोत

क्या n और n ^ 3 में अंकों का समान सेट है?

परीक्षण के मामलों

पायथन 3, 36 32 बाइट्स

05AB1E , 6 बाइट्स

सी, 73 बाइट्स

पर्ल, 31 + 2 ( -plध्वज) = 25 21 18 34 33 बाइट्स

गणितज्ञ, 34 बाइट्स

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

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

सीजेएम, 8 बाइट्स

व्याख्या

जावास्क्रिप्ट ईएस 6, 55 51 बाइट्स

सी #, 241 208 205 201 193 233 222 220 212 203 177 159 बाइट्स (109 वैकल्पिक)

जावा 8, 154 वर्ण

दे घुमा के, 69, 59 बाइट्स

x86-64 मशीन कोड फ़ंक्शन, 40 बाइट्स।

या 37 बाइट्स यदि 0 बनाम गैर-शून्य को "सत्य" के रूप में अनुमति दी जाती है, तो स्ट्रैम्प की तरह।

हास्केल, 47 बाइट्स

Dyalog एपीएल , 10 बाइट्स

क्लोजर, 35 बाइट्स

जावा 7, 185 178 अक्षर

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

अजगर, 10 बाइट्स

कोटलिन: 46/88/96 बाइट्स

समारोह: 46 बाइट्स

मुख्य () पहले प्रोग्राम तर्क का उपयोग करते हुए: 88 बाइट्स

मुख्य () मानक इनपुट का उपयोग: 96 बाइट्स

हास्केल, 54 52 बाइट्स

जावास्क्रिप्ट (ईएस 6), 44 बाइट्स

पर्ल 6 , 22 बाइट्स

विस्तारित:

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

आर, 65 79 70 बाइट्स

सी ++ 14, 93 बाइट्स

हास्केल, 47 बाइट्स

ब्रेकीलॉग , 11 बाइट्स

व्याख्या

PowerShell v2 +, 94 93 बाइट्स

ग्रूवी, 35 51 चार्ट / बाइट्स

रूबी, 48 बाइट्स

पर्ल, 31 + 2 ( `-pl`ध्वज) = 25 21 18 34 33 बाइट्स