이 질문은 이 HNQ 에서 영감을 얻었습니다 .

시리즈 소개

이 질문은 이제 AGM 방법에 대한 시리즈의 일부입니다. 시리즈의 첫 번째 게시물은 실제로를 계산하는 것 AGM입니다. 이것을 다른 코드 골프 도전과 같이 취급하고 시리즈에 대해 전혀 걱정하지 않고 대답 할 수 있습니다. 그러나 모든 과제에는 리더 보드가 있습니다.

산술-기하학적 평균

두 숫자 의 산술-기하 평균 은 산술 및 기하 평균 을 반복적으로 수렴하는 숫자로 정의됩니다. 당신의 임무는 몇 n번의 반복 후에이 번호를 찾는 것 입니다.

설명

• a, b, n합리적인 형식으로 세 개의 숫자를 사용 합니다.
• 들면 n반복의 산술 및 기하 평균 소요 a과 b하고 그 설정 a하고 b.
• 두 숫자 a및 b의 경우 산술 평균은로 정의됩니다 (a + b) / 2.
• 기하 평균은로 정의됩니다 √(a * b).
• a그리고 b서로 접근해야한다.
• 그리고, 출력 모두 a와 b.
• 플로트 부정확성 등에 대해 걱정할 필요가 없습니다.
• 이것은 코드 골프 이므로 바이트 단위의 가장 짧은 코드가 승리합니다!

테스트 사례

[0, [24, 6]] -> [24, 6]    
[1, [24, 6]] -> [15.0, 12.0]
[2, [24, 6]] -> [13.5, 13.416407864998739]
[5, [24, 6]] -> [13.458171481725616, 13.458171481725616]
[10, [100, 50]] -> [72.83955155234534, 72.83955155234534]

The next one is 1/Gauss's Constant:
[10, [1, 1.41421356237]] -> [1.198140234734168, 1.1981402347341683]

리더 보드

마틴의 시리즈에서 도난당했습니다.

다음 스 니펫은 시리즈의 모든 과제에서 리더 보드를 생성합니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 모든 답변을 헤드 라인으로 시작하십시오.

# Language Name, N bytes

여기서 N은 제출 크기입니다. 점수를 높이면 헤드 라인을 쳐서 오래된 점수를 유지할 수 있습니다. 예를 들어 :

# Ruby, <s>104</s> <s>101</s> 96 bytes

/* Configuration */

var QUESTION_IDs = [66068]; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!.FjwQBrX2KXuFkv6p2lChi_RjzM19";

/* App */

var answers = [], page = 1, currentQ = -1;

function answersUrl(index) {
  return "http://api.stackexchange.com/2.2/questions/" +  QUESTION_IDs.join(";") + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}


