वेरी फ्राइडमैन नंबर

Question

एक फ्रीडमैन नंबर एक सकारात्मक पूर्णांक है जो एक गैर-तुच्छ अभिव्यक्ति के बराबर है जो संचालन +, -, *, /, ^, कोष्ठक और संगति के साथ संयोजन में अपने स्वयं के अंकों का उपयोग करता है।

नाइस फ्रीडमैन नंबर एक सकारात्मक पूर्णांक है जो एक गैर-तुच्छ अभिव्यक्ति के बराबर है जो अपने मूल क्रम में अंकों के साथ, समान संचालन के साथ संयोजन में अपने अंकों का उपयोग करता है।

एक बहुत अच्छा फ्राइडमैन नंबर (VNFN), जो मैं यहां आविष्कार कर रहा हूं, एक अच्छा फ्राइडमैन नंबर है जिसे इस तरह की अभिव्यक्ति के कम सुंदर (मेरी राय में) भागों के बिना लिखा जा सकता है। कोष्ठक, संघनन और एकात्मक अवहेलना को रोक दिया जाता है।

इस चुनौती के लिए, कोष्ठक के बिना अभिव्यक्ति लिखने के तीन संभावित तरीके हैं।

उपसर्ग: यह बाईं-समरूपता के बराबर है। इस प्रकार की अभिव्यक्ति सभी ऑपरेटरों के अंकों के बाईं ओर लिखी जाती है। प्रत्येक ऑपरेटर निम्नलिखित दो अभिव्यक्तियों पर लागू होता है। उदाहरण के लिए:

*+*1234 = *(+(*(1,2),3),4) = (((1*2)+3)*4) = 20

एक VNFN जो इस तरह लिखा जा सकता है 343:

^+343 = ^(+(3,4),3) = ((3+4)^3) = 343

उपसर्ग: यह सम-समरूपता के समतुल्य है। यह उपसर्ग संकेतन की तरह है, सिवाय इसके कि ऑपरेशन अंकों के दाईं ओर जाए। प्रत्येक ऑपरेटर दो पिछले अभिव्यक्तियों पर लागू होता है। उदाहरण के लिए:

1234*+* = (1,(2,(3,4)*)+)* = (1*(2+(3*4))) = 14

एक VNFN जिसे इस तरह लिखा जा सकता है वह है 15655:

15655^+** = (1,(5,(6,(5,5)^)+)*)* = (1*(5*(6+(5^5)))) = 15655

Infix: Infix संकेतन पाँच परिचालनों के संचालन के मानक क्रम का उपयोग करता है। चुनौती के प्रयोजनों के लिए, संचालन के उस क्रम को निम्नानुसार परिभाषित किया जाएगा: ^पहले कोष्ठक , सही ढंग से। फिर, कोष्ठक *और /एक साथ, सहयोगी रूप से छोड़ दिया। अंत में, कोष्ठक +और -एक साथ, सहयोगी रूप से छोड़ दिया।

1-2-3 = (1-2)-3 = -4
2/3*2 = (2/3)*2 = 4/3
2^2^3 = 2^(2^3) = 256
1^2*3+4 = (1^2)*3+4 = 7

एक VNFN जिसे इस तरह लिखा जा सकता है वह है 11664:

1*1*6^6/4 = (((1*1)*(6^6))/4) = 11664

चुनौती: एक सकारात्मक पूर्णांक को देखते हुए, यदि इसे उपसर्ग, इन्फिक्स या पोस्टफ़िक्स नोटेशन में अपने स्वयं के अंकों की गैर-तुच्छ अभिव्यक्ति के रूप में व्यक्त किया जा सकता है, तो उस अभिव्यक्ति का उत्पादन। यदि नहीं, तो आउटपुट कुछ नहीं।

स्पष्टताएं: यदि कई अभ्यावेदन संभव हैं, तो आप उनमें से किसी भी गैर-रिक्त उपसेट का उत्पादन कर सकते हैं। उदाहरण के लिए, 736 एक VNFN है:

+^736 = 736
7+3^6 = 736

+^736, 7+3^6या दोनों सभी स्वीकार्य आउटपुट होंगे।

