분쇄기에 오신 것을 환영합니다.

당신의 임무는 큰 바위를 분쇄하여 작은 바위로 만드는 것입니다.

큰 크기의 바위를 입력 n > 3 하고 갈아 입으십시오.

모든 암석의 크기가 될 때까지 분쇄기에 분쇄하여 암석을 계속 분쇄하십시오 2.

암석은 항상 같은 반쪽으로 연마됩니다. 연삭 결과가 홀수이면 결과-1을 취하십시오.

진행하면서 각 연삭의 결과물을 인쇄하십시오.

예

입력: 5

산출: 22

결과는 크기가 2 인 두 개의 암석입니다.

입력: 50

산출:

2424 //two rocks of size 24
12121212 //four rocks of size 12
66666666 //8 rocks of size 6
2222222222222222

결과는 크기 2의 16 개의 암석입니다.

입력: 30

산출:

1414
6666
22222222

결과는 크기 2의 8 개의 바위입니다.

이것은 코드 골프 이므로 가장 짧은 코드가 승리합니다! 재미와 행운을 빕니다!

TSQL, 61 59 바이트

DECLARE @ int=50

,@x int=1WHILE @>2SELECT @=@/4*2,@x*=2PRINT replicate(@,@x)

사용해보십시오

COW, 297 291 바이트

MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmoOMoOmoOmoOoommOoMoOMOOmoOMMMmoOMMMmoOOOOMoOmOoMOOMOomoOmoO
MOOMOomOoMOomoOmoomOoMMMOOOMoOmoOMMMmOomOomoomoOmoOMOOMOomOomOomOoMOomoOmoOmoOmoomOomOomOo
mOomOoMMMmoOMMMMOOMOomoOOOMmOomOoMoOmoOmoomOomOoMoomoOmoOmoOMOOMOoMOomoOMoOmOomoomoOMMMOOO
mOoMMMMMMmOoMMMMOomoo

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

이 코드는 각 번호를 자체 줄에 인쇄하고 추가 줄 바꿈으로 반복을 구분합니다. 또한 첫 번째 반복 자체를 인쇄 한 다음 줄 바꿈을 인쇄합니다. 따라서 5를 입력 5 2 2하면 공백 대신 줄 바꿈을 제외하고 출력이 나타납니다 . 샘플 출력 50은 다음과 같습니다.

설명 트리 :

MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmoOMoOmoOmoOoom ;Store 10 in [0], 1 in [1], and integer input in [3]
mOoMoO                                        ;Store 1 in [2]
MOO                                           ;Loop while [2] is non-zero
   moOMMMmoOMMMmoOOOOMoOmOo                   ;   Copy [3] to [4], clear contents of [5], and store 1 in [5]
   MOO                                        ;   Loop while [4] is non-zero
      MOomoOmoO                               ;      Decrement 4 and move to 6
      MOO                                     ;      Loop while [6] is non-zero
         MOomOoMOomoO                         ;         Decrement [5] and [6]
      moo                                     ;      End loop once [6] is empty
      mOoMMMOOOMoOmoOMMMmOomOo                ;      Copy [5] to [6], and reset [5] to 1, then move back to [4]
   moo                                        ;   End loop now that [4] is empty.  [6] now contains the parity of [3]
   moOmoO                                     ;   Navigate to [6]
   MOO                                        ;   Loop while [6] is non-empty
      MOomOomOomOoMOomoOmoOmoO                ;      Decrememnt [3] and [6]
   moo                                        ;   End loop now that [6] is empty.  [3] now contains the largest even number less than the previous iteration.
   mOomOomOomOomOoMMMmoOMMM                   ;   Copy [1] to [2]
   MOO                                        ;   Loop while [2] is non-empty
      MOomoOOOMmOomOoMoOmoO                   ;      Decrement [2], increment [1], and print the number in [3].
   moo                                        ;   End loop now that [2] is empty
   mOomOoMoo                                  ;   Print a new line
   moOmoOmoO                                  ;   Navigate to [3]
   MOO                                        ;   Loop while [3] is non-empty
      MOoMOomoOMoOmOo                         ;      Decrement [3] twice and increment [4] once
   moo                                        ;   [4] now contains half of [3]
   moOMMMOOOmOoMMM                            ;   Copy [4] to [3] and clear [4]
   MMMmOoMMMMOo                               ;   Copy [3] to [2] and decrement once
moo                                           ;End loop now that [2] is empty