function getAnswers() {
  $.ajax({
    url: answersUrl(page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      if (data.has_more) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SIZE_REG = /\d+(?=[^\d&]*(?:<(?:s>((?!>).)*<\/s>|((?!>).)+>)[^\d&]*)*$)/;
var NUMBER_REG = /\d+/;
var LANGUAGE_REG = /^#*\s*([^\n,]+)(?=,)/;//

function shouldHaveHeading(a) {
  var pass = false;
  var lines = a.body_markdown.split("\n");
  try {
    pass |= /^#/.test(a.body_markdown);
    pass |= ["-", "="]
              .indexOf(lines[1][0]) > -1;
    pass &= LANGUAGE_REG.test(a.body_markdown);
  } catch (ex) {}
  return pass;
}

function shouldHaveScore(a) {
  var pass = false;
  try {
    pass |= SIZE_REG.test(a.body_markdown.split("\n")[0]);
  } catch (ex) {}
  if (!pass) console.log(a);
  return pass;
}

function getAuthorName(a) {
  return a.owner.display_name;
}

function getAuthorId(a) {
  return a.owner.user_id;
}

function process() {
  answers = answers.filter(shouldHaveScore)
                   .filter(shouldHaveHeading);
  answers.sort(function (a, b) {
    var aB = +(a.body_markdown.split("\n")[0].match(SIZE_REG) || [Infinity])[0],
        bB = +(b.body_markdown.split("\n")[0].match(SIZE_REG) || [Infinity])[0];
    return aB - bB
  });

  var users = {};
  answers.forEach(function (a) {
    var headline = a.body_markdown.split("\n")[0];
    var question = QUESTION_IDs.indexOf(a.question_id);
    var size = parseInt((headline.match(SIZE_REG)||[0])[0]);
    var language = headline.match(LANGUAGE_REG)[1];
    var user = getAuthorName(a);
    var userId = getAuthorId(a);
    if (!users[userId]) users[userId] = {name: user, nAnswer: 0, answers: []};
    if (!users[userId].answers[question]) {
      users[userId].answers[question] = {size: Infinity};
      users[userId].nAnswer++;
    }
    if (users[userId].answers[question].size > size) {
      users[userId].answers[question] = {size: size, link: a.share_link}
    }
  });
  
  
  var sortedUsers = [];
  for (var userId in users)
    if (users.hasOwnProperty(userId)) {
      var user = users[userId];
      user.score = 0;
      user.completedAll = true;
      for (var i = 0; i < QUESTION_IDs.length; ++i) {
        if (user.answers[i])
          user.score += user.answers[i].size;
        else
          user.completedAll = false;
      }
      sortedUsers.push(user);
    }  
  
  sortedUsers.sort(function (a, b) {
    if (a.nAnswer > b.nAnswer) return -1;
    if (b.nAnswer > a.nAnswer) return 1;
    return a.score - b.score;
  });
  
  var place = 1;
  for (var i = 0; i < sortedUsers.length; ++i) {
    var user = sortedUsers[i];
    var row = '<tr><td>'+ place++ +'.</td><td>'+user.name+'</td>';
    for (var j = 0; j < QUESTION_IDs.length; ++j) {
      var answer = user.answers[j];
      if (answer)
        row += '<td><a href="'+answer.link+'">'+answer.size+'</a></td>';
      else
        row += '<td class="missing"></td>';
    }
    row += '<td></td>';
    if (user.completedAll)
      row += '<td class="total">'+user.score+'</td>';
    else
      row += '<td class="total missing">'+user.score+'</td>';
    row += '</tr>';
    $("#users").append(row);
  }
}

body { text-align: left !important}

#leaderboard {
  width: 500px; 
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

td.total {
  font-weight: bold;
  text-align: right;
}

td.missing {
  background: #bbbbbb;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="leaderboard">
  <h2>Leaderboard</h2>
  <p>
    Missing scores are shown as grey cells. A grey total indicates that the user has not participated in all challenges and is not eligible for the overall victory yet.
  </p>
  <table class="_user-list">
    <thead>
      <tr><td></td><td>User</td>
        <td><a href="http://codegolf.stackexchange.com/q/66068">#1</a></td>
        <td></td><td>Total</td>
      </tr>
    </thead>
    <tbody id="users">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

CJam, 16 바이트

{{_2$+2/@@*mq}*}

스택의 입력을 a b n위치 a와 b더블 로 취합니다 . 온라인 데모

Dyalog APL , 22 21 15 바이트

.5∘(+.×,×.*⍨)⍣⎕

( a , b )를 올바른 인수로 취하고 n을 프롬프트합니다 .

(

  +.× 0.5의 내적과 올바른 주장

 , 뒤에

  ×.*⍨올바른 논쟁의 "점 파워"와 0.5 ^*

)⍣⎕ 숫자 프롬프트 시간을 적용했습니다.

^* "dot power"는 내적과 유사하지만 다음과 같이 더하기 및 곱하기 대신 곱셈과 곱셈을 사용합니다.

      _n
A ×.*⍨ B 은 ∏ B _i ^A = ∏ B ₁ ^A B ₂ ^{A
       i = 1입니다.}

ngn 덕분에 -3 바이트

구 버전:

{((+/÷≢),.5*⍨×/)⍣⍺⊢⍵}

소요 n 왼쪽 인수로 및 a b오른쪽 인자로.

⊢⍵RightArg에서
(... )⍣⍺LeftArg 시간
(+/÷≢)합계를 tally로 나눈
,다음 다시 계산 합니다.
.5*⍨×/ 제품의 제곱근을 합니다.

모든 테스트 사례 :

      f←{((.5×+/),.5*⍨×/)⍣⍺⊢⍵}
      0 1 2 5 10 10 f¨ (24 6)(24 6)(24 6)(24 6)(100 50)(1,2*.5)
┌────┬─────┬────────────────┬───────────────────────┬───────────────────────┬───────────────────────┐
│24 6│15 12│13.5 13.41640786│13.45817148 13.45817148│72.83955155 72.83955155│1.198140235 1.198140235│
└────┴─────┴────────────────┴───────────────────────┴───────────────────────┴───────────────────────┘

TI-BASIC, 22 바이트

Input N
For(I,1,N
{mean(Ans),√(prod(Ans
End
Ans

알고리즘이 말하는 것을 정확하게 수행합니다. 프롬프트에서 N을 가져오고 A와 B를 Ans두 요소 목록으로 가져옵니다 .

N이 0이면 For(루프가 완전히 건너 뜁니다.

자바 스크립트 ES7, 48 43 바이트

Downgoat 덕분에 -5!

f=(n,a,b)=>n?f(n-1,(a+b)/2,(a*b)**.5):[a,b]

매우 간단한 재귀 함수.

MATLAB / 옥타브, 69 65 바이트

function [a,b]=r(a,b,n)
for i=1:n;j=(a+b)/2;b=(a*b)^.5;a=j;end

경쟁하지 않는 젤리

9 바이트이 답변은 도전 과제를 수행하는 기능을 사용하므로 경쟁이 아닙니다.

SH;P½¥ðṛ¡

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

작동 원리

SH;P½¥ðṛ¡    Input: x (vector) -- y (repetitions)

SH           Take the sum (S) of x and halve (H) the result.
   P½        Take the product (P) of x and the square root (½) of the result.
     ¥       Combine the last two instructions in a dyadic chain.
  ;          Concatenate the results to the left and to the right.
      ð      Push the preceding, variadic chain; begin a new, dyadic chain.
       ṛ     Return the right argument (y).
        ¡    Repeat the pushed chain y times.

진심으로, 11 바이트

,p`;π√@æk`n

육각 덤프 :

2c70603be3fb40916b606e

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

설명:

,                    Read in the list as [n,a,b]
 p                   pop list to yield: n [a,b]
  `      `n          Push a quoted function and run it n times.
   ;                 Duplicate [a,b] pair
    π√               Compute its product and square root it (GM)
      @              Swap the other copy of the pair to the top
       æ             Compute its mean.
        k            Compile the stack back into a list.

C ++, 108 (102) 100 바이트

6 바이트를 절약 해 준 @RetoKoradi와 @AlexA에게 감사합니다.

C ++는 좋은 골프 언어가 아니기 때문에 경쟁이 아닙니다. 재미를 위해 이것을 했습니까 :)

#include<cmath>
std::string f(float a,float b,int n){return n==0?a+" "+b:f((a+b)/2,sqrt(a*b),n-1);}

이것은 JS 회답과 매우 유사한 간단한 재귀 함수입니다.

K5, 15 바이트

매우 문자 그대로 :

{(+/x%2;%*/x)}/

실제로 :

 {(+/x%2;%*/x)}/[0; 24 6]
24 6
 {(+/x%2;%*/x)}/[5; 24 6]
1.345817e1 1.345817e1

불행히도, 인터프리터가 현재 부사의 투영 (커링)을 지원하지 않기 때문에 이것은 oK에서 작동하지 않습니다. 실제 k5에서 작동합니다.

oK에서는 현재 정의를 람다로 감싸 야합니다.

  {x{(+/x%2;%*/x)}/y}[5; 24 6]
13.4582 13.4582

J, 18 13 바이트

-:@+/,%:@*/^:

용법:

   agm =: -:@+/,%:@*/^:
   5 agm 24 6
13.4582 13.4582

apt , 24 바이트 25 33

저장된 9 7 바이트 @ETHproductions에 감사

Uo r@[VW]=[V+W /2(V*W q]

ES6 파괴를 활용합니다.

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

Ungolfed && 설명

Uo r@[VW]=[V+W /2(V*W q]

       // Implicit: U: 1st input, V: 2nd input, W: 3rd input
Uo     // Range from 0 to 1st input
r@     // Loop over range
  [V,W]=    // Set 2nd and 3rd input to...
   [V+W /2,   // Add 2nd and 3rd inputs, divide by 2
   (V*W q]    // Multiple 2nd and 3rd inputs, find square root
            // Set's to the above respectively 
       // Implicit: return [V,W]

Matlab, 54 바이트

function x=f(x,n)
for k=1:n
x=[mean(x) prod(x)^.5];end

예:

>> f([24 6], 2)
ans =
  13.500000000000000  13.416407864998739

피스, 12

u,.OG@*FG2EQ

테스트 스위트

설명

u,.OG@*FG2EQ    ##  implicit: Q = eval(input())
u         EQ    ##  reduce eval(input()) times, starting with Q
                ##  the reduce lambda has G as the previous value and H as the next
  .OG           ##  arithmetic mean of last pair
     @*FG2      ##  geometric mean of last pair, uses *F to get the product of the list
                ##  and @...2 to get the square root of that
 ,              ##  join the two means into a two element list

Minkolang v0.14, 23 바이트

여기에서 보십시오 !

$n[$d+2$:r*1Mi2%?!r]$N.
$n                      C get all input C
  [                ]    C pop N; repeat inner N times C
   $d                   C duplicate stack [1,2] => [1,2,1,2] C
     +                  C add top two elements C
      2$:               C divide by two C
         r              C reverse stack (get the other two) C
          *             C multiply them together C
           1M           C take square root C
             i2%?!r     C reverse the stack if an odd step number C
                    $N  C output stack
           1M           C take square root C
             i          C get step in for loop C

Pyth, 15 바이트

u,^*FG.5csG2vzQ

파이썬 3, 65 55 바이트

lambda연산자를 사용하여 더 짧은 버전을 지적 해준 mathmandan에게 감사합니다 .

f=lambda a,b,n:f((a+b)/2,(a*b)**.5,n-1)if n else(a,b)

내 원래 버전 :

def f(a,b,n):
 if n:f((a+b)/2,(a*b)**.5,n-1)
 else:print(a,b)

내 chagrin에게 재귀 함수 (JavaScript 및 C ++ 답변)는 간단한 for 루프보다 짧았습니다.

R, 66 바이트

f=function(a,b,n){while(n){x=(a+b)/2;b=(a*b)^.5;n=n-1;a=x};c(a,b)}

용법:

> f(24,6,0)
[1] 24  6
> f(24,6,1)
[1] 15 12
> f(24,6,2)
[1] 13.50000 13.41641
> f(24,6,3)
[1] 13.45820 13.45814
> f(24,6,4)
[1] 13.45817 13.45817
> f(100,50,10)
[1] 72.83955 72.83955
> f(1,1.41421356237,10)
[1] 1.19814 1.19814

Mathematica, 31 30 바이트

Martin Büttner 덕분에 1 바이트를 절약했습니다.

{+##/2,(1##)^.5}&@@#&~Nest~##&

용법:

In[1]:= {+##/2,(1##)^.5}&@@#&~Nest~##&[{24, 6}, 5]

Out[1]= {13.4582, 13.4582}

루아, 62 바이트

n,a,b=...for i=1,n do a,b=(a+b)/2,math.sqrt(a*b)end print(a,b)

용도에서 줄 인수를 명령 ...에 할당 n, a그리고 b, 나는 최근에 루아에 대해 알게 멋진 트릭.

하스켈, 40 바이트

(!!).iterate(\(a,b)->((a+b)/2,sqrt$a*b))

익명의 기능. 사용법 예 :

>> let f=(!!).iterate(\(a,b)->((a+b)/2,sqrt$a*b)) in f (1.0,1.41421356237) 10
(1.198140234734168,1.1981402347341683)

람다 함수 (\(a,b)->((a+b)/2,sqrt$a*b))는 튜플에서 산술 및 기하 평균을 취합니다. 이는 첫 번째 입력 (튜플)부터 반복 된 다음 (!!)두 번째 입력을 인덱싱하여 반복 횟수를 지정합니다.

펄, 60 바이트

perl -ape'F=($F[0]/2+$F[1]/2,sqrt$F[0]*$F[1])for 1..shift@F;$_="@F"'

NB : 당 이 메타 포스트 , 나는 믿는다 나는 점수가 올바른있어. 실제 코드 (작은 따옴표 사이)는 58 자입니다. a그리고 p가장 짧은 호출과의 차이로 +2를 추가 하고 플래그를 추가했습니다 .perl -e'...'

모호한 불만

나는 분명한 개선이 빠진 잔소리가 있습니다. "골프를 환영합니다"라는 것을 알고 있지만 평소보다 더 많은 합니다. 합니다.

초기에 나는 $\약간의 성공으로 두 번째 용어 로 사용하는 것에 혼란을 겪었 지만 위의 접근법은 추가로 2 바이트 더 짧아졌습니다.ap 필요한 플래그가 졌습니다. 마찬가지로 명시 적 $_할당을 피하는 것이 좋지만 루프가 어렵습니다.

shift@F버그 나도; 그래도 그렇게하지 않으면 (또는 사용하십시오.@F=(0,...,...) 바이트를 저장하지 않는 대신 ) @F할당에 오류가 있습니다.

예

echo 5 24 6 | perl -ape'F=($F[0]/2+$F[1]/2,sqrt$F[0]*$F[1])for 1..shift@F;$_="@F"'

출력

13.4581714817256 13.4581714817256

줄리아, 49 바이트

(a,b,n)->(for i=1:n;a,b=(a+b)/2,√(a*b)end;(a,b))

매우 직접적인 반복 알고리즘. 은 Using √기호와 여러 반환하는 것은 몇 바이트를 저장하지만 루프에 대한 구문은 몇 비용이 든다.

하스켈, 47 바이트

f a b 0=(a,b)
f a b n=f((a+b)/2)(sqrt$a*b)(n-1)

줄리아, 42 바이트

f(a,b,n)=n>0?f((a+b)/2,(a*b)^.5,n-1):(a,b)

이것은 재귀 함수입니다 f세 개의 숫자를 받아들이고 튜플을 반환 입니다.

언 골프 드 :

function f(a::Real, b::Real, n::Integer)
    if n > 0
        # Recurse on the arithmetic and geometric means, decrementing n
        return f((a + b) / 2, sqrt(a * b), n - 1)
    else
        # Return the pair
        return (a, b)
    end
end

LabVIEW, 21 LabVIEW 프리미티브

이 메타 포스트에 따라 프리미티브가 계산되었습니다 .

설명하기가 쉽지 않습니다.

파이썬 2, 62 61 62 바이트

def f(a,b,n):
 while n:a,b=(a+b)/2.,(a*b)**.5;n-=1
 print a,b

CJam, 16 바이트

{{_:+2/\:*mq]}*}

이것은 익명의 기능입니다. 입력은 두 개의 값 (두 배)과 반복 횟수가있는 목록입니다. 온라인으로 사용해보십시오테스트를 위해 I / O 코드를 사용 으로 .

@PeterTaylor가 질문을보기 전에 똑같이 긴 CJam 답변을 게시했기 때문에 일반적으로 이것을 게시하지 않았을 것입니다. 그러나 이것이 시리즈의 시작으로 알려지기 때문에 시리즈가 흥미있는 경우 옵션을 열어두기를 원했습니다.

길이는 Peter의 대답과 동일하지만 코드는 다릅니다. Peter가 별도의 값을 사용한 목록에서 두 값을 가져 와서 다른 입력 형식을 선택했습니다. 따라서 두 가지 입력 형식 중 많은 것이 없지만 코드는 매우 다르게 보입니다.

{     Start loop over number of iterations.
  _     Copy the current pair of values.
  :+    Reduce pair with + operator.
  2/    Divide by 2.
  \     Swap second copy of pair to top.
  :*    Reduce pair with * operator.
  mq    Calculate square root.
  ]     Wrap the two new values in a list for next iteration.
}*    End iteration loop.

펄 6 ,  53  47 바이트

{(($^a,$^b),->(\a,\b){((a+b)/2,sqrt(a*b))}...*)[$^n]} # 53 bytes

용법:

# give it a name
my &code = {(($^a,$^b),->(\a,\b){((a+b)/2,sqrt(a*b))}...*)[$^n]}

say code 100,50,10;          # (72.8395515523453 72.8395515523453)
say code 1,1.41421356237,10; # (1.19814023473417 1.19814023473417)

입력을에서 a,b,n로 변경하면 (a,b),n몇 바이트를 절약 할 수 있습니다.

{($^l,->(\a,\b){((a+b)/2,sqrt(a*b))}...*)[$^n]} # 47 bytes

용법:

my &code = {($^l,->(\a,\b){((a+b)/2,sqrt(a*b))}...*)[$^n]}

say code (100,50),10;          # (72.8395515523453 72.8395515523453)
say code (1,1.41421356237),10; # (1.19814023473417 1.19814023473417)

say code (24,6),$_ for 0,1,2,5;
# (24 6)
# (15 12)
# (13.5 13.4164078649987)
# (13.4581714817256 13.4581714817256)

{
  (
    $^l,          # first 2 element tuple
    ->            # pointy block (lambda)
      (\a,\b)     # take a single tuple, and give its 2 elements each a name
    {
      (           # create a 2 element tuple
        (a+b)/2,  # arithmetic mean
        sqrt(a*b) # geometric mean
      )
    } ... *       # create a lazy infinite sequence of tuples
  )[ $^n ]        # take the nth "tuple" from the outer sequence
}

실제로 ... *with를 바꾸면 매개 변수 ... -> (\a,\b) { a =~= b }가 필요하지 않습니다 $^n.
( ==대신 사용 하지 =~=마십시오. 멈추지 않을 수도 있습니다)

my &code = {($^l,->(\a,\b){((a+b)/2,sqrt(a*b))}...->(\a,\b){a=~=b})[*-1]}

say code (24,6);           # (13.4581714817256 13.4581714817256)
say code (100,50);         # (72.8395515523453 72.8395515523453)
say code (1,1.41421356237) # (1.19814023473417 1.19814023473417)

프롤로그, 80 바이트

암호:

p(A,B,0):-write([A,B]).
p(A,B,N):-X is(A+B)/2,Y is sqrt(A*B),M is N-1,p(X,Y,M).

예:

p(100,50,10).
[72.83955155234534, 72.83955155234534]

여기에서 온라인으로 사용해보십시오

자바, 103 96 84 바이트

String f(int n,double a,double b){return n>0?f(n-1,(a+b)/2,Math.sqrt(a*b)):a+","+b;}

모든 테스트 케이스를 확인하십시오.

이전 버전 (96 바이트) :

String f(int n,double a,double b){for(;n>0;a=(a+b)/2,b=Math.sqrt((b-2*a)*b))n--;return a+","+b;}

이전 버전 (103 바이트) :

String f(int n,double a,double b){double t;for(;n>0;t=(a+b)/2,b=Math.sqrt(a*b),a=t)n--;return a+","+b;}