ম্যাথমেটিকায় গল্ফ করার টিপস

Question

গাণিতিকায় গল্ফ করার জন্য আপনার কাছে কোন সাধারণ টিপস রয়েছে? আমি এমন ধারণাগুলি সন্ধান করছি যা গণিতের ক্ষেত্রে কমপক্ষে কিছুটা নির্দিষ্ট কোড গল্ফ সমস্যার ক্ষেত্রে প্রয়োগ করা যেতে পারে (যেমন "মন্তব্যগুলি সরান" কোনও উত্তর নয়)।

Answer 1

নীচের টিপসগুলি সবচেয়ে অর্থনৈতিক থেকে সর্বাধিক ব্যবহৃত ব্যবহৃত পরিবর্তিত হয়:

1. ম্যাথমেটিকার উচ্চ-স্তরের কমান্ডগুলি যেখানে সম্ভব সেখানে ব্যবহার করুন, এমনকি বড়গুলিও:

   • MorphologicalComponents: কোড-গল্ফ: গণনা দ্বীপপুঞ্জ

   • চিত্র ম্যানিপুলেশন ক্ষমতা: যেমন আজ (24 সেপ্টেম্বর) হন্ডার জন্মদিন

   • Subsets

   • IntegerPartitions

   • দূরত্ব এবং সাদৃশ্য ব্যবস্থা: যেমন EuclideanDistanceবাইট সেভার হতে পারে। তবে খেয়াল করুন, এটি লেখার Total@Abs[a-b]পরিবর্তে a~ManhattanDistance~bএবং Max@Abs[a-b]পরিবর্তে সাধারণত খাটো হয় a~ChessboardDistance~b।

2. Graphics and Textআসকি শিল্পের জন্য ব্যবহার করুন : যেমন স্টার প্রোগ্রামিং! এবং একটি অ্যানালগ ঘড়ি তৈরি করুন

3. উত্সর্গীকৃত প্রতীক:

   • যুক্তিযুক্ত এবং তাদের দীর্ঘ ফর্ম নামের পরিবর্তে অপারেশন প্রতীক সেট করুন: ⋂, ⋃, ∧, ∨

   • Mapএবং Apply: /@, //@। @@,@@@

4. উপসর্গ এবং ইনফিক্স স্বরলিপি:

   • Print@"hello" জায়গায় Print["hello"]

   • a~f~b জায়গায় f[a,b]

5. যখন কোনও ফাংশন কেবল একবার ব্যবহার করা হয়, একটি খাঁটি ফাংশন একটি অক্ষর বা দুটিকে অর্থনীতিতে পরিণত করতে পারে।

6. একটি তালিকায় স্ট্রিং যোগদান। ""<>{"a","b","c"}পরিবর্তেStringJoin@{"a","b","c"}

7. তালিকাভুক্ত ফাংশনগুলি শোষণ করুন। আর তালিকাগুলি আরও ভাল হয়।

   {a, b, c} + {x, y, z}= {a+x, b+y, c+z}

   {2, 3, 4} {5, 6, 7}= {10, 18, 28}

   {{a, b}, {c, d}}^{2, 3} = {{a^2, b^2}, {c^3, d^3}}

Comments