입력 50의 샘플 출력 :

50

24
24

12
12
12
12

6
6
6
6
6
6
6
6

2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2

05AB1E , 12 11 바이트

¸[4÷·€D=¬<#

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

설명

¸             # wrap input in a list
 [            # start infinite loop
  4÷          # elementwise integer divison by 4
    ·         # elementwise multiplication by 2
     €D       # duplicate each element in the list
       =      # print it
        ¬     # get the first element of the list
         <    # decrease it by 1
          #   # if true: exit loop

파이썬 2, 55 53 바이트

n=input()
while n[0]>2:n=len(n)*2*[n[0]/4<<1];print n

4로 나누고 왼쪽 시프트를 1로 나누면 특수 부서가 생깁니다.

하스켈, 75 71 60 50 47 바이트

f 0=[]
f n|x<-f$2*div n 4=show n:zipWith(++)x x

온라인으로 사용해보십시오! 편집 : 출력이 이제 입력을 포함한 목록 이 될 수 있으므로 10 13 바이트를 저장할 수 있습니다.

용법:

Prelude> f 50
["50","2424","12121212","66666666","2222222222222222"]

원본 60 바이트 버전 :

2%x=""
n%x|z<-2*div n 4=([1..x]>>show z)++"\n"++z%(x*2)
(%2)

온라인으로 사용해보십시오! 더 짧은 공식을 지적한 Christian Sievers에게 감사드립니다.

용법:

Prelude> (%2)50
"2424\n12121212\n66666666\n2222222222222222\n"

자바 스크립트 (ES6) 64 59 57 바이트

f=s=>{for(n=1;s>2;)console.log(`${s=s/4<<1}`.repeat(n*=2))}

console.log(f.toString().length); 
f(5);
f(50);
f(30);                                  

파이썬 2, 48 47 바이트

s=input()
n=1
while s>3:s=s/4*2;n*=2;print`s`*n

자바, 85 바이트

n->{String s="";for(int q=2,i;n>2;q*=2,s+="\n")for(i=q,n=n/4*2;i-->0;)s+=n;return s;}

테스트 및 ungolfed

import java.util.function.*;

class Ideone {
  public static void main(String[] args) throws java.lang.Exception {
    Function<Integer, String> f = number -> {
      String result = "";
      for (int quantity = 2, i; number > 2; quantity *= 2) {
        number = number / 4 * 2; // Make sure that the next is half or half - 1 if odd
        for (i = quantity; i > 0; i--) { // copy "quantity" times.
          result += number;
        }
        result += "\n"; // append new line
      }
      return result;
    };
    System.out.println(f.apply(50));
  }
}

참고 : 왜 Ideone이 내부 오류를 계속하는지 알지 못하므로 테스트하는 것이 문제입니다. 테스트하려면 표준 Java IDE에서 복사 / 붙여 넣기 및 실행 만하면됩니다. (여기서 작동합니다.)

C #, 88 86 83 바이트

Skorm 덕분에 3 바이트 절약

변수 선언을 포함 while하는 for루프로를 변경하여 다른 바이트를 저장했습니다.

Yodle 덕분에 1 바이트 절약

n=>{var r="";for(int i,c=2;n>2;c*=2,r+="\n")for(i=0,n=n/4*2;i++<c;)r+=n;return r;};

각 연삭 결과로 구성된 문자열을 반환하는 익명 함수.

ungolfed 방법 및 테스트 사례가 포함 된 전체 프로그램 [마지막 편집 전]

using System;

public class Program
{
    public static void Main()
    {
        Func<int, string> f =
        n =>
        {
            var r = "";
            for (int i, c = 1; n > 2; )  // iterator and counter variable
            {
                    n = n/4 * 2;    // make sure the result if even
                    c *= 2;         // keep track of the number of rocks
                    for (i = 0; i++ < c; )  // store the current line made of [c] rocks of size [n]
                        r += n;
                    r += "\n";      // add a trailing newline to the string resulted from this step
            }
            return r;       // return the entire history
        };

        //test cases:
        Console.WriteLine(f(5));
        Console.WriteLine(f(50));
        Console.WriteLine(f(30));
    }
}

CJam , 21 바이트

l~]{{2/-2&_}%_n_2-}g;

온라인으로 사용해보십시오! (테스트 스위트로)

설명

l~]      e# Read input, evaluate and wrap it in a singleton list.
{        e# Do while...
  {      e#   Map this block over the list of rocks.
    2/   e#   Halve the rock.
    -2&  e#   Bitwise AND with -2, clearing the least-significant bit and
         e#   rounding down to an even integer.
    _    e#   Duplicate.
  }%
  _n     e# Print a copy of the current list of rocks.
  _2-    e# Continue if the current list of rocks contains values that aren't 2.
}g
;        e# Discard the final result to prevent printing it again.

