10 진수 표현의 모든 여러 자리 하위 문자열도 소수 인 모든 양수를 인쇄 / 출력합니다.


15

직무

당신의 임무는 십진수 표현의 모든 여러 자리 하위 문자열도 소수 모든 양수 를 인쇄하거나 출력 하는 것입니다. 숫자가 2 자리 이상이면 숫자 자체도 소수 여야합니다.

  • 6197시퀀스에있는 모든 서브 스트링의 여러 자리 때문에 6197, 즉 소수 : 61, 19, 97, 619, 197, 6197(자체).
  • 참고 6주요 아니지만 6197때문에 순서에 아직도 6의 멀티 자리가 아니입니다 6197.
  • 8모든 다중 자릿수 부분 문자열 8이 소수 이므로 시퀀스에도 있습니다 . 에 여러 자릿수 하위 문자열 8이 없으므로 이것은 진실이 사실 입니다.

명세서

  • 출력을 하드 코딩하거나 출력과 관련된 정보를 프로그램에 저장할 있다는 점을 제외하고 표준 허점이 적용됩니다 .
  • 출력의 숫자는 임의의 순서로 지정할 수 있습니다 .
  • 출력의 번호는 허용 중복을 가지고.
  • 출력 대신 인쇄를 선택하면 구분 기호를 사용할 수 있습니다 .
  • 출력 대신 인쇄를 선택하면 접두사 및 / 또는 접미사 출력 이 허용 됩니다.
  • 구분 기호와 접두사 및 접두사는 숫자를 포함 할 수 없습니다 (U + 0030 ~ U + 0039).

전체 목록 (58 개 항목)

1
2
3
4
5
6
7
8
9
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97
113
131
137
173
179
197
311
313
317
373
379
419
431
479
613
617
619
673
719
797
971
1373
3137
3797
6131
6173
6197
9719

참고


언제나 그렇듯이 의견에 명확하게 설명해야 할 사항을 자유롭게 적어주십시오.


2
Brachylog ( wiki link ) ( TIO link ) ( chatroom ) 에서이 도전에 대한 가장 작은 답변을 제출하는 @Fatalize를 제외한 모든 사람에게 +300 현상금을 제공합니다 .
Leaky Nun

2
@Fatalize가 나쁩니다. 이것이 바로 언어를 만들기위한 것입니다
Luis Mendo

