परिचय

आपका कार्य 2 के वर्गमूल और 3 के वर्गमूल के अंक-वार राशि के निरंतर अंश प्रतिनिधित्व में पहले 1000 शब्द उत्पन्न करना है।

दूसरे शब्दों में, वास्तव में निम्न सूची का उत्पादन करें (लेकिन आउटपुट स्वरूप लचीला है)

[2, 6, 1, 5, 7, 2, 4, 4, 1, 11, 68, 17, 1, 19, 5, 6, 1, 5, 3, 2, 1, 2, 3, 21, 1, 2, 1, 2, 2, 9, 8, 1, 1, 1, 1, 6, 2, 1, 4, 1, 1, 2, 3, 7, 1, 4, 1, 7, 1, 1, 4, 22, 1, 1, 3, 1, 2, 1, 1, 1, 7, 2, 7, 2, 1, 3, 14, 1, 4, 1, 1, 1, 15, 1, 91, 3, 1, 1, 1, 8, 6, 1, 1, 1, 1, 3, 1, 2, 58, 1, 8, 1, 5, 2, 5, 2, 1, 1, 7, 2, 3, 3, 22, 5, 3, 3, 1, 9, 1, 2, 2, 1, 7, 5, 2, 3, 10, 2, 3, 3, 4, 94, 211, 3, 2, 173, 2, 1, 2, 1, 14, 4, 1, 11, 6, 1, 4, 1, 1, 62330, 1, 17, 1, 5, 2, 5, 5, 1, 9, 3, 1, 2, 1, 5, 1, 1, 1, 11, 8, 5, 12, 3, 2, 1, 8, 6, 1, 3, 1, 3, 1, 2, 1, 78, 1, 3, 2, 442, 1, 7, 3, 1, 2, 3, 1, 3, 2, 9, 1, 6, 1, 2, 2, 2, 5, 2, 1, 1, 1, 6, 2, 3, 3, 2, 2, 5, 2, 2, 1, 2, 1, 1, 9, 4, 4, 1, 3, 1, 1, 1, 1, 5, 1, 1, 4, 12, 1, 1, 1, 4, 2, 15, 1, 2, 1, 3, 2, 2, 3, 2, 1, 1, 13, 11, 1, 23, 1, 1, 1, 13, 4, 1, 11, 1, 1, 2, 3, 14, 1, 774, 1, 3, 1, 1, 1, 1, 1, 2, 1, 3, 2, 1, 1, 1, 8, 1, 3, 10, 2, 7, 2, 2, 1, 1, 1, 2, 2, 1, 11, 1, 2, 5, 1, 4, 1, 4, 1, 16, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 8, 1, 2, 1, 1, 22, 3, 1, 8, 1, 1, 1, 1, 1, 9, 1, 1, 4, 1, 2, 1, 2, 3, 5, 1, 3, 1, 77, 1, 7, 1, 1, 1, 1, 2, 1, 1, 27, 16, 2, 1, 10, 1, 1, 5, 1, 6, 2, 1, 4, 14, 33, 1, 2, 1, 1, 1, 2, 1, 1, 1, 29, 2, 5, 3, 7, 1, 471, 1, 50, 5, 3, 1, 1, 3, 1, 3, 36, 15, 1, 29, 2, 1, 2, 9, 5, 1, 2, 1, 1, 1, 1, 2, 15, 1, 22, 1, 1, 2, 7, 1, 5, 9, 3, 1, 3, 2, 2, 1, 8, 3, 1, 2, 4, 1, 2, 6, 1, 6, 1, 1, 1, 1, 1, 5, 7, 64, 2, 1, 1, 1, 1, 120, 1, 4, 2, 7, 3, 5, 1, 1, 7, 1, 3, 2, 3, 13, 2, 2, 2, 1, 43, 2, 3, 3, 1, 2, 4, 14, 2, 2, 1, 22, 4, 2, 12, 1, 9, 2, 6, 10, 4, 9, 1, 2, 6, 1, 1, 1, 14, 1, 22, 1, 2, 1, 1, 1, 1, 118, 1, 16, 1, 1, 14, 2, 24, 1, 1, 2, 11, 1, 6, 2, 1, 2, 1, 1, 3, 6, 1, 2, 2, 7, 1, 12, 71, 3, 2, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 1, 3, 5, 5, 1, 1, 1, 1, 4, 1, 1, 1, 3, 1, 4, 2, 19, 1, 16, 2, 15, 1, 1, 3, 2, 3, 2, 4, 1, 3, 1, 1, 7, 1, 2, 2, 117, 2, 2, 8, 2, 1, 5, 1, 3, 12, 1, 10, 1, 4, 1, 1, 2, 1, 5, 2, 33, 1, 1, 1, 1, 1, 18, 1, 1, 1, 4, 236, 1, 11, 4, 1, 1, 11, 13, 1, 1, 5, 1, 3, 2, 2, 3, 3, 7, 1, 2, 8, 5, 14, 1, 1, 2, 6, 7, 1, 1, 6, 14, 22, 8, 38, 4, 6, 1, 1, 1, 1, 7, 1, 1, 20, 2, 28, 4, 1, 1, 4, 2, 2, 1, 1, 2, 3, 1, 13, 1, 2, 5, 1, 4, 1, 3, 1, 1, 2, 408, 1, 29, 1, 6, 67, 1, 6, 251, 1, 2, 1, 1, 1, 8, 13, 1, 1, 1, 15, 1, 16, 23, 12, 1, 3, 5, 20, 16, 4, 2, 1, 8, 1, 2, 2, 6, 1, 2, 4, 1, 9, 1, 7, 1, 1, 1, 64, 10, 1, 1, 2, 1, 8, 2, 1, 5, 4, 2, 5, 6, 7, 1, 2, 1, 2, 2, 1, 4, 11, 1, 1, 4, 1, 714, 6, 3, 10, 2, 1, 6, 36, 1, 1, 1, 1, 10, 2, 1, 1, 1, 3, 2, 1, 6, 1, 8, 1, 1, 1, 1, 1, 1, 1, 2, 40, 1, 1, 1, 5, 1, 3, 24, 2, 1, 6, 2, 1, 1, 1, 7, 5, 2, 1, 2, 1, 6, 1, 1, 9, 1, 2, 7, 6, 2, 1, 1, 1, 2, 1, 12, 1, 20, 7, 3, 1, 10, 1, 8, 1, 3, 1, 1, 1, 1, 2, 1, 1, 6, 1, 2, 1, 5, 1, 1, 1, 5, 12, 1, 2, 1, 2, 1, 2, 1, 1, 3, 1, 1, 1, 8, 2, 4, 1, 3, 1, 1, 1, 2, 1, 11, 3, 2, 1, 7, 18, 1, 1, 17, 1, 1, 7, 4, 6, 2, 5, 6, 4, 4, 2, 1, 6, 20, 1, 45, 5, 6, 1, 1, 3, 2, 3, 3, 19, 1, 1, 1, 1, 1, 1, 34, 1, 1, 3, 2, 1, 1, 1, 1, 1, 4, 1, 2, 1, 312, 2, 1, 1, 1, 3, 6, 6, 1, 2, 25, 14, 281, 4, 1, 37, 582, 3, 20, 2, 1, 1, 1, 2, 1, 3, 7, 8, 4, 1, 11, 2, 3, 183, 2, 23, 8, 72, 2, 2, 3, 8, 7, 1, 4, 1, 4, 1, 2, 2, 1, 2, 1, 8, 2, 4, 1, 2, 1, 2, 1, 1, 2, 1, 1, 10, 2, 1, 1, 5, 2, 1, 1, 1, 2, 1, 1, 2, 1, 3, 2, 9]