Pyth, 18 16 13 바이트

WhQ=Q*2my/d4\n

^{* \n는 새 줄입니다}
.

W              # While
 hQ            # first element of Q - 0 is falsy
   =Q          # assign to Q
     *2        # the double of the (list) that is returned
       m       # form this \/ map
         /d4   # divide every element by 4
        y      # and double
            \n # print Q

여기를보십시오

MATL , 13 바이트

`K/kEthttH>]x

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

`       % Do...while
  K/k   %   Divide by 4 and round down. Takes input implicitly in the first iteration
  E     %   Multiply by 2
  th    %   Attach a copy of itself (creates a longer array)
  t     %   Duplicate. This copy will be used for further grinding, keeping the original
  tH>   %   Duplicate. True if the values exceed 2. Used as loop condition
]       % End. The loop exits if the latest array contains 2
x       % Delete last copy. Implicitly display the entire stack

PHP, 72 67 64 바이트

for($n=$argv[$k=1];$n>2;)echo str_repeat($n=$n/2&~1,$k*=2),"\n";

명령 행에서 인수를 취합니다. 로 실행하십시오 -r.

젤리 , 13 12 11 바이트

:4Ḥx2µȦпṖY

TryItOnline!

참고 : OP는 입력이 출력에있을 수도 있다고 명시했습니다.

방법?

:4Ḥx2µȦпṖY - Main link: rockSize
     µ      - monadic separation
       п   - loop collect intermediate results while
      Ȧ     - any
:4          -     integer division (vectorises) by 4
  Ḥ         -     double (vectorises)
   x2       -     repeat the elements 2 times
         Ṗ  - pop (remove the trailing list of zeros)
          Y - join with line feeds

12 바이트 동안 입력이없는 버전 : :4Ḥḟ0x2µÐĿḊG

펄, 40 35 30 + 1 = 31 바이트

-n플래그로 실행

@Dada 덕분에 -4 바이트

say$_ x($.*=2)while$_=$_>>1&~1

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

Perl 은 설정 $_되면 변수로 입력을 자동으로 읽습니다 -n. $.는 1인터프리터가 프로그램 시작 부분에 설정 한 특수 변수 이므로 더블링의 기준으로 사용할 수 있습니다. while루프가 반복 될 때마다 비트 시프트 $_다운되고 마이너스 1에 대해 논리 AND를 수행하여 1 비트를 취소합니다.

PowerShell 3+, 58 54 바이트

for($s=$input;$s;$s=($s-shr2)*2){"$s"*(2-shl($i++)-1)}

4 바이트 절약 해 주셔서 감사합니다. TimmyD !

약간 골퍼 (포맷)

for ( $s = $input ; $s ; $s = ( $s -shr 2 ) * 2 ) {
    "$s" * (2 -shl ($i++)-1)
}

설명

나는 다른 많은 답변과 같은 4 나누기와 2 트릭을 똑같이 사용하고 있지만 문제가 발생했습니다. PowerShell은 나누는 동안 필요한 경우 숫자를 부동 소수점으로 변환하고와 $v/4*2같은 무언가가 되기 때문에 성가신 골프를 위해 [int]($v/4)*2. 나는 디비전을 위해 비트 쉬프팅을 사용하여-shr .

반복을 인쇄하는 횟수를 계산하기 위해 (2^$i)-1잘 작동하며 입력 값을 생략하는 추가 효과가 있습니다. 0부터 시작하면 값을 높이기가 어려워지고 $i*=21부터 시작하면 숫자를 올바르게 맞추려면 너무 많은 수정이 필요 하기 때문에 2를 곱하는 것은 문제가되었습니다 .

PowerShell에는 운영자가 없기 때문에 피하고 싶기 때문에 [Math]::Pow()2의 거듭 제곱을 위해 비트 시프 팅에 다시 의존했습니다.

파이썬 2, 47 바이트

OP가 입력을 포함 한 1D 배열이 훌륭하다고 말했기 때문에 불행히도 현재 Python 우승자와 만 관련이있는이 재귀 함수를 생각해 냈습니다.

