이 숫자는 계승입니까?


38

작업

자연수를 입력 값으로 지정하면 입력 값이 자연수의 계승인지에 따라 참 또는 거짓 값을 출력해야합니다. 입력 번호는 항상 언어가 지원하는 숫자 범위에 있다고 가정 할 수 있지만 문제를 사소하게하기 위해 기본 숫자 유형을 남용 해서는 안됩니다 .

표준 허점이 적용됩니다.


입력

자연수 (유형 Integer또는 유사)가 제공됩니다.

사전 정의 된 변수에 있다고 가정하는 것을 제외하고 원하는 방식으로 입력 할 수 있습니다. 파일, 콘솔, 대화 상자 ( prompt), 입력 상자 등에서 읽을 수 있습니다. 함수 인수로 입력도 가능합니다!


산출

프로그램은 입력 숫자가 자연수의 계승인지에 따라 참 또는 거짓 값을 출력해야합니다.

진리 / 거짓 값이 모든 입력에 대해 일관성이 있는지 확인하십시오. 즉, 1과 0의 쌍을 사용하여 각각 진리 값과 거짓 값을 나타내는 경우 프로그램은 값이 진실이어야하는 모든 입력에 대해 1을 출력해야합니다. 잘못된 값을 가져야하는 모든 입력.

변수에 쓰지 않고 원하는 방식으로 출력 할 수 있습니다. 파일, 콘솔, 화면 등에 쓰기가 가능합니다. 기능 return도 가능합니다!

프로그램이 입력에 오류를 발생시키지 않아야합니다!


테스트 사례

Input     Output

1         Truthy (0! or 1!)
2         Truthy (2!)
3         Falsey
4         Falsey
5         Falsey
6         Truthy (3!)
7         Falsey
8         Falsey
24        Truthy (4!)
120       Truthy (5!)

승리 기준

이것은 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!


2
언어가 {0,1} 범위의 숫자 만 지원하는 경우 입력이 항상 1?
eush77

11
@ eush77 기본 숫자 유형을 사용하여 문제를 사소하게하는 것은 기본적으로 금지되어 있습니다.
데니스

1
4입니다! 진실한가?
tuskiomi

질문 : 왜 I / O 기본값을 사용하지 않습니까?
CalculatorFeline

답변:


37

Brachylog , 1 바이트

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

설명

다음 관계를 주장하는 내장 기능입니다. 출력은 입력의 계승입니다. 우리는 단순히 출력을 설정하고 변수 입력으로 성공하는지 여부를 확인합니다.


6
그것이 프롤로그에 인쇄되어 방식이기 때문에 그의를 @BetaDecay (이것은 사실과 관련이있다 true.성명과 true하지 않습니다)
Fatalize

6
사소한 솔루션이지만 프롤로그 작동 방식으로 인해 영리합니다.
과일 만들기 Esolanging


17
첫 번째 사용자 지정 언어, 사용자 지정 인코딩 ... 코드 골프는 죽었습니다. 우리는 처음부터 이러한 재미있는 문제의 요점을 완전히 전복했습니다
Alexander

13
@Alexander 커스텀 인코딩은 당신이 말하는 어떤 문제와도 관련이 없습니다. 대신 "기존"인코딩을 사용할 수 있으며 여전히 1 바이트입니다. 가독성이 훨씬 떨어집니다.
치명적


19

젤리 , 4 바이트

Œ?IE

가장 짧은 젤리 답변은 아니지만 오히려 효율적입니다.

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

작동 원리

Œ?IE  Main link. Argument: n

Œ?    Yield the n-th permutation of the positive integers, without the sorted tail.
      For 120, this yields [5, 4, 3, 2, 1], the tail being [6, 7, 8, ...].
  I   Increments; compute all forward differences.
      For 120, this yields [-1, -1, -1, -1].
   E  Check if all differences are equal.

2
우리는 코드 골퍼들이 효율성에 관심을 갖기 때문에.
Okx

12
그것은 1 바이트의 비용으로 극적인 복잡성 개선이며 내가 직접 말할 수 있다면 내장 기능을 영리하게 사용합니다. ¯ \ _ (ツ) _ / ¯
Dennis

흥미롭게도 @LeakyNun의 3 바이트 응답은 일반적으로 훨씬 느리지 만 0에 대해서는 false를 올바르게 반환합니다. 효율적인 실행 시간 응답에서 0에 대해 false를 반환하려면 추가 바이트가 필요합니까?
데드 코드

@Deadcode 0을 확인하려면 두 개의 추가 바이트가 필요합니다. OP의 "자연수"정의에 0이 포함되어 있는지 확실하지 않은 경우 테스트 사례는 ...
Dennis

17

ECMAScript를 정규식 733+ 690+ 158 119 118 (117🐌) 바이트

정규식에 대한 나의 관심은 4½ 년 동안 활동이 없었던 새로운 활력으로 촉발되었습니다. 따라서 나는 단항 ECMAScript 정규 표현식과 일치하는 더 자연스러운 숫자 세트와 기능을 찾고 정규식 엔진 개선을 재개했으며 PCRE에서도 브러시 작업을 시작했습니다.