3
나는 50 바이트 대답을 가지고있다 :(
Fatalize

1
프로그램을 종료해야합니까?
Fatalize

2
@LeakyNun 누군가가 그 현상금을 얻는 것처럼 보입니다!
Jordan

답변:



7

05AB1E , 15 13 바이트

암호:

4°GN§ŒD9›ÏpP–

설명:

  G            # For N in range 1,
4°             #   10000
   N           # Push N
    §          # Convert that to string
     Œ         # Get all substrings
      D9›Ï     # Keep all substrings that are greater than 9
          p    # Check each of them if they are prime
           P   # Product
            –  # If 1, print N

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! (몇 초가 걸릴 수 있음).


5

Brachylog , 18 17 15 16 15 바이트

ℕ₁<l4&≜sᶠ{Ḋ|ṗ}ᵐ

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

-1 Fatalize와 토론 후 바이트는 그냥 스왑 경우 어떻게되는지 나에게 영감을 l하고 <주위를.

이 술어 는 출력 변수가 제한되지 않는 한 입력 변수를 통해 출력을 생성 합니다. 중복이 허용되므로 각 숫자는 소수 인 소수 자릿수의 거듭 제곱으로 2와 동일한 다중 도로 생성됩니다.

ℕ₁                 The input variable is a natural number
  <                less than
   l4              some number with length 4 (maximized as 9999).
     &≜            Assign a number to the input, and assert that
       sᶠ          every substring of it
         { | }ᵐ    is either
            ṗ      a prime number
          Ḋ        or a single digit.

이전 버전 :

{≜ℕsᶠ{Ḋ!|ṗ}ᵐ&}ᶠ⁵⁹b
7^₅⟦₁{sᶠ{Ḋ|ṗ}ᵐ&}ˢ
8ḟ⟦₁{sᶠ{Ḋ|ṗ}ᵐ&}ˢ
∧8ḟ>?ℕ₁≜sᶠ{Ḋ|ṗ}ᵐ

최대 40320까지 모든 것을 검사하는 것이 빠르지 않기 때문에 이것은 16 바이트이지만 테스트되지 않았습니다.8ḟ⟦₁{sᶠ{Ḋ|ṗ}ᵐ&}ˢ
String

그것은 잘 상부 불구하고, 대신 10000의 경계 주어진 종료됩니다 tio.run/##SypKTM6ozMlPN/r/39AACB7NX/...
관련없는 문자열

4

Brachylog , 18 바이트

또 다른 Brachylog 솔루션. Erik The Outgolfer의 Brachylog 솔루션보다 짧게 얻을 수 없었습니다 . 길이는 동일하지만 반대 방향에서 세대에 접근합니다.

{≜ℕ{sℕ₁₀}ᶠṗᵐ&}ᶠ⁵⁹b

Unrelated String이 축하하는 많은 인물에 의해 이것을 이겼습니다.

설명:

{≜ℕ                Brute force all nonnegative integers to find any that match the constraints
   {s               Create a predicate that finds all subsequences of digits of said integer
     ℕ₁₀            Constrains those subsequences to be >= 10
        }ᶠ          Finds all possible values of that predicate: all multi-digit subsequences
          ṗᵐ        Apply a primality constraint to all of those subsequences
            &       Make the predicate output the input integer rather than a prime subsequence
             }ᶠ⁵⁹   Find the first 59 results (all of the puzzle's solutions, and zero)
                 b  Remove the first element of the list, i.e. 0

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


3

젤리 , 17 바이트

DẆṖÐfḌÆP€Ạ
³²RÇÐf

나의 첫번째 젤리 답변! @Leaky Nun 덕분에 3 바이트가 절약되었습니다 !

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

설명:

DẆṖÐfḌÆP€Ạ      The helper link, which checks if a given number satisfy the conditions.
DẆ              Convert the argument to a list of its digits and get all its substrings.
  ṖÐf           Remove all lists of length 1.
     ḌÆP€Ạ      Convert back each element to an integer and check if all of them are prime.

³²RÇÐf          Main link.
³²              Create a 100 and square it, which gives 10000.
  R             Create a list from 1 to it.
   ÇÐf          Filter out all the elements where the helper link gives false.

첫 번째 젤리 답변을 축하합니다!
Leaky Nun

2
RÇÐf로 교체 할 수 있습니다 Ç€T. ṖÐfḌÆP€로 교체 할 수 있습니다 ḌḟDÆP.
Dennis

3

자바 8, 182 바이트

v->{for(int n=0;++n<1e4;)if(P(n)>0)System.out.println(n);}int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}int P(int n){return n>99?p(n)*p(n%100)*p(n%1000)*P(n/10):n<10?n:p(n);}

gastropner 의 C (gcc) 답변의 포트 , 그래서 그의 대답을 upvote해야합니다!

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

설명:

// Loop in range [1,10000), and print any primes corresponding to the challenge description
v->{for(int n=0;++n<1e4;)if(P(n)>0)System.out.println(n);}

// Checks if the given integer is a prime (return unchanged input if prime, 0 if not)
int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n;}

// Recursive method that checks if every part of length 2+ is a prime, or is below 10
int P(int n){return n>99?p(n)*p(n%100)*p(n%1000)*P(n/10):n<10?n:p(n);}

2

PowerShell v2 +, 107104 바이트

1..10+(11..1e4|?{($x=11..($i=$_)|?{"$i"-match$_}).count-eq($x|?{'1'*$_-match'^(?!(..+)\1+$)..'}).count})

경고 : Kinda Slow