चुनौती

जारी रखा अंश के लिए निम्न सामान्य परिचय चुनौती से लिया गया है एक निरंतर अंश को सरल बनाएं ।

निरंतर भिन्नताएं ऐसे भाव हैं जो आंशिक रूप से भिन्न का वर्णन करते हैं। उनका रेखांकन किया जा सकता है:

या उन्हें मूल्यों की सूची के रूप में दर्शाया जा सकता है: [a₀, a₁, a₂, a₃, ... a_n]

इस चुनौती के अंकों के लिहाज से योग के निरंतर अंश पता लगाने के लिए है sqrt(2)और sqrt(3), अंकों के लिहाज से योग इस प्रकार परिभाषित किया गया है,

के दशमलव प्रतिनिधित्व अंक ले लो sqrt(2)और sqrt(3), और अंकों द्वारा योग अंकों प्राप्त:

    1.  4  1  4  2  1  3  5  6  2  3 ...
+   1.  7  3  2  0  5  0  8  0  7  5 ...
=   2. 11  4  6  2  6  3 13  6  9  8 ...

फिर केवल योग के अंतिम अंक को रखें और उन्हें वास्तविक संख्या के दशमलव प्रतिनिधित्व में संकलित करें

    1.  4  1  4  2  1  3  5  6  2  3 ...
