제곱 시퀀스 x _n 의 각 항은 x _n-1 을 취하고 제곱 한 다음 처음 네 자리를 제외한 모든 단어를 제거하여 만들어집니다 .

시퀀스는 항상 x ₁ = 1111로 시작합니다 . 이것을 제곱하면 1234321이되므로 x ₂ = 1234

처음 몇 용어는 다음과 같습니다.

1111
1234
1522
2316
5363
...

도전

음수가 아닌 정수 n이 주어지면 x _n을 계산해야 합니다. I / O를 수행하는 전체 프로그램 또는 n 을 매개 변수로 사용하는 기능을 제출할 수 있습니다 .

솔루션을 지정하는 한 솔루션의 인덱스는 0 또는 1이 될 수 있습니다.

이 순서의 모든 용어는 5 자리보다 짧으므로 코드도 최대한 짧아야합니다. 표준 코드 골프 허점이 적용됩니다.

최고의 골퍼가 이길 수 있습니다!

테스트 사례

참고 : 이들은 1- 색인입니다.

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

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 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

자바 스크립트 (ES7), 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않기 때문에 사용 **합니다.

하스켈, 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         

매스 매 티카, 48 바이트

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

정수 인수를 취하는 이름없는 함수; 인덱스가 0입니다. 네 개의 3 바이트 문자를 ⌊⌊⌋⌋사용합니다. Mathematica는 Floor[x]또는 ⌊x⌋을 사용 하여 실수를 정수로 내림합니다. 후자는 일반적으로 1 바이트 미만입니다. 정수를 문자열로 변환하는 Mathematica의 명령 이름이 너무 길기 때문에 수학 계산을 통해 x ^ 2의 처음 네 자리를 찾습니다. x ^ 2의 밑이 10 인 로그를 취하고 정수 부분을 빼고 10의 거듭 제곱으로 돌아가서 1000을 곱하고 내립니다.

tl; dr : 로그 ftw

파이썬 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에게 감사합니다. :)}

V , 19 바이트

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

온라인으로 사용해보십시오!

0 기반 인덱싱을 사용합니다.

물론 숫자는 정확히 V의 장점 이 아니기 때문에 이 아니기 때문에 골프는 아닙니다. 그러나 V가 vim보다 유리한 장점을 보여줍니다. '0'은 카운트가 아닌 명령이므로 매크로를 0 번 실행할 수 있습니다 . vim에서는 불가능합니다.

여기에는 인쇄 할 수없는 많은 문자가 포함되어 있으므로 다음은 16 진수 덤프입니다.

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

젤리 , 12 9 바이트

1 기반 색인 생성 및 ṁ금형 / 변형 원자를 사용하는 Dennis 덕분에 -3 바이트 . 골프 제안을 환영합니다! 온라인으로 사용해보십시오!

²Dṁ4Ḍ
1Ç¡

언 골핑

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.

펄, 37 바이트

36 바이트의 코드 + -p플래그.

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

그것을 실행하려면 :

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

파워 쉘, 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 에 X _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

몇 가지 참고 사항 :

• Powershell을 사용하면 참조하는 동일한 명령문에서 변수를 지정할 수 있습니다. 예를 들어, 1..($n=4)|%$ n을 4로 설정 한 다음 $ n 번 실행되는 루프를 시작합니다. 1정수로 변경할 수 있으며 $ n- [정수] +1 번 반복됩니다.
• [math]::Powershell에서 사용할 때 기본 데이터 유형 은 두 배입니다. 위의 코드 에서 Powershell에는 double을위한 함수 가 없기 때문에 명시 적으로 $B문자열로 캐스트 해야합니다 ..substring().substring()

파이썬 2,  44  41 바이트

xnor 덕분에 -3 바이트 (정수 나누기를 사용하여 피하십시오 and)

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

반복

1 기반 재귀 함수.

경우 n>1정수 분할은 1/n, 결과 0다음 0*1111=0, falsey 인 오른쪽이되도록 or의 제곱 표현의 처음 네 글자 소요되며, 평가 n-1번째 결과; 그런 다음로 캐스팅됩니다 int.

경우 n=1정수 분할은 1/n, 결과 1그런 다음 1*1111=1111, truthy이고 어느 int 1111내지 An 캐스트 int이다 1111.

그루비, 49 바이트

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

파이크, 10 바이트