에서 루프 111e4(즉, 10000사용하여 숫자 아웃) 및 당긴 Where-Object선택을 ( |?{...}). 이 절은 두 개의 구성 요소입니다. 첫 번째 11는 현재 숫자까지 루프 하고 현재 숫자 Where-Object의 하위 문자열을 형성하는 숫자를 뽑는 데 사용 됩니다 ( -match정규 연산자 를 통해 ). 하위 문자열을에 저장합니다 $x. 제 2 부분은 관통 루프 $x및 용법 Where-Object은 USING 모든 소수 꺼내 프라임 정규식 . 우리 .count는 두 가지 중 하나 를 취하고 실제로 점검은 -equal 인지 확인합니다 . 예를 들어, 971의지 $x = (71,97,971)와 각이 소수이므로3-eq3 이며 $TRUE, 따라서 971선택됩니다.

그 결과는 범위로 배열로 연결됩니다 1..10. 결과 배열은 파이프 라인에 남아 있으며 기본적으로 요소 사이에 줄 바꿈이있는 출력이 암시 적입니다.



2

C (GCC) , 144 (142) 140 136 134 132 바이트

Kevin Cruijssen에게 -2 감사합니다. ceilingcat 덕분에 -2

... 그리고 그것에 영감을 받아 for 루프에서 2 바이트를 더 얻을 수 있습니다.

또한 Kevin-Cruijssen의 대답 에서 다른 -4에 대한 다소 나은 프라임 체커를 부끄러워하지 않았습니다 .

p(n,i){for(i=2;i<n;)n*=n%i++||n<10;i=n;}P(n){n=p(n)*(n<99||p(n%100)*p(n%1000)*P(n/10));}f(n){for(n=1e4;--n;)P(n)&&printf("%d\n",n);}

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


||n<10할 수 있습니다 |n<10for(n=1;n<1e4;n++)수 있습니다 for(n=0;++n<1e4;)-2 바이트.
Kevin Cruijssen

@KevinCruijssen 건배!
gastropner

2

Malbolge Unshackled (20 트릿 회전 변형), 2,5254e7 바이트 또는 1,9809e7 바이트

