오리, 오리, 요세푸스

49

정수 배열이 주어지면 :

  1. 첫 번째 숫자부터 시작
  2. n이 현재 위치의 값인 n 위치 앞으로 이동
  3. 현재 위치를 삭제하여 다음 위치를 현재 위치로 만듭니다.
  4. 하나의 숫자가 남을 때까지 2 단계로갑니다.
  5. 그 번호를 인쇄

규칙

배열은 둘러 쌉니다 (어레이에서 마지막 숫자 다음의 숫자는 첫 번째 숫자입니다).

0은 (분명히) 자체를 제거합니다.

음수는 입력으로 허용되지 않습니다.

테스트 사례

[1] => 1
[1,2] => 1
[1,2,3] => 3
[1,2,2] => 1
[1,2,3,4] => 1
[6,2,3,4] => 4
[1,2,3,4,5] => 5
[0,1] => 1
[0,0,2,0,0] => 0

단계별 예

[1,4,2,3,5]
 ^          start from the first position
   ^        jump 1 position (value of the position)
[1,  2,3,5] remove number in that position
     ^      take next position of the removed number (the 'new' 'current' position)
         ^  jump 2 positions
[1,  2,3  ] remove number in that position
 ^          take next position (looping on the end of the array)
     ^      jump 1 position
[1,    3  ] remove number in that position
       ^    take next position (looping)
 ^          jump 3 positions (looping on the end of the array)
[      3  ] remove number in that position
print 3

실시 예 # 2

[4,3,2,1,6,3]
 ^            start from the first position
         ^    jump 4 positions
[4,3,2,1,  3] remove number in that position    
           ^  take next position
     ^        jump 3 positions
[4,3,  1,  3] remove number in that position    
       ^      take next position
           ^  jump 1 positions
[4,3,  1    ] remove number in that position    
 ^            take next position
   ^          jump 4 positions
[4,    1    ] remove number in that position    
       ^      take next position
 ^            jump 1 position
[      1    ] remove number in that position
print 1

이것은 code-golf 이며 바이트 단위로 가장 짧은 대답이 이깁니다!

code-golf  array-manipulation 
— 워크 플로우
소스
14
좋은 첫 도전!
— Luis Mendo
2
@LuisMendo 예 있습니다 .. "이 같은 건너 ..."도전
— J42161217
2
@Jenny_mathy 나는 비슷한 것이 있다고 생각하지 않았지만 Luis가 말했듯이 랩 어라운드 배열은 골프에 흥미로운 도전을합니다. 내 생각 : /
— workoverflow
3
@EriktheOutgolfer 정말 속임수가 아닙니다. 거기에있는 요소는 구별 할 수없고 단계 크기는 고정되어 있습니다. 루이스는 훨씬 더 가깝지만 여전히 충분히 다릅니다.
— Martin Ender
3
실제로 최종 숫자를 인쇄해야합니까, 아니면 그냥 반환 할 수 있습니까? 실제로 숫자를 반환해야합니까, 아니면 함수를 실행 한 후 배열에 숫자 만 포함되도록 배열 내에서 제대로 작동 할 수 있습니까?
— iamnotmaynard

답변:

7

하스켈 , 54 50 48 바이트

f[x]=x
f(x:r)=f$snd<$>zip r(drop(x+1)$cycle$x:r)

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

설명:

  • f[x]=x: 주어진리스트가 싱글 톤리스트라면 그 원소를 반환합니다.
  • f(x:r)=f$ ...: 그렇지 않으면 f다음 목록에 재귀 적으로 적용 됩니다.
    • 현재 목록의 요소는 무한정 순환됩니다 ( cycle$x:r),
    • 첫 번째 x+1요소가 제거 된 ( drop(x+1)$)
    • 의 길이로 잘립니다 r. ( snd<$>zip r보다 짧은 대안입니다 take(length r)).

이전 54 바이트 버전 :

f=(%)=<<head
_%[x]=x
n%(x:r)|n<1=f r|s<-r++[x]=(n-1)%s

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

— 라이 코니
소스
6

MATL , 21 바이트