ECMAScript 정규식에서 수학 함수를 작성하는 외계인에 매료되었습니다. 완전히 다른 관점에서 문제에 접근해야하며, 핵심 통찰력이 도착할 때까지 문제가 해결 가능한지 여부는 알 수 없습니다. 특정 문제를 해결하기 위해 사용할 수있는 수학적 속성을 찾는 데 훨씬 더 넓은 그물을 캐스트합니다.

계승 수를 일치시키는 것은 2014 년에도 다루지 않았던 문제였습니다. 또는 내가 그럴 가능성이 너무 적다는 것을 잠시 무시한 것입니다. 그러나 지난 달, 나는 그것이 가능하다는 것을 깨달았습니다.

다른 ECMA 정규 표현식 게시물과 마찬가지로 경고 메시지표시됩니다. ECMAScript 정규 표현식에서 단항 수학 문제를 해결하는 방법을 배우는 것이 좋습니다. 그것은 나를 위해 매혹적인 여행이었고, 나는 그것을 스스로 시도하고 싶을지도 모르는 사람, 특히 수 이론에 관심이있는 사람들을 위해 그것을 망치고 싶지 않습니다. 스포일러 태그가 붙은 권장 문제를 하나씩 해결하기위한 연속적인 문제 목록은 이 게시물참조하십시오 .

따라서 고급 단항 정규식 마법을 원하지 않는다면 더 이상 읽지 마십시오 . 이 마법을 스스로 파악하는 데 총력을 기울이고 싶다면 위에 링크 된 게시물에 요약 된 ECMAScript 정규식의 일부 문제를 해결하는 것이 좋습니다.

이것은 내 생각이었다 :

대부분의 다른 것과 마찬가지로이 숫자 집합을 일치시키는 문제는 ECMA에서 일반적으로 루프에서 두 개의 변화하는 숫자를 추적 할 수 없다는 것입니다. 때때로 그것들은 다중화 될 수 있습니다 (예 : 같은베이스의 힘을 모호하게 추가 할 수 있습니다). 그러나 그것은 그들의 속성에 달려 있습니다. 따라서 입력 번호로 시작하여 1에 도달 할 때까지 점진적으로 증가하는 배당으로 나눌 수 없었습니다 (적어도 생각했습니다).

그런 다음 요인 수의 소수 요인에 대한 몇 가지 연구를 수행하고 이에 대한 공식이 있다는 것을 알게 되었습니다. 이는 ECMA 정규식에서 구현할 수있는 것입니다!

잠시 동안 그것을 조롱하고 그 동안 다른 정규 표현식을 작성한 후, 나는 계승 정규 표현식을 작성하는 임무를 맡았습니다. 몇 시간이 걸렸지 만 결국 잘 작동했습니다. 추가 보너스로 알고리즘은 역 계승을 일치로 반환 할 수 있습니다. 심지어 피하는 것도 없었다. ECMA에서 구현되어야하는 방식의 본질 상, 다른 일을하기 전에 역 계승이 무엇인지 추측해야합니다.

단점은이 알고리즘이 매우 긴 정규식을 위해 만들어 졌다는 것입니다 ...하지만 651 바이트 곱셈 정규식 (50에 대한 다른 방법으로 인해 쓸모없는 결과)에 사용되는 기술이 필요하다는 것을 알게되어 기뻤습니다 바이트 정규식). 나는이 트릭을 필요로하는 문제가 발생하기를 바랐다. 동일한베이스의 두 가지 힘인 두 숫자를 반복적으로 반복하여 모아서 추가하고 각 반복에서 분리하여 루프에서

그러나이 알고리즘의 어려움과 길이로 인해 분자 모양을 사용하여 알고리즘 (?*...)을 구현했습니다. 이는 ECMAScript 또는 다른 주류 정규식 엔진이 아니라 엔진에서 구현 한 기능입니다 . 분자식 미리보기 내부에 캡처가 없으면 기능적으로 원자 적 미리보기와 동일하지만 캡처하면 매우 강력 할 수 있습니다. 엔진은 lookahead로 역 추적되며, 입력 문자를 소비하지 않고 모든 가능성 (나중에 테스트를 위해)을 순환하는 값을 추측하는 데 사용될 수 있습니다. 그것들을 사용하면 훨씬 깔끔한 구현이 가능합니다. (가변 길이 룩 베어는 분자 룩어 헤드와 비교하여 최소한의 힘이지만, 후자는보다 간단하고 우아한 구현을 만드는 경향이 있습니다.)

따라서 733 및 690 바이트 길이는 실제로 솔루션의 ECMAScript 호환 화신을 나타내지 않습니다. 따라서 "+"는 뒤에옵니다. 그 알고리즘을 순수한 ECMAScript (길이가 조금 길어질 것입니다)로 이식하는 것이 가능하지만 훨씬 더 간단하고 컴팩트 한 알고리즘을 생각했기 때문에 그 방법을 찾지 못했습니다! 분자 예견없이 쉽게 구현할 수있는 것. 또한 훨씬 빠릅니다.

이 새로운 것은 이전과 마찬가지로 역 요인을 추측하여 모든 가능성을 순환하고 일치하는지 테스트해야합니다. N을 2로 나눠서 필요한 작업을위한 공간을 마련한 다음 입력을 3으로 시작하고 매번 증가하는 제수로 반복적으로 입력을 나누는 루프를 시드합니다. (따라서 1!과 2!는 주 알고리즘과 일치시킬 수 없으며 별도로 처리해야합니다.) 제수는 실행 몫에 추가하여 추적합니다. 이 두 숫자는 M! == N, 실행 몫은 M과 같아 질 때까지 M으로 계속 나눌 수 있습니다.