이 답변의 크기가 게시 가능한 최대 프로그램 크기 (eh)를 초과하므로 코드가 내 GitHub 저장소에 있습니다 (참고 : CTRL + A 및 CTRL + C를 사용하여 코드를 복사하지 마십시오. 마우스 오른쪽 버튼을 클릭하고 "대상 요소를 다른 이름으로 저장"을 클릭하십시오. .. ").

이것을 실행하는 방법?

순진한 Haskell 통역사가 이것을 실행하기 위해 나이가 들기 때문에 이것은 까다로운 부분 일 수 있습니다. TIO는 괜찮은 Malbogle Unshackled 통역사가 있지만 슬프게도 사용할 수 없습니다 (제한 사항).

내가 찾을 수있는 가장 좋은 방법은 고정밀 20 회전 회전 폭 변형입니다.

인터프리터를 좀 더 빠르게 만들기 위해 Matthias Lutter의 Malbolge Unshackled 인터프리터에서 모든 검사를 제거했습니다.

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const char* translation = "5z]&gqtyfr$(we4{WP)H-Zn,[%\\3dL+Q;>U!pJS72Fh"
        "OA1CB6v^=I_0/8|jsb9m<.TVac`uY*MK'X~xDl}REokN:#?G\"i@";

typedef struct Word {
    unsigned int area;
    unsigned int high;
    unsigned int low;
} Word;

void word2string(Word w, char* s, int min_length) {
    if (!s) return;
    if (min_length < 1) min_length = 1;
    if (min_length > 20) min_length = 20;
    s[0] = (w.area%3) + '0';
    s[1] = 't';
    char tmp[20];
    int i;
    for (i=0;i<10;i++) {
        tmp[19-i] = (w.low % 3) + '0';
        w.low /= 3;
    }
    for (i=0;i<10;i++) {
        tmp[9-i] = (w.high % 3) + '0';
        w.high /= 3;
    }
    i = 0;
    while (tmp[i] == s[0] && i < 20 - min_length) i++;
    int j = 2;
    while (i < 20) {
        s[j] = tmp[i];
        i++;
        j++;
    }
    s[j] = 0;
}

unsigned int crazy_low(unsigned int a, unsigned int d){
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    int position = 0;
    unsigned int output = 0;
    while (position < 10){
        unsigned int i = a%3;
        unsigned int j = d%3;
        unsigned int out = crz[i+3*j];
        unsigned int multiple = 1;
        int k;
        for (k=0;k<position;k++)
            multiple *= 3;
        output += multiple*out;
        a /= 3;
        d /= 3;
        position++;
    }
    return output;
}

Word zero() {
    Word result = {0, 0, 0};
    return result;
}

Word increment(Word d) {
    d.low++;
    if (d.low >= 59049) {
        d.low = 0;
        d.high++;
        if (d.high >= 59049) {
            fprintf(stderr,"error: overflow\n");
            exit(1);
        }
    }
    return d;
}

Word decrement(Word d) {
    if (d.low == 0) {
        d.low = 59048;
        d.high--;
    }else{
        d.low--;
    }
    return d;
}

Word crazy(Word a, Word d){
    Word output;
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    output.area = crz[a.area+3*d.area];
    output.high = crazy_low(a.high, d.high);
    output.low = crazy_low(a.low, d.low);
    return output;
}

Word rotate_r(Word d){
    unsigned int carry_h = d.high%3;
    unsigned int carry_l = d.low%3;
    d.high = 19683 * carry_l + d.high / 3;
    d.low = 19683 * carry_h + d.low / 3;
    return d;
}

// last_initialized: if set, use to fill newly generated memory with preinitial values...
Word* ptr_to(Word** mem[], Word d, unsigned int last_initialized) {
    if ((mem[d.area])[d.high]) {
        return &(((mem[d.area])[d.high])[d.low]);
    }
    (mem[d.area])[d.high] = (Word*)malloc(59049 * sizeof(Word));
    if (!(mem[d.area])[d.high]) {
        fprintf(stderr,"error: out of memory.\n");
        exit(1);
    }
    if (last_initialized) {
        Word repitition[6];
        repitition[(last_initialized-1) % 6] =
                ((mem[0])[(last_initialized-1) / 59049])
                    [(last_initialized-1) % 59049];
        repitition[(last_initialized) % 6] =
                ((mem[0])[last_initialized / 59049])
                    [last_initialized % 59049];
        unsigned int i;
        for (i=0;i<6;i++) {
            repitition[(last_initialized+1+i) % 6] =
                    crazy(repitition[(last_initialized+i) % 6],
                        repitition[(last_initialized-1+i) % 6]);
        }
        unsigned int offset = (59049*d.high) % 6;
        i = 0;
        while (1){
            ((mem[d.area])[d.high])[i] = repitition[(i+offset)%6];
            if (i == 59048) {
                break;
            }
            i++;
        }
    }
    return &(((mem[d.area])[d.high])[d.low]);
}

unsigned int get_instruction(Word** mem[], Word c,
        unsigned int last_initialized,
        int ignore_invalid) {
    Word* instr = ptr_to(mem, c, last_initialized);
    unsigned int instruction = instr->low;
    instruction = (instruction+c.low + 59049 * c.high
            + (c.area==1?52:(c.area==2?10:0)))%94;
    return instruction;
}

int main(int argc, char* argv[]) {
    Word** memory[3];
    int i,j;
    for (i=0; i<3; i++) {
        memory[i] = (Word**)malloc(59049 * sizeof(Word*));
        if (!memory) {
            fprintf(stderr,"not enough memory.\n");
            return 1;
        }
        for (j=0; j<59049; j++) {
            (memory[i])[j] = 0;
        }
    }
    Word a, c, d;
    unsigned int result;
    FILE* file;
    if (argc < 2) {
        // read program code from STDIN
        file = stdin;
    }else{
        file = fopen(argv[1],"rb");
    }
    if (file == NULL) {
        fprintf(stderr, "File not found: %s\n",argv[1]);
        return 1;
    }
    a = zero();
    c = zero();
    d = zero();
    result = 0;
    while (!feof(file)){
        unsigned int instr;
        Word* cell = ptr_to(memory, d, 0);
        (*cell) = zero();
        result = fread(&cell->low,1,1,file);
        if (result > 1)
            return 1;
        if (result == 0 || cell->low == 0x1a || cell->low == 0x04)
            break;
        instr = (cell->low + d.low + 59049*d.high)%94;
        if (cell->low == ' ' || cell->low == '\t' || cell->low == '\r'
                || cell->low == '\n');
        else if (cell->low >= 33 && cell->low < 127 &&
                (instr == 4 || instr == 5 || instr == 23 || instr == 39
                    || instr == 40 || instr == 62 || instr == 68
                    || instr == 81)) {
            d = increment(d);
        }
    }
    if (file != stdin) {
        fclose(file);
    }
    unsigned int last_initialized = 0;
    while (1){
        *ptr_to(memory, d, 0) = crazy(*ptr_to(memory, decrement(d), 0),
                *ptr_to(memory, decrement(decrement(d)), 0));
        last_initialized = d.low + 59049*d.high;
        if (d.low == 59048) {
            break;
        }
        d = increment(d);
    }
    d = zero();

    unsigned int step = 0;
    while (1) {
        unsigned int instruction = get_instruction(memory, c,
                last_initialized, 0);
        step++;
        switch (instruction){
            case 4:
                c = *ptr_to(memory,d,last_initialized);
                break;
            case 5:
                if (!a.area) {
                    printf("%c",(char)(a.low + 59049*a.high));
                }else if (a.area == 2 && a.low == 59047
                        && a.high == 59048) {
                    printf("\n");
                }
                break;
            case 23:
                a = zero();
                a.low = getchar();
                if (a.low == EOF) {
                    a.low = 59048;
                    a.high = 59048;
                    a.area = 2;
                }else if (a.low == '\n'){
                    a.low = 59047;
                    a.high = 59048;
                    a.area = 2;
                }
                break;
            case 39:
                a = (*ptr_to(memory,d,last_initialized)
                        = rotate_r(*ptr_to(memory,d,last_initialized)));
                break;
            case 40:
                d = *ptr_to(memory,d,last_initialized);
                break;
            case 62:
                a = (*ptr_to(memory,d,last_initialized)
                        = crazy(a, *ptr_to(memory,d,last_initialized)));
                break;
            case 81:
                return 0;
            case 68:
            default:
                break;
        }

        Word* mem_c = ptr_to(memory, c, last_initialized);
        mem_c->low = translation[mem_c->low - 33];

        c = increment(c);
        d = increment(d);
    }
    return 0;
}

성능 메모

응용 프로그램이 내 컴퓨터에서 약 40 분 동안 실행되어 16 진수 시퀀스를 생성했습니다. 나는 한 시간 정도 계산을 멈추고 0x11에서 끝났습니다.

이 답변은 실제로 숫자를 계산하므로 무기한으로 계산할 수 있기 때문에 다른 답변과 다릅니다.

응용 프로그램은 약 7GB의 스핀 업 버퍼를 할당하므로 사용 가능한 RAM을 더 잘 준비하십시오.

대체 변형

대체 변형은 약 2GB의 메모리를 덜 사용하지만 ASCII 문자 (0 = ASCII (0x0), 10 = 줄 바꿈 등) 형식으로 출력을 생성하며 여기에서 사용할 수 있습니다 . 도전 요구 사항으로 인해 경쟁하지는 않습니다.


코드 골프는 짧은 답변을 제공하는 것입니다.
Alfe

2
@Alfe Malbolge는 프로그래밍하기가 매우 어려운 언어입니다 (wikipedia 링크) . 이것이 가능 하다는 사실 은 상당히 인상적입니다.
Giuseppe

4
그래서 사실 이것은 이다 짧은 대답은. 표준 만 바뀌 었습니다. 약간.
Alfe

3
@Alfe 당신은 약간의 바이트를 면도하려고 시도하는 것을 환영합니다! ;-)
Giuseppe