1`yy)+ynX\[]w(5Mynq]x

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

1        % Push 1: current position in the array
`        % Do...while
  yy     %   Duplicate top two elements in the stack. Takes input implicitly
         %   in the first iteration.
         %   STACK: array, position, array, position
  )      %   Get specified entry in the array
         %   STACK: array, position, selected entry
  +      %   Add
         %   STACK: array, position (updated)
  y      %   Duplicate from below
         %   STACK: array, position, array
  n      %   Number of elements of array
         %   STACK: array, position, number of elements or array
  X\     %   1-based modulus
         %   STACK: array, position (wrapped around)
  []     %   Push empty array
         %   STACK: array, position, []
  w      %   Swap
         %   STACK: array, [], position
  (      %   Write value into specified entry in array. Writing [] removes
         %   the entry
         %   STACK: array (with one entry removed)
  5M     %   Push latest used position. Because of the removal, this now
         %   points to the entry that was after the removed one
         %   STACK: array, position
  y      %   Duplicate from below
         %   STACK: array, position, array
  n      %   Number of elements of array
         %   STACK: array, position, number of elements of array
  q      %   Subtract 1
         %   STACK: array, position, number of elements of array minus 1
]        % End. If top of the stack is nonzero, proceed with next iteration
         % STACK: array (containing 1 entry), position
x        % Delete. Implicitly display
         % STACK: array (containing 1 entry)
— 루이스 멘도
소스
1
참고 : 포인터를 유지하는 대신 목록 회전을 사용하면 아마도 훨씬 짧아 질 것입니다.
— Outgolfer Erik
1
@Erik 감사합니다. 그러나 내가 생각하는 설명을 추가 지금 내가 이런 식으로 떠날거야
— 루이스 Mendo에게
글쎄, 당신은 항상 설명을 제거 할 수 있습니다, 그것은 역사에 보관됩니다 :)
— 에릭 The Outgolfer
5

CJam , 15 바이트