이 정규식은 루프의 가장 안쪽 부분에서 변수별로 나눕니다. 나누기 알고리즘은 다른 정규 표현식과 동일하며 곱셈 알고리즘과 유사합니다. A≤B, A * B = C 인 경우 C % A = 0 및 B가 B≤C를 만족하는 가장 큰 숫자 인 경우에만 및 C % B = 0 및 (CB- (A-1)) % (B-1) = 0 (여기서 C는 피제수, A는 제수, B는 몫). (A≥B 인 경우에도 유사한 알고리즘을 사용할 수 있으며, A와 B를 비교하는 방법을 모르는 경우 하나의 추가 분할 성 테스트 만 있으면됩니다.)

그래서 문제가 골프 최적화 피보나치 정규식 보다 훨씬 덜 복잡하게 줄어들 수 있다는 것을 좋아 하지만 멀티플렉싱 파워 오브 더 동일한베이스 기술이 다른 문제를 기다려야한다는 실망에 한숨을 쉬고 있습니다. 이것은 실제로 필요하지 않기 때문에 필요합니다. 내 651 바이트 곱셈 알고리즘이 50 바이트로 대체되고 있다는 이야기입니다.

편집 : 몫이 제수보다 크거나 같은 경우 Grimy 가 발견 한 트릭을 사용하여 1 바이트 (119 → 118)를 삭제할 수있었습니다 .

더 이상 고민하지 말고 정규 표현식을 사용하십시오.

참 / 거짓 버전 (118 바이트) :

^((x*)x*)(?=\1$)(?=(xxx\2)+$)((?=\2\3*(x(?!\3)xx(x*)))\6(?=\5+$)(?=((x*)(?=\5(\8*$))x)\7*$)x\9(?=x\6\3+$))*\2\3$|^xx?$

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

역 계승 또는 불일치 (124 바이트)를 반환합니다.

^(?=((x*)x*)(?=\1$)(?=(xxx\2)+$)((?=\2\3*(x(?!\3)xx(x*)))\6(?=\5+$)(?=((x*)(?=\5(\8*$))x)\7*$)x\9(?=x\6\3+$))*\2\3$)\3|^xx?$

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

ECMAScript +\K (120 바이트) 로 역 계승 또는 불일치를 반환합니다 .

^((x*)x*)(?=\1$)(?=(xxx\2)+$)((?=\2\3*(x(?!\3)xx(x*)))\6(?=\5+$)(?=((x*)(?=\5(\8*$))x)\7*$)x\9(?=x\6\3+$))*\2\K\3$|^xx?$

그리고 코멘트가있는 자유 공간 버전 :

  ^
  (?=                           # Remove this lookahead and the \3 following it, while
                                # preserving its contents unchanged, to get a 119 byte
                                # regex that only returns match / no-match.
    ((x*)x*)(?=\1$)             # Assert that tail is even; \1 = tail / 2;
                                # \2 = (conjectured N for which tail == N!)-3; tail = \1
    (?=(xxx\2)+$)               # \3 = \2+3 == N; Assert that tail is divisible by \3
    # The loop is seeded: X = \1; I = 3; tail = X + I-3
    (
      (?=\2\3*(x(?!\3)xx(x*)))  # \5 = I; \6 = I-3; Assert that \5 <= \3
      \6                        # tail = X
      (?=\5+$)                  # Assert that tail is divisible by \5
      (?=
        (                       # \7 = tail / \5
          (x*)                  # \8 = \7-1
          (?=\5(\8*$))          # \9 = tool for making tail = \5\8
          x
        )
        \7*$
      )
      x\9                       # Prepare the next iteration of the loop: X = \7; I += 1;
                                # tail = X + I-3
      (?=x\6\3+$)               # Assert that \7 is divisible by \3
    )*
    \2\3$
  )
  \3                            # Return N, the inverse factorial, as a match
|
  ^xx?$                         # Match 1 and 2, which the main algorithm can't handle

이 정규식의 내 골프 최적화의 전체 역사는 github에 있습니다.

계승 번호 일치하는 정규식 - 다수 - 비교에있어서, 분자와 lookahead.txt의
계승 numbers.txt 일치위한 정규식 (하나 위에 표시된)

((x*)x*)((x*)+)((x+)+)n=3!\233=0

.NET 정규식 엔진은 ECMAScript 모드에서이 동작을 에뮬레이트하지 않으므로 117 바이트 정규식이 작동합니다.

온라인으로 사용해보십시오! (.NET 정규식 엔진 + ECMAScript 에뮬레이션을 사용한 지수 감속 버전)


14

자바 스크립트 (ES6), 30 29 28 바이트

양의 정수가 필요합니다. 반환 -1falsy 및 -2truthy합니다.

f=(n,k=2)=>n>1?f(n/k,k+1):~n