एक "तुच्छ" अभिव्यक्ति का अर्थ है, जो किसी भी ऑपरेटर का उपयोग नहीं करता है। यह केवल एक अंक की संख्या के लिए प्रासंगिक है, और इसका मतलब है कि एक अंक संख्या VNFN नहीं हो सकती है। यह एक फ्रीडमैन नंबर की परिभाषा से विरासत में मिला है।

उत्तरों को सेकंड या मिनट में एक मिलियन से कम इनपुट पर चलना चाहिए।

सम्बंधित।

IO: मानक IO नियम। पूर्ण कार्यक्रम, कार्य, क्रिया या समान। एसटीडीआईएन, कमांड लाइन, फ़ंक्शन तर्क या समान। "नथिंग" के आउटपुट के लिए, रिक्त स्ट्रिंग, एक रिक्त रेखा, nullया समान और एक खाली संग्रह सभी ठीक हैं। आउटपुट एक स्ट्रिंग के साथ सीमांकित हो सकता है जो एक प्रतिनिधित्व में नहीं हो सकता है, या स्ट्रिंग्स का एक संग्रह हो सकता है।

उदाहरण:

127
None

343
^+343

736
736^+
7+3^6

2502
None

15655
15655^+**

11664
1*1*6^6/4
1^1*6^6/4

5
None

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

इसके अलावा, यदि आप एक खोज करते हैं, तो कृपया अपने उत्तर में एक नया बहुत अच्छा फ्राइडमैन नंबर दें।

Comments

*(+(*(1,2),3,4)एक नज़दीकी ,3

— पार्न

"सेकंड या मिनट में" टोपी क्या है? चार घंटे अभी भी .... कई ... मिनटों में हैं।

— नहीं कि चार्ल्स

@NothatCharles 4 घंटे बहुत अधिक है। मान लीजिए कि मेरी मशीन पर 1 घंटा है, कुछ विगेल रूम के साथ। बहु अंकों वाली संख्याओं के बारे में, जो कि मैं Parentheses, concatenation and unary negation are disallowed.

— संक्षेपण के

Answer 1

पर्ल, 345 334 318 293 263 245B

$_='$_=$i=pop;$c=y///c-1;sub f{say if$c&&$i==eval pop=~s/\^/**/gr}A$m)$1$4"})};f"("x$c.$m}globOx$c.$i;A$1$4($m"})};f$m.")"x$c}glob$i.Ox$c;map{f$_}glob joinO,/./g';s!O!"{+,-,*,/,^}"!g;s!A!'map{m{(\d)((?R)|(\d)(?{$m=$3}))(.)(?{$m="'!ge;s!d!D!;eval

के साथ बुलाना perl -M5.10.0 scratch.pl 736

---

परिणाम

पहले कुछ परिणाम जो मुझे मिले वो हैं:

^+343
736^+
7+3^6
^+/3125
^+^3125
/^+-11664
/^--11664
1-1+6^6/4
/^++14641
^^++14641
1+5^6/1-8
1+5^6^1-8
1+5^6-2-2
1+5^6-2^2
1+5^6+2-4
1+5^6+4^2
-^+^16377
-^-+16377
/^+^16384
/^-+16384

---

व्याख्या

पूरी तरह से अनगढ़

मैंने बाद में गोल्फ को आसान बनाने के लिए जितना संभव हो सके खुद को दोहराने की कोशिश की।

#!perl
use 5.10.0;

$_ = $input = pop;

# y///c counts characters in $_
$count = y///c - 1;

sub f {
    say if $count && $input == eval pop =~ s/\^/**/gr
}

# PREFIX
map {
    m{                            # Parses *^+1234
        (\D)                      # $1 = first symbol
        (
            (?R)                  # RECURSE
        |
            (\d)(?{               # $3 = first digit
                $match=$3
            })
        )
        (.)(?{                    # $4 = last digit
            $match="$match)$1$4"
        })
    }x;
    f "(" x $count . $match
}
    # glob expands '{0,1}{0,1}' into 00,01,10,11
    glob "{+,-,*,/,^}" x $count . $input;

# POSTFIX
map {
    m{(\d)((?R)|(\d)(?{$match=$3}))(.)(?{$match="$1$4($match"})};
    f $match. ")" x $count
}
    glob $input . "{+,-,*,/,^}" x $count;

# INFIX
# /./g splits $_ into characters
map { f $_} glob join "{+,-,*,/,^}", /./g

यह कैसे गोल्फ है

• व्हॉट्सएप और टिप्पणियां निकालें और सभी वर्णों को 1-वर्ण संस्करण के साथ बदलें
• में लपेटें कार्यक्रम $_=q! ... !;eval
• तार निकालें और उन्हें बाद में स्थानापन्न करें।

यह कुछ इस तरह देता है, जिससे आप परिणाम के लिए लाइन ब्रेक को हटा सकते हैं:

$_='
    $_=$i=pop;
    $c=y///c-1;
    sub f{say if$c&&$i==eval pop=~s/\^/**/gr}
    A$m)$1$4"})};f"("x$c.$m}globOx$c.$i;
    A$1$4($m"})};f$m.")"x$c}glob$i.Ox$c;
    map{f$_}glob joinO,/./g
';
s!O!"{+,-,*,/,^}"!g;
s!A!'map{m{(\d)((?R)|(\d)(?{$m=$3}))(.)(?{$m="'!ge;
s!d!D!;
eval

Comments

जवाब के लिए धन्यवाद, और पहले स्थान पर रहने के लिए बधाई। व्यापक हमलों में, यह कैसे काम करता है?

— isaacg

मुझे पता नहीं है, लेकिन ऐसा लगता है कि यह संभव है कि 3 घटनाओं को निकाला जाए }globऔर कुछ बाइट्स को बचाया जाए।