l~_,({_0=m<1>}*

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

설명

포인터를 추적하는 대신 현재 요소가 항상 앞에 오도록 배열을 주기적으로 이동합니다.

l~     e# Read and evaluate input.
_,(    e# Get its length L and decrement to L-1.
{      e# Run this block L-1 times...
  _0=  e#   Get the first element X.
  m<   e#   Rotate the array left by X positions.
  1>   e#   Discard the first element.
}*
       e# The final element remains on the stack and gets printed implicitly.

불행히도 바이트를 저장하지 않는 재미있는 대안 :

l~_{;m<1>_0=}*;
— 마틴 엔더
소스
5

Brain-Flak , 88 바이트

([[]]()){({}<(({})){({}<({}<([]){({}{}<>)<>([])}{}>)<>{({}[<>[]])<>}<>>[()])}{}{}>())}{}

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

설명

([[]]())                      Push negative N: the stack height - 1
{({}< … >())}{}               Do N times
     (({}))                     Duplicate M: the top of the stack
     {({}< … >[()])}{}          Do M times 
                                  Rotate the stack by 1:
          ({}< … >)               Pop the top of the stack and put it back down after
          ([]){({}{}<>)<>([])}{}  Pushing the rest of the stack on to the other one, in reverse, with the stack height added to each element (to ensure that all are positive)
          <>{({}[<>[]])<>}<>      Push the rest of the stack back, unreversing, and subtracting the stack height from each element
                      {}        Pop the top of stack
— H.PWiz
소스
1
매우 이상한 골프이지만 88 바이트 입니다.
— 밀 마법사
1
@WheatWizard 니스, 놀랍게도 나는 이전에 그런 것을 시도했다.
— H.PWiz
사람들이 어떻게 그렇게 코드를 작성하는지 알 수 없습니다! 의사 코드 번역기 등이 있습니까?
— workoverflow
1
@workoverflow 아니오, 솔직히보기보다 쉽습니다. 실제로 시작하기 전에 매우 어려웠지만 명령이 간단 할 때 배우기 쉽습니다.
— H.PWiz
5

파이썬 2 , 55 바이트

def f(a):
 while a[1:]:l=a[0]%len(a);a[:]=a[-~l:]+a[:l]

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

기본적 으로 허용 되는대로 단일 목록으로 출력 합니다. 함수 인수를 수정할 수 있음을 상기시켜줌으로써 Dennis 덕분에 몇 바이트를 절약했습니다 .

작동 원리

  • def f(a)-매개 변수를 사용하여 함수를 정의합니다 a.

  • while a[1:]:- a첫 번째 요소가 제거 된 상태에서 진실 된 상태로 따르려면 코드 블록을 실행하십시오. 하나 이상의 요소가있는 목록은 사실적이고 파이썬에서 빈 목록은 거짓이므로 a길이가 1에 도달하면 중지됩니다 .

  • l=a[0]%len(a)-첫 번째 요소를 취하고 나머지 부분을 길이로 구합니다 a. 에 결과를 할당하십시오 l.

  • a[:]=a[-~l:]+a[:l]- 요소 a별로 왼쪽으로 회전 l하고 첫 번째 요소를 제거하면서a 를 제자리에 .

파이썬 2 , 63 바이트

f=lambda a,i=0:a[1:]and f(a,a.pop(((a*-~i)[i]+i)%len(a))+1)or a

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

더 길지만 훨씬 더 우아해 보입니다. 또한 채팅을 도와 준 ov에게 감사합니다.

— 미스터 Xcoder
소스
1
a,*b=input()(python3)과 같은 작업을 수행 하고 몇 바이트를 절약 할 수 없습니까? 그러나 그게 어떤 영향이 있을지 확신 할 수없는거야 l와 슬라이스
— 로드
1
@로드 그렇게 생각하지 않습니다. 파이썬 3에서도 입력을 평가해야합니다.
— Mr. Xcoder
3

수학, 36 바이트

마틴의 알고리즘을 사용 

#//.l:{x_,__}:>Rest@RotateLeft[l,x]&

Misha Lavrov && Martin Ender의 -5 바이트

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

— J42161217
소스
1
패턴을 사용하여 첫 번째 요소를 선택하여 2 바이트를 절약 할 수 있습니다 #//.{x_,y__}:>Rest@RotateLeft[{x,y},x]&. (때문에 단 하나 개의 요소가있을 때이 중지 {a}더 이상 패턴과 일치하지 않습니다 {x_,y__}.)
— 미샤 라브 로프
1
@MishaLavrov는 지금 테스트 할 수 없지만을 삭제 y하고 전체 목록을 호출 l한 다음 l대신 을 사용하여 추가로 단축 할 수 있습니다 {x,y}.
— Martin Ender
1
@MartinEnder 다음과 같은 의미 #//.l:{x_,__}:>Rest@RotateLeft[l,x]&입니까?
— Misha Lavrov
1
@MishaLavrov 네.
— Martin Ender
3

J , 21 17 바이트

FrownyFrog 덕분에 -4 바이트

((1<#)}.{.|.])^:_

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

기발한:

([:}.{.|.])^:(1<#)^:_

작동 방식 :

^:_ 결과 변경이 멈출 때까지 반복

^:(1<#) 목록의 길이가 1보다 큰 경우

{.|.] 목록을 첫 번째 항목 시간 왼쪽으로 회전

[:}. 첫 번째 요소를 버리고 포크를 덮습니다.

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

— 갈렌 이바노프
소스
@ FrownyFrog 감사합니다, 나는 이것을 시도하지 않았습니다-훨씬 낫습니다!
— Galen Ivanov
3

자바 스크립트 (ES6), 54 60 바이트

@Shaggy 고정 버전으로 1 바이트 절약
(+6 바이트)

입력 배열을 수정하여 싱글 톤으로 줄입니다.

f=(a,p=0)=>1/a||f(a,p=(p+a[p%(l=a.length)])%l,a.splice(p,1))

테스트 사례

코드 스 니펫 표시

어떻게?

당면 과제에 설명 된 알고리즘을 재귀 적으로 적용합니다. 정지 조건 만 1/a약간 이상하게 보일 수 있습니다. 산술 연산자를 적용 할 때 :

  • 하나 개 이상의 소자의 어레이로 강제되고 NaN그리고 1/NaN도 NaN(falsy).
  • 정확히 하나 개의 정수들의 어레이 중 하나를 초래하는 정수로 강제된다 1/0 = +Infinity또는 1/N = positive float위해 N> 0 (모두 truthy).
f = (a, p = 0) =>                 // a = input array, p = pointer into this array
  1 / a ||                        // if a is not yet a singleton:
    f(                            //   do a recursive call with:
      a,                          //     a
      p = (                       //     the updated pointer
        p + a[p % (l = a.length)] //
      ) % l,                      //
      a.splice(p, 1)              //     the element at the new position removed
    )                             //   end of recursive call
— 아르나 울드
소스
로보고 splice원래 배열을 수정, 당신은 할 수 f=(a,p=0)=>1/a||f(a,p=p+a[p]%a.length,a.splice(p,1))에 대한 52 바이트
— 얽히고 설킨
그것은 단계별로 두 번째 단계에 대한 올바른 결과를 제공하지 않는 것 같습니다, f=(a,p=0)=>1/a?a:f(a,p=(p%a.length+a[p%a.length])%a.length,a.splice(p,1))괜찮지 만 최적화 될 수 있습니다
— Nahuel Fouilleul
트윗 담아 가기 어느 시점에서 괄호를 p+a[p]제거 할 수 있다고 생각했습니다 . 물론 그렇지 않습니다. 보고 해 주셔서 감사합니다!
— Arnauld
@Neil이 여기에 주목 한이 컨센서스를 참조 하십시오 .
— Shaggy
@Shaggy 오, 알겠습니다. 감사합니다! (저는 처음으로 TIO 링크를 놓쳤습니다 ...)
— Arnauld
3

자바 8, 79 바이트

이 람다는 a를 받아들이고 or를 Stack<Integer>반환합니다 .intInteger

l->{for(int i=0,s=l.size();s>1;)l.remove(i=(i+l.get(i%s))%s--);return l.pop();}

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

언 골프

l -> {
    for (
        int i = 0, s = l.size()
        ; s > 1
        ;
    )
        l.remove(
            i = (i + l.get(i % s)) % s--
        );
    return l.pop();
}

감사의 말

  • Nahuel Fouilleul 덕분에 -2 바이트
— 야콥
소스
1
i%=s만약 삭제 될 수 l.get(i)변경l.get(i%s)
— 나우 Fouilleul
2

Pyth , 9 바이트

.WtHt.<Zh

여기 사용해보십시오!

기본적 으로 허용 되는대로 결과를 단일 목록으로 출력합니다. .

작동 원리

.WtHt.<Zh ~ Full program.

.W        ~ Functional while. It takes three arguments, two functions: A and B
            and a starting value, which in this case is automatically assigned
            to the input. While A(value) is truthy, value is set to B(value).
            Returns the ending value. A's argument is H and B's is Z.
  tH      ~ A (argument H): Remove the first element of H. A singleton list
            turns into [], which is falsy and thus breaks the loop. Otherwise,
            it is truthy and the loops goes on until the list reaches length 1.
     .<Zh ~ B (argument Z): Cyclically rotate Z by Z[0] places, whereas Z[0]
            represents the first element of Z.
    t     ~ And remove the first element.

참고 : 대괄호를 표시하지 않으려면 전체 코드 앞에 h또는 e앞에 추가하십시오 .

— 미스터 Xcoder
소스
2

펄 6 , 46 45 바이트

(브래드 길버트 덕분에 1 바이트)

{($_,{(|$_ xx*)[.[0]+(1..^$_)]}...1)[*-1][0]}

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

($_, { ... } ... 1)입력 목록부터 시작하여 $_각 연속 요소가 중괄호 표현식에 의해 생성되고 목록이 스마트 일치 할 때 종료됩니다. 1즉, 길이가 1 인 경우 일련의 목록을 생성합니다.[* - 1] 최종 요소를 취득하고, 결승전 [0]단일 요소 목록에서 유일한 요소를 가져옵니다.

(|$_ xx *)현재 요소의 평평하고 무한 복제 된 사본을 생성합니다. 이 목록은 .[0] + (1 ..^ $_)계열에서 다음 유한 목록을 추출 할 수 있는 범위 로 색인화됩니다 .

— 션
소스
1
부푼 마음 OO
— 아드리안
[*-1][0][*-1;0]바이트 저장 으로 결합 할 수 있습니다 . 또한 바이트 1..$_-1를 1..^$_다시 저장하는 것이 좋습니다 .
— 브래드 길버트 b2gills
@ BradGilbertb2gills 내가 시도 [*-1;0]했지만 어떻게 든 동등하지 않은 것 같습니다. 그런 다음이 함수는 숫자가 아닌 목록을 반환합니다.
— Sean
즉, 멈추지 않는다 1..^$_최적화
— 브래드 길버트는 b2gills
1

펄 5 , 47 43 41 + 2 ( -ap) = 43 바이트

$\=splice@F,($_+=$F[$_%@F])%@F,1while@F}{

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

공백으로 구분 된 숫자로 입력을받습니다.

— Xcali
소스
그것은 다음의 단계별 예제와 정확히 동일하지는 않지만 더 길다$x%=@F,splice@F,$x=($x+$F[$x])%@F,1while$#F;$_="@F"
— Nahuel Fouilleul
1
wow oO 게임을 시작해야합니다.
— Adrian
1

자바 8 , 325 바이트

골프 :

static void n(Integer[]j){Integer[]h;int a=0;h=j;for(int i=0;i<j.length-1;i++){if(h.length==a){a=0;}a=(a+h[a])%h.length;h[a]=null;h=m(h);}System.out.print(h[0]);}static Integer[] m(Integer[]array){Integer[]x=new Integer[array.length-1];int z=0;for(int i=0;i<array.length;i++){if(array[i]!=null){x[z]=array[i];z++;}}return x;}

언 골프 드 :

 interface ArrayLeapFrog {
static void main(String[] z) throws Exception {
    Integer[] j = {6, 2, 3, 4};
    n(j);
}

static void n(Integer[] j) {
    Integer[] h;
    int a = 0;
    h = j;
    for (int i = 0; i < j.length - 1; i++) {
        if (h.length == a) {
            a = 0;
        }
        a = (a + h[a]) % h.length;
        h[a] = null;
        h = m(h);
    }
    System.out.print(h[0]);
}

static Integer[] m(Integer[] array) {
    Integer[] x = new Integer[array.length - 1];
    int z = 0;
    for (int i = 0; i < array.length; i++) {
        if (array[i] != null) {
            x[z] = array[i];
            z++;
        }
    }
    return x;
  }
}
— 개발자 개발
소스
4
어서 오십시오! 몇 가지 팁 : static키워드 를 세지 않아도됩니다 . 일반적으로 다중 메소드 솔루션은 클래스의 비 정적 멤버로 구현되며 main테스트 할 인스턴스를 작성합니다. 또한 그렇게하면 Java 7을 지원하고 단순히 "Java"솔루션으로 제출할 수 있습니다. 나중에 참조 할 수 있도록 입력 형식은 여기에서 매우 유연한 경향이 있으므로 예를 들어 입력을 List(이 문제에 매우 도움이되는) 입력으로 선택할 수 있습니다 .
— Jakob
1

APL + WIN, 36 바이트

¯1↑⍎¨(1⌈¯1+⍴v←,⎕)⍴⊂'v←(1<⍴v)↓v[1]⌽v'

설명:

화면 입력을 요구합니다. 

'v←(1<⍴v)↓v[1]⌽v' Loop logic as a string

 (1<⍴v)↓ only drop the first when number of elements n>1

 (1⌈¯1+⍴v←,⎕)⍴⊂ create a nested vector of logic of length 1 max n-1

 ⍎¨ execute each element of the nested vector in turn

¯1↑ take answer from executing final element
— 그레이엄
소스
1

파이썬 2, 61 바이트

def f(x):
 while x[1:]:y=x[0]%len(x);x=x[y+1:]+x[:y]
 print x
— Rɪᴋᴇʀ
소스
1
나는 많은 파이썬 답변이 존재한다는 것을 알고 있지만 내 자신을 추가 할 수도 있다고 생각했습니다.
— Rɪᴋᴇʀ
1

자바 스크립트, 58 56 59 바이트

let f =

a=>{for(i=0,k=a.length;k>1;)i+=a[i%=k],a.splice(i%=k--,1)}
<h2>Test</h2>
Enter or paste a valid array literal within square brackets and click Run.
<blockquote>
   <input id = "array" type="text" length="20">
   <button type="button" onclick="run()">Run</button>
</blockquote>
Result: <pre id="o"></pre>

<script>
    function run() {
       let a = JSON.parse(array.value);
       f(a);
       o.textContent = a;
    }
</script>
스 니펫 확장

입력 배열에 남아있는 유일한 요소로 결과가 반환되며 그 자리에서 업데이트됩니다.

for 루프 본문에서 블록 명령문 대신 쉼표로 구분 된 명령문을 사용하여 2 바이트를 절약했습니다! 배열 끝에서 삭제 된 요소에서 건너 뛰기 위해 3 바이트가 손실되었습니다 (:

덜 골프 :

a => {
    for(i=0,k=a.length;k>1;) // once less than array length
        i+=a[i%=k],          // the new index
        a.splice(            // delete an element
           i%=k--,           // ensuring index is within array,
                             // and post decrement loop count
           1
        )
}
— traktor53
소스
에 대한 잘못된 답변을 제공하는 것 같습니다 [3, 5, 7, 9].
— Neil
잘못되었습니다 [3,5,7,9]. 예상 값 5
— edc65
이 함수는 값을 반환하지 않습니다. 바이트 수는 그 자체로 작동 할 수 없기 때문에이를 명심하십시오.
— Brian H.
@ edc65와 Neil, 덕분에-배열 끝에서 삭제 된 요소의 색인이 단축 배열의 시작 부분으로 조정되지 않았습니다.
— traktor53
@BrianH. 함수는 그것에 대해 합의가, 그 매개 변수를 수정 codegolf.meta.stackexchange.com/a/4942/21348
— edc65
1

Brain-Flak , 104 바이트

H.PWiz는 여기에 더 짧은 답변을 제공 하므로 확인해야합니다.

([[]]()){({}()<(({})){({}[()]<({}<(([])<{{}({}<>)<>([])}{}<>>)<>>)<>{({}[()]<({}<>)<>>)}{}<>>)}{}{}>)}{}

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

설명

([[]]())   #Push 1 minus stackheight
{({}()<    #N times
 (({}))    #Get a copy of the top
 {({}[()]< #N times
  ({}<(([])<{{}({}<>)<>([])}{}<>>)<>>)<>{({}[()]<({}<>)<>>)}{}<>
           #Roll the top to the bottom (From the wiki)
 >)}{}     #End loop
 {}        #Remove one value
>)}{}      #End loop
— 밀 마법사
소스
나는 내가 경쟁 할 것이라고 생각했다 . 그럼 난 내 거의 정확하게 것을 깨달았다 당신 같은 떨어져 다른 "최고 롤"에서,
— H.PWiz
나는 것을보고 ;). 모든 것이 음이 아니라는 사실을 사용하는 것은 오히려 영리합니다.
— 밀 마법사
1

R 111 117 126 바이트

while 루프로 변경하여 11 바이트를 골라내는 @Giuseppe 덕분에 기능을 제거하고 사용자 입력을 직접 읽음으로써 또 다른 4 개를 얻었습니다.

나는 거기에 도착하는 데 대해 기분이 좋지 않습니다. 더 우아한 솔루션이 존재한다고 확신합니다.

i=scan();m=1;while((l=sum(i|1))-1){j=i[m];p=`if`(j+m>l,j%%l+!m-1,j+m);p=`if`(!p,m,p);i=i[-p];m=`if`(p-l,p,1)};i

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

Ungolfed 코드

i=scan()
m=1
while((l=sum(i|1))-1){
  j=i[m]
  p=`if`(j+m>l,j%%l+!m-1,j+m)
  p=`if`(!p,m,p)
  i=i[-p]
  m=`if`(p-l,p,1)
}
i
— 표
소스
117 바이트 -이 함수는 재귀 함수이므로 이름 f=을 포함해야합니다.
— Giuseppe
1
배열 회전이없는 1 기반 인덱스 언어로는 이것이 매우 어려운 과제라는 것을 알았습니다. 이것은 while루프 가있을 때 잠재적으로 1-3 바이트 더 짧습니다 .
— 주세페
— 주세페
우리 f=가 재귀 함수 의 일부를 잊어 버렸기 때문에 내 이전 115 바이트는 유효하지 않습니다 . :(
— 주세페
나는 재귀를 반영하기 위해 이전 점수와 새로운 점수를 업데이트했습니다. :) 'while'루프를 사용하여 스캔을 사용하여 다른 4 바이트를 골랐습니다.
— Mark
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.