console.log(1,  '-->',f(1))   // Truthy (0! or 1!)
console.log(2,  '-->',f(2))   // Truthy (2!)
console.log(3,  '-->',f(3))   // Falsey
console.log(4,  '-->',f(4))   // Falsey
console.log(5,  '-->',f(5))   // Falsey
console.log(6,  '-->',f(6))   // Truthy (3!)
console.log(7,  '-->',f(7))   // Falsey
console.log(8,  '-->',f(8))   // Falsey
console.log(24, '-->',f(24))  // Truthy (4!)
console.log(120,'-->',f(120)) // Truthy (5!)

참고 :이 함수는 매우 큰 입력을 지원합니다 ( 'JS의 경우 꽤 큼'으로 읽어야 함). 그것은 안전하게까지 작동합니다 2 (53) - (1) . N = 121,645,100,408,831,992 에서 시작하면 실패합니다 .이 입력은 19 로 반올림됩니다 ! IEEE-754 인코딩으로 인해 121,645,100,408,832,000 입니다. 반올림 오류로 인해 121,645,100,408,831,991 이전에 다른 오 탐지 결과 가 있을 수 있지만 확실하지 않습니다.


니스- ~마지막에 사용하는 것을 정말로 좋아합니다 .
Steve Bennett

편집 취소 할 수 있도록 편집 할 수 있습니까? (내가 다운 보트 한 이유를 알고 싶다면이 질문의 특이한 I / O 규칙을 잊었 기 때문입니다.)
CalculatorFeline

@Arnauld Undownvoted.
CalculatorFeline

11

파이썬 3 , 39 38 바이트

f=lambda n,i=1:n>1and f(n/i,i+1)or n<1

재귀 함수 정수 촬영 n결과를 나타내는 inversley 부울 값을 반환 (truthy을 : False, falsey을 : True)

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

반복적으로 분할 n하여 i초기 값과, 1상기 나머지는 작거나 같거나 될 때까지 1그 나머지 미만이면 테스트 1만 계승은 나머지 끝날은 동일 1하고, <보다 바이트 짧다 ==.


@ovs 우리는 두 가지 일관된 출력으로 제한되었습니다. 1불행히도을 반환 하는 것을 제외한 모든 계승에 1대해 반환합니다 True.
Jonathan Allan

11

자바 8, 46 바이트

i->{int j=1,c=0;for(;j<i;j*=++c);return j==i;}

이것은 Roman Gräf의 항목을 기반으로합니다. 나는 거기에 그것을 제안했을 것입니다. 그러나 나는 아직 논평할만한 평판이 없습니다! 수정 된 테스트 러너 코드 :

import java.util.function.Function;
import java.util.stream.IntStream;

public class IsFactorial {
    public static Function<Integer, Boolean> isFactorial = i->{int j=1,c=0;for(;j<i;j*=++c);return j==i;};
    public static int[] truthyCases = {1,2,6,24,120};
    public static int[] falsyCases = {3,4,5,7,8};
    public static void main(String[] args){
        System.out.println(
            IntStream.of(truthyCases).allMatch(i->isFactorial.apply(i)) &&
            IntStream.of(falsyCases).allMatch(i->!isFactorial.apply(i)));
    }
}

9

망막 , 50 38 바이트

@Neil 덕분에 루프 단축과 결합 제거로 12 바이트 절약 ;

.+
1¶$&$*
+`^(1+)¶(\1)+$
1$1¶$#2$*
¶.$

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

1true 및 0false에 대한 출력 .

.+ 정수와 일치

1¶$&$*그것을 1새 줄로 바꾸고 일치는 단항으로 변환

나머지 프로그램은 양의 정수를 연속적으로 증가시키고 맨 위 줄을 계속 추적하여 맨 아래의 단항 수를 나누는 것이 가능합니다.

+` 문자열이 동일하게 유지 될 때까지 반복

  • ^(1+)¶(\1)+$상단 선 많은 일치 1의 그것의 여러 많은 1하단 라인들과 함께 교체

  • 1$1¶$#2$*최상위 라인 1은 다른 라인 과 함께 많은 수 1, 즉 최상위 라인으로 표시되는 숫자를 1 씩 증가시키고 그 다음 줄 바꿈과 맨 아래 라인에서 최상위 라인의 일치 횟수를 증가시킵니다 (예 : 두 번째 캡처 그룹의 일치 횟수). ) 많은 1s, 즉 맨 아래 숫자를 맨 위 숫자로 나눕니다.

더 이상 그렇게 할 수 없으면

¶.$이 정규식과 일치하는 횟수를 지정하십시오. 1결론에 고독한 것이 있습니까? 숫자가 계승 인 경우에만 발생합니다.


진실 / 거짓 값 대신 충돌 없음 / 충돌이 허용되면 36 34 바이트를 얻을 수 있습니다 .