2

파이썬 3 , 118 바이트

r=range(9720)
for n in r[1:]:all(all(l%k+9//l for k in r[2:l])for l in(n%10**(i%5)//10**(i//5)for i in r))and print(n)

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

설명

경고 :이 솔루션에는 실제 문자열이 없습니다.

r=range(9720)
for n in r[1:]:                                        # For each positive integer up to 9720
 all( ... for l in(n%10**(i%5)//10**(i//5)for i in r)) # Check for all its substrings
  all(l%k ... for k in r[2:l])                         # If it is either prime
   +9//l                                               # Or smaller than 10
and print(n)                                           # Then print

1

루비, 81 + 8 = 89 바이트

8은 바이트 -rprime.

puts (?1..?9*4).select{|m|(r=2..m.size).all?{|i|r.all?{|j|m[i-2,j].to_i.prime?}}}

repl.it에서 참조하십시오 : https://repl.it/CniR/2


1

펄 6 ,  47 44  43 바이트

for 1..9719 {all(m:ex/..+/).Int.is-prime&&.say}
put grep {is-prime +all(m:ex/..+/):},1..9719
put grep {is-prime +all m:ex/..+/:},1..9719

설명:

# print the values space separated, with trailing newline
put

# that match
grep -> $_ {

  # call the method 「.is-prime」 ( that is what 「:」 is for )
  # (autothreaded)
  is-prime

  # convert following to numeric (autothreaded)
  +
  # a junction of
  all(
    # all substrings 2 characters or greater
    $_ ~~ m :exhaustive / . .+ /
  )

  # needed to indicate that 「is-prime」 is a method call
  :

},

# in this Range
1..9719

1

C #을, 261 249 247 바이트

Leaky Nun 덕분에 12 바이트 절약

()=>{Action<int>w=System.Console.WriteLine;int i=0,n,j,k,p,m,b;for(;++i<10001;){n=(i+"").Length;if(n<2)w(i);else{b=1;for(j=1;++j<=n;)for(k=0;k+j<=n;){p=int.Parse((i+"").Substring(k++,j));if(p%2<1)b=0;for(m=3;m<p;m+=2)if(p%m<1)b=0;}if(b>0)w(i);}}};

이것은로 컴파일됩니다 Func<List<int>>.

형식이 지정된 버전은 다음과 같습니다.

() =>
{
    Action<int> w = System.Console.WriteLine;

    int i = 0, n, j, k, p, m, b;

    for (; ++i < 10001;)
    {
        n = (i + "").Length;

        if (n < 2)
            w(i);

        else
        {
            b = 1;
            for (j = 1; ++j <= n; )
                for (k = 0; k + j <= n; )
                {
                    p = int.Parse((i + "").Substring(k++, j));

                    if (p % 2 < 1)
                        b = 0;

                    for (m = 3; m < p; m += 2)
                        if (p % m < 1)
                            b = 0;
                }

            if (b > 0)
                w(i);
        }
    }
};

리스트를 사용하지 않고 직접 인쇄
Leaky Nun

대신 false하거나 true, 사용 0>10<1
새는 수녀

추가 골프 팁에 대해서는 내용을 참조하십시오 .
Leaky Nun

@LeakyNun 팁을 주셔서 감사합니다, 나는 보통 골프 버전을 게시하고 거기에서 이동하고 싶습니다.
TheLethalCoder

1

스위프트 4 , 144 바이트

let p={n in !(2..<n).contains{n%$0<1}}
print((1...971).filter{$0<10||p($0)&&($0<100||p($0/10)&&p($0%100))}+[1373,3137,3797,6131,6173,6197,9719])

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

설명

let p={n in !(2..<n).contains{n%$0<1}} // Helper function p, tests if a number is prime
print((1...971).filter{                // Print every number n in the range 1 to 971
 $0<10                                 //  that is less than 10
 ||p($0)&&                             //  or a prime and
 ($0<100                               //   is less than 100 or
  ||p($0/10)&&p($0%100))}              //   n/10 and n%100 are primes
+[1373,3137,3797,6131,6173,6197,9719]) // Print the four digit numbers

1

자바 스크립트 (Node.js) , 130 바이트

난 무한 스택을 가정 할 수 있다면 i*i<=n&&제거 될 수 i*i>n로 회전 i>=n아마 9 바이트 코드를 감소시키는 재귀 메인 변환 기능 : https://tio.run/##LYpBDoIwEEX33AMyAxVbXUmccgX2xkWDRYeQaSPqyrvXkrj5ef/lze7j1vHJ8bWTcPMpTQRMWjm6XJFs0/DZ@EM/ASunBmCsKtfG9/rIiJ0rIoEoJpNbKXPdx@1jx5akGEiytqdNYp2nNFr / wR @ xHkD2Rn81dpLGIGtYfLuEO0yAmH4 (119 바이트)

_=>eval(`for(a=[i=1];++i<1e4;)P(i)&&a.push(i)`)||a
p=(n,i=1)=>i*i<=n&&n%++i?p(n,i):n%i
P=n=>n>9?p(n)*p(n%100)*p(n%1e3)*P(n/10|0):n

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


1

말 볼지 , 1361 바이트

간단하고 지루한 버전. 가장 높은 숫자를 표시합니다.

D'`r^"!=[YG3yUCvA-csNqp-nJ$HYFgDC#AbQ,|*)\rwvutm3kSonmlkdihg`&dc\aZ_X|V[ZYXQPt7SRQPOHGkKJIHG@d>=<A:98\}|:981U5.-2+0/.'K%$#G!E}e#z!~}v<]yxwpun4rkj0nmfN+ihaf_^$\a`_XW{>=YXWVONrLKPINGkE-IBAe(>=<;_?>=}|:3W1w543,P0).-&J*)(!E}|B"!~}|{zyr8potml2jongfkjibg`&d]\"`_XW{>=YXWVONr54JIHMFj-,HGF?>b%A@?87[;:981w543,P0).-&J*j(!EfeB"!~}_u;yrqpun4rqpihmlkjihg`&d]\"`_X|\[ZYXQuUNMLQJnH0LKJIBAe(>=<`#"8\<5Y9270T43,Pqp.-&J$)"!~D|#"y~}|u;s9qvotsrk1inglkdihg`&d]\"Z~XWVUZYXQu87SLKo2NGFjDIHGF?>bBA#"8\6;:981Uv.32+*)Mnm%$)('~D|{A!xwv{zyr8vXnsrkjoh.fNdchg`ed]#aC_^WVz=YXQPt7SRQPOHGkK-IHGF?>bBA#"8\6;:981Uv.32+*)Mnm%*#"F&%$#cy?}v<]\xwpun4rqSonmf,diha'eG]#a`_X|V[ZYXWPt76LKoIHGLEiCHGFED=aA:?>7[;:981w/4-,PO)o'&J*j(!E%edz@~}_u;yxqpo5mrqpoh.f,jibgf_%]\[!_XW{[ZYXQu87SLKo2NGFjJIHAF?c=BA@?>=<5Y38765.-Q10)o'&J*j(!E%e{z@~}|{ts9qpotsrk1oQglkd*)gIed]#DZ_^]VzZYRQuONMRKJnNGLEJCgG)(D=aA:?>=<;4X816/43,P0).-&+$H('gf|Bcb~w|u;yxwYutmrqj0nmleMib(fH%cba`_X|VUZYXWPt7SRQPOHGkEDIHG@dDC<;@?8\6|:32V0T43,+O)o'&J*)('&}C{"yxwv<tyr8vun4Ukpoh.fN+c)gIed]#DZ_^]VzTSRWPtTSLQJnH0LKJIBAe(>=BA@987[;:381Uv.32+*)Mnm%$)('~D${"y?}_uzyxqpo5srqSonmf,jihgfeG]#a`_X|V[ZYXWPt76LKo2NGFjJIH*)ED=a;@?>76;4X816/43,P*).',%I)('~Ded"y~}|u;srqvo5mlqpih.fN+cba`&d]\aZ~^]VUZSwWPUTSLpJ2NGLEiCHGFED=a;:?>7<5YX876v43,+O).-,+$H('&feBz!x}v{zsr8punsrk1inglkdihg`&d]\"Z~X]V[ZSwQVUTMRKo2NGFjDIHGF?>b%A@?87[;{921U5.3210)M-,%k#(!EfeB"y~}v{zyr8%

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


0

TI-83 / 84 기본, 124 바이트

For(A,1,E4
DelVar Nint(log(A→P
Ans→Q
While Ans
For(I,0,Q-Ans
10^(P+1
AnsfPart(iPart(A/10^I)/Ans→S
min(Ans={2,3,5
If S≥7 and fPart(.5S
min(remainder(S,3+2cumSum(not(binompdf(int(.5√(S)),0
N+not(Ans→N
End
P-1→P
End
If not(N
Disp A
End

처음 10k 정수를 반복합니다. 각 하위 문자열 소수를 확인하기 위해 카운터를 N으로 설정하고 int (log (A는 현재 숫자의 자릿수보다 적은 수를 검색합니다.) 그런 다음 두 번째 변수에서 그 숫자를 따로 설정하여 각 길이를 통해 P를 단계적으로 줄일 수 있습니다 10 ^ ... 및 AnsfPart (iPart (``, 현재 하위 문자열을 생성하여 소수를 확인한 다음 Ans에서 1 또는 0으로 소수 검사를 수행합니다.) 하위 문자열이 소수가 아닌 경우 N을 증가시키고 N이 여전히 0이면 모든 하위 문자열을 검사 한 후 현재 숫자를 인쇄합니다.

이 테스트에 대한 우선 순위 점검의 효율성을 높이기 위해 약간의 조정이 가능합니까? TI-83 형식으로 출력을 직접 저장하는 것보다 적은 바이트로 알고리즘을 찾았습니다.



0

PHP , 135 바이트

for(;++$n<1e4;$p||print"$n
")for($p=$i=0;$i<$l=strlen($n);$i++)for($j=1;$j++<$l-$i;$p|=$k)for($k=($m=substr($n,$i,$j))-1;$k&&$m%$k--;);

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

for(;                         // level 1 loop on
  ++$n<1e4;                   // all numbers from 1 to 10,000, $n is current number
  $p||print"$n\n"             // at the end of loop for each number, print $n if all multi digit sub strings were prime ($p=0)
)
  for(                        // level 2 loop on each digit of $n
    $p=                       // $p is a flag for all sub string primes and is set to 0 for each new $n
      $i=0;                   // $i is position of current digit (and sub string start position)
    $i<$l=strlen($n);         // $l is the total digits count in $n
    $i++                      // increment $i by one
  )
    for(                      // level 3 loop to create sub strings
      $j=1;                   // $j is length of sub string, we only care about multi digit sub strings so it starts from 1
      $j++<$l-$i;             // continue the loop as long as $j has not reached last digit and increment it by one
      $p|=$k                  // THIS IS RUN AFTER LOOP LEVEL 4: update $p flag based on value of $k
                              //     $p will be left at 0 only if all of the sub strings are prime (if $k is always 0)
    )
      for(                    // level 4 loop to check each sub string to be prime
        $k=(                  // $k is set to current sub string minus 1
          $m=substr($n,$i,$j) // $m is current sub string
        )-1;                  // 
        $k && $m%$k--;        // as long as $k is more than 0 and $m%$k is not zero, decrement $k by one and continue
                              //     a prime number will only get a 0 remainder, when $k gets to 1
                              //     so $k will be 0 for primes and more than 0 for non-primes
      );
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.