TI-BASIC में गोल्फ के लिए टिप्स

Question

TI-83/84 + श्रृंखला कैलकुलेटर के लिए आपके पास TI-BASIC में गोल्फिंग के लिए क्या सामान्य सुझाव हैं? मैं उन विचारों की तलाश कर रहा हूं, जिन्हें कोड-गोल्फ समस्याओं पर लागू किया जा सकता है और जो कम से कम कुछ हद तक TI-BASIC के लिए विशिष्ट हैं (उदाहरण के लिए "टिप्पणियां हटाएं" एक उत्तर नहीं है)।

कृपया प्रति उत्तर एक टिप पोस्ट करें।

Comments

कृपया हमेशा शामिल करें कि आप किस संस्करण का उल्लेख कर रहे हैं!

— दोष

Answer 1

आपका कैलकुलेटर आपके लिए लाइनों के अंत में बहुत स्मार्ट है, और इस तरह आप कुछ पात्रों को छोड़ सकते हैं।

:Disp "HELLO WORLD    //is the same as...
:Disp "HELLO WORLD"

For(लूप में इस तरह एक वाक्यविन्यास है - For(variable, start, end, increment)लेकिन आप वेतन वृद्धि को छोड़ सकते हैं और यह 1 का उपयोग करेगा

:For(A,1,5     //is the same as...
:For(A,1,5,1)

और आप बोर्ड भर में कोष्ठक (लाइनों के अंत में) को छोड़ सकते हैं:

:Output(1,1,A
:int(A
:round(A
etc.

_{मेरे TI-84 सिल्वर एडिशन कैलकुलेटर पर परीक्षण किया गया}

_{अगर आपको लगता है कि यह एक से अधिक विचार है (अंत का उल्लेख करते हुए) तो मैं उन्हें अलग कर दूंगा}

Comments

.... यह सिर्फ गलत है

— बीटा डिके

इसके अलावा, कोड को फिर से लिखने का प्रयास करें ताकि आप कम से कम संख्या में कोष्ठक का उपयोग करें। हर पंक्ति के केवल अंतिम अभिव्यक्ति पर, आपको कोष्ठक मुफ्त में मिलते हैं, इसलिए सबसे नेस्टेड स्टेटमेंट को अंत तक ले जाएं। यानी not(iPart(B))+(A=5हो सकता है (A=5)+not(iPart(B।

— lirtosiast

यह उन सभी चीजों के लिए लागू होता है जिन्हें बंद करने की आवश्यकता होती है, न कि केवल कोष्ठक (अर्थात् {lists}, "strings"और [[matrices]])। जब आप एक नई रेखा, बृहदान्त्र (newline के लिए एक स्टैंड-इन) तक पहुँच जाते हैं, तो स्वचालित रूप से अभिव्यक्तियाँ बंद हो जाएंगी, तार पर लागू नहीं होती हैं, हालाँकि, जैसा कि वे कॉलन को शामिल कर सकते हैं) या चर असाइनमेंट तीर ( →, STO typ `बटन के साथ टाइप किया गया। )। भाषा की ऐसी अजीब विशेषता।

— MI राइट

Answer 2

उपयोग Ans

यदि आप केवल अगली पंक्ति में एक अभिव्यक्ति का उपयोग करेंगे, तो इसे एक चर में संग्रहीत न करें! विशेष Ans वैरिएबल एक-बाइट टोकन है जो मूल्यांकन किए गए अंतिम अभिव्यक्ति के मूल्य को संग्रहीत करता है। इस प्रकार:

Xsin(A)->R
Disp R+tanh(R

हो सकता है

Xsin(A)
Disp Ans+tanh(Ans

दो बाइट्स बचा रहा है।

Answer 3

फ़्लोटिंग-पॉइंट संख्याओं में एन्कोडेड लुकअप तालिका का उपयोग करें

थोड़ा उन्नत टिप:

छोटे लुकअप टेबल कोड गोल्फ के लिए उपयोगी होते हैं: यह बहुत बार होता है कि हमें एक फ़ंक्शन की आवश्यकता होती है, उदाहरण के लिए, 0 से 1, 1 से 2, 2 से 1 और बाकी सब 0. से। हालांकि, TI-BASIC सरणियाँ अनुकूल नहीं हैं इस उद्देश्य के लिए: एक चीज़ के लिए, वे एक-आधारित हैं, और दूसरे के लिए, मान तब तक नहीं निकाला जा सकता जब तक कि सरणी Ansया सूची चर में संग्रहीत न हो जाए ।

यहाँ मेरे उत्तर में , मैं बेस 11 में एक मैजिक कंटेंट में एक छोटी लुकअप टेबल स्टोर करता हूं। बस उन मूल्यों को सूचीबद्ध करें जिन्हें आप उपयोग करना चाहते हैं,

{0,-1,5,-1,-1,2,9,-1,8,6}

एक उपयोगी रूप में परिवर्तित करें

{1,0,6,0,0,3,10,0,9,7}

अपने इच्छित आधार (आधार 11) में लिखें

.106003A097

और बेस 10 में परिवर्तित करें

-1+int(11fPart(11^Ans.0954191904

सबसे छोटा सरणी दृष्टिकोण 8 बाइट्स लंबा है!

{1,0,6,0,0,3,10,0,9,7}-1:Ans(X+1

TI-BASIC केवल 14 दशमलव अंकों तक ही संग्रहीत करता है, इसलिए आप 44ish बिट्स तक स्टोर कर सकते हैं लेकिन केवल 14 दशमलव अंक।

बेस-एन एन्कोडिंग के बजाय एक जादू निरंतर खोजने के लिए जानवर-बल खोज का उपयोग करके इस तकनीक को अक्सर और बेहतर बनाया जा सकता है। मैं अभी भी ऊपर दिए गए उत्तर को गोल करने की प्रक्रिया में हूं, लेकिन वेंगिरी ( फोरम TI-BASIC) पर 30 वीं संख्या (यानी एक दोहराई गई सूची ) के साथ सहसंबंध के बीच के अंतर को उत्पन्न करने के लिए इस पद्धति का इस्तेमाल किया6, 4, 2, 4, 2, 4, 6, 2 गया था। इस स्निपेट के साथ डेवलपर:

2+2iPart(3fPart(576e^(fPart(I/8

576 का जादू मैथेमेटिका का उपयोग करते हुए पाया गया था, लेकिन अगर आप अपनी पसंदीदा भाषा में स्क्रिप्ट का उपयोग नहीं करते हैं।

Answer 4

बार-बार होने वाले एक्सप्रेशन समीकरण चर लगाएं।

पूर्व:

Remainder(randInt(1,9),1
Remainder(randInt(1,9),5
Remainder(randInt(1,9),10

हो सकता है:

"randInt(1,9→u
Remainder(u,1
Remainder(u,5
Remainder(u,10

नोट: इसके लिए एक अच्छा उपयोग खोजना मुश्किल है, लेकिन इसका मतलब यह नहीं है कि आपको समीकरण चर भूल जाना चाहिए: P

स्रोत: http://tibasicdev.wikidot.com/selfmodify

-ओमूनागा से C4ooo

Comments

इस उदाहरण में, आप फ़ंक्शन nके साथ, पहली अभिव्यक्ति में जोड़कर अधिक बचत कर सकते हैं Remainder(।

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

Answer 5

अनावश्यक चर आरंभिक छोड़ें

वर्तमान सहमति सभी कोड को नए सिरे से व्याख्या करने की अनुमति देने के लिए है। हम इसका लाभ उठा सकते हैं - सभी गैर-विनिर्मित वास्तविक चर 0TI-BASIC में Xminशुरू होते हैं , और संभवतः उपयोगी मूल्य के रूप में शुरू होते हैं -10। इसलिए यदि आपको कभी भी एक प्रोग्राम में एक रनिंग टोटल लेने की आवश्यकता होती है जो Ans से इनपुट नहीं लेता है, या आपको वास्तव -10में एक कम बाइट की आवश्यकता है, तो यह टिप आपकी मदद कर सकती है।

Comments

Xmax 10 है और Ymin और Ymax समान व्यवहार करते हैं, है ना? इसके अलावा कुछ अन्य ग्राफ़ पैरामीटर हैं जिनके कुछ अन्य मूल्य हैं, मुझे लगता है।

— फेबियन रोइंग

Answer 6

छोटी सूची पीढ़ी

यदि आपको एक सूची की आवश्यकता है {1,2,...,N}, जहां एन, कहते हैं, 42, इसे बनाने का स्पष्ट तरीका है

seq(X,X,1,42. 

हालाँकि, एक बाइट उससे छोटी है जो binomcdf((संचयी द्विपद वितरण) कमांड का उपयोग करके एक साफ-सुथरी हैक है ।

cumSum(binomcdf(41,0

यह केवल तभी काम करता है जब N एक स्थिरांक होता है, क्योंकि बचत N-1 की जगह कोड में इसके मूल्य से आती है।

दो मामले हैं जो छोटे कोड को भी अनुमति देते हैं।

यदि आपके पास पहले से ही L1आयाम N की सूची है:

cumSum(1 or L1

यदि आपको आदेश की परवाह नहीं है:

randIntNoRep(1,N     ;random permutation of numbers from 1 to N

Comments

एक बाइट छोटी (और बेवकूफी से धीमी) होने की गारंटी seq(X,X,1,Nतब भी जब Nनिरंतर नहीं है cumSum(1 or rand(N।

— मीशा लावरोव

Answer 7

किसी प्रोग्राम के अंत में इफ ब्लॉक के लिए स्टेटमेंट को खत्म करें

दो बाइट्स बचाता है: एक एंड के लिए और एक लाइनब्रेक के लिए। यह आपको अंतिम पंक्ति पर निहित विवाद का उपयोग करने की अनुमति देता है, अक्सर एक अतिरिक्त बाइट की बचत होती है।

[code]
If A>5
Then
Output(1,1,Ans²+Ans+A
Disp 3ln(A
End
//end of program

हो सकता है:

[code]
If A>5
Then
Output(1,1,Ans²+Ans+A
3ln(A
//end of program

Comments

यह ध्यान दिया जाना चाहिए कि यह टिप लूप ब्लॉक के लिए काम नहीं करता है। अच्छा टिप के लिए +1 हालांकि

— ताओ

Answer 8

अपने मुहावरों को जानिए

यहाँ कुछ स्निपेट हैं जिन्हें मैं आमतौर पर कोड गोल्फ में उपयोग करता हूं:

• सत्य-मान में बदलें (0/1): not(not(Ansया Ans and 1। कौन सा उपयोग करना है, यह आवश्यक कोष्ठकों पर निर्भर करता है।
• एक सत्य-मूल्य में एक जोड़ें int(e^(Ans:। एक ओपन-परेन बचाता है 1+(Ans। बहुत उपयोगी है, क्योंकि TI-BASIC में एक-आधारित सरणियाँ हैं।
• नक्शा {0,1} के लिए {1,-1}: cos(πAns। एक-एक बाइट बचा लेता है 1-2Ans।

---

• किसी संख्या का संकेत कार्य: tanh(ᴇ9Ans
• सकारात्मक अनंत की ओर दौर: -int(-Ans
• एक सकारात्मक पूर्णांक में अंकों की संख्या: 1+int(log(Ans
• सूची के लिए जटिल संख्या {Re,Im}:imag(Ans{i,1

---

• स्ट्रिंग को सूची में बदलें: seq(inString("...",sub(Ans,X,1)),X,1,length(Ans( ...खोज स्ट्रिंग कहां है)
• सूची के पहले तत्व को काट लें: ΔList(cumSum(Ans
• सूची के अंतिम तत्व को काट दें: ΔList(cumSum(Ans)-Ans
• जाँच करें कि सूची के सभी तत्व L1 अद्वितीय हैं:SortA(L1:min(ΔList(L1
• एक सूची में संख्या X के लिए खोजें (पहली घटना होती है): 1+sum(not(cumSum(Ans=X
• किसी एकल मोड के मौजूद होने पर सूची का मोड, और सूची में अधिकतम 10 तत्व होते हैं: (बदसूरत, लेकिन छोटा): median(Ans,10^(seq(sum(Ans=Ans(X)),X,1,dim(Ans

Comments

मैं सच में समझ में नहीं आता कि tanh(ᴇ9Ansएक काम क्यों करता है।

— SuperJedi224

@ SuperJedi224 खैर, tanh (0 शून्य है, और बाईं और दाईं ओर अनंत की सीमाएँ -1 हैं और 1. यह घातीय रूप से उन मूल्यों के करीब हो जाता है, इसलिए पिछले -17 या तो यह + -1 की गोलाई त्रुटि के भीतर है। यदि निरपेक्ष मूल्य पहले से ही 17ish से अधिक हैं, तो हम सिर्फ tanh का उपयोग करते हैं (अकेले।

— lirtosiast

Answer 9

यदि आप स्वयं का उपयोग कर पाते हैं

0→G ;or any other variable
;other lines of code

तब, आप उपयोग कर सकते हैं (बाइट बचाने के लिए):

DelVar G;other lines of code

ऐसा इसलिए है क्योंकि जब आप किसी चर ( G) को हटाते हैं , तो यह इस मामले में, उसका डिफ़ॉल्ट मान बन जाता है 0। फिर, आप DelVarस्टेटमेंट के बाद एक नई लाइन के बिना दूसरी लाइन डाल सकते हैं । किसी DelVarस्टेटमेंट के बाद महत्वपूर्ण नियंत्रण स्टेटमेंट डालते समय सावधानी बरतें ।

(TI-84 पर परीक्षण)

Comments

यह शायद ही कभी उपयोगी है; चर को डिफ़ॉल्ट रूप से 0 पर प्रारंभ किया जाता है, और आप ZStandard करके Y को शून्य कर सकते हैं।

— lirtosiast

@ThomasKwa यह मेरे लिए कई उदाहरणों, esp के लिए उपयोगी है। जब निष्पादन के माध्यम से रीसेट की आवश्यकता होती है।

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

कोड गोल्फ में? कब? यदि आप मुझे प्रोग्राम दिखाते हैं तो मुझे लगता है कि मैं डेल्वार को ऑप्टिमाइज़ कर सकूंगा।

— 3

@ThomasKwa नहीं xode गोल्फ प्रति से , बल्कि, कम डिस्क स्थान (TI-83) पर प्रोग्रामिंग। अभी मेरा कोई कार्यक्रम नहीं है। मैं उस पर तुम्हारे पास वापस आऊंगा।

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

कुछ मिनटों के विचार के बाद, मैं कुछ परिदृश्यों के बारे में सोच सकता हूं जब DelVar संभवतः सबसे कम हो सकता है, जैसे एकल-पंक्ति के बाद यदि कथन।

— lirtosiast

Answer 10

कौन सी सूची चर का उपयोग करें?

सूचियों का उपयोग करते समय, एक-अक्षर के नामों के साथ नामित सूचियों के पक्ष में डिफ़ॉल्ट सूचियों L₁से बचें L₆: के ᶫAमाध्यम से ᶫZ(जहां)ᶫ थोड़ा एल है)।

या तो संदर्भ के लिए दो बाइट्स की लागत होती है (हालांकि L₁एक एकल टोकन है, यह एक दो-बाइट टोकन है) लेकिन जब किसी सूची में मान संग्रहीत करते हैं, तो आप ᶫबाइट को बचाते हुए प्रतीक को छोड़ सकते हैं :

{1,2,3,4,5→ᶫA

हो सकता है

{1,2,3,4,5→A

कैलकुलेटर यह तय करने के लिए कि परिणाम कहां संग्रहीत है, अभिव्यक्ति के डेटा प्रकार की जांच करता है।

इसी तरह, Input Aया अगर उपयोगकर्ता एक संख्या के बजाय एक सूची में प्रवेश करता है, तो Prompt Aस्टोर करेगा ᶫA।

कई अन्य आदेशों का उपयोग बिना किया जा सकता है ᶫ, हालांकि उनमें से ज्यादातर का उपयोग शायद ही कभी गोल्फ में किया जाता है। उदाहरण के लिए, अपने तीसरे, चौथे और उच्च तर्कों में हटाए जाने की Matr►list(अनुमति देता ᶫहै।

सामान्य नियम यह है कि, यदि कमांड एक सूची चर नाम लेता है और सूची अभिव्यक्ति नहीं है , और यदि कोई वैकल्पिक वाक्यविन्यास नहीं है जो एक अलग प्रकार का चर डाल सकता है, तो कमांड के साथ काम कर सकता हैᶫ बाईं ओर से है।

यह किसी सूची की एकल प्रविष्टि को संशोधित करने के साथ काम नहीं करता है: 1→ᶫA(3इसे बदला नहीं जा सकता 1→A(3।

बेशक, उपयोग करने के लिए सबसे अच्छी सूची चर हमेशा होती है Ans।

Comments

रुको क्या? " Input A" ᶫAअगर उपयोगकर्ता किसी सूची में प्रवेश करता है तो उसे स्टोर करता है। "इसका मतलब है कि मेरे कई कार्यक्रम तोड़ने में बहुत आसान हैं। फिर यह अच्छा है कि मेरे पास Inputवैसे भी कई कार्यक्रम नहीं हैं , मेरे पास या तो छोटे उपकरण हैं जिनमें कोई त्रुटि नहीं है या पूरा खेल जो GetKeyइसके बजाय उपयोग करते हैं Input।

— Fabian Röling

यदि आप वास्तव में इस के खिलाफ अपने कार्यक्रमों के उपयोगकर्ता-प्रूफिंग के लिए उत्सुक हैं, तो आप हमेशा एक यादृच्छिक मूल्य को स्टोर कर सकते हैं Aऔर जांचें कि क्या यह बाद में बदल गया है Input A।

— मिशा लावरोव

Answer 11

अपनी चर असाइनमेंट लागत को जानें

यदि आप एक- बार Bअभिव्यक्ति Nसमय का उपयोग करते हैं , तो क्या आपको इसे एक चर पर असाइन करना चाहिए?

Ansलागत 1+Nबाइट्स का उपयोग करने के लिए (प्रत्येक लाइनब्रेक के लिए एक और हर बार इसका उपयोग करने के लिए है, इसलिए जब Ans का उपयोग करें (B-1)*(N-1)>2। Ansप्रति पंक्ति केवल एक ही हो सकता है , इसलिए इसके लिए सभी मानों को आज़माएं Ansजो उपयोगी हो सकता है।

वास्तविक चर (जैसे X) लागत 3+Nबाइट्स, इसलिए जब उन्हें उपयोग करें (B-1)*(N-1)>4।

सूची चर लागत 3+2Nबाइट्स, इसलिए जब उन्हें उपयोग करें (B-2)*(N-1)>5।

समीकरण चर कम से कम उपयोगी होते हैं: उन्हें 4+2Nबाइट्स की आवश्यकता होती है। जब उनका उपयोग करें (B-2)*(N-1)>6।

Min. bytes in an expression to save
 N \ var. | Ans | Real | List | Eqn
------------------------------------
 2           4     5      8      9
 3           3     4      5      6
 4           2     3      4      5

जब कोई फ़ंक्शन किसी सूची का मूल्यांकन करता है, तो उसे समीकरण चर के बजाय सूची में संग्रहीत करें u; यह एक बाइट बचाता है।

ध्यान रखें कि करीबी कोष्ठक की उपस्थिति या अनुपस्थिति अक्सर भंडारण अभिव्यक्तियों का कारण बन सकती है यदि वे फिर से व्यवस्थित हो जाएं।

अब मैं खुद का खंडन करूंगा और कहूंगा कि जितना हो सके एक लाइन पर कोड लिखना चाहिए। क्यूं कर? आमतौर पर जब एक लाइन पर एक लंबी दोहराया अभिव्यक्ति होती है, तो इसे सरल बनाया जा सकता है।

Answer 12

int (रैंड ओवर रैंडआईंट)

X + int (Yrand randInt की तुलना में या उससे कम बाइट्स के बराबर है (X, Y as randInt एक 2 बाइट टोकन है। कुछ संभावित लाभ:

दो बाइट की बचत होने पर X + को छोड़ा जा सकता है

रांडआईंट से पहले एक्स + आवश्यक है (वैसे भी कुछ स्थितियों में, उदाहरण के लिए एक चरण फ़ंक्शन से यादृच्छिक जैसे {2,5,8,11}

X + int (Yrand (N का उपयोग केवल randInt के रूप में किया जा सकता है), X, Y, N, यादृच्छिक संख्याओं की सूची उत्पन्न करने के लिए

ग्राफस्क्रीन आरंभीकरण

लाइन जैसे कार्यों का उपयोग करने के लिए (पिक्सेल निर्देशांक के साथ आसानी से यह ग्राफ़िक्स कुल्हाड़ियों को चौकोर पिक्सेल को आरम्भ करने और कुल्हाड़ियों को हटाने के लिए आवश्यक है:

AxesOff
84→Xmin
72→Ymax
ZInteger

दबाना

min(U,max(L,N

जहां N संख्या या एल्गोरिथ्म है और U और L ऊपरी और निचले सीमा हैं

सूची में एन है

max(N={X,Y,Z

अधिक सूची गणित

L1*L2→L3

instead of

for(A,1,dim(L1
L1(A)*L2(A→L3(A
End

This also works for things like this:
not(L1
L1 and L2

उत्पादन

Disp और Text (दोनों को जंजीर किया जा सकता है, इसलिए Disp A, B अलग-अलग लाइनों पर A तब B प्रदर्शित करेगा और पाठ (28,40, A, B एक रेखा पर B के आगे A प्रिंट करेगा)

इष्टतम आंदोलन लूप से टेक

इनमें से बहुत सारे अनुकूलन, सबसे कम बाइट्स में स्क्रीन के चारों ओर एक चरित्र को स्थानांतरित करने के लिए उपयोग की जाने वाली तकनीक का हिस्सा हैं

http://tibasicdev.wikidot.com/movement

टोकन साइज़ सूची

http://tibasicdev.wikidot.com/tokens

स्कोरिंग में मदद के लिए