^
1¶
{`.+$
$*
^(1+)¶(\1)+$
1$1¶$#2

이것은 같은 접근법으로 진행되지만 $*세 번째와 네 번째 줄로 결합합니다 . 세 번째 줄은 같은 루프의 일부이며 나머지 줄을 루프로 묶는 곳 {은 짧습니다 . 계승은 루프에서 빠져 나가는 프로그램에서 종료되는 반면, 비 계승은 Retina가 마지막 교체 실패로 인한 OverflowException을 던질 때까지 영원히 루프에 갇히게됩니다. 결론을 10 진수에서 단항으로 변환하므로 빠르게 터집니다.+((


교체가 끝났을 1때 암시 된대로 를 제거하여 바이트를 저장하십시오 $*.
Neil

더 좋은 방법 $*은 다른 두 줄과 결합하십시오 .
Neil


3
Retina가 조건부로 충돌하는 방법을 찾았다는 것에 깊은 인상을 받았습니다. :)
Martin Ender

2
설명을 추가 할 수 있습니까?
CalculatorFeline

8

05AB1E , 4 바이트

L!QO

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

설명

L      # range [1 ... input]
 !     # calculate factorial of each
  Q    # compare with input for equality
   O   # sum

1
입력이 L팝업 되어 입력을 먼저 복제하지 않아도 됩니까? 또한 Å!입력 값보다 작거나 같은 계승 목록을 제공합니다.
닐 A.

@NeilA. 다행히도 작업에 대한 인수가 충분하지 않으면 입력이 다시 팝업되므로 D여기서는 필요하지 않습니다 . 에 대한 좋은 캐치 Å!. 나는 항상 list-commands를 잊어 버린다. 바이트를 저장하지는 않지만 더 효율적입니다.
Emigna

입력이 다시 튀어 나오는 것에 대해 몰랐습니다.
Neil A.

@NeilA. 상당히 새로운 기능입니다. 한 달 전에 추가 된 것 같아요.
Emigna

8

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

#include<cmath>
int a(int n){int i=n,j=0;for(;i;)j|=lround(exp(lgamma(i--+1)))==n;return j;}

모든 값을 통해 루프 0n하고 동일하다면 계승하고 검사를 계산 n.

크리스토프 감사합니다! (8 바이트 절약)


안녕하세요! PPCG에 오신 것을 환영합니다! 좋은 첫 대답! 미래에 행운을 빕니다!
Arjun

좋은 첫 번째 대답! 다음과 같이 몇 바이트를 저장할 수 있습니다 int a(int n){int i=n,j=0;for(;i;)j|=lround(exp(lgamma(i--+1)))==n;return j;}. lround하고 lgamma있는 이미 C ++ (11) 그래서 간단하게 할 수 있었다 #include<cmath>. 아마 당신은 내 제안을 더 향상시킬 수 있습니다 :)
Christoph

7

하스켈 , 43 26 바이트

f n=elem n$scanl1(*)[1..n]

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


2
f n=elem n$scanl1(*)[1..n]말도 안되는 비효율적이지만 짧습니다.
Laikoni

코드 효율성에 대한 규칙이 없습니까?
sudee

1
내가 아는 것은 없습니다. code-golf 는 효율성 문없이 가능한 한 적은 바이트로 솔루션을 요청합니다. 또한 내 컴퓨터 40430에서이 기능은 눈에 띄게 지연없이 작동합니다 .
Laikoni

나는 "합리적인 기간 내에 솔루션을 종료해야한다"는 라인을 따라 무언가를 의미했지만, 어느 쪽이든 요구 사항에 맞는 것 같습니다. 감사!
sudee

1
좋고 간단합니다. 나는, 부문 - 말과 함께 더 잘 할 수 있다고 생각 divMod하여 [1..]1 (계승)의 몫 또는 제로가 아닌 나머지 (비 계승)와 제로 나머지 부분에 도달 할 때까지 연속적으로, 그러나 올바른 방법이 될 것 같지 않습니다. 그래도이 귀여운 46 자 해결책을 찾았습니다 f|let x%n=mod n x==0&&(x+1)%div n x||n==1=(1%).
존 퍼디

6

하스켈 , 38 바이트

m#n=n<2||mod n m<1&&(m+1)#div n m
(2#)

온라인으로 사용해보십시오! 사용법 예 : (2#) 24. 반환 True또는 False.

이것은 여전히 ​​매우 효율적이지만 얻을 수있는 가장 짧은 것입니다. 숫자가 큰 경우에도

145183092028285869634070784086308284983740379224208358846781574688061991349156420080065207861248000000000000000000

결과는 즉시 제공됩니다. 용액 입력 나눔으로써 작동 n하여 m = 2,3,4,5,...어느 하나의 결과이거나까지 n로 나누어 아니다 m.

n!계승이 아닌 입력을 계산하는 짧지 만 놀라운 비효율적 인 26 바이트 솔루션은 여기를 참조하십시오 .



5

푸리에 , 40 39 바이트

I~Q1~N(i^~i*N~N{Q}{1~Xo}N>Q{1}{1~X0o}X)

FourIDE에서 사용해보십시오!

기본적으로 N이 입력과 같거나 (출력 1) 더 클 때 (출력 0)가 될 때까지 숫자 N에 증가량을 곱합니다.

의사 코드 :

Q = Input
N = 1
While X != 1
    i += 1
    N = N*i
    If N = Q Then
        Print 1
        X = 1
    End If
    If N > Q Then
        Print 0
        X = 1
    End If
End While

5

apt , 8 6 바이트

ol x¥U

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

false는 0, true는 1을 출력합니다.

설명

 ol x¥ U
Uol x==U
Uo       # Create the range [0 ... input]
  l      # Replace each element by its factorial
     ==U # Compare each element to the input (yielding 1 if equal and 0 otherwise)
    x    # And sum the result

1
나는 "포함"내장을 추가해야한다. : P
ETHproductions

1
헤이 오, 당신은 변경할 수 aU ¦Jx¥U(각지도 XX==U불구하고이 TIO에 작업을하지 않습니다, 그리고 합계).
ETHproductions

2becuase 실패 o는 당신에게 줄 것이다 [0,1]. 다음 은 1 바이트 절약을 위한 수정 사항 입니다.
얽히고 설킨

4

펄 5, 31 바이트

$a=<>;$a/=++$i while$a>1;exit$a

STDIN을 통해 입력이 이루어지고 종료 코드를 통해 출력이 제공됩니다 (계수의 경우 1, 비계 수의 경우 0).

입력은 1 또는 1보다 작은 분수가 될 때까지 연속 정수로 나눠져 결과로 잘립니다.


-5 바이트 TIO
Nahuel Fouilleul

4

펄 6 , 29 바이트

{($_,{$_/++$}...2>*).tail==1}

그것을 테스트

넓히는:

{   # bare block lambda with implicit parameter 「$_」

  (              # generate a sequence

    $_,          # starting with the input

    {
      $_ / ++$   # divide previous element by an ever increasing number
                 # 1,2,3,4,5,6,7,8 ... *
    }

    ...          # keep generating until

    2 > *        # 2 is greater than what was generated
                 # ( 1 or a fractional number )

  ).tail == 1    # check if it ended at 1
}

17 바이트 : {$_∈[\*] 1..$_}. 또 다른 흥미로운 접근법은 2>*.polymod(1..*).sum입니다.
nwellnhof

4

setlX , 32 바이트

f:=n|=>exists(x in{0..n}|n==x!);

f잠재적 계승을 매개 변수로 사용 하는 함수 를 작성합니다.

임의의 정수 크기로 작동하지만 상당히 비효율적입니다.

(그런데 : 이것은 프로그래밍 퍼즐에 대한 나의 첫 참여)




4

C # (. NET 코어) , 68 바이트

bool f(System.Numerics.BigInteger n,int k=2)=>n<2||n%k<1&f(n/k,k+1);

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

가장 짧은 해결책은 아니지만 실제로 큰 숫자로 작동합니다. TIO 링크에는가 포함 된 예가 포함되어 10000!있습니다.

다음은 int최대 값이 2147483647 인 짧은 버전입니다 .

C # (. NET 코어) , 45 바이트

bool f(int n,int k=2)=>n<2||n%k<1&f(n/k,k+1);

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

두 답변 모두에서 총 3 바이트의 골프를 쳤다는 것은 @KevinCruijssen에게 감사드립니다!


2
&&에 golfed 할 수 있습니다 &, 그리고 후행는 ;람다 함수에 대한 계산 할 필요가 없습니다. 또한,이 할 수없는 ulong k=2uint k=2당신의 50 바이트 대답?
Kevin Cruijssen

1
&대 에 좋은 캐치 &&. 스택 오버플로가 발생했다고 생각했지만 결국 작동하는 것 같습니다. ulong반면 64 비트입니다 uint다른 사람이 사용하고있는 것 같습니다 (32)이다 int어쩌면 난 그냥 짧은 버전이 사용됩니다. 후행과 관련하여 ;이들은 람다가 아닌 전체 기능이므로 포함해야한다고 생각합니까?
dana

즉 .NET 해결할 수있는 방법을 정말 이상하다 /%사이 ulonguint, 그러나 ulongint. 몰랐어요 :)
dana

1
@Oliver- double어느 시점에서 반올림이 시작됩니다 (예 : 24)! 그리고 120! 불합격. System.Numerics.BigInteger가장 정밀 하지만 가장 int짧은 답은 :)
dana

1
@Deadcode-당신은 0에 대해 맞습니다 :) 도전의 예를 기반으로, 나는 "자연수"를 1,2로 해석했습니다 ... 실제 세계에서는 단락 &&연산자 를 사용하는 것이 좋습니다 . 그러나 이것은 코드 골프입니다.) 10000!예 를 좋아합니다 !
다나

4

C ++ (클랑), 51 바이트

골프가 진행되는 한 재귀가 이깁니다.

51 바이트, 0은 true입니다.

int f(int n,int i=2){return n<2?!n:n%i|f(n/i,i+1);}

이것은 1 바이트 절약을 위해 많은 속도를 희생합니다. 논리 OR의 단락 평가로 인해를 빨리 교체하려면 |로 교체하십시오 ||.

온라인으로 사용해보십시오! (51 바이트 느린 버전)
온라인으로 사용해보십시오! (52 바이트 빠른 버전)

풀리지 않은 느린 버전 :

int isFactorial(int n, int i=2)
// returns 0 for true, and nonzero for false
{
    if (n < 2) // same as "if (n==0 || n==1)" in our natural number input domain
    {
        if (n==0)
            return 1; // not factorial
        else // n==1
            return 0; // is factorial (could be either 0! or 1!)
    }

    // Because any nonzero value represents "false", using "|" here is equivalent
    // to "||", provided that the chain of recursion always eventually ends. And
    // it does always end, because whether or not "n" is factorial, the "n / i"
    // repeated division will eventually give the value of zero or one, satisfying
    // the above condition of termination.
    return (n % i) | isFactorial(n / i, i+1);
}

Ungolfed 빠른 버전 :

int isFactorial(int n, int i=2)
// returns 0 for true, and nonzero for false
{
    if (n < 2) // same as "if (n==0 || n==1)" in our natural number input domain
    {
        if (n==0)
            return 1; // not factorial
        else // n==1
            return 0; // is factorial (could be either 0! or 1!)
    }

    if (n % i != 0)
        return 1; // not factorial
    else
        return isFactorial(n / i, i+1);
}

이를 재정렬하는 방법에는 여러 가지가 있습니다.

52 바이트, 0이 아닌 경우 :

int f(int n,int i=2){return n<2?n:n%i?0:f(n/i,i+1);}

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

52 바이트, 0은 true입니다.

int f(int n,int i=2){return!n?1:n%i?n-1:f(n/i,i+1);}

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

재귀에 의지하기 전에, 나는 반복적 인 버전을 만들려고 시도했고 그것들은 가까워졌습니다.

54 바이트, 0이 아닌 경우 :

int f(int n){for(int i=2;n>1;)n=n%i?0:n/i++;return n;}

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

54 바이트, 0은 true입니다 ( Roman Gräf의 Java 8 제출 기준 ).

int f(int n){int a=1,i=0;for(;a<n;a*=++i);return a-n;}

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

이제 배럴의 바닥에 대해 n==0처리 가없는 재귀 버전 (0은 자연수이며 매우 한정된 사용의 "자연수"를 정의하지 않는 정의이므로 유효하지 않은 것으로 간주합니다). 아래 버전에서 무한 재귀 f(0)는 스택 오버플로로 인해 segfault를 트리거하거나 반복으로 최적화하는 컴파일러를 사용하여 끝없이 반복됩니다.

48 바이트, 0은 true입니다.

int f(int n,int i=2){return n%i?n-1:f(n/i,i+1);}

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

48 바이트, 0은 참입니다 ( Hagen von Eitzen의 33 바이트 C (gcc) 제출 기준 ) :

int f(int n,int e=0){return n%++e?n-1:f(n/e,e);}

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


50 편집 : 49 , 재귀 없음.
그리미

48의 재귀로 돌아갑니다 . 그리고 당신은 아마 이것을 좋아하지 않을 것입니다, 그러나 전역 변수를 사용하여 44 .
그리미

3

Mathematica, 20 바이트

!FreeQ[Range[#]!,#]&

큰 숫자를 테스트하는 다른 버전 (댓글 참조)

Range[10^3]!~MemberQ~#&

1000까지 테스트!


2
내가 질문을 이해하면서 Mathematica가 1001을 취할 수 있다면! 입력으로 다음 사양을 충족하지 않습니다.
피터 테일러

2
모든 입력에 유효하게하면서 3 바이트를 저장할 수도 있습니다. 10 ^ 3을 #으로 바꾸십시오. 당신은 범위를 사용하여 다른 바이트를 절약 할 수 @ #
줄리앙 클루

@Julien Klugethen 1243234에 대한 검색은 영원히 걸릴 것입니다 ...
J42161217

1
나는 다음 Range[#]과 같이 바꿔서 다른 바이트를 절약 할 수 있다고 생각한다. Range@#:)
numbermaniac

3
접두사 구문으로 또 다른 바이트를 저장할 수있는 것 같습니다 : !Range@#!~FreeQ~#&.
numbermaniac

3

Cubix , 24 바이트

U0O@1I1>-?1u>*w;W;@Orq)p

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

Cubified

    U 0
    O @
1 I 1 > - ? 1 u
> * w ; W ; @ O
    r q
    ) p

우리는 밀어 시작 1, I, nput 1스택에. 이것들은 각각 인덱스, 목표 및 누산기입니다.

그런 다음 반복합니다. 반복 할 때마다 입력에서 누산기를 뺍니다. 결과가 0이면 완료되었으므로 1, Output 및 exit를 누릅니다 . 음수이면 너무 멀리 갔으므로 0, Output 및 exit를 누릅니다 . 그렇지 않으면, 우리는 참조

;p)*rq;
;         Pop the difference off the stack.
 p)       Move the index to the top of the stack and increment it.
   *      Multiply the accumulator by the index to get the next factorial.
    rq;   Put the stack back in the right order.

3

Neim , 8 바이트

𝐈Γ𝐈𝐩₁𝔼)𝐠

설명:

Example input: 6
𝐈         Inclusive range [1 .. input]
          [1, 2, 3, 4, 5, 6]
 Γ        For each...
  𝐈         Inclusive range [1 .. element]
            [[[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6]]
   𝐩        Product
            [1, 2, 6, 24, 120, 720]
     𝔼      Check for equality with
    ₁       the first line of input
            [[0, 0, 1, 0, 0, 0]]
      )   End for each
       𝐠  Select largest element
          [1]

시도 해봐!

Neim , 3 바이트 (비경쟁)

포함 토큰 및 팩토리얼 토큰이 챌린지 후에 추가되었으므로 비경쟁.

𝐈𝐓𝕚

설명:

Example input: 6
𝐈     Inclusive range [1 .. input]
      [[1, 2, 3, 4, 5, 6]
 𝐓    Factorial each
      [[1, 2, 6, 24, 120, 720]]
  𝕚   Check that the [cycled] input is in the list
      [1]

시도 해봐!


3

> <> , 24 22 바이트

@Aaron 덕분에 -2 바이트

새로운 언어를 시도하고 있습니다 (Mathematica 라이센스가 만료 된 이후…)

01\{=n;
?!\$1+:@*:{:}(

온라인 또는 물고기 놀이터 에서 사용해보십시오

입력 번호가 이미 스택에 있다고 가정하고 0 또는 1을 반환 한다고 가정 합니다. 첫 번째 n 수를 입력보다 작게 멈출 때까지 곱한 다음 입력과 같으면 1을 인쇄하고 입력과 같으면 0을 인쇄하여 작동합니다. 티.


당신을 당신 v>\n<^으로 변형시킬 수 있습니다 \\n/; 여기를보십시오
Aaron

@Aaron, 훌륭합니다, 감사합니다!
나무가 아님

3

APL (Dyalog Unicode) , 5 6 7 바이트

Outgolfer Erik ×/에게 !감사를 전하며 바이트를 골퍼

⊢∊!∘⍳

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

설명

                          Range of numbers from 1 to argument, 1 2 3 4 .. n
   !                       Factorial; 1! 2! 3! 4! .. n!
⊢∊                         Is the right argument a member of this list?

누적 합계?
Leaky Nun

@LeakyNun 고정
Kritixi Lithos

GNU APL 1.2의 1 바이트 추가 N∊×\⍳N←⎕이것은 어떻게 인수를 취합니까? 나는 n아무데도 보이지 않습니다 . 이것은 Dyalog에 특정한 것입니까?
Arc676

2
@ Arc676 내 솔루션은 기차이며 (⊢∊(×/⍳)) right_argumentTIO 링크에서 볼 수 있듯이 그렇게 부르십시오 . 그리고 올바른 주장을 말합니다.
Kritixi Lithos

참고 : AGL은 바이트를 절약합니다. ⊢∊×\ä⍳. "올바른"(그러나 더 긴) 해결책은 0=1|!⍣¯1; "역 계승은 정수입니까?"
Adám

2

자바 스크립트 (ES6), 71 바이트

이것은 함수 인수로 입력을 alert받고 출력을 가져옵니다. 출력 0falsey 및 1truthy합니다.

f=n=>n?n*f(n-1):1;g=(n,r=0,i=0)=>{while(i<=n){r=f(i)==n|r;i++}alert(r)}

설명

이 프로그램은 두 가지 기능으로 구성되어, fg. f재귀 적 계승 계산 기능이며 g프로그램의 주요 기능입니다. 단일 인수가 g 있다고 가정 합니다 n. 그것은 기본 인수 정의 r0의 값과의 값을 다른 기본 인수를 0. 그런 다음 모든 정수를 0에서 ~까지 n반복하고, 각 반복에서 f적용된 함수 i(현재 색인)가와 같은지 n여부, 즉 n계승 인지 여부를 확인합니다 i. 그런 경우가 발생 될 경우 r의 값은 함수의 끝에서 1로 설정되어 r있다 alert에드.

테스트 스 니펫

( 참고 : 스 니펫 console.log()은 너무 성가신 것처럼 아무도 사용 하지 않습니다 alert(). )

f=n=>n?n*f(n-1):1;g=(n,r=0,i=0)=>{while(i<=n){r=f(i)==n|r;i++}console.log(r)}

g(1)
g(2)
g(3)
g(4)
g(5)
g(6)
g(7)
g(8)
g(24)
g(120)


코드 블록을 사용하는 것보다 평가 시간이 짧을 수 있습니다.
Downgoat

@ Downgoat 어떻게해야합니까? 너무 명백하면 미안 해요! : P
Arjun

2

QBIC , 21 19 바이트

[:|q=q*a~q=b|_x1}?0

설명

[:|     Start a FOR loop from 1 to n
q=q*a   q starts as 1 and is multiplied by the FOR loop counter
        consecutively: q=1*1, *2, *3, *4 ... *n
~q=b|   If that product equals n
_x1     Then quit, printing a 1
}       Close the IF and the FOR
?0      If we're here, we didn't quit early and didn't find a factorial, print 0

이전

[:|q=q*a┘c=c+(q=b)}?c

설명:

[:|         Start a FOR loop from 1 to n
q=q*a       q starts as 1 and is multiplied by the FOR loop counter
            consecutively: q=1*1, *2, *3, *4 ... *n
┘           Syntactic line break
c=c+        c starts out at 0 and then keeps track of 
    (q=b)       how often our running total == n
}           Closes the FOR-loop
?c          Print c, which is 0 fir non-factorials and -1 otherwise.

2

자바 8, 59 바이트

i->{for(int j=1,c=0;j<=i;j*=++c)if(j==i)return 1;return 0;}

테스트 코드

import java.util.function.IntFunction;
import java.util.stream.IntStream;

public class IsFactorial
{
    public static IntFunction<Integer> isFactorial = i->
    {
        for(int j=1,c=0;j<=i;j*=++c)
            if(j==i)return 1;return 0;
    };

    public static int[] truthyCases = {1,2,6,24,120};
    public static int[] falsyCases = {3,4,5,7,8};

    public static void main(String[] args)
    {
        System.out.println
        (
            IntStream.of(truthyCases)
                .allMatch(i->isFactorial.apply(i)==1)
            && IntStream.of(falsyCases)
                .allMatch(i->isFactorial.apply(i)==0)
        );
    }
}
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.