f=lambda s,n=1:[s]*n+(f(s/4*2,n*2)if s>3else[])

펄, 47 바이트

$a=<>>>1;say 2*(($a>>=1)||die)x(1<<$_)for 1..$a

이번에는 명령 행 옵션이 없습니다 (일반적으로 Perl의 경우). 기본 아이디어는 주어진 단계의 모든 암석이 같은 크기이므로 전체 목록을 기록하는 대신 크기 (in $a) 및 숫자 (in $_)를 기록하는 것입니다. 나는 공간 (또는 제거하는 방법을 찾을 수 없습니다 +) 이후 say; 이동할 수는 2*있지만 여는 괄호 뒤에 올 바르면 올바르게 구문 분석되지 않습니다.

나는 이것이 불가능하다는 느낌을 떨쳐 버릴 수는 없지만 어떻게 볼 수는 없습니다.

Vim 61 54 바이트

qqYpPJ0yw:s;\d*;="/2
;g
:let @t=(">7)+1
@tkjjG@qq@q

TryItOnline!

인쇄 할 수없는 항목 :

qqYpPJ0yw:s;\d*;^R=^R"/2
;g
:let @t=(^R">7)+1
@tkjjG@qq@q

다행히 vim은 x / 2에서 자동으로 잘립니다.

자바 스크립트, 71 63 59 58 바이트

글쎄, 나는이 자바 스크립트 솔루션을 생각해 냈습니다. 골프에서 완전히 새로운 것이지만, 나는 이것이 재미있는 도전을 foudn

for 루프를 사용한 Titus 제안 덕분에 4 바이트가 절약되었습니다.

ungolfed 기준 :

for(o = i = 30; i > 1; i= i/4<<1) {
   console.log(`${i}`.repeat(o / i));
}

골프 버전

for(o=i=30;i>1;i=i/4<<1){console.log(`${i}`.repeat(o/i));}

나는 그것을 향상 / 골프를 배우는 방법에 대한 제안을 위해 열려 있습니다

입력 테스터

function test(a){
var el = document.getElementById('output');
var text = []; 
for(o = i = parseInt(a); i > 1; i= i/4<<1) {
   text.push(`${i}`.repeat(o / i));
}
  el.innerText = text.join('\n');
}

<input type="input" onchange="test(this.value)"><button>run</button>
<pre id="output">
</pre>

BASH, 81 바이트

n=$1
h=1
while [ ${n//2} ];do
printf -v s %$[h=h*2]s
echo ${s// /$[n=n/4*2]}
done

스위프트, 84 바이트

func g(n:Int){var n=n,i=2;while n>2{n=n/4*2;print(Array(repeating:n,count:i));i*=2}}

언 골프

func grind(rockSize: Int) {
    var rockSize = rockSize
    var rockCount = 1

    while rockSize > 2 {
        rockSize = rockSize / 4 * 2
        rockCount *= 2

        let output = Array(repeating: rockSize, count: rockCount)
        print(output)
    }
}

Befunge, 45 바이트

&1vg0_\:.\v
:\<  ^!:-1<p00:*2\.:*2/4,+55_@#`2

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

설명

&           read the rock size
1           initialise the count
<           start of main loop going right to left

  \         swap the size to the top of the stack
  :2`#@_    if size is not > 2 then exit
  55+,      output a line break
  4/2*      size = size/4*2, i.e. split into even halves
  :.        output the size
  \         swap the count to the top of the stack
  2*        count = count*2
  :00p      save count for later

  <         start of inner loop
    1-      decrement the count
    :!^_    break out of the loop if the count is zero
    \       swap the size to the top of the stack
    :.      output the size
    \       swap the count to the top of the stack
    v       back to the start of the inner loop    

  0g        restore the saved count
  v         back to the start of the main loop

자바 스크립트, 106 바이트

첫 번째 코드 골프는 내가 갈 줄 알았습니다. (별로 좋지 않습니다).

for(;i[i.length-1]>3;){for(var x=0;x<i.length;x++)i[x]/=2,i[x]%2===1&&i[x]--;i=i.concat(i),console.log(i)}

미완성 :

while (input[input.length - 1] > 3) {
    for (var x = 0; x < input.length; x++) {
        input[x] /= 2;
        if (input[x] % 2 === 1) input[x]--;
    }
    input = input.concat(input);
    console.log(input);
}