1RVX`4*4<b

여기 사용해보십시오!

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

R, 58 56 55 53 바이트

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

Nstdin에서 가져 옵니다. 3334는 실제로 X_0이며, for-loop는 적어도 한 번 실행되어야하기 때문에 필요합니다 (스킵하는 데 시간이 더 오래 걸립니다).

R은 정말 숫자의 처음 네 자리를 복용에 대한 끔찍한 언어이지만, 경우의 수는 제한되어 있기 때문에, 우리는 단지의 사각형에 대해 걱정할 필요 x<3163하고 x>3162, 이전의 수율 6 자리 숫자, 후자의 7 자리 숫자 .

나머지는 매우 간단 %/%하고 나머지를 나누고 무시합니다. xstdout에 인쇄됩니다.

@ETHproductions 덕분에 2 바이트 절약

Javagony -153 바이트

Javagony는 제한된 Java 버전으로, 재귀 및 try-catchfor 루프, for 루프, while 루프 또는 if를 제외한 제어 흐름을 허용하지 않습니다 . 그것에 코딩하는 것은 꽤 재미있는 운동이지만 좌절입니다. 일반적인 Java가 그 자체만큼 실망 스럽지는 않습니다.

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;}}

PHP, 55 52 바이트

@ user59178 덕분에 3 바이트 절약

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

색인이없는 명령 행에서 실행하십시오.

내 변수가 어떤 유형인지 신경 쓰지 않아서 고맙습니다. PHP! 여기서 우리는 단순히 숫자를 제곱하고 처음 4 자리를지나 모든 것을 잘라 내고, 세상에서 신경 쓰지 않고 숫자와 문자열을 번갈아 번갈아 가며 변경합니다.

Brachylog , 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

C, 56 바이트

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

하나의 색인.

클로저, 76 바이트

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

첫 Clojure 골프 (좋은 언어처럼 보입니다). 이것은 1 인덱스입니다.

나중에 코드를 설명하겠습니다.

C #, 64 60 바이트

Java 답변에 대한 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;};

ungolfed 방법 및 테스트 사례가 포함 된 전체 프로그램 :

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
        }
    }
}

루비, 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

Pyth, 13 12 바이트

-1 바이트에 대한 @Jakube 덕분에

us<*4`*GG4Q1

1 인덱스 정수를 입력 받아 결과를 출력하는 프로그램입니다.

테스트 스위트

이것은 @Adnan의 답변 과 비슷한 접근법을 사용합니다 .

작동 원리

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

CJam , 15 바이트

'14*ri{i2#s4<}*

0 기반 인덱싱을 사용합니다.

온라인으로 사용해보십시오!

배치, 82 바이트

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

Perl과 마찬가지로 정수는 문자열이지만 Perl과 달리 변수의 하위 문자열 만 사용할 수 있으며 루프 내에서 하위 문자열을 가져 오는 것은 다소 어색합니다.

펄 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)

Matlab, 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를 설정하여 바이트를 면도

자바 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.

Java를 온라인으로 사용해보십시오 !

게시물 기록 :

• 77 바이트 : 초기 코드 (불완전)

• Olivier Grégoire의 +16 바이트 : Lambda 함수로 작성하여 코드를 완성했습니다.

• -19 바이트 : 교체 while와 for주기.

• -4 바이트 : longs 대신 ints 사용

• Roman Gräf의 -2 바이트 : 불필요한 괄호 제거

• +9 바이트, 누락 된 return명령문

감사몇 가지 문제를 지적 해 주신 @ OlivierGrégoire와 @ RomanGräf에게 !

잠깐, Java가 이길 ... (드럼 롤) Clojure 와 Matlab이 여기 있습니다! 자바에 큰 박수 부탁드립니다!

펄, 36 바이트

다른 Perl 솔루션과 다른 접근 방식으로 코드가 약간 짧아졌습니다. -M5.010바이트 수에 포함되지 않는 일반적인 버전 선택 인수 이외의 명령 줄 인수는 필요 하지 않습니다. 이는 동일한 코드 양이지만 적은 수의 벌점을 가짐으로써 전반적인 점수가 향상됨을 의미합니다.

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

우리는 반복 및 eval문자열을 통해 루프 언더로드 스타일을 만듭니다 . 중간에서 문자열을 시작하는 실험을했지만 시작에서 시작하는 것이 가장 짧았습니다. 우리는 $&(마지막 정규 표현식 일치의 결과) 자체를 곱하여 제곱합니다. 결과가 0이면, 우리 는 결과 대신에 1x4(즉 1111, Perl에는 숫자의 숫자를 포함하여 물건을 반복하는 연산자가 있습니다)를 사용합니다. 그런 다음 처음 네 문자를 정규식으로 만듭니다. 전체는 내부 say에 있기 때문에 목록 컨텍스트에서 실행 되므로 최종 결과 eval는 최종 경기의 괄호 내용입니다.

자바, 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 바이트 :

@ETHProduction 덕분에.

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));}

Pushy , 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