— ईसैक

s!B!}glob!g;BBB-> 15 बी; }glob}glob}glob-> 15B :)

— अलेक्जेंडर-ब्रेट

डारन, इतने करीब।

— इसहाक

Answer 2

रूबी 2.1.5 केवल - 213 220 238 + 9 = 247

यकीन नहीं होता कि रूबी पर्ल को कैसे पीटती है, लेकिन यहाँ तुम जाओ ...

इसे -rtimeout फ्लैग के साथ चलाएं (और या तो -W0 या अपना stderr अन्यत्र भेजें)।

इसे थोड़ा और मजबूत बनाने के लिए , अतिरिक्त चरित्र के send([].methods[81],z-1)साथ बदलें repeated_permutation(z-1)और स्कोर करें (इसलिए, 248 )।

g=$*[0].split //
exit if 2>z=g.size
d=->a,s{$><<a*''&&exit if$*[0].to_i==timeout(2){eval"#{(s*'').gsub(?^,'**')}"}rescue p}
l,r=[?(]*z,[?)]*z
%w{* / + - ^}.send([].methods[81],z-1){|o|d[m=g.zip(o),m]
d[g+o,l.zip(m)+r]
d[o+g,l+g.zip(r,o)]}

मूल रूप से, ऑपरेटरों के सभी क्रमपरिवर्तन से गुजरते हैं और उस क्रम में infix, postfix, और उपसर्ग आज़माते हैं। dविधि का उपयोग करता है evalदूसरा पैरामीटर पर गणना करने के लिए, किसी भी DivideByZero या ओवरफ्लो अपवादों को पकड़ने।

आपको stderr को / dev / null पर भेजने की आवश्यकता है, हालाँकि, या फिर evalकभी-कभी चेतावनी भी प्रिंट करेंगे (eval):1: warning: in a**b, b may be too big।

जब मैं इस असहयोग के साथ आया, तो मुझे तीन वर्णों को बचाने का एक तरीका मिला!

अपंग (पुराने लेकिन समान सिद्धांत):

input = $*[0]
digits = input.split //
num_digits = digits.size
exit if 2 > num_digits # one-digit numbers should fail

def print_if_eval print_array, eval_array
  # concatenate the array and replace ^ with **
  eval_string = (eval_array * '').gsub(?^, '**') 
  val = eval(eval_string)
  if input.to_i == val
    $><<print_array*''
    exit
  end
rescue
  # this catches any DivideByZero or Overflow errors in eval.