পরিবর্তে লেখার জন্য এটি সর্বদা সংক্ষিপ্ত । (Norm[#-#2]&)EuclideanDistance

— ব্যবহারকারী 202729

Answer 2

দীর্ঘ নামের সাথে কিছু অন্তর্নির্মিত ফাংশনগুলি সংক্ষিপ্ত প্রকাশের সাথে প্রতিস্থাপন করা যেতে পারে।

উদাহরণ স্বরূপ:

• Total => Tr
• Transpose=> Threadবা\[Transpose]
• True => 1<2
• False => 1>2
• Times => 1##&
• Alternatives => $|##&
• IntegerQ => ⌊#⌋==#&
• a[[1]] => #&@@a
• a[[All,1]] => #&@@@a
• ConstantArray[a,n]=> Array[a&,n]বাTable[a,{n}]
• Union@a=> {}⋃aবাa⋃a
• ToExpression@n=> FromDigits@nযদি nএকটি সংখ্যা হয়
• Divisible[n,m] => m∣n
• FromDigits[n,2]=> Fold[#+##&,n]যদি গুলি এবং এর nএকটি তালিকা হয়01
• Complex@z=> ফর্মের একটি তালিকা {1,I}.zযেখানেz{x,y}

Comments

@ বিলেসারিয়াস Thread[{{a,b},{c,d}}]== Thread[List[{a,b},{c,d}]]== {List[a,c],List[b,d]}== {{a,c},{b,d}}==Transpose[{{a,b},{c,d}}]

— আলেফাল্ফ

আমি মনে করি আপনার Foldজন্য কৌশলটি FromDigitsব্যতীত অন্য কোনও বেসের জন্যও কাজ করে 10। উদা FromDigits[n,5]-> Fold[4#+##&,n](ঘাঁটিগুলির জন্য অতিরিক্ত বাইট সংরক্ষণের বোনাস সহ 100এবং 1000)।

— মার্টিন ইন্ডার

ইউটিএফ -8 এ @ mbomb007 3 বাইট। আসলে এই চরিত্রটি U+F3C7।

— আলেফাল্ফা

আমি শেষ পর্যন্ত ইনস্টল 10.3। আমরা যদি পুরো প্রোগ্রামগুলি বিবেচনা করি Echoতবে আমি মনে করি না এটি একটি বিকল্প, কারণ এটি >>প্রকৃত স্ট্রিং প্রিন্ট করার আগে স্টুডুটে (এবং একটি স্থান) প্রিন্ট করে।

— মার্টিন এন্ডার

কারণ Complex[x,y] => {1,I}.{x,y}, আমি মনে করি x+y*Iএকই প্রভাব সহ অনেক খাটো?

— শিয়েরু আসাকোটো

Answer 3

পুনরাবৃত্তি মান সহ তালিকাভুক্ত

এটি কাজ করার জন্য বেশ সাধারণ ভেক্টর:

{0,0}

দেখা যাচ্ছে এটি একটি বাইট দ্বারা সংক্ষিপ্ত করা যেতে পারে:

0{,}

আরও বেশি বাইটস সংরক্ষণ করা হয় যদি ভেক্টর দুটি শূন্যের চেয়ে দীর্ঘ হয়। এটি শূন্য ম্যাট্রিক্স সূচনা করতেও ব্যবহার করা যেতে পারে, যেমন নীচেরগুলি শূন্যগুলির 2x2 ম্যাট্রিক্স দেয়:

0{{,},{,}}

এটি শূন্য-অমূল্যগুলির জন্যও ব্যবহার করা যেতে পারে যদি তারা যথেষ্ট পরিমাণে বা পর্যাপ্ত পরিমাণে বা নেতিবাচক হয়। নিম্নলিখিত জোড়া তুলনা করুন:

{100,100}
0{,}+100

{-1,-1}
0{,}-1

{3,3,3,3}
0{,,,}+3

তবে মনে রাখবেন যে values ​​টি মান থেকে শুরু করে 1~Table~6আপনি এই ক্ষেত্রে ভাল হতে পারেন (সম্ভাব্যতার আগে, অগ্রাধিকার প্রয়োজনীয়তার উপর নির্ভর করে)।

এই কাজটি করার কারণটি হ'ল ,তালিকায় দুটি যুক্তি উপস্থাপন করে তবে বাদ দেওয়া যুক্তি (ম্যাথামেটিকায় যে কোনও জায়গায়) অন্তর্নিহিত Nullএস। তদুপরি, গুণটি হ'ল Listableএবং 0*xএটি 0প্রায় xকোনওর জন্য (যেমন Infinityএবং কিছু বাদে Indeterminate), তাই এখানে যা ঘটছে তা এখানে:

  0{,}
= 0*{,}
= 0*{Null,Null}
= {0*Null,0*Null}
= {0,0}

এর তালিকাগুলির জন্য 1, আপনি ক্ষতিকারক বিধিগুলি ব্যবহার করে অনুরূপ কৌশল ব্যবহার করতে পারেন। বাইট সংরক্ষণের দুটি ভিন্ন উপায় আছে যদি আপনার 1তালিকায় কমপক্ষে তিনটি থাকে :

{1,1,1}
1^{,,}
{,,}^0

Comments

+1 টি; এটি কেবল এটি দেখায় যে ম্যাথামেটিকায় সমস্ত কিছুর জন্য অন্তর্নির্মিত থাকতে পারে, এতে গল্ফ করা সত্যিকারের চ্যালেঞ্জ হতে পারে।

— LegionMammal978

আপনি যদি এমন একটি অ্যারে চান যা শেষ পর্যন্ত 1s দিয়ে পূর্ণ হয় তবে 1^{,,,}তার চেয়ে এক বাইট ছোট 0{,,,}+1।

— মিশা লাভরভ

@ মিশা লাভরভ ওহ, ভাল ক্যাচ এটি তিনটি মানকে সংক্ষিপ্ত করে তোলে এবং আপনি এটি ব্যবহার করতে পারেন {,,}^0। আমি পোস্টটি সম্পাদনা করব।

— মার্টিন ইন্ডার

Answer 4

আপনার খাঁটি ফাংশন যুক্তিগুলি জানুন

গল্ফিং কোড করার সময়, আপনি প্রায়শই একটি কার্যকরী পদ্ধতির নিয়োগ করেন, যেখানে আপনি &শর্টহ্যান্ড সিনট্যাক্স সহ বেনাম (খাঁটি) ফাংশন ব্যবহার করেন । এই জাতীয় ফাংশনের আর্গুমেন্ট অ্যাক্সেস করার বিভিন্ন উপায় রয়েছে এবং আপনি প্রায়শই সম্ভাব্যতার উপর ভাল করে উপলব্ধি করে কয়েকটা বাইট ছাঁটাই করতে পারেন।

একক যুক্তি অ্যাক্সেস করা

আপনি যদি আগে বিশুদ্ধ ফাংশন ব্যবহার করেন তবে আপনি সম্ভবত এটি জানেন। এন ম যুক্তি হিসাবে উল্লেখ করা হয় #n, এবং #জন্য একটি alias হিসাবে কাজ করে #1। সুতরাং, যদি বলুন, আপনি এমন একটি ফাংশন লিখতে চান যা প্যারামিটার হিসাবে অন্য ফাংশন এবং তার যুক্তি (সেই ফাংশনে যুক্তিটি পাস করার জন্য) লাগে, ব্যবহার করুন

#@#2&

এটি নেতিবাচক সংখ্যাগুলির সাথে কাজ করে না (যেমন আপনি তালিকাগুলি অ্যাক্সেস করার সময় ব্যবহার করতে পারেন)।

নামযুক্ত আর্গুমেন্ট অ্যাক্সেস করা (ভি 10 তে নতুন)

ম্যাথমেটিকা ​​10-এ নতুন নতুন ভাষার বৈশিষ্ট্যগুলির মধ্যে একটি হ'ল Association, যা মূলত স্বেচ্ছাসেবক মূল প্রকারের সাথে মূল-মানচিত্রের মানচিত্র, যেমন লিখিত

<| x -> 1, "abc" -> 2, 5 -> 3 |>

যদি এই জাতীয় সমিতিটি খাঁটি ফাংশনটির প্রথম যুক্তি হিসাবে প্রেরণ করা হয় তবে এর কিছু যুক্তি যদি নামযুক্ত প্যারামিটার হিসাবে থাকে তবে আপনি কিছু অ্যাক্সেস করতে পারেন:

{#, #2, #3, #abc, #xyz} & [<| "abc" -> "1st", "xyz" -> "2nd", abc -> "3rd" |>, "4th", "5th"]
(* {<| "abc" -> "1st", "xyz" -> "2nd", abc -> "3rd" |>, "4th", "5th", "1st", "2nd"} *)

মনে রাখবেন যে #প্রত্যাশা অনুযায়ী এখনও পুরো সমিতিটিকে বোঝায়। নামযুক্ত পরামিতিগুলি কাজ করার জন্য, কীগুলি স্ট্রিং থাকতে হবে (উদাহরণস্বরূপ আপনি অপরিজ্ঞাত ভেরিয়েবলগুলি ব্যবহার করলে এটি কাজ করবে না) এবং এই স্ট্রিংগুলি অবশ্যই একটি অক্ষর দিয়ে শুরু হওয়া উচিত এবং কেবল অক্ষর এবং অঙ্কগুলি থাকতে হবে।

"স্ব" যুক্তি #0

একটি কম পরিচিত বৈশিষ্ট্য হ'ল #0এটিও বিদ্যমান এবং এটি আপনাকে ফাংশন অবজেক্টটি দেয়। এটি কুইনস এবং জেনারালাইজড কুইনে সত্যই কার্যকর হতে পারে। আসলে, সবচেয়ে সংক্ষিপ্ত ম্যাথমেটিকা ​​কুইন (আমি জানি)

ToString[#0][] & []

কিছুটা বিরক্তিকর হ'ল এটি হ'ল এটি আপনাকে প্রবেশ করানো সঠিক অক্ষরগুলি দেয় না। উদাহরণস্বরূপ, যদি @ফাংশন অ্যাপ্লিকেশনের জন্য ব্যবহার করা হয় তবে এটি এখনও রেন্ডার করে [...]এবং কিছু জায়গায় স্পেস .োকানো হবে। এটি সাধারণত কুইনটিকে আপনার পছন্দ হতে চেয়ে কিছুটা দীর্ঘ করবে তবে এটি সর্বদা কাজ করবে, প্রথমে কুইনের গল্ফ করে এবং তারপরে তার অনুলিপিটি অনুলিপি করে - যা এখন সত্যিকারের রানী হওয়া উচিত।

কুইন্স বাদে এর অর্থ হ'ল আপনি নিজের ফাংশনটির নাম না রেখেই পুনরাবৃত্ত কোড লিখতে পারেন। এই তিনটি (নিষ্পাপ তবে গল্ফযুক্ত) ফিবোনাচি বাস্তবায়নের সাথে তুলনা করুন:

f@0=0;f@1=1;f@n_:=f[n-1]+f[n-2]
f@n_:=If[n<2,n,f[n-1]+f[n-2]]
If[#<2,#,#0[#-1]+#0[#-2]]&

যুক্তিগুলির ক্রম

এখন এখান থেকেই আসল যাদু শুরু হয়। গল্ফিংয়ে সিকোয়েন্সগুলি প্রায়শই ব্যবহৃত হয় না, কারণ Sequenceএটি বেশিরভাগ সময়ের পক্ষে মূল্যবান হওয়ার জন্য খুব দীর্ঘ একটি নাম। খাঁটি ফাংশনগুলিতে তারা জ্বলজ্বল করে। আপনি যদি সিকোয়েন্সগুলির সাথে পরিচিত না হন তবে এগুলি মূলত কিছু অন্যান্য ভাষায় স্প্ল্যাটের মতো হয়, যদি আপনি Listকোনও ক্রিয়াকলাপের যুক্তি বা তালিকার তালিকায় একটি সিক্যুয়েন্স ব্যবহার করেন তবে এর উপাদানগুলি স্বয়ংক্রিয়ভাবে আলাদা স্লটে প্রসারিত হবে। সুতরাং

{1, Sequence[2, 3, 4], 5} == {1, 2, 3, 4, 5}
f["a", Sequence[0, {}], "b"] == f["a", 0, {}, "b"]

এখন, খাঁটি ফাংশনে ##বা ##1সমস্ত আর্গুমেন্টের ক্রম। অনুরূপভাবে, ##2দ্বিতীয় থেকে শুরু সব আর্গুমেন্ট একটি ক্রম ##3সব আর্গুমেন্ট তৃতীয় ইত্যাদি সুতরাং একটি শুরুর জন্য থেকে শুরু, আমরা শুধু reimplement করতে Sequenceযেমন ##&, 5 বাইট সংরক্ষণ। উদাহরণস্বরূপ ব্যবহার হিসাবে, এটি আমাদের একটি বিকল্প সরবরাহ করে Join@@list( এই টিপটি দেখুন ), যা কোনও বাইট সংরক্ষণ করে না, তবে যেভাবেই হোক তা জেনে রাখা ভাল:

 ##&@@@list

এটি কার্যকরভাবে নেস্টেড তালিকার প্রথম স্তরের সমতলকরণ করে। এর সাথে আমরা আর কী করতে পারি? এখানে 2 বাইটের সংক্ষিপ্ত বিকল্প রয়েছে RotateLeft:

 RotateLeft@list
 {##2,#}&@list

এই বিষয়গুলির একার জন্য এটি এই বৈশিষ্ট্যটি মাথায় রাখার উপযুক্ত। তবে, আমরা আরও ভাল করতে পারি! ক্রমগুলি সত্যই আকর্ষণীয় হয় যখন বিবেচনা করুন যে অপারেটরগুলি হুডের নীচে ফাংশন হিসাবে বাস্তবায়িত হয়। যেমন a+bবাস্তবে মূল্যায়ন করে Plus[a,b]। সুতরাং আমরা যদি একটি ক্রম দেয় ...

1+##&[1,2,3]
=> Plus[1,##] 
=> Plus[1,1,2,3]
=> 7

এই কৌতুক ব্যবহার হয়েছে এই ডগা মধ্যে একটি বাইট সংরক্ষণ করতে Times, কারণ সন্নিধি টেকনিক্যালি এছাড়াও শুধু একটি অপারেটর হল:

1##&[1,2,3]
=> Times[1,##]
=> Times[1,1,2,3]
=> 6

আপনি Unequalযদি একটি একক-বর্ণের মান বা ভেরিয়েবল জানেন যা আপনার যুক্তিগুলিতে না থাকে তবে এটি Nসম্ভবত বাইট সংরক্ষণ করতে ব্যবহার করতে পারেন ( সম্ভবত 99% ক্ষেত্রে কাজ করবে):

Unequal[a,b,c]
N!=##&[a,b,c]

এটি আনরি অপারেটরগুলির সাথে আরও আকর্ষণীয় হয়ে যায় -এবং /- দ্বিতীয় দুটি প্রকৃতপক্ষে গুণন এবং ক্ষয়ক্ষতির ক্ষেত্রে প্রয়োগ করা হয়। এখানে আপনি যে কাজগুলি করতে পারেন তার একটি তালিকা এখানে রয়েছে, যেখানে সর্বশেষ কলামটি ধরে নিয়েছে যে ফাংশনটি আর্গুমেন্টগুলি পাস করেছিল a, b, c:

Operator    Function                Expanded                    Equivalent to

+##         Plus[##]                Plus[a,b,c]                 a+b+c
1##         Times[1,##]             Times[1,a,b,c]              a*b*c
-##         Times[-1,##]            Times[-1,a,b,c]             -a*b*c
x+##        Plus[x,##]              Plus[x,a,b,c]               x+a+b+c
x-##        Plus[x,Times[-1,##]]    Plus[x,Times[-1,a,b,c]]     x-a*b*c
x##         Times[x,##]             Times[x,a,b,c]              x*a*b*c
x/##        Times[x,Power[##,-1]]   Times[x,Power[a,b,c,-1]]    x*a^b^c^-1
##/x        Times[##,Power[x,-1]]   Times[a,b,c,Power[x,-1]]    a*b*c/x
x^##        Power[x,##]             Power[x,a,b,c]              x^a^b^c
##^x        Power[##,x]             Power[a,b,c,#]              a^b^c^x
x.##        Dot[x,##]               Dot[x,a,b,c]                x.a.b.c

অন্যান্য সাধারণ অপারেটার হয় !=, ==, &&, ||। কম প্রচলিত বেশী মনে রাখা হয় |, @*, /*। উপসংহারে, এখানে একটি সামান্য বোনাস কৌশল:

####        Times[##,##]            Times[a,b,c,a,b,c]          (a*b*c)^2

এগুলি নিয়ে পরীক্ষা চালিয়ে যান এবং আপনি যদি অন্য কোনও দরকারী বা বিশেষত আকর্ষণীয় অ্যাপ্লিকেশন খুঁজে পান তবে আমাকে জানান let

Answer 5

Sqrt@2বা 2^.5=>√2

a[[1]]=>a〚1〛

#+#2&=>+##&

Flatten@a=> Join@@a(কখনও কখনও)

Function[x,x^2]=> xx^2বা#^2&

a〚1;;-1;;2〛=>a〚;;;;2〛

a〚2;;-1 ;;2〛=>a〚2;;;;2〛

a〚All,1〛=>a〚;;,1〛

{{1}}〚1,1〛=>Tr@{{1}}

0&~Array~10=>0Range@10

Range[10^3]=>Range@1*^3

Comments

নোট যখন বাইট পরিমাপ করে ব্যবহার করে 〚এবং 〛নেয় 3 প্রতিটি (অনুমান UTF8 হওয়া) বাইট

— user202729

Answer 6

অপারেটরগুলি ফাংশন হিসাবে

জুলিয়ার জন্য ডেনিসের সাম্প্রতিক আবিষ্কারের দ্বারা অনুপ্রাণিত হয়ে আমি ভেবেছিলাম ম্যাথমেটিকার জন্য আমি এটি সন্ধান করব। আমি সচেতন ছিলাম যে ম্যাথামেটিকা ​​বিপুল সংখ্যক অব্যবহৃত অপারেটর সংজ্ঞায়িত করেছেন, কিন্তু কখনই এটির দিকে খুব বেশি মনোযোগ দেননি।

রেফারেন্সের জন্য, সমস্ত অপারেটরগুলির তালিকা এখানে একটি অগ্রাধিকার সারণীর আকারে পাওয়া যাবে । শেষ কলামের ত্রিভুজটি নির্দেশ করে যে অপারেটরের অন্তর্নির্মিত অর্থ আছে কি না। যেগুলি যেগুলি সহজে সংজ্ঞায়িত করা যায় না তাদের সবগুলি না হলেও তাদের বেশিরভাগই পারেন।

সুবিধাজনকভাবে, 256 এরও কম কোডডপয়েন্ট সহ দুটি অব্যবহৃত অপারেটর রয়েছে, যেমন তারা আইএসও 8859-1 এনকোডেড উত্স ফাইলে একক বাইট হিসাবে ব্যবহার করতে পারে:

• ± (0xB1) হয় আনারি প্রিফিক্স অপারেটর বা বাইনারি ইনফিক্স অপারেটর হিসাবে ব্যবহার করা যেতে পারে।
• · (0xB7) এন> 2 এর জন্য একটি ভেরিয়াদিক বা এন-অ্যারি ইনফিক্স অপারেটর হিসাবে ব্যবহার করা যেতে পারে।

তবে আরও একটি ধরা আছে: এই অপারেটরগুলির সংজ্ঞা দেওয়ার সময় কিছু অদ্ভুত কারণে আপনার সামনে তাদের একটি জায়গা প্রয়োজন, নাহলে ম্যাথামেটিকা ​​একটি গুণকে পার্স করার চেষ্টা করে। এগুলি ব্যবহার করার সময় আপনার কোনও স্পেসের প্রয়োজন নেই যদিও:

±x_:=2x
x_ ±y_:=x+y
x_ ·y_ ·z_:=x*y+z
Print[±5]  (* 10 *)
Print[3±4] (*  7 *)
Print[3·4·5] (* 17 *)

এর সাথে তুলনা করুন:

f@x_:=2x
x_~g~y_:=x+y
h[x_,y_,z_]:=x*y+z
Print[f@5]   (* 10 *)
Print[3~g~4] (*  7 *)
Print[h[x,y,z]] (* 17 *)

সুতরাং এটি ফাংশনটি সংজ্ঞায়িত করার সময় একটি বাইট এবং এটি ব্যবহার করার সময় দুটি বাইট সংরক্ষণ করে। নোট করুন যে সংজ্ঞাটি ·চারটি অপারেটরের জন্য বাইট সংরক্ষণ করবে না এবং আরও অপারেটরগুলির জন্য বাইটস ব্যয় করতে শুরু করবে, তবে যুক্তিগুলিতে ব্যবহৃত অপারেটরগুলির নজির নির্ভর করে ব্যবহারটি এখনও বাইট সংরক্ষণ করতে পারে। এটি লক্ষ্য করাও ভাল যে আপনি সস্তাভাবে একটি বৈকল্পিক ফাংশনটি সংজ্ঞায়িত করতে পারেন যা আরও বেশি দক্ষতার সাথে বলা যেতে পারে:

x_ ·y__:={y}
Print[1·2·3·4·5] (* {2, 3, 4, 5} *)

তবে মনে রাখবেন যে একক যুক্তি দিয়ে এই বিচিত্র ক্রিয়াকলাপগুলি কল করা সহজেই সম্ভব নয়। (আপনি করতে পারতেন CenterDot[x]বা ##&[]·xতবে আপনার যদি সত্যি প্রয়োজন হয় তবে একটি ভাল সুযোগের আলাদা সমাধান দিয়ে আপনি আরও ভাল off

অবশ্যই এটি সমাধানের জন্য কোনও কিছুই সংরক্ষণ করছে না যেখানে কোনও নামহীন ফাংশনই যথেষ্ট, তবে কখনও কখনও আপনাকে পরবর্তী সময়ে ব্যবহারের জন্য সহায়ক ফাংশনগুলি সংজ্ঞায়িত করতে হবে এবং কখনও কখনও এটি বিভিন্ন পরামিতিগুলির জন্য পৃথক সংজ্ঞা স্থাপনের জন্য নামযুক্ত ফাংশনগুলি সংজ্ঞায়িত করার চেয়ে ছোট। এই ক্ষেত্রে, পরিবর্তে অপারেটর ব্যবহার করা একটি শালীন পরিমাণের বাইট সংরক্ষণ করতে পারে।

নোট করুন যে এই আইএসও 8859-1 এনকোডযুক্ত ফাইলগুলি ব্যবহার $CharacterEncodingকরার জন্য উইন্ডোজ ডিফল্টের মতো সামঞ্জস্যপূর্ণ মানটিতে সেট করা দরকার WindowsANSI। কিছু সিস্টেমে এই ডিফল্ট UTF-8যেখানে একক বাইট থেকে এই কোড পয়েন্টগুলি পড়তে সক্ষম হবে না।

Comments

এটি সত্যিই দুর্দান্ত, আমি জানতাম না যে ম্যাথামেটিকায় অপারেটরগুলির একটি তালিকা রয়েছে এবং এমনকি তাদের নজিরও রয়েছে। আপনি যে দু'জন অপারেটরকে পেয়েছেন আমি নিশ্চিত সে কাজে আসবে।

— মাইল

Answer 7

পূর্ণসংখ্যার উপর ভিত্তি করে মান নির্বাচন করা

সাদাসিধা পদ্ধতির মধ্যে নির্বাচন করতে yএবং zতার উপর নির্ভর করে কিনা, xহয় 0বা 1হয়

If[x<1,y,z]

তবে, একটি ছোট উপায় আছে:

y[z][[x]]

এই কাজ কারণ [[0]]দেয় Headএকটি অভিব্যক্তি, এই ক্ষেত্রে y, যেহেতু [[1]]শুধুমাত্র প্রথম উপাদান দেয় - প্রথম আর্গুমেন্ট এই ক্ষেত্রে, z।

এমনকি আপনি এটি দুটিরও বেশি মানের মধ্যে চয়ন করতে ব্যবহার করতে পারেন:

u[v,w][[x]]

নোট করুন যে এটি কোনও কাজ করে না যদি uএমন কোনও ফাংশন যা আসলে কোনও কিছুর মূল্যায়ন করে। ম্যাথমেটিকাকে u[v,w]যেমন রাখা ঠিক তেমনি এটি গুরুত্বপূর্ণ । তবে এটি বেশিরভাগ ক্ষেত্রে কাজ করে, একটিটি যদি uএকটি সংখ্যা, একটি স্ট্রিং বা একটি তালিকা অন্তর্ভুক্ত থাকে including

এই কৌতূহলের ক্রেডিট আলেফাল্ফায় যায় - আমি তার একটি উত্তরে এটি আবিষ্কার করেছি।

যদি xশূন্য-ভিত্তিক পরিবর্তে 1-ভিত্তিক হয় তবে কেবল ব্যবহার করুন

{y,z}[[x]]

অথবা

{u,v,w}[[x]]

কিছু বিরল ক্ষেত্রে, আপনি এমনকি সত্যটি ব্যবহার করতে পারেন যে কয়েকটি মানের জন্য গুণনটি মূল্যায়ন করা হয় না:

{"abc","def"}[[x]]
("abc""def")[[x]]

নোট যে যদিও ম্যাথামেটিকাল হবে আসলে আর্গুমেন্ট পুনর্বিন্যাস, একটি গুণ এর যদি এটা unevaluated রয়ে, তাই উপরে অভিন্ন করার

("def""abc")[[x]]

Answer 8

বিকল্প Length

এটি সম্পূর্ণরূপে লেজিওনম্যামাল978 এবং মিশা ল্যাভ্রভের কিছু পরামর্শ দিয়ে আবারও লেখা হয়েছিল। উভয়কে অনেক ধন্যবাদ।

অনেক ক্ষেত্রে Lengthব্যবহার করে কিছুটা ছোট করা যায় Tr। মূল ধারণাটি হ'ল ইনপুটটিকে গুলিগুলির তালিকায় পরিণত করা 1, যাতে Trতাদের যোগফল যোগ হয় যা তালিকার দৈর্ঘ্যের সমান হবে।

এটি করার সর্বাধিক সাধারণ উপায় হ'ল ব্যবহার 1^x(তালিকার জন্য x)। এই কাজ করে কারণ Powerহয় Listableএবং 1^nসবচেয়ে পারমাণবিক মানের জন্য nঠিক হয় 1(সমস্ত সংখ্যা, স্ট্রিং এবং চিহ্ন সহ)। সুতরাং আমরা ইতিমধ্যে এটি দিয়ে একটি বাইট সংরক্ষণ করতে পারি:

Length@x
Tr[1^x]

অবশ্যই, এটি ধরে নেয় যে xতুলনায় উচ্চতর প্রাধান্য সহ একটি অভিব্যক্তি ^।

যদি xকেবলমাত্র 0গুলি এবং 1গুলি থাকে তবে আমরা অন্য একটি বাইট ব্যবহার করে সংরক্ষণ করতে পারি Factorial(ধরে xনিচ্ছি যে এর চেয়ে বেশি অগ্রাধিকার রয়েছে !):

Length@x
Tr[x!]

কিছু বিরল ক্ষেত্রে, এর xচেয়ে কম অগ্রাধিকার থাকতে পারে ^তবে গুণণের চেয়ে আরও বেশি অগ্রাধিকার রয়েছে। সেক্ষেত্রে এর তুলনায় কম অগ্রাধিকারও থাকবে @, সুতরাং আমাদের সত্যিই তুলনা করা দরকার Length[x]। যেমন একটি অপারেটর উদাহরণ .। এই ক্ষেত্রে, আপনি এখনও এই ফর্মটি দিয়ে একটি বাইট সংরক্ষণ করতে পারেন:

Length[x.y]
Tr[0x.y+1]

এটি কী ধরণের তালিকাগুলিতে কাজ করে তা সম্পর্কে অবশেষে কিছু মন্তব্য:

উপরে উল্লিখিত হিসাবে, এটি কেবল সংখ্যা, স্ট্রিং এবং চিহ্ন সহ সমতল তালিকাতে কাজ করে। তবে এটি কিছু গভীর তালিকার উপরেও কাজ করবে, যদিও এটি আসলে কিছুটা পৃথক করে গণনা করে। একটি এন- ডি আয়তক্ষেত্রাকার অ্যারে ব্যবহার Trকরে আপনাকে সংক্ষিপ্ত মাত্রা দেয় (প্রথমটির বিপরীতে)। আপনি যদি জানেন যে বাইরেরতম মাত্রাটি সবচেয়ে সংক্ষিপ্ত, বা আপনি জানেন যে তারা Trসমস্তগুলি সমান, তবে- এক্সপ্রেশনগুলি সমান Length।

Comments

শুধু একটি এমনকি খাটো সমাধান পাওয়া: Length@x == Tr[1^x]। সর্বাধিক তালিকার সাথে কাজ করা উচিত।

— LegionMammal978

@ লেজিওনম্যামাল ৯78 এটি আশ্চর্যজনক, ধন্যবাদ :) আমি শীঘ্রই এটি সম্পাদনা করব।

— মার্টিন এেন্ডার

এখন দু'বার, আমি বিশেষ ক্ষেত্রে একটি বাইট সংরক্ষণ করার Tr[x!]পরিবর্তে নিজেকে ব্যবহার করতে পেয়েছি Tr[1^x]যেখানে xকেবল শূন্য এবং একটি রয়েছে।

— মিশা লাভরভ

@ মিশা লাভরভ এটি সত্যিই ঝরঝরে! :)

— মার্টিন ইন্ডার

Answer 9

1. পুনরাবৃত্তির সমাধানগুলি সন্ধান করুন - গাণিতিক একাধিক দৃষ্টান্ত, তবে কার্যকরী পদ্ধতির প্রায়শই সবচেয়ে অর্থনৈতিক হয়। NestWhileঅনুসন্ধানের সমস্যাগুলির জন্য একটি খুব কমপ্যাক্ট সমাধান হতে পারে NestWhileListএবং FoldListযখন আপনাকে মধ্যবর্তী পুনরাবৃত্তির ফলাফলগুলি ফিরে আসতে বা প্রক্রিয়া করার প্রয়োজন হয় তখন শক্তিশালী হয়। Map (/@), Apply (@@, @@@), MapThread, এবং সত্যিই উল্ফর্যাম এর উপর সবকিছু কার্যকরী প্রোগ্রামিং ডকুমেন্টেশন পৃষ্ঠাটিতে ক্ষমতাশালী উপাদান।

2. বর্ধিত / হ্রাসের জন্য সংক্ষিপ্ত রূপ - উদাহরণস্বরূপ, পরিবর্তে While[i<1,*code*;i++]আপনি এটি করতে পারেন
   While[i++<1,*code*]

3. আপনি প্রাক-বৃদ্ধি / হ্রাস করতে পারেন তা ভুলে যাবেন না - উদাহরণস্বরূপ, --iপরিবর্তে i--। এটি কখনও কখনও একটি প্রস্তুতিমূলক অপারেশন বাদ দিয়ে আশেপাশের কোডে কয়েকটি বাইট সংরক্ষণ করতে পারে।

4. ডেভিড ক্যারাহারের # 5 এর সমাবর্তন: যখন একই ফাংশনটি বহুবার ব্যবহৃত হয়, তখন এটিতে একটি প্রতীক বরাদ্দ করা বাইট সংরক্ষণ করতে পারে। উদাহরণস্বরূপ, আপনি ToExpressionযদি কোনও সমাধানে 4 বার t=ToExpressionব্যবহার করে থাকেন তবে t@*expression*তারপরে আপনাকে এটি সক্ষম করে। যাইহোক, আপনি এটি করার আগে একই ফাংশনটির বারবার প্রয়োগ আরও অর্থনৈতিক পুনরাবৃত্তি পদ্ধতির জন্য কোনও সুযোগকে নির্দেশ করে কিনা তা বিবেচনা করুন।

Comments

MapThreadপ্রায়শই প্রতিস্থাপন করা যেতে পারে \[Transpose]। Tio ।

— ব্যবহারকারী 202729

Answer 10

আপনি {}যদি ব্যবহার করছেন তবে ব্যবহার করবেন না @@@।

কিছু ক্ষেত্রে, আপনি যেমন একটি মত প্রকাশের মুখোমুখি হতে পারেন:

f@@@{{a,b},{c,d}}

লিখে লিখে বাইট হ্রাস করা সম্ভব:

f@@@{a|b,c|d}

Alternativesখুব কম নজরে রয়েছে, সুতরাং প্রকাশটি লিখতে সাধারণত ঠিক থাকে (একটি উল্লেখযোগ্য ব্যতিক্রম খাঁটি ফাংশন; আপনি এটি কেবলমাত্র বামতম উপাদানটিতে ব্যবহার করতে পারেন Alternatives)।

f@@@{f@a|b~g~1,#^2&@c|d@2}

মনে রাখবেন যে f@@a|b|c(এর পরিবর্তে f@@{a,b,c}) কাজ করে না কারণ Applyতার চেয়ে বেশি অগ্রাধিকার রয়েছে Alternative।

এই ক্ষেত্রে, আপনার কেবল ব্যবহার করা উচিত f@@{a,b,c}।

Answer 11

গণিত 10 শুধুমাত্র

অপারেটর ফর্ম

ম্যাথমেটিকা ​​10 তথাকথিত "অপারেটর ফর্মগুলি" সমর্থন করে যা মূলত কিছু ফাংশন কারি করা যায়। কোনও ক্রিয়াকলাপটি কারি করা হচ্ছে এর অপারেটরগুলির মধ্যে একটিকে ঠিক করে নতুন ফাংশন তৈরি করা। বলুন, আপনি SortBy[list, somereallylongfunction&]প্রচুর বিভিন্ন ব্যবহার করছেন list। আগে, আপনি সম্ভবত অ্যাসাইন করে থাকতে পারে SortByজন্য sএবং বিশুদ্ধ ফাংশন fতাই

s=SortBy;
f=somereallylongfunction&;
list1~s~f;
list2~s~f;
list3~s~f;

এখন আপনি তরকারী করতে পারেন SortBy, যার অর্থ এখন আপনি করতে পারেন

s=SortBy[somereallylongfunction&];
s@list1;
s@list2;
s@list3;

অন্যান্য ফাংশন, যা সহ একটি তালিকা বা ফাংশন যুক্তি গ্রহণ (কিন্তু সীমাবদ্ধ নয়) অনেক জন্য একই কাজ Select, Map, Nearest, ইত্যাদি

ম্যাথমেটিকা.এসইতে ইবেল্টুকভ ওভার এইগুলির একটি সম্পূর্ণ তালিকা তৈরি করতে সক্ষম হয়েছিল :

{"AllTrue", "AnyTrue", "Append", "Apply", "AssociationMap", "Cases", 
 "Count", "CountDistinctBy", "CountsBy", "Delete", "DeleteCases", 
 "DeleteDuplicatesBy", "Extract", "FirstCase", "FirstPosition", 
 "FreeQ", "GroupBy", "Insert", "KeyDrop", "KeyExistsQ", "KeyMap", 
 "KeySelect", "KeySortBy", "KeyTake", "Map", "MapAt", "MapIndexed", 
 "MatchQ", "MaximalBy", "MemberQ", "Merge", "MinimalBy", "NoneTrue", 
 "Position", "Prepend", "Replace", "ReplacePart", "Scan", "Select", 
 "SelectFirst", "SortBy", "StringCases"}

রচনা এবং রাইটকোপজিশন

Composition( @*) এবং RightComposition( /*) এর জন্য নতুন শর্টহ্যান্ড রয়েছে । এই অক্ষরগুলি সংরক্ষণ করতে পারে যেখানে একটি স্পষ্টরূপে প্রস্তাবিত উদাহরণ নিম্নলিখিত তিনটি সমতুল্য লাইনে দেখা যায়

Last@Range@# & /@ Range[5]
Last@*Range /@ Range[5]
Range /* Last /@ Range[5]

Answer 12

0-যুক্তি ফাংশন লিখবেন না

এর মতো কোডের প্রয়োজন নেই:

f[]:=DoSomething[1,2]
(*...*)
f[]
(*...*)
f[]

:=ডান হাতের পুনরায় মূল্যায়নের জন্য জোর করে আপনি কেবল একটি পরিবর্তনশীল ব্যবহার করতে পারেন :

f:=DoSomething[1,2]
(*...*)
f
(*...*)
f

এর অর্থ হ'ল আপনি যে কোনও ক্রিয়াকলাপটি প্রায়শই সম্পাদন করতে পারেন (এটি এমনকি কিছু কিছু হলেও n++) 5 বাইট ব্যয়ে একটি চরিত্রের কাছে। সুতরাং এটি ক্ষেত্রে n++চতুর্থ ব্যবহারের পরে প্রদান করে:

n++;n++;n++;n++
f:=n++;f;f;f;f

Answer 13

%একটি বিনামূল্যে ভেরিয়েবল পেতে ব্যবহার করুন

এই টিপটি কেবল তখনই প্রযোজ্য যদি গণিতের আরপিএল পরিবেশ অনুমান করা যায়। %কোডটি যখন স্ক্রিপ্ট হিসাবে চালিত হয় তখন সংজ্ঞায়িত হয় না।

তুমি কখন করতে REPL বৈশিষ্ট্যের ব্যবহার করতে, এটা করো না:

a=someLongExpression;some[other*a,expression@a,using^a]

পরিবর্তে, মনে রাখবেন যে ম্যাথমেটিকা ​​সর্বশেষ মূল্যায়িত (নিউলাইন-টার্মিনেটেড) এক্সপ্রেশনটি এতে সংরক্ষণ করে %:

someLongExpression;
some[other*%,expression@%,using^%]

যুক্ত হওয়া নতুন লাইনের জন্য একটি বাইট খরচ হয় তবে আপনি অপসারণ করে দুটি সাশ্রয় করছেন a=, সুতরাং সামগ্রিকভাবে এটি একটি বাইট সংরক্ষণ করে।

কিছু ক্ষেত্রে (যেমন আপনি যে aকোনও উপায়ে মুদ্রণ করতে চান ), আপনি এমনকি ;দুটি বাইট সংরক্ষণ করে ছাড়তে পারেন :

someLongExpression
some[other*%,expression@%,using^%]

এক বা দুটি বাইট মোটামুটি নাবালক মনে হতে পারে তবে এটি একটি গুরুত্বপূর্ণ বিষয়, কারণ এটি গল্ফ করার সময় বারবার প্রকাশের (যা একটি খুব সাধারণ কৌশল) এক্সট্রাকশন করে তোলে:

পুনরাবৃত্তি প্রকাশ প্রকাশের সাধারণ কৌশলটির জন্য ওভারহেডের চারটি বাইট খরচ হয়, যা এক্সপ্রেশনটির আরও ব্যবহারের মাধ্যমে সংরক্ষণ করা দরকার। এখানে কিছু সংরক্ষণের জন্য নামযুক্ত ভেরিয়েবলে নিষ্কাশন করার জন্য একটি অভিব্যক্তির সর্বনিম্ন সংখ্যার ব্যবহারের (সংক্ষেপের দৈর্ঘ্য অনুসারে) একটি সংক্ষিপ্ত সারণি এখানে দেওয়া হয়েছে:

Length   Min. Uses
2        6
3        4
4        3
5        3
6        2
...      2

নামবিহীন ভেরিয়েবলটি ব্যবহার করে, বেশ কয়েকটি বার প্রায়শই কয়েক বার বাইট সংরক্ষণ করা সম্ভব হবে:

When ; is required                        When ; can be omitted

Length   Min. Uses                        Length   Min. Uses
2        5                                2        4
3        3                                3        3
4        3                                4        2
5        2                                ...      2
...      2

---

আমি মনে করি না %%বা %nগল্ফিংয়ের জন্য ব্যবহার করা যেতে পারে, কারণ আপনি যদি এগুলি কমপক্ষে দু'বার ব্যবহার না করেন তবে আপনি যেখানে প্রয়োজন সেখানে কেবল ভাবটি ঠিক রাখতে পারেন। এবং আপনি যদি এটি দুটিবার ব্যবহার করেন তবে ভেরিয়েবল নামের অতিরিক্ত অক্ষর কিছু বাদ দেওয়া থেকে সঞ্চয় বাতিল করে দেয় x=।

Comments

নোট করুন যে এটি স্ক্রিপ্ট মোডে কাজ করে না।

— আলেফাল্ফা

@alephalpha স্ক্রিপ্ট মোড কি?

— মার্টিন এন্ডার

একটি গণিতের লিপি ।

— আলেফাল্ফা

@ এলাল্ফাল ওহ ঠিক আছে, আমি আমার মস্তিষ্কটি এক সেকেন্ডের জন্য সেখানে বন্ধ করে রেখেছি ... সুতরাং এর অর্থ হ'ল এটি আর ব্যবহার করা যাবেনা, যদি না আরপিএল পরিবেশ অনুমান করা যায় না।

— মার্টিন এন্ডার

Answer 14

কোনও তালিকা বাছাই করা হচ্ছে কিনা তা পরীক্ষা করা হচ্ছে

এটি মূলত এই টিপটির একটি বাস্তবায়ন কিন্তু এটি যথেষ্ট সাধারণ কাজ যা আমি মনে করি এটি এর নিজের উত্তরটির প্রেরণা দেয়।

কোনও তালিকা ক্রমযুক্ত কিনা তা যাচাই করার জন্য নিখুঁত উপায়টি ব্যবহার করা হচ্ছে

OrderedQ@a

আমরা আরও ভাল করে একটি বাইট করতে পারি

Sort@a==a

তবে, ইতিমধ্যে একটি ভেরিয়েবল যাচাই করতে আমাদের কাছে জিনিসটি না থাকলে এটি কাজ করে না। (আমাদের এমন কিছু দরকার Sort[a=...]==aযা অহেতুক দীর্ঘ long) তবে, এর বাইরে আরও একটি বিকল্প রয়েছে:

#<=##&@@a

সেরা জিনিসটি হ'ল ইনপুটটি একই বাইট গণনার জন্য বিপরীতভাবে সাজানো হয়েছে কিনা তা পরীক্ষা করতে ব্যবহার করা যেতে পারে:

#>=##&@@a

আরও একটি বাইট সংরক্ষণ করা যায় যদি ক) আমরা জানি যে তালিকার উপাদানগুলি স্বতন্ত্র এবং খ) আমরা 0 এবং 9 এর মধ্যে একটি নিম্ন সীমা জানি (অন্তর্ভুক্ত; বা বিপরীত সাজানো ক্রমের জন্য উপরের আবদ্ধ):

0<##&@@a
5>##&@@a

এটি কেন কাজ করে তা দেখতে, শীর্ষে লিঙ্কিত টিপটিতে "যুক্তির ক্রমগুলি" দেখুন।

Comments

অন্যথা, (প্রখর) কম-বাউন্ড জন্যও কাজ বিপরীত সাজানো: ##>0&@@a। বাছাইয়ের জন্য উপরের-আবদ্ধের জন্য অনুরূপ।

— ব্যবহারকারী 202729

@ ব্যবহারকারী 202729 ওহ ভাল কথা, সম্পাদনা করতে নির্দ্বিধায় (অন্যথায় যদি আমি মনে করি তবে আমি এটি সপ্তাহান্তে চেষ্টা করার চেষ্টা করব)।

— মার্টিন ইন্ডার

Answer 15

একটি স্ট্রিং পুনরাবৃত্তি

পরিবর্তে StringRepeat[str,n]ব্যবহার (0Range[n]+str)<>""। অথবা যদি strকোনো স্লট আর্গুমেন্ট উপর নির্ভর করে না, এমনকি উত্তম Array[str&,n]<>""অনুযায়ী এই ডগা।

Comments

প্রত্নতাত্ত্বিক: পরিবর্তে StringRepeat[s,n+1]ব্যবহারের Array[s&,n]<>s(এমনকি আপনার ইতিমধ্যে n+1একটি ভেরিয়েবল থাকা অবস্থায়ও)।

— মার্টিন ইন্ডার

ভাল,Table[str,n]<>""

— attinat

Answer 16

যদি আপনার বিপরীতে সাজানো সংখ্যার একটি তালিকা প্রয়োজন হয় তবে ব্যবহার করবেন না

Reverse@Sort@x

কিন্তু

-Sort@-x

ছয় বাইট সংরক্ষণ নেতিবাচক মান অনুসারে বাছাই করা SortByপরিস্থিতিগুলির জন্যও দরকারী :

Reverse@SortBy[x,Last]
SortBy[x,-Last@#&]

Comments

কি হবে -Sort@-x?

— জংহওয়ান মিন

@ জংহওয়ানমিন ওহ, আহ্, হ্যাঁ, এটি আরও ভাল। :)

— মার্টিন ইন্ডার

Answer 17

আপনি একটি অভিব্যক্তি আটকে রাখতে Breakপারেন যাতে এক বা দুটি অক্ষর সংরক্ষণ করতে পারে। উদাহরণ ( অন্যান্য বিবরণ স্পষ্টতার জন্য গল্ফ করা হয়নি ):

result = False;
Break[]

পরিণত হতে পারে

Break[result = False]

একটি চরিত্র সংরক্ষণ করতে। যদি প্রশ্নে অভিব্যক্তিটির ফাংশন অ্যাপ্লিকেশনটির চেয়ে কম অগ্রাধিকার না থাকে তবে আপনি অন্য একটি চরিত্রও সংরক্ষণ করতে পারবেন:

Print@x;
Break[]

পরিণত হতে পারে

Break@Print@x

অনির্ধারিত হলেও, যুক্তিটি Breakআশেপাশের লুপ দ্বারা প্রত্যাবর্তিত বলে মনে হচ্ছে, যা সম্ভবত আরও বেশি সঞ্চয় করতে পারে।

Answer 18

স্ট্রিং থেকে সমস্ত সাদা স্থান সরাতে sব্যবহার করুন

StringSplit@s<>""

এটি হ'ল StringSplitডিফল্ট (অ-হোয়াইটস্পেস উপাদানগুলিতে বিভক্ত) ব্যবহার করুন এবং কেবল তাদের আবার একসাথে যোগদান করুন। আপনি যদি অন্য কোনও চরিত্র বা সাবস্ট্রিং থেকে মুক্তি পেতে চান তবে একই সম্ভবত এখনও সংক্ষিপ্ত:

s~StringSplit~"x"<>""

Answer 19

বিকল্প Range

খুব সাধারণ কাজটি হ'ল 1 থেকে a n(সাধারণত ইনপুট হিসাবে দেওয়া হয়) থেকে সমস্ত সংখ্যায় কিছু ধরণের ফাংশন প্রয়োগ করা । এটি করার জন্য মূলত 3 টি উপায় রয়েছে (উদাহরণ হিসাবে একটি নামবিহীন পরিচয় ফাংশন ব্যবহার করে):

#&/@Range@n
Array[#&,n]
Table[i,{i,n}]

আমি প্রথমটির জন্য যেতে চাই (যে কোনও কারণেই হোক) তবে এটি খুব কমই সেরা পছন্দ।

Arrayপরিবর্তে ব্যবহার করা হচ্ছে

উপরের উদাহরণটি দেখায় যে ব্যবহারে Arrayএকই বাইট গণনা রয়েছে। তবে এটির একটি সুবিধা রয়েছে যে এটি একক প্রকাশ। বিশেষত, আপনি যদি কোনও ফাংশন দিয়ে ফলাফলটি আরও প্রক্রিয়া করতে চান তবে আপনি fউপসর্গ স্বরলিপিটি ব্যবহার করতে পারেন, যা একটি বাইট সংরক্ষণ করে Range:

f[#&/@Range@n]
f@Array[#&,n]

তদতিরিক্ত, আপনি আপনার নামবিহীন ফাংশনটির আশেপাশে প্রথম বন্ধনীর হাতছাড়া করতে সক্ষম হতে পারেন যা আপনার প্রয়োজন হতে পারে Range, যেমন

15/(#&)/@Range@n
15/Array[#&,n]

আপনি যদি এটিকে আর ব্যবহার করতে না চান (বা এমন অপারেটরের সাথে যার কম অগ্রাধিকার রয়েছে), আপনি তার পরিবর্তে Arrayইনফিক্স স্বরলিপিতে লিখতে এবং একটি বাইট সংরক্ষণ করতে পারেন :

#&/@Range@n
#&~Array~n

সুতরাং, Arrayপ্রায় অবশ্যই তুলনায় ভাল Range।

Tableপরিবর্তে ব্যবহার করা হচ্ছে

এখন টেবিলটি 3 বাইট বা কমপক্ষে 2 বর্ধিত করতে হবে যখন ইনফিক্স নোটেশন একটি বিকল্প:

#&/@Range@n
i~Table~{i,n}

ইনফিক্স স্বরলিপি ব্যবহার না করার সময় , Tableযদি আপনার ফাংশনটিতে বেশ কয়েকটি বিবৃতি থাকে:

(#;#)&/@Range@n
Table[i;i,{i,n}]

এটি এখনও দীর্ঘ, তবে নীচে উল্লিখিত ক্ষেত্রে অতিরিক্ত সঞ্চয় দেয়।

আসল সঞ্চয়গুলি স্টেমটি যে Tableচলমান চলকটিকে একটি নাম দেয় তা খারিজ করা উচিত নয়। প্রায়শই, আপনি অনিচ্ছাকৃত ফাংশনগুলি নেস্টেড করতে পারেন যেখানে আপনি অভ্যন্তরীণ ফাংশনগুলির মধ্যে একটির ভিতরে বাইরের ভেরিয়েবল ব্যবহার করতে চান। যখন এটি হয়, Tableতার চেয়ে কম হয় Range:

(i=#;i&[])&/@Range@n
Table[i&[],{i,n}]
i&[]~Table~{i,n}

আপনি কেবল বরাদ্দকরণের জন্য অক্ষরগুলি সংরক্ষণ করেন না i, আপনি প্রক্রিয়াটির একক বিবৃতিতে ফাংশনটি হ্রাস করতেও সক্ষম হতে পারেন, যা আপনাকে এটির উপরে ইনফিক্স স্বরলিপি ব্যবহার করতে দেয়। রেফারেন্সের জন্য, Arrayএই ক্ষেত্রে আরও দীর্ঘ, তবে এখনও এর চেয়ে ছোট Range:

(i=#;i&[])&~Array~n

আপনি কখন ব্যবহার করবেন Range?

যখনই আপনার মানগুলি প্রক্রিয়াকরণের জন্য কোনও ফাংশন কলের প্রয়োজন হয় না, উদাহরণস্বরূপ যখন কোনও ভেক্টরাইজড ক্রিয়াকলাপের মাধ্যমে ম্যাপিং করা যায়। এই ক্ষেত্রে:

5#&~Array~n
5Range@n

#^2&~Array~n
Range@n^2

অবশ্যই আপনি যদি কোনও ফাংশন ম্যাপ করতে না চান তবে এটিও খাটো

Mean@Array[#&,n]
Mean@Range@n

Comments

অবশেষে অন্য কেউ যিনি f/@Range[x]নিয়মিত ব্যবহার করেন ...

— LegionMammal978

Answer 20

শর্তটি সন্তুষ্ট করে এমন ক্ষুদ্রতম সংখ্যা সন্ধান করা

কিছু নির্মাণ যেমন i=1;While[cond[i],i++]ঠিক আছে ঠিক তেমন, তবে একটি বিকল্প রয়েছে যা দুটি বাইট সংক্ষিপ্ত:

1//.i_/;cond[i]:>i+1

উপরের কোডটি শর্তটি পূরণ করার iসাথে সাথে একটি সংখ্যাকে বারবার প্রতিস্থাপন i+1করে cond[i]। এই ক্ষেত্রে, এ iশুরু হয় 1।

দ্রষ্টব্য যে পুনরাবৃত্তির ডিফল্ট সর্বাধিক সংখ্যা 2 ^ 16 (= 65536)। আপনার যদি এর চেয়ে বেশি পুনরাবৃত্তি প্রয়োজন হয় Whileতবে ভাল would ( MaxIterations->∞খুব দীর্ঘ)

Answer 21

অপব্যবহার শর্ট সার্কিট মূল্যায়ন

আপনি কখনও কখনও Ifএকটি লজিকাল অপারেটর দিয়ে প্রতিস্থাপন করতে পারেন ।

উদাহরণস্বরূপ, আসুন আমরা বলি যে আপনি এমন একটি ফাংশন তৈরি করতে চান যা কোনও নম্বর প্রধান কিনা তা পরীক্ষা করে এবং প্রিন্টটি 2*(number) - 1যদি এটি সত্য হয়:

If[PrimeQ@#,Print[2#-1]]&

আপনি যদি এর &&পরিবর্তে ব্যবহার করেন তবে এটি খাটো :

PrimeQ@#&&Print[2#-1]&

এমনকি আপনার একাধিক এক্সপ্রেশন থাকলেও আপনি এখনও বাইট (গুলি) সংরক্ষণ করেন:

If[PrimeQ@#,a++;Print[2#-1]]&

PrimeQ@#&&a++&&Print[2#-1]&
(* or *)
PrimeQ@#&&(a++;Print[2#-1])&

আপনি ||যখন চান শর্তটি চান তখন আপনি ক্ষেত্রে ব্যবহার করতে পারেন False:

If[!PrimeQ@#,Print[2#-1]]&
(* or *)
If[PrimeQ@#,,Print[2#-1]]&
(* can become *)
PrimeQ@#||Print[2#-1]&

এই কৌশলগুলি কাজ করে কারণ লজিকাল অপারেটরগুলি সংক্ষিপ্ত-প্রচারিত হতে পারে ; দ্বিতীয় যুক্তি এবং তারপরেও বৈধ বুলিয়ান এক্সপ্রেশন হওয়ার দরকার নেই।

অবশ্যই, যদি আপনার রিটার্ন ভ্যালু Ifবা আপনার সত্য এবং মিথ্যা উভয় যুক্তির প্রয়োজন হয় তবে এটি কাজ করে না If।

Answer 22

অপারেটর ইনপুট ফর্মগুলির লোড সহ এখানে একটি তালিকা রয়েছে যা প্রচুর পরিমাণে সংক্ষিপ্ত করতে পারে। এর মধ্যে কয়েকটি অন্যান্য পোস্টে উল্লেখ করা হয়েছে, তবে তালিকাটি দীর্ঘ এবং সেখানে আমি কয়েকটি নতুন জিনিস খুঁজে পেয়ে সর্বদা অবাক হয়েছি:

Comments

তবে এটি কেবল তখনই কাজ করে যখন অপারেটর কম ইউটিএফ -8 বাইট ব্যবহার করে।

— LegionMammal978

Answer 23

ব্যবহার Optional (:)

Optional (:) বিস্তারের জন্য পৃথক নিয়ম সংজ্ঞায়িত না করে প্রতিস্থাপনগুলিতে তালিকাগুলি সম্প্রসারণ করতে ব্যবহার করা যেতে পারে।

আমার এই উত্তর এবং @ উত্তরিজিসের এই উত্তর উদাহরণ examples

ব্যবহার

... /. {p___, a_: 0, b_, q___} /; cond[b] :> ...

উপরের প্রতিস্থাপনটি প্রথমে প্যাটার্ন ব্যবহার করে {p___, a_, b_, q___}এবং এমন একটি মিল খুঁজে পায় যা bএকটি নির্দিষ্ট শর্ত পূরণ করে।

যখন এর মতো কোনও মিল খুঁজে পাওয়া যায় না, এটি বাদ দেয় a_এবং পরিবর্তে অনুসন্ধান করে {p___, b_, q___}। aঅনুসন্ধানে অন্তর্ভুক্ত নেই এবং মান রয়েছে বলে মনে করা হয় 0।

মনে রাখবেন যে দ্বিতীয় প্যাটার্ন অনুসন্ধান কেবলমাত্র bতালিকার শুরুতে ঘটে এর জন্য কাজ করবে ; bকোনও শর্তকে সন্তুষ্ট করার মান যদি মাঝখানে থাকে তবে {p___, a_, b_, q___}তার পরিবর্তে (যার উচ্চতর প্রাধান্য রয়েছে) এটি মিলবে।

তালিকার শুরুতে সন্তুষ্টিজনক শর্ত 0যখন bআসে তখন প্রতিস্থাপনটি একটি প্রেন্ডিংয়ের সমতুল্য । (অর্থাত্ পৃথক নিয়ম সংজ্ঞায়িত করার দরকার নেই, {b_, q___} /; cond[b] :> ...)

Answer 24

নামযুক্ত বিশুদ্ধ ফাংশন আর্গুমেন্ট কখন এবং কখন ব্যবহার করবেন তা জেনে নিন Know

কোড গল্ফের জন্য, খাঁটি Functionযুক্তি সর্বাধিক সাধারণভাবে Slots ব্যবহার করে উল্লেখ করা হয় ; যেমন #প্রথম যুক্তির #2জন্য, দ্বিতীয়টির জন্য ইত্যাদি for ( আরও তথ্যের জন্য এই উত্তরটি দেখুন)।

অনেক ক্ষেত্রে, আপনি বাসাতে চাইবেন Function। উদাহরণস্বরূপ, 1##&@@#&এটি একটি Functionযা তার প্রথম যুক্তি হিসাবে একটি তালিকা গ্রহণ করে এবং এর উপাদানগুলির ফলাফলকে আউটপুট করে। এখানে সেই ফাংশনটি এখানে TreeForm:

শীর্ষ স্তরে পাস হওয়া আর্গুমেন্টগুলি Functionকেবলমাত্র শীর্ষ স্তরগুলিতে উপস্থিত Slotগুলি এবং SlotSequenceগুলি পূরণ করতে পারে, এক্ষেত্রে এর অর্থ এই যে SlotSequenceঅভ্যন্তরীণ অভ্যন্তরীণ Functionঅংশটি শীর্ষ স্তরে আর্গুমেন্ট অ্যাক্সেস করার কোনও উপায় রাখে না Function।

কিছু ক্ষেত্রে, তবে, আপনি Functionঅন্যের মধ্যে নেস্টেড থাকতে চাইতে পারেন যাতে বাহ্যিকের Functionসাথে যুক্তিগুলি উল্লেখ করতে সক্ষম হয় Function। উদাহরণস্বরূপ, আপনি এমন কিছু চাইতে পারেন Array[fun,...]&যেখানে ফাংশনটি funশীর্ষ স্তরের একটি যুক্তির উপর নির্ভর করে Function। সংক্ষিপ্ততার জন্য, আসুন আমরা বলি যে এর funইনপুটটির স্কোয়ারের বাকি অংশটি ইনপুটটিকে শীর্ষ স্তরের ইনপুট দেওয়া উচিত Function। এটি সম্পাদন করার একটি উপায় হ'ল ভেরিয়েবলের উপরে শীর্ষ স্তরের যুক্তি নির্ধারণ করা:

(x=#;Array[Mod[#^2,x]&,...])&

xঅভ্যন্তরে যেখানেই প্রদর্শিত Function Mod[#^2,x]&হবে, এটি প্রথম যুক্তিকে বাইরের দিকে নির্দেশ করবে Function, যেখানে #অভ্যন্তরের প্রথম যুক্তিকে বোঝাবে Function। আরও ভাল পদ্ধতির সাথে Functionদুটি যুক্তি ফর্ম রয়েছে এমন সত্যটি ব্যবহার করা হয় যেখানে প্রথম যুক্তিটি প্রতীক বা চিহ্নগুলির তালিকা যা নামযুক্ত যুক্তিগুলির প্রতিনিধিত্ব করবে Function(নামবিহীন Slotএর বিপরীতে )। এটি এই ক্ষেত্রে আমাদের তিনটি বাইট সংরক্ষণ করে:

xArray[Mod[#^2,x]&,...]

U+F4A1বাইনারি ইনফিক্স অপারেটরের প্রতিনিধিত্বকারী তিন বাইট বেসরকারী ব্যবহারের অক্ষর \[Function]। আপনি Functionঅন্যটির মধ্যে বাইনারি ফর্মটি ব্যবহার করতে পারেন Function:

Array[xMod[x^2,#],...]&

এটি উপরের সমতুল্য। কারণটি হ'ল, যদি আপনি নামধারী আর্গুমেন্ট ব্যবহার করেন তবে Slotএর উপরের SlotSequencesঅংশে অন্তর্ভুক্ত বলে ধরে নেওয়া হয় Functionযা নামযুক্ত আর্গুমেন্ট ব্যবহার করে না।

এখন কেবল কারণ আমরা এইভাবে বাসা বাঁধতে পারি Function, এর অর্থ এই নয় যে আমাদের সর্বদা করা উচিত। উদাহরণস্বরূপ, আমরা যদি কোনও তালিকার সেই উপাদানগুলিকে বেছে নিতে চাই যা ইনপুটটির চেয়ে কম হয় তবে আমরা নীচের মতো কিছু করতে প্ররোচিত হতে পারি:

Select[...,xx<#]&

এটি ব্যবহার করা Casesএবং Functionসম্পূর্ণভাবে নেস্টেডের প্রয়োজনীয়তা এড়াতে আরও খাটো হবে :

Cases[...,x_/;x<#]&

Answer 25

আপনি চারপাশে কাজ করে Prependবা বাইট সংরক্ষণ করতে পারেন PrependTo:

l~Prepend~x
{x}~Join~l
{x,##}&@@l

অথবা

l~PrependTo~x
l={x}~Join~l
l={x,##}&@@l

দুর্ভাগ্যক্রমে, এটি আরও সাধারণের পক্ষে সহায়তা করে না Append, যা Array.push()অন্য ভাষাগুলির সাথে সংক্ষিপ্ততম সমতুল্য বলে মনে হয় ।

Answer 26

গণিত 10.2: BlockMapহয় Partition+Map

এই টিপটির শিরোনামও হতে পারে, "রিলিজ নোটগুলি পড়ুন, তাদের সবকটি"। (রেফারেন্সের জন্য, এখানে 10.2 এর জন্য প্রকাশিত নোটগুলি এবং আজকের 10.3 প্রকাশের জন্য এখানে রয়েছে ))

যাইহোক, এমনকি ছোটখাট প্রকাশগুলিও নতুন বৈশিষ্ট্যগুলির প্রচুর পরিমাণে ধারণ করে এবং 10.2 থেকে আরও কার্যকর (গল্ফের জন্য) একটি নতুন BlockMapফাংশন। এটি মূলত একত্রিত হয় Partitionএবং Mapযা গল্ফারদের জন্য দুর্দান্ত, কারণ Partitionএটি প্রায়শই ব্যবহৃত হয় এবং এটি একটি বিরক্তিকর দীর্ঘ ক্রিয়া নাম। নতুন ফাংশনটি Partitionনিজেই সংক্ষিপ্ত হবে না , তবে আপনি যখনই পার্টিশনগুলিতে কোনও ফাংশন মানচিত্র করতে চান (যা সম্ভবত প্রায়শই বেশি ঘটে থাকে) আপনি এখন একটি বা দুটি বাঁচাতে পারবেন:

#&/@l~Partition~2
BlockMap[#&,l,2]

#&/@Partition[l,3,1]
BlockMap[#&,l,3,1]

যখন নামবিহীন ফাংশনের নতুন অবস্থান আপনাকে নিজের কিছু বন্ধনী সংরক্ষণ করতে দেয় তখন সঞ্চয়গুলি আরও বড় হয়:

#&@@(#&/@Partition[l,3,1])
#&@@BlockMap[#&,l,3,1]

দুর্ভাগ্যক্রমে, আমি জানিনা কেন BlockApplyতারা যখন সেখানে ছিল তখন তারা কেন যোগ করে নি ...

এছাড়াও নোট করুন যে BlockMapচতুর্থ Partitionতালিকা পেতে আপনি যে 4 তম প্যারামিটারটি ব্যবহার করতে পারেন তা সমর্থন করে না :

Partition[Range@5, 2, 1, 1]
(* Gives {{1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 1}} *)
BlockMap[f, Range@5, 2, 1, 1]
(* Nope... *)

Answer 27

একটি চলক মধ্যে ফাংশন এবং এক্সপ্রেশন সংরক্ষণ করা

যদি আপনার উত্তর একই ফাংশন বা এক্সপ্রেশনগুলি একাধিকবার ব্যবহার করে শেষ হয় তবে আপনি এগুলি ভেরিয়েবলগুলিতে সঞ্চয় করার বিষয়টি বিবেচনা করতে পারেন।

যদি আপনার অভিব্যক্তি দৈর্ঘ্য হয় lএবং আপনি এটি nবার ব্যবহার করেন তবে এটি সাধারণত l * nবাইটগুলি ব্যবহার করে ।

তবে, আপনি যদি এটি দৈর্ঘ্য -১ ভেরিয়েবলে সংরক্ষণ করেন তবে এটি কেবল 3 + l + nবাইটস (বা 2 + l + nবাইটস, যদি আপনি ভেরিয়েবলটি যেখানে আপনার প্রয়োজন হয় না CompoundExpression (;)বা প্রথম বন্ধনী প্রয়োজন হয় ) লাগবে ।

---

উদাহরণস্বরূপ, আসুন একটি সাধারণ সমস্যা বিবেচনা করুন, এন এর চেয়ে কম যমজ প্রাইমগুলি সন্ধান করুন

কেউ এই 54 বাইট সমাধান লিখতে পারে:

Select[Range@#,PrimeQ@#&&(PrimeQ[#+2]||PrimeQ[#-2])&]&

এই উদাহরণে, ফাংশনটি PrimeQতিনবার ব্যবহৃত হয়।

PrimeQএকটি ভেরিয়েবলের নাম নির্ধারণ করে , বাইট গণনা হ্রাস করা যায়। নিম্নলিখিত দুটিই 48 বাইট (54 - 6 বাইট):

Select[p=PrimeQ;Range@#,p@#&&(p[#+2]||p[#-2])&]&
Select[Range@#,(p=PrimeQ)@#&&(p[#+2]||p[#-2])&]&

Answer 28

একটি আরোহণ কী-মান তালিকাটি অর্জন করতে, Sortপরিবর্তে ব্যবহার করুনSortBy

যেমন তালিকার জন্য list = {{1, "world"}, {0, "universe"}, {2, "country"}}, নিম্নলিখিত তিনটি বিবৃতি প্রায় সমতুল্য।

SortBy[list,#[[1]]&]
list~SortBy~First
Sort@list

একত্রিত SelectএবংSortBy

কখনও কখনও আমাদের বৃহত্তর সেট থেকে এন্ট্রি বাছাই করতে হবে এবং ন্যূনতম / সর্বাধিক সন্ধান করার জন্য তাদের বাছাই করতে হবে। কিছু পরিস্থিতিতে দুটি অপারেশন এক সাথে একত্রিত হতে পারে।

উদাহরণস্বরূপ, সর্বনিম্ন জন্য, নিম্নলিখিত দুটি বিবৃতি প্রায় সমতুল্য।

SortBy[Select[l,SomeFormula==SomeConstant&],SortValue&]
SortBy[l,SortValue+99!(SomeFormula-SomeConstant)^2&]

এবং

SortBy[Select[l,SomeFormula!=SomeConstant&],SortValue&]
SortBy[l,SortValue+1/(SomeFormula-SomeConstant)&]

1/0হয় ComplexInfinityযা সব বাস্তব সংখ্যার চেয়ে "বৃহত্তর"।

একটি মূল-মান তালিকার জন্য, উদাহরণস্বরূপ:

{SortValue,#}&/@SortBy[Select[l,SomeFormula==SomeConstant],SortValue&]
Sort[{SortValue+99!(SomeFormula-SomeConstant)^2,#})&/@l]

Answer 29

একটি Arrayসঙ্গে সমতল করা##&

ফলস্বরূপ হওয়া দরকার এমন ফলাফলগুলির একটি গণনা করার জন্য একটি বহুমাত্রিক অ্যারে ব্যবহার ##&করার সময়, চতুর্থ যুক্তি হিসাবে ব্যবহার করুন । এটি অ্যারের প্রধানগুলি পরিবর্তে ##&(সমতুল্য Sequence) দিয়ে প্রতিস্থাপন করে List, তাই চূড়ান্ত ফলাফল ফলাফলের একটি (ফ্ল্যাট) হবে Sequence।

দুটি মাত্রায়, তুলনা করুন

{Array[f,dims,origin,##&]}
Join@@Array[f,dims,origin]

অবশ্যই, Join@@Array[f,dims] এখনও 2 (বা 3, যদি ইনফিক্স স্বরলিপি ব্যবহার করা যায়) বাইটের চেয়ে কম হয় {Array[f,dims,1,##&]}।

তিন বা ততোধিক মাত্রায়, {Array[f,dims,origin,##&]}বিকল্পটি সর্বদা সংক্ষিপ্ত হয়, এমনকি যদিও এটি উত্স 1 হয়।

{Array[f,dims,1,##&]}
f~Array~dims~Flatten~2

Answer 30

ডিফল্ট মান

ডিফল্ট মানগুলি দক্ষ পদ্ধতিতে নিখুঁত প্যাটার্ন আর্গুমেন্টগুলির সাথে ডিল করে। উদাহরণস্বরূপ, আমরা যদি Exp[c_*x]কোনও ভ্যালু এর কোনও নিয়মের জন্য কোনও নিয়মে মেলে cধরতে চাই

Exp[x] + Exp[2x] /. {Exp[c_*x] -> f[c], Exp[x] -> f[1]}
(*    f[1] + f[2]    *)

cএটি যখনই অনুপস্থিত হয় তার জন্য আমরা ডিফল্ট মানটি ব্যবহার করি তার চেয়ে অনেক বেশি বাইট ব্যবহার করে :

Exp[x] + Exp[2 x] /. Exp[c_.*x] -> f[c]
(*    f[1] + f[2]    *)

একটি ডিফল্ট ব্যবহার প্যাটার্ন পর একটি বিন্দু দিয়ে নির্দেশিত হয়: c_.।

ডিফল্ট মান অপারেশন সাথে সংযুক্ত করা হয়: উপরের উদাহরণে, অপারেশন Timesমধ্যে c_.*x, এবং একটি অনুপস্থিত মান c_এইভাবে সঙ্গে যুক্ত ডিফল্ট মান থেকে নেওয়া হয় Times, যা 1. জন্য, Plusডিফল্ট মান 0 হয়:

Exp[x] + Exp[x + 2] /. Exp[x + c_.] -> f[c]
(*    f[0] + f[2]    *)

জন্য Powerবহিঃপ্রকাশ, ডিফল্ট 1:

x + x^2 /. x^n_. -> p[n]
(*    p[1] + p[2]    *)