+   1.  7  3  2  0  5  0  8  0  7  5 ...
=   2. 11  4  6  2  6  3 13  6  9  8 ...
->  2.  1  4  6  2  6  3  3  6  9  8 ...

के अंकों के लिहाज से योग sqrt(2)और sqrt(3)इसलिए है 2.1462633698..., और जब यह जारी रखा अंश के साथ पहले 1000 मूल्यों (यानी व्यक्त किया जाता है करने के लिए ) प्राप्त परिचय खंड में सूचीबद्ध होते हैं।a₀a₉₉₉

चश्मा

आप एक समारोह या एक पूर्ण कार्यक्रम लिख सकते हैं। न ही इनपुट लेना चाहिए। दूसरे शब्दों में, फ़ंक्शन या प्रोग्राम को बिना किसी इनपुट के ठीक से काम करना चाहिए। इससे कोई फर्क नहीं पड़ता कि यदि गैर-रिक्त इनपुट प्रदान किया जाता है तो फ़ंक्शन या प्रोग्राम क्या करता है।
आपको STDOUT पर आउटपुट देना चाहिए। केवल अगर आपकी भाषा STDOUT को आउटपुट देने का समर्थन नहीं करती है तो क्या आपको अपनी भाषा में निकटतम समकक्ष का उपयोग करना चाहिए।
आपको STDERR को साफ रखने की आवश्यकता नहीं है, और जब तक आवश्यक आउटपुट STDOUT या इसके समकक्षों में नहीं किया जाता है, तब तक प्रोग्राम को त्रुटि से रोकने की अनुमति है।
आप किसी भी मानक फॉर्म के माध्यम से आउटपुट प्रदान कर सकते हैं ।
यह कोड-गोल्फ है , सबसे कम बाइट्स जीतती है।
हमेशा की तरह, डिफ़ॉल्ट कमियां यहां लागू होती हैं।

— वीजुन झोउ
स्रोत

2

कोटलिन 1.1 स्क्रिप्ट , 304 293 बाइट्स

import java.math.BigDecimal as b
import java.math.*
val m=MathContext(1022)
var B=b(2)
var A=b((""+B.sqrt(m)).zip(""+b(3).sqrt(m)).joinToString(""){(a,b)->if(a=='.')".";else ""+(a-'0'+(b-'0'))%10})
val g=b(1).setScale(1022)
repeat(1000){println(B);A=g/(A-B);B=A.setScale(0,RoundingMode.FLOOR)}

दुर्भाग्य से एक बिट क्रिया: /

JDK 9 के साथ चलना चाहिए, जैसा sqrtकि BigDecimalइस रिलीज़ में जोड़ा गया था । दिलचस्प बात यह है कि, मुझे कोटलिन 1.1 और JDK 9 दोनों विशेषताओं के साथ एक TIO साइट नहीं मिल पाई है (Ideone और repl.it दोनों को चलाने के लिए कोटलिन 1.0 है, जिसने लैम्ब्डा में विनाशकारी का समर्थन नहीं किया, और TIO की शिकायत है कि sqrtमौजूद नहीं है।)

प्रत्येक तत्व को एक नई रेखा से अलग करता है।

संपादित करें ( -11): printlnलूप बॉडी की शुरुआत में चले गए और विधि कॉल को दोहराने से बचने के लिए एक अतिरिक्त पुनरावृत्ति जोड़ा। एक अतिरिक्त गणना की जाती है, लेकिन इसका उपयोग किसी भी चीज के लिए नहीं किया जाता है।

— मोइरा
स्रोत

2

पायथन 2 , 193 ... 179 178 बाइट्स

d=10
u=d**2000
v=u*u
def s(n,a=d,i=9):
 while a-i:i,a=a,(a+n/a)/2
 return a
p,q,r,t=s(2*v),s(3*v),1,0
while p:t+=(p+q)%d*r;p/=d;q/=d;r*=d
for i in range(1000):print t/u;t=v/(t%u)

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

गणना करना sqrt(2)और sqrt(3)शॉर्ट कोड के साथ इस तरह की शुद्धता को पायथन और अन्य भाषाओं में एक कठिन काम है।

~~विस्तार सही है~~ (1020 पर्याप्त है, ~~यह सुनिश्चित करने के लिए 2000 अंकों की आवश्यकता है~~ , लेकिन मैं इसे संशोधित नहीं करने जा रहा हूं क्योंकि इसमें कोई सुधार नहीं है), और 4-6 लाइनें पूर्णांक वर्गमूल हैं।

193> 180: डिजि-वार मॉडुलो योग अब सरणी हेरफेर के बजाय एक लूप द्वारा किया जाता है

180> 179: 5 बाइट्स के साथ परिभाषित करने की लागत के साथ 10उपयोग की 6 घटनाओं को बदल दिया d, कुल मिलाकर 1 बाइट काटकर

179> 178: बस एहसास है कि a!=iद्वारा प्रतिस्थापित किया जा सकता हैa-i

— शायरु असकोतो
स्रोत

1

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

ȷ*`
%¢¢²¤:
2,3×Ñ×ÑÆ½DS%⁵ḌÇȷÐ¡Ṗ:Ñ

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

मूल रूप से निश्चित-बिंदु अंकगणित का उपयोग करें। एम यहां बेहतर काम कर सकता है, लेकिन किसी भी तरह floor(HUGE_NUMBER × sqrt(2)बहुत बड़े के लिए मूल्यांकन नहीं करना चाहता है HUGE_NUMBER। वैसे भी निश्चित-बिंदु विभाजन निश्चित रूप से बेहतर है।

स्पष्टीकरण:

-------
ȷ*`       Calculate the base for fixed-point arithmetic.
ȷ         Number 1000.
 *        Raise to the power of...
  `       self. (so we have 1000 ** 1000 == 1e3000) Let B=1e3000.

-------
%¢¢²¤:    Given f × B, return a number approximately (1/frac(f)) × B.
          Current value: f × B.
%¢        Modulo by B. Current value: frac(f) × B.
  ¢²¤     B² (that is, 1e6000)
     :    integer-divide by. So we get B²/(frac(f)×B) ≃ 1/frac(f) × B.

-------
2,3×Ñ×ÑÆ½DS%⁵ḌÇȷÐ¡Ṗ:Ñ  Main link.
2,3                    The list [2,3].

    Ñ                  This refers to the next link as a monad, which is the
                       first link (as Jelly links wraparound)
   ×                   Multiply by. So we get [2,3]×1e3000 = [2e3000,3e3000]
     ×Ñ                Again. Current value = [2e6000,3e6000] = [2B²,3B²]

       Æ½              Integer square root.
                       Current value ≃ [sqrt(2B²),sqrt(3B²)]
                                     = [B sqrt(2),B sqrt(3)]

         DS            Decimal digits, and sum together.
           %⁵          Modulo 10.
             Ḍ         Convert back from decimal digits to integer.

                Ð¡     Repeatedly apply...
              Ç          the last link...
               ȷ         for 1000 times, collecting the intermediate results.
                  Ṗ    Pop, discard the last result.
                   :Ñ  Integer divide everything by B.

— user202729
स्रोत

दुर्भाग्य से ×⁺Ñकाम नहीं करता है। वैकल्पिक रूप से ×Ñ²$।

— user202729

Upvoted। स्पष्टीकरण की बहुत सराहना की जाएगी।

— वीजुन झोउ

1

@ WeijunZhou किया, मुझे बताओ अगर तुम कुछ समझ में नहीं आता है।

— user202729

1

हस्केल 207 बाइट्स

मैं जारी अंश लाज़ली की गणना करने का आसान तरीका नहीं खोज सका, इसलिए मैंने 2000 अंकों के साथ काम किया।

import Data.Ratio
r#y|x<-[x|x<-[9,8..],r>(y+x)*x]!!0=x:(100*(r-(y+x)*x))#(10*y+20*x)
c r|z<-floor r=z:c(1/(r-z%1))
main=print.take 1000.c$foldl1((+).(10*))(take 2000$(`mod`10)<$>zipWith(+)(3#0)(2#0))%10^1999

— डेमियन
स्रोत

अफ़सोस की बात है! मैं एक हास्केल उत्तर को देखने की उम्मीद कर रहा था जो अनंत सूची बनाता है और इसका मूल्यांकन करता है आलसी ...

— वीज़ुन झोउ

@ WeijunZhou मैं इसे बाद में कोशिश करूँगा जब मेरे पास कुछ समय होगा। कम से कम sqrt अनंत सूची बनाता है। मुझे केवल यह पता लगाना है कि दशमलव संख्या को इनफिनिटी सूची के रूप में कैसे उल्टा करना है। शायद कोई मदद कर सकता है

— डेमियन

स्क्वायर रूट्स के अंक-वार योग के निरंतर अंश