end
# technically, this should be * (num_digits - 1), but as long as we 
# have AT LEAST (num_digits - 1) copies of the operators, this works
operators = %w{* / + - ^} * num_digits
left_parens = ['('] * num_digits
right_parens = [')'] * num_digits
operators.permutation(num_digits-1) { |op_set|
  # infix
  # just uses the native order of operations, so just zip it all together
  # 1+2-3*4/5^6
  print_if_eval(digits.zip(op_set),
                digits.zip(op_set))

  # postfix
  # leftparen-digit-operator, repeat; then add right_parens
  # (1+(2-(3*(4/(5^(6))))))
  # 
  print_if_eval(digits+op_set,
                (left_parens.zip(digits, op_set) + right_parens))

  # prefix
  # leftparens; then add digit-rightparen-operator, repeat
  # ((((((1)+2)-3)*4)/5)^6)
  print_if_eval(op_set+digits,
                left_parens + digits.zip(right_parens, op_set))
}

बदलाव का

247 ने टाइमिंग आउट के बजाय बड़ी संख्या के लिए यह काम किया।

220 चर्मपत्रों को घोषित कर तीन वर्णों का मुंडन, और एक बग तय किया जहां एक-अंकीय संख्याओं को VNFN माना जाता था

213 प्रारंभिक प्रतिबद्ध

Comments

महान समाधान - मेरे लिए पूरा काला जादू! मुझे लगता है कि रूबी बीट्स पर्ल तब से बना हुआ है जब इसमें बिल्ट-इन जिप और क्रमपरिवर्तन कार्य हैं।

— अलेक्जेंडर-ब्रेट

@ अलेक्जेंडर-ब्रेट कोई बेहतर? a.zip(b,c)सरणी की एक सरणी देता है जैसे [ [a[0],b[0],c[0]],[a[1],b[1],c[1]], etc.]और ['hi', 'there']*''बस सरणी मानों के स्ट्रिंग प्रतिनिधित्व को समेटता है।

— नहीं कि चार्ल्स

ओह, और [a,b]*3पैदावार[a,b,a,b,a,b]

— नहीं कि चार्ल्स

Answer 3

MATLAB (435 बी)

n=input('');b=str2num(fliplr(num2str(n)));l=floor(log(b)/log(10));a=unique(nchoosek(repmat('*+-/^', 1,5), l), 'rows');for k=1:numel(a(:,1)),for j=0:2,c=strcat((j>1)*ones(l)*'(',mod(b,10)+48);for i=1:l,c=strcat(c,a(k,i),(j<1)*'(',mod(floor(b/10^i),10)+48,(j>1)*')'); end,c=strcat(c,(j<1)*ones(l)*')');if eval(c(1,:))==n,fprintf('%s%s%s%s\n',c(1,1:(j==1)*numel(c(1,:))),fliplr(a(k,1:(j>1)*l)),(j~=1)*num2str(n),a(k,1:(j<1)*l));end,end,end

---

इसे यहाँ आज़माएँ

http://octave-online.net/

Comments

अभी भी और अधिक सुधार की आवश्यकता है

— अब्राहम

यहाँ मतलूब के साथ लोग आदतन नहीं हैं?

— अब्राहम

Answer 4

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

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

from itertools import*
n=input()
l=len(n)-1
E=eval
for c in product('+-*/^',repeat=l):
 L=lambda x,y:x.join(map(y.join,zip(n,c+('',)))).replace('^','**')
 C=''.join(c)
 try:
    if`E(L('',''))`==n:print L('','')
    if`E('('*-~l+L('',')'))`==n:print C[::-1]+n
    if`E(L('(','')+')'*l)`==n:print n+C
 except:pass

**इसके बजाय Infix आउटपुट शामिल होंगे ^। यदि यह अनुमति नहीं है, .replace('**','^')तो एक और 18 बाइट्स जोड़ और घटाना होगा

स्पष्टीकरण:

# get all possible combinations of operators (with repetitions)
product('+-*/^',repeat=l)  

# create string from input and operators like
# if passed '(' and '' will return (a+(b+(c
# if passed '' and ')' will return a)+b)+c)
# if passed '' and '' will return a+b+c
lambda x,y:x.join(map(y.join,zip(n,c+('',)))).replace('^','**')

# evaluate infix
E(L('',''))
# evaluate prefix
E('('*-~l+L('',')')) 
# evaluate postfix
E(L('(','')+')'*l)
# all evals need to be inside try-except to handle possible 0 division

# prefix output is need to be swapped (which IMO is not needed)
n:print C[::-1]+n