स्क्वेरिंग सीक्वेंस में प्रत्येक पद, x _n , को x _n-1 के द्वारा बनाया गया है , इसे स्क्वेर किया गया है, और सभी सभी प्रथम अंकों को हटा दिया गया है।

अनुक्रम हमेशा x ₁ = 1111 से शुरू होता है । यह पैदावार 1234321 है, इसलिए x ₂ = 1234 है

पहले कुछ शब्द हैं:

चुनौती

आपका कार्य है, एक गैर-नकारात्मक पूर्णांक n दिया गया , x _{n की} गणना करें । आप एक पूर्ण कार्यक्रम प्रस्तुत कर सकते हैं जो I / O करता है, या एक फ़ंक्शन जो एक पैरामीटर के रूप में n लेता है ।

जब तक आप निर्दिष्ट करते हैं कि आपका समाधान शून्य या एक अनुक्रमित हो सकता है।

क्योंकि इस क्रम की सभी शर्तें 5 अंकों से छोटी हैं, इसलिए आपका कोड भी कम से कम होना चाहिए। स्टैंडर्ड कोड-गोल्फ लूपहोल्स लागू होते हैं।

सर्वश्रेष्ठ गोल्फर जीत सकते हैं!

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

नोट: ये 1-अनुक्रमित हैं।

1   -> 1111
8   -> 6840
15  -> 7584
20  -> 1425
80  -> 4717

— FlipTack
स्रोत

2

यहाँ एक संबंधित लिंक है :)

— FlipTack

11

05AB1E , 8 7 बाइट्स

कोड:

$Fn4×4£

स्पष्टीकरण:

$        # Push 1 and the input
 F       # Input times do...
  n      #   Square the number
   4×    #   Repeat that string 4 times
     4£  #   Take the first four characters
         # Output the last computed number

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

3

मुझे 20 सेकंड से हराया :(।

— जादू ऑक्टोपस कलश

24

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

f=n=>--n?(f(n)**2+f).slice(0,4):1111

यह दुर्व्यवहार के प्रकार का एक बड़ा उदाहरण है: **अपने दोनों तर्कों को संख्याओं में +परिवर्तित करता है , और इसके दोनों तर्कों को तब तक परिवर्तित करता है जब तक कि वे दोनों संख्याएँ न हों। इसका मतलब यह है कि f(n)**2+fपहले f(n)एक संख्या में परिवर्तित होता है और इसे वर्ग करता है, फिर परिणाम को स्ट्रिंग प्रतिनिधित्व के साथ समेटता है f। फिर हम .sliceस्ट्रिंग के पहले 4 वर्णों को पुनः प्राप्त करने के लिए उपयोग कर सकते हैं ।

यहां कुछ वैकल्पिक दृष्टिकोण दिए गए हैं जो तार का उपयोग नहीं करते हैं:

f=(n,x=1111)=>x<1e4?--n?f(n,x*x):x:f(n,x/10|0)
f=n=>--n?(x=f(n))*x/(x>3162?1e4:1e3)|0:1111

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

let f=n=>--n?(Math.pow(f(n),2)+f).slice(0,4):1111

<input id=I type="number" step="1" min="1" value="1"><button onclick="console.log(f(I.value))">Run</button>

स्निपेट का विस्तार करें

नोट: यह सभी ब्राउज़रों में समर्थित नहीं होने के Math.powकारण उपयोग करता **है।

— ETHproductions
स्रोत

6

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

((iterate(read.take 4.show.(^2))1111)!!)

यह 0-आधारित अनुक्रम है। प्रयोग उदाहरण: ((iterate(read.take 4.show.(^2))1111)!!) 79-> 4717।

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

iterate (   ) 1111               -- repeatedly apply a function starting
                                 -- with 1111 and collect the results in a list
                                 -- the function is
           (^2)                  -- square
        show                     -- turn into string
     take 4                      -- take the first 4 chars
  read                           -- turn back to number
                     !!          -- finally pick the nth element from the list

— nimi
स्रोत

6

मैथेमेटिका, 48 बाइट्स

Nest[⌊10^(3-⌊t=2Log[10,#]⌋+t)⌋&,1111,#]&

पूर्णांक तर्क लेने की क्रिया; 0 अनुक्रमित। चार तीन-बाइट वर्णों ⌊⌊⌋⌋का उपयोग करता है: गणितज्ञ Floor[x]या तो ⌊x⌋एक वास्तविक संख्या को पूर्णांक में राउंड करने के लिए उपयोग करता है , और बाद वाला आम तौर पर एक कम बाइट है। पूर्णांक को तार में परिवर्तित करने के लिए मैथेमेटिका में कमांड का नाम बहुत लंबा है, इसलिए इसके बजाय हम x ^ 2 के पहले चार अंकों को खोजने के लिए एक गणितीय गणना करते हैं: हम x ^ 2 के आधार -10 लघुगणक को लेते हैं, अपने पूर्णांक भाग को घटाते हैं, बढ़ाते हैं 10 उस शक्ति पर वापस, और 1000 से गुणा करें और नीचे गोल करें।

tl; dr: logarithms ftw

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

6

पायथन 2, 51 46 44 बाइट्स

मैं ifअगर संभव हो तो क्लंकी से छुटकारा पाना चाहूंगा , लेकिन मुझे लगता है कि execयह छोटा हो सकता है .. उस पल के execलिए कम हो जाता है। फिर से गलत! पुनरावर्ती फ़ंक्शन देता है। यह एक-अनुक्रमित है।

f=lambda n:1111*(n<2)or int(`f(n-1)**2`[:4])

एक साथ 46-बाइट समाधान exec:

s=1111;exec's=int(`s*s`[:4]);'*input();print s

एक वैकल्पिक 49-बाइट पुनरावर्ती समाधान:

f=lambda n,s=1111:s*0**n or f(n-1,int(`s*2`[:4]))

^{Flp.Tkc के लिए धन्यवाद मुझे याद दिलाकर एक बाइट को बचाने के लिए कि स्क्वेरिंग को घातांक की आवश्यकता नहीं है :)}

— Kade
स्रोत

एक और 46 बाइट्स समाधान:f=lambda n:1111if n<2else int(`f(n-1)**2`[:4])

— एक्रोलिथ

@daHugLenny जो वास्तव में 45 हो सकती है: repl.it/EejD

— FlipTack

1

@ Flp.Tkc और यह वास्तव में 44 हो सकता है;)

— केड

5

वी , 19 बाइट्स

4é1Àñ|C="*"
5|D

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

यह 0-आधारित इंडेक्सिंग का उपयोग करता है।

बेशक, के बाद से संख्या वास्तव में वी के नहीं हैं विशेष क्षमता , यह बहुत golfy है। हालाँकि, यह दिखाता है कि एक अच्छा फायदा वी का ओवर है। आप एक मैक्रो को 0 बार चला सकते हैं , जो कि '0' के बाद से संभव नहीं है क्योंकि एक कमांड एक गिनती नहीं है।

इसमें कई अचूक अक्षर शामिल हैं, इसलिए यहां एक हेक्सडंप है:

0000000: 34e9 31c0 f17c 4312 3d12 222a 1222 0a1b  4.1..|C.=."*."..
0000010: 357c 44                                  5|D

और यहाँ एक पठनीय संस्करण है:

4é1Àñ|C<C-r>=<C-r>"*<C-r>"
<esc>5|D

स्पष्टीकरण:

4                           " 4 times:
 é1                         " Insert a '1'
   Àñ                       " Arg1 times:
     |                      "   Move to the first character on this line
      C                     "   Delete this whole line and enter insert mode
       <C-r>=               "   Insert the following evaluated as vimscript:
             <C-r>"         "     Insert what we just deleted
                   *        "     Times
                    <C-r>"  "     What we just deleted
<esc>                       "   Escape to normal mode
     5|                     "   Move to the fifth column on this line
       D                    "   And delete until the end of this line
                            " The second 'ñ' is added implicitly

— DJMcMayhem
स्रोत

5

जेली , 12 9 बाइट्स

1-आधारित अनुक्रमण और ṁमोल्ड / पुनर्वसन परमाणु का उपयोग करके डेनिस के लिए -3 बाइट्स धन्यवाद । गोल्फ सुझाव आपका स्वागत है! इसे ऑनलाइन आज़माएं!

²Dṁ4Ḍ
1Ç¡

Ungolfing

Helper link
²       Square.
 D      Integer to decimal (a list of digits).
  ṁ4    Mold/reshape list_of_digits to be 4 digits long.
    Ḍ   Decimal to integer.

Main link: implicit left argument n
1     Start with the nilad 1.
 Ç¡   Call the helper link n times.

— Sherlock9
स्रोत

यह 1-आधारित अनुक्रमण के साथ 3 बाइट्स बचाता है।

— डेनिस

उह, मुझे नहीं लगता कि आप 1इसके बजाय उपयोग कर सकते हैं ⁽¡n।

— आउटगोल्फ

@EriktheOutgolfer कैसे आए?

— शर्लक

@ शर्लक 9 ओह, आप इस अनुक्रम को 1-इंडेक्स करते हैं? हम्म, ऐसा लगता है कि कोड को समझने के लिए थोड़ा मुश्किल है ...

— एरिक द आउटगलर

4

पर्ल, 37 बाइट्स

कोड + -pध्वज के 36 बाइट्स ।

$\=1x4;$\=substr$\*$\,0,4while--$_}{

इसे चलाने के लिए:

perl -pe '$\=1x4;$\=substr$\*$\,0,4while--$_}{' <<< 80

— बापू
स्रोत

4

पॉवर्सशेल, 73 55 बाइट्स

18 बाइट्स से शेविंग करने के लिए TimmyD को बहुत-बहुत धन्यवाद!

कोड:

for($A=1111;$args[0]---1;$A=-join"$(+$A*$A)"[0..3]){}$A

~~$A=1111;1..($n=2)|%{[string]$B=[math]::pow($A,2);$A=$B.substring(0,4)};$A~~

$nहै n में एक्स _n-1

स्पष्टीकरण और विस्फोट कोड:

$A=1111                            #starting number
$n=4                               #n in formula
for($i=0; $i -lt $n;$i++)          #loop n times
{
    [string]$B=[math]::pow($A,2)   #create a new string $B and set it to $A raised to the power of 2
    $A=$B.substring(0,4)           #set $A to the first 4 characters of $B
}
$A                             #print $A

कुछ नोट:

पॉवर्सशेल आपको उन्हीं कथनों में वेरिएबल असाइन करने देता है, जहाँ आप उनका संदर्भ देते हैं। उदाहरण के लिए, 1..($n=4)|%$ n को 4 पर सेट करेगा और फिर एक लूप शुरू करेगा जो $ n से चलता है। 1किसी भी पूर्णांक में बदला जा सकता है और यह $ n- [आपका पूर्णांक] +1 बार लूप करेगा।
[math]::Powershell का उपयोग करते समय डिफ़ॉल्ट डेटा प्रकार एक डबल है। उपरोक्त कोड में, हमें स्पष्ट रूप $Bसे एक स्ट्रिंग डाली जानी है ताकि हम उस .substring()पर कॉल कर सकें क्योंकि .substring()पॉवरशेल में डबल्स के लिए कोई फ़ंक्शन नहीं है ।

— wubs
स्रोत

4

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

-3 बाइट्स xnor के लिए धन्यवाद (बचने के लिए पूर्णांक विभाजन का उपयोग करें and)

f=lambda n:int(1/n*1111or`f(n-1)**2`[:4])

repl.it

1-आधारित पुनरावर्ती कार्य।

जब n>1पूर्णांक विभाजन, 1/nफलित होता है 0, तब 0*1111=0जो गलत होता है, इसलिए orमूल्यांकन का अधिकार है, जो n-1वें परिणाम के वर्ग के प्रतिनिधित्व के पहले चार वर्ण लेता है ; यह तो एक करने के लिए डाली है int।

जब n=1पूर्णांक विभाजन, 1/nमें परिणाम करता है 1, तब 1*1111=1111, जो सत्य है, और int 1111कास्ट टू ए intहै 1111।

— जोनाथन एलन
स्रोत

अच्छा एक, निंजा मुझे एक बाइट द्वारा!

— 20

मैंने सिर्फ आपके जवाब की तलाश की और फिर महसूस किया कि आपने चुनौती लिखी है! अच्छी नौकरी।

— जोनाथन एलन

1

intबाहर ले जाने के साथ अच्छा विचार है । यदि आप 1-इंडेक्स करते हैं, तो आप बेस केस को छोटा कर सकते हैं g=lambda n:int(1/n*1111or`g(n-1)**2`[:4])।

— 21

1

"44 को पार किया अभी भी 44 की तरह दिखता है :("

— FlipTack

1

@ Flp.Tkc उतना नहीं जितना वह बिना  एस के करता है !

— जोनाथन एलन

3

ग्रूवी, 49 बाइट्स

{x=1111;(it-1).times{x="${x**2}"[0..3] as int};x}

— जादू ऑक्टोपस Urn
स्रोत

3

पाइके, 10 बाइट्स

1RVX`4*4<b

यहाँ यह कोशिश करो!

— नीला
स्रोत

3

MATL , 14 , 13 बाइट्स

1111G:"UV4:)U

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

स्पष्टीकरण:

1111            % Push 1111
    G           % Push input
     :"         % Input times:
       U        %   Square the top of the stack
        V       %   Convert it to a string
         4:)    %   Take the first four digits
            U   %   Convert it back to a number
                % Implictly display

— DJMcMayhem
स्रोत

2

आप उपयोग कर सकते हैं U(वर्ग, संख्यात्मक इनपुट के लिए)t*

— लुइस मेंडो

1

@LuisMendo मेरे द्वारा सुझाए गए फ़ंक्शन की याद दिलाने के लिए धन्यवाद! : पी

— DJMcMayhem

3

आर, 58 56 55 53 बाइट्स

x=3334;for(e in N<-scan():1)x=x^2%/%10^(3+(x>3162));x

लेता है N से है। 3334 व्यावहारिक रूप से X_0 है, जिसकी आवश्यकता है क्योंकि फॉर-लूप को कम से कम एक बार निष्पादित किया जाना चाहिए (इसे छोड़ना अधिक लंबा होगा)।

आर वास्तव में एक संख्या के पहले चार अंक लेने के लिए एक भयानक भाषा है, लेकिन चूंकि मामलों की संख्या सीमित है, हमें केवल वर्गों के बारे में चिंता करना होगा x<3163 औरx>3162 , पूर्व में एक 6 अंकों की संख्या, बाद में एक 7 अंकों की संख्या। ।

बाकी बहुत सीधा है, %/%शेष को विभाजित और अनदेखा करता है।xस्टडआउट के लिए मुद्रित किया जाता है।

सहेजे गए 2 बाइट्स @ETHproductions के लिए धन्यवाद

— JAD
स्रोत

यह बहुत ही कुख्यात है। प्रतिभाशाली!

— आंद्रे

1

अच्छा है! यदि आप 3334(या शायद 3333) से शुरुआत करते हैं तो क्या होगा ?

— ETHproductions

@ETHproductions 3333^2 = 11108889तो उपज होगा 1110, और .... im जाँच के रूप में मुझे लगता है 3334यह काम करेगा: । मुझे यकीन नहीं है कि मैंने अब और क्यों नहीं जांचा।

— JAD

3

Javagony - 153 बाइट्स

जवागनी जावा का एक प्रतिबंधित संस्करण है, जो पुनरावृत्ति को छोड़कर किसी भी नियंत्रण प्रवाह की अनुमति नहीं देता है और try-catchछोरों के लिए नहीं है, जबकि छोरों, या यदि है। इसमें कोडिंग एक बहुत ही मजेदार व्यायाम है, लेकिन निराशा होती है। ऐसा नहीं है कि नियमित रूप से जावा लगभग खुद से निराशा के रूप में नहीं है।

int a(int i){return a(i-1,1111);}int a(int i,int n){try{int x=1/i;return a(i-1,Integer.parseInt((n*n+"").substring(0,4)));}catch(Exception e){return n;}}

— Maltysen
स्रोत

3

PHP, 55 52 बाइट्स

सहेजे गए 3 बाइट @ user59178 के लिए धन्यवाद

for($i=1111;$argv[1]--;)$i=substr($i**2,0,4);echo$i;

कमांड लाइन से चलाएँ, शून्य-अनुक्रमित।

मेरे चर किस प्रकार के हैं, इसकी परवाह न करने के लिए धन्यवाद, PHP! यहां हम केवल संख्या को पार करते हैं और दुनिया में बिना किसी परवाह के संख्या और स्ट्रिंग के बीच आकस्मिक रूप से बारी-बारी से पहले 4 अंकों के अतीत को ट्रिम कर देते हैं।

— Xanderhall
स्रोत

आप $argv[1]--लूप काउंटर के रूप में उपयोग करके 3 बाइट्स बचा सकते हैं ।

— user59178

2

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

,1111:?:{^@[.l4,}i

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

यह उत्तर 0-अनुक्रमित है।

व्याख्या

,1111:?:{       }i      Iteratively call Input times the predicate in brackets starting with
                          input 1111:

         ^                  Square
          @[.               Output is a prefix of the square
            .l4,            Its length is 4

— Fatalize
स्रोत

2

सी, 56 बाइट्स

a;s(n){for(a=1111;--n;)a=a*a/(a>3162?1e4:1e3);return a;}

एक-अनुक्रमित।

— लिन
स्रोत

1

मुझे लग रहा है कि आप पुनर्मिलन के लिए जा सकते हैं ...

— मुकुल कुमार

2

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

(defn s[n](if(= n 1)1111(read-string(subs(str(*(s(dec n))(s(dec n))))0 4))))

पहला क्लोजर गोल्फ (एक अच्छी भाषा की तरह लगता है)। यह 1-अनुक्रमित है।

बाद में कोड समझाएगा।

— clismique
स्रोत

2

सी #, 64 60 बाइट्स

Olivier Grégoire की जावा उत्तर पर टिप्पणी के बाद 4 बाइट्स सहेजे गए !

n=>{int x=1111;for(;n-->1;)for(x*=x;x>1e4;x/=10);return x;};

पिछला संस्करण ( 64 बाइट्स ):

n=>{int x=1111;while(n-->1){x*=x;while(x>9999)x/=10;}return x;};

पूर्ण कार्यक्रम असंसाधित विधि और परीक्षण मामलों के साथ:

using System;

namespace SquaringSequence
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int, int> f = n =>
            {
                int x = 1111;
                while (n-- > 1)
                {
                    x *= x;
                    while (x > 9999)
                        x /= 10;
                }
                return x;
            };

            // test cases:
            Console.WriteLine(f(1));    // 1111
            Console.WriteLine(f(8));    // 6840
            Console.WriteLine(f(15));   // 7584
            Console.WriteLine(f(20));   // 1425
            Console.WriteLine(f(80));   // 4717
        }
    }
}

— adrianmp
स्रोत

1

अंधेरे के लिए +1 ऑपरेटर के लिए चला जाता हैn-->1

— कार्ल नेफ

2

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

पहला गोल्फ! -nविकल्प के साथ बाइट्स बचाता है (लेकिन फिर भी 1! :) के रूप में गिना जाता है।

a=1111;$_.to_i.times{a="#{a*a}"[0,4].to_i};p a

0 अनुक्रमित। इसे चलाने के लिए:

ruby -ne 'a=1111;$_.to_i.times{a="#{a*a}"[0,4].to_i};p a' <<< 80

— ghivert
स्रोत

साइट पर आपका स्वागत है, और अच्छा पहला जवाब! एक नाइटपिक हालांकि, तकनीकी रूप से यह 47 बाइट्स है क्योंकि बाइट काउंट की ओर कमांड लाइन के झंडे गिनने की हमारी नीति है । उसके अलावा, यह मुझे अच्छा लगता है!

— DJMcMayhem

धन्यवाद! नियम नहीं पता था, जवाब बदल गया!

— घिरवते

2

अजगर, १३ 12 बाइट्स

@ बाइट के लिए शुक्रिया -1 बाइट

us<*4`*GG4Q1

एक प्रोग्राम जो 1-अनुक्रमित पूर्णांक का इनपुट लेता है और परिणाम को प्रिंट करता है।

परीक्षण सूट

यह @ अदनान के उत्तर के समान दृष्टिकोण का उपयोग करता है ।

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

us<*4`*GG4Q1  Program. Input: Q
u         Q1  Execute the following Q times, starting at 1, with variable G:
      *GG      Yield G*G
     `          Convert to string
   *4           Repeat 4 times
  <      4      Yield first 4 characters
 s              Convert to integer
              Implicitly print

— TheBikingViking
स्रोत

1

*GGइसके बजाय^G2<space>

— जकुबे

1

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

'14*ri{i2#s4<}*

0-आधारित अनुक्रमण का उपयोग करता है।

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

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

1

बैच, 82 बाइट्स

@set n=1111
@for /l %%i in (1,1,%1)do @set/an*=n&call set n=%%n:~0,4%%
@echo %n%

पर्ल की तरह, पूर्णांक तार होते हैं, लेकिन पर्ल के विपरीत मैं केवल एक चर का विकल्प ले सकता हूं, और एक लूप के अंदर सबस्ट्रिंग लेना कुछ अजीब है।

— नील
स्रोत

मुझे लगता है कि आप @ के बाद अंतरिक्ष छोड़ सकते हैं।

— YourDeathIsComing

@YourDeathIsComing 'के लिए' एक आंतरिक या बाहरी कमांड, ऑपरेशनल प्रोग्राम या बैच फ़ाइल के रूप में मान्यता प्राप्त नहीं है।

— नील

1

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

{(1111,{+$_².substr(0,4)}...*)[$_]}

स्पष्टीकरण:

{                                 } # bare block lambda
  1111,                  ...        # sequence generator
                            *       # without a limit
       {                }           # lambda used to generate the next value
         $_²                        # start by squaring the previous value
            .substr(0,4)            # take only the first four digits
        +                           # make it numeric ( not necessary )
 (                           )[$_]  # return the requested value

परीक्षा:

say {(1111,{+$_².substr(0,4)}...*)[$_]}( 1,8,15,20,80 X- 1 ).perl
# (1111, 6840, 7584, 1425, 4717)

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

1

मैटलैब, 79 , 78 बाइट्स

function a=s(n)
if n<2;a=1111; else f=s(n-1);a=fix(f^2/10^(3+(f>1e7^.5)));end

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

s(79) = 2172
s(49) = 8059
s(6)  = 2876

अद्भुत समाधान नहीं। मुझे यकीन है कि 4 अंकों को काट देने का एक बेहतर तरीका होना चाहिए, लेकिन मुझे आज पता नहीं है।

संपादित करें: 0.5 -> .5 सेट करके एक बाइट शेव की गई

— ओवेन मॉर्गन
स्रोत

1

जावा 8, 77 93 74 71 69 78 बाइट्स

int n=1111;int m=1;while(x>m++){n=Integer.parseInt((n*n+"").substring(0,4));} x->{int n=1111;int m=1;while(x>m++){n=Integer.parseInt((n*n+"").substring(0,4))‌;}return n;} x->{int n=1111;for(;--x>0;){n=Integer.parseInt((n*n+"").substring(0,4));}} x->{long n=1111;for(;--x>0;){n=Long.valueOf((n*n+"").substring(0,4));}}

x->{long n=1111;for(;--x>0;)n=Long.valueOf((n*n+"").substring(0,4));return n;}

प्रत्येक पुनरावृत्ति nपहले 4 वर्ण बनाती हैn*n ।

जावा ऑनलाइन की कोशिश करो !

इतिहास पोस्ट करें:

77 बाइट्स: प्रारंभिक कोड (अपूर्ण)
+16 बाइट्स, ओलिवियर ग्रेगोइरे द्वारा: इसे लैम्ब्डा फंक्शन बनाकर कोड पूरा किया।
-19 बाइट्स: चक्र के whileसाथ बदलें for।
-4 बाइट्स: प्रयुक्त longबजाय रों intरों
रोमन ब्यूफ द्वारा -2 बाइट्स: अनावश्यक कोष्ठक हटा दिए गए
+9 बाइट्स, लापता returnबयान

धन्यवादकुछ मुद्दों की ओर इशारा करने लिए @ OlivierGrégoire और @ RomanGräf को !

रुको, जावा धड़कता है ... (ढोलक) क्लोजर और मतलाब यहां! कृपया जावा के लिए एक बड़ा तालियाँ!

— RudolfJelin
स्रोत

2

यह उत्तर अधूरा है। xघोषित नहीं किया गया। यह एक फ़ंक्शन या पूर्ण कार्यक्रम होना चाहिए। कोड स्निपेट नहीं।

— NonlinearFruit

@NonlinearFruit मैं समारोह के लिए जा रहा था। मुझे लगता है यह याद किया। क्या आपका मतलब है कि मुझे x को एक नंबर से बदलना चाहिए?

— रुडोल्फजेलिन

1

@NonlinearFruit ने जो कहा है, वह यह है कि आपका उत्तर, आपके वर्तमान कोड के साथ, बोना होना चाहिए: x->{int n=1111;int m=1;while(x>m++){n=Integer.parseInt((n*n+"").substring(0,4));}return n;}(91 की कुल बाइट गिनती के लिए)। ऐसा इसलिए है क्योंकि स्निपेट्स की अनुमति नहीं है: केवल फ़ंक्शन या पूर्ण प्रोग्राम।

— ओलिवियर ग्रेजायर 15

@ OlivierGrégoire 93 बाइट्स नहीं है? और लाम्बा फफूंदों को इंगित करने के लिए धन्यवाद।

— रुडोल्फजेलिन

आप सही हैं, यह 93 बाइट्स हैं, मुझे पिछले, दोष वाले संस्करण से जाँच करनी चाहिए। हालाँकि, मैंने जो भी किया था वह सब लपेट रहा था ताकि आपका कार्यक्रम एक वैध प्रविष्टि हो। अब आप इसे से बाहर नरक गोल्फ कर सकते हैं! उदाहरण के लिए, यहाँ केवल 75 बाइट्स के लिए आपके प्रोग्राम का एक गोल्फ संस्करण है: x->{Long n=1111;for(;--x>0;)n=n.valueOf((n*n+"").substring(0,4));return n;}(इस्तेमाल की Longजाने वाली कई तकनीकों के Long.valueOfसाथ, कम बाइट्स के साथ उपयोग करने में सक्षम) , यह सामान्य प्रोग्रामिंग में अनुशंसित नहीं है, लेकिन पूरी तरह से गोल्फिंग में; mइसे अनावश्यक रूप से हटा दिया जाता है यदि हम घटते हैं xइसके बजाय, हटाए गए ब्रेसिज़ को हटा दिया जाता है)

— ओलिवियर ग्रेजायर

1

पर्ल, 36 बाइट्स

अन्य पर्ल समाधान से एक अलग दृष्टिकोण, थोड़ा कम कोड के लिए अग्रणी। कोई कमांड-लाइन तर्क की आवश्यकता नहीं है (सामान्य संस्करण चयन तर्क के अलावा -M5.010, जो बाइट की गिनती के खिलाफ नहीं गिनता है), जिसका अर्थ है कि यह कोड की समान मात्रा है, लेकिन कम दंड के साथ, एक बेहतर समग्र स्कोर देता है।

say+eval'($&*$&||1x4)=~/(....)/;'x<>

हम evalएक स्ट्रिंग को दोहराने और -ing के माध्यम से एक लूप अंडरलोड-शैली बनाते हैं ; मैंने बीच में स्ट्रिंग शुरू करने के साथ प्रयोग किया, लेकिन शुरुआत में इसे शुरू करना सबसे कम हो गया। इसे गुणा करने के लिए हम $&स्वयं (पिछले रेगेक्स मैच का परिणाम) गुणा करते हैं; यदि परिणाम का शून्य, हम उपयोग करते हैं 1x4(यानी 1111; पर्ल के पास परिणाम के बजाय चीजों को दोहराने के लिए एक ऑपरेटर है, जिसमें संख्या के अंक भी शामिल हैं)। फिर हम पहले चार वर्णों को फिर से जोड़ते हैं। पूरी बात अंदर होने के कारण सूची के संदर्भ में चलती है say, इस प्रकार evalइच्छा का अंतिम परिणाम अंतिम मैच के कोष्ठकों की सामग्री होगी।

1

जावा, 79 67 66 64 बाइट्स

संस्करण 2.2 / 64 बाइट्स:

@Oliver Grégoire को धन्यवाद।

int a(int i){i=i<2?1111:a(--i);for(i*=i;i>1e4;)i/=10;return i;}

संस्करण 2.1 / 66 बाइट्स:

@ETHProduct के लिए धन्यवाद।

long a(long i){i=i<2?1111:a(--i);for(i*=i;i>1e4;)i/=10;return i;}

संस्करण 2.0 / 67 बाइट्स:

@Xanderhall से विचार के साथ प्रतिस्थापित प्रतिस्थापन और सामान

long a(long i){i=i<2?1111:a(--i);i*=i;for(;i>1e4;)i/=10;return i;}

संस्करण 1.0 / 79 बाइट्स:

यद्यपि छोटे समाधान हैं जो मैं एक पुनरावर्ती पोस्ट करना चाहता था :)। और मैं सबसे छोटा "वास्तविक" फ़ंक्शन हूं :)। संपादित करें: लगता है जैसे मैं अब सबसे छोटा हूं :)))

long a(long i){i=i<2?1111:a(--i);return Long.valueOf((i*i+"").substring(0,4));}

— रोमन ग्रैफ़
स्रोत

क्या आप कर सकते हैं for(i*=i;i>1e4;)i/=10;? इससे बाइट बच जाएगी।

— ETHproductions

हम्म ... सबसे कम जावा फ़ंक्शन के बारे में आपके दावे के बारे में, इस फ़ंक्शन में कुछ शब्द होने चाहिए ;-)

— ओलिवियर ग्रेजायर

हम्म, इसके बारे में सोचकर, आप भी longएस का उपयोग क्यों करते हैं ? आप intएस का उपयोग करके दो बाइट्स मार सकते हैं ।

— ओलिवियर ग्रेगोइरे

मुझे याद आया कि जब मैंने 2.0 को अपडेट किया था

— रोमन ग्रैफ

1

पुष्य , 26 20 बाइट्स

1111@:2esL4-:.;Kjk;#

कमांडलाइन पर तर्क दें $ pushy sqseq.pshy 79:।

स्पष्ट रूप से, स्वरूपित:

            % Implicit: N is on stack
1111@       % Push 1111, and then reverse stack to get [1111, n]
:           % N times do: (this consumes N)
 2e         %   Square last term
 s          %   Split into individual digits
 L4-:.;     %   Get stack length -4, pop that many times
 Kj         %   Join remaining digits (Uses flag "K" for whole stack)
 k          %   Set "K" flag to false, so operations only affect last item
;           % End loop.       
#           % Output final calculated term

— FlipTack
स्रोत

स्क्वरिंग सीक्वेंस

चुनौती

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

05AB1E , 8 7 बाइट्स

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

टेस्ट स्निपेट

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

मैथेमेटिका, 48 बाइट्स

पायथन 2, 51 46 44 बाइट्स

वी , 19 बाइट्स

जेली , 12 9 बाइट्स

पर्ल, 37 बाइट्स

पॉवर्सशेल, 73 55 बाइट्स

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

ग्रूवी, 49 बाइट्स

पाइके, 10 बाइट्स

MATL , 14 , 13 बाइट्स

आर, 58 56 55 53 बाइट्स

Javagony - 153 बाइट्स

PHP, 55 52 बाइट्स

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

व्याख्या

सी, 56 बाइट्स

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

सी #, 64 60 बाइट्स

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

अजगर, १३ 12 बाइट्स

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

बैच, 82 बाइट्स

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

स्पष्टीकरण:

परीक्षा:

मैटलैब, 79 , 78 बाइट्स

जावा 8, 77 93 74 71 69 78 बाइट्स

इतिहास पोस्ट करें:

पर्ल, 36 बाइट्स

जावा, 79 67 66 64 बाइट्स

पुष्य , 26 20 बाइट्स