에서 안노 비디오 게임 시리즈 이들의 제목은 항상 특정 패턴에 매년 기능 초기 2019에 대한 발표 7 일 6 개 게임이 있습니다

Anno 1602, Anno 1503, Anno 1701, Anno 1404, Anno 2070, Anno 2205, Anno 1800

• 디지털 합계는 항상 9입니다.
• 연도는 4 자리 숫자입니다.
• 그것들은 적어도 하나의 0을 포함합니다.

이러한 제약에는 109 개의 가능한 제목이 있습니다.

[1008,1017,1026,1035,1044,1053,1062,1071,1080,1107,1170,1206,1260,1305,1350,1404,1440,1503,1530,1602,1620,1701,1710,1800,2007,2016,2025,2034,2043,2052,2061,2070,2106,2160,2205,2250,2304,2340,2403,2430,2502,2520,2601,2610,2700,3006,3015,3024,3033,3042,3051,3060,3105,3150,3204,3240,3303,3330,3402,3420,3501,3510,3600,4005,4014,4023,4032,4041,4050,4104,4140,4203,4230,4302,4320,4401,4410,4500,5004,5013,5022,5031,5040,5103,5130,5202,5220,5301,5310,5400,6003,6012,6021,6030,6102,6120,6201,6210,6300,7002,7011,7020,7101,7110,7200,8001,8010,8100,9000]

당신의 목표는 가장 적은 수의 바이트로 합리적인 형식으로 모든 것을 나열하는 것입니다.

R , 59 51 바이트

유효한 숫자 를 201 목록의 이름 으로 출력합니다 . 왜 201? ASCII 0은 48이고 4 * 48 + 9는 ... 예입니다. 앨리어싱으로 6 바이트의 저장 ^을 Map사용하여 다른 2 및 1:9e3범위로.

"^"=Map;x=sum^utf8ToInt^grep(0,1:9e3,,,T);x[x==201]

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

설명

# Create list of sums of ASCII char values of numbers,
# with the original numbers as the names of the list
x <- Map(sum,
  # Create a list from the strings where each element is the string split 
  # into ASCII char values
  Map(utf8ToInt,
      # Find all numbers between 1 and 9e3 that contain a zero
      # Return the matched values as a vector of strings (6th T arg)
      grep(pattern=0,x=1:9000,value=TRUE)
  )
)
# Pick out elements with value 201 (i.e. 4-digits that sum to 9)
# This implicitly only picks out elements with 4 digits, since 3-digit 
# sums to 9 won't have this ASCII sum, letting us use the 1:9e3 range
x[x==201] 

펄 6 , 35 33 바이트

Jo King 덕분에 -2 바이트

{grep {.ords.sum==201&&/0/},^1e4}

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

파이썬 2 , 67 66 64 바이트

print[y for y in range(9001)if('0'in`y`)*sum(map(ord,`y`))==201]

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

저장 됨 :

• Luis felipe De Jesus Munoz 덕분에 -1 바이트
• Kevin Cruijssen 덕분에 -2 바이트

젤리 , 11 바이트

9ȷṢ€æ.ẹ9ṫ19

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

작동 원리

9ȷṢ€æ.ẹ9ṫ19  Main link. No arguments.

9ȷ           Set the left argument and the return value to 9000.
  Ṣ€         Sort the digits of each integer in [1, ..., 9000].
    æ.       Perform the dot product of each digit list and the left argument,
             which gets promoted from 9000 to [9000].
             Overflowing digits get summed without multiplying, so we essentially
             map the digit list [a, b, c, d] to (9000a + b + c + d).
      ẹ9     Find all 1-based indices of 9.
             Note that 9000a + b + c + d == 9 iff a == 0 and b + c + d == 9.
        ṫ19  Tail 19; discard the first 18 indices.

PowerShell , 50 49 바이트

999..1e4-match0|?{([char[]]"$_"-join'+'|iex)-eq9}

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

구축의 범위 999까지를 10000다음 인라인 사용 -match하는 정규식 매치 대해 해당 항목을 꺼내 필터로 0. 이것은 우리를 1000, 1001, 1002, etc.우리 에게 남겨 Where-Object두고 현재 숫자를 문자열로 가져 와서 배열 "$_"로 캐스팅하고 char, -join그 문자를 함께 합산 +하고 (eval과 비슷한) Invoke- Expression과 함께 숫자 합을 얻 습니다. 우리는 이것이 -eq최종적 인지 확인 9하고, 그렇다면 파이프 라인에 전달됩니다. 프로그램 완료시 해당 숫자는 파이프 라인에서 선택되어 내재적으로 출력됩니다.

자바 스크립트 (ES6), 78 73 바이트

@KevinCruijssen 덕분에 2 바이트 절약

공백으로 구분 된 문자열을 반환합니다.

f=(n=9e3)=>n>999?f(n-9)+(eval([...n+''].join`+`)&/0/.test(n)?n+' ':''):''

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

어떻게?

0 이 아닌 숫자는 무시하고 9 단위로 $[1008..9000]$ 범위를 반복합니다 .$9$$0$

이 모든 숫자는 $9$ 배수 이므로 숫자의 합도 $9$ 의 배수가 보장됩니다 .

유효한 숫자는 하나 이상이 있기 때문에 $0$ 을 갖기 때문에 두 개 이상의$9$ 가지므로 나머지 숫자의 합은 최대$18$ 입니다. 따라서 숫자의 합이 홀수인지 테스트하면 충분합니다.

따라서 테스트 :

(eval([...n + ''].join`+`) & /0/.test(n)

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

[...Array(9e3)].map(_=>i++,i=1e3).filter(a=>(s=[...a+""]).sort()[0]<1&eval(s.join`+`)==9)

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

• @ETHproductions 덕분에 -4 바이트

자바 스크립트 (Node.js를) 129 127 126 124 115 114 111 110 105 97 93 92 90 바이트

[...Array(9e3)].map(f=(_,i)=>eval(s=[...(i+=1e3)+""].sort().join`+`)-9|s[0]?0:i).filter(f)

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

설명

[...Array(9e3)].map(f=(_,i)=>eval(s=[...(i+=1e3)+""].sort().join`+`)-9|s[0]?0:i).filter(f)
[...Array(9e3)].map(f=(_,i)=>                                                  )           // Create a 9000-length array and loop over it; store the loop body
                                    [...(i+=1e3)+""]                                       // Add 1000 to the index and split it into an array of characters (17 -> ["1", "0", "1", "7"])
                                                    .sort()                                // Sort the array of characters in ascending order by their code points ("0" will always be first) (["1", "0", "1", "7"] -> ["0", "1", "1", "7"])
                                  s=                       .join`+`                        // Join them together with "+" as the separator (["0", "1", "1", "7"] -> "0+0+2+9"); store the result
                             eval(                                 )-9                     // Evaluate and test if it's different than 9
                                                                       s[0]                // Take the first character of the string and implicitly test if it's different than "0"
                                                                      |    ?0              // If either of those tests succeeded, then the number doesn't meet challenge criteria - return a falsey value
                                                                             :i            // Otherwise, return the index
                                                                                .filter(f) // Filter out falsey values by reusing the loop body

JavaScript에서 코드 골프를 처음하는 것. 나는 그것을 말할 필요가 없다고 생각하지만, 내가 잘못하고 있다면 아래 의견에 저에게 알려주십시오.

• @Luis felipe De jesus Munoz 덕분에 -3 바이트

• @Kevin Cruijssen 덕분에 -6 바이트

파이썬 2 , 57 바이트

n=999
exec"n+=9\nif'0'in`n`>int(`n`,11)%10>8:print n\n"*n

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

Dennis 덕분에 2 바이트

exec루프를 사용하여 n9 단계에서 1008, 1017, ..., 9981, 9990 으로 카운트 업 하여 조건에 맞는 것을 인쇄합니다.

9의 배수 만 숫자 합 9를 가질 수 있지만이 범위의 9의 배수도 18과 27의 숫자 합을 가질 수 있습니다 int(`n`,11)%10>8. n기수 11에서 해석 할 때, 그 숫자의 합은 수 10의 수와 같고, 기수 10에서와 같은 숫자는 그 수의 합과 9입니다. (9, 18, 27)의 자릿수는 (9, 8, 7)에 해당합니다. 모듈로 10을 사용 >8하여 9를 걸러내는 작업을 수행합니다.

0을 포함하는 숫자는 문자열 멤버쉽으로 확인합니다. '0'in`n`. 이 조건은 파이썬 2가 문자열을 숫자보다 큰 것으로 취급한다는 점을 사용하여 체인 부등식으로 다른 조건과 결합됩니다.

sed 및 grep (및 seq), 72 64 63 바이트

seq 9e3|sed s/\\B/+/g|bc|grep -wn 9|sed s/:9//|grep 0|grep ....

하스켈 , 55 바이트

[i|i<-show<$>[1..5^6],201==sum(fromEnum<$>i),elem '0'i]

@Laikoni 덕분에 의견을 참조하십시오.

읽을 수있는 :

import Data.Char (digitToInt)

[i | i <- show <$> [1000..9999]
   , sum (digitToInt <$> i) == 9
   , '0' `elem` i
   ]

R , 82 바이트

write((x=t(expand.grid(1:9,0:9,0:9,0:9)))[,colSums(x)==9&!apply(x,2,all)],1,4,,"")

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

x앞에 오는 0을 제외하고 열을 아래로 내리는 가능한 모든 4 자리 숫자 의 행렬 을 생성합니다 . 그런 다음 9의 열 (디지털) 합계 및 0을 포함하는 필터, 즉 0 all이 아닌 필터 . 너비 와 구분 기호 를 사용 write하여 열을 인쇄합니다 .writestdout4""

J.Doe에 의해 아웃 고프

Japt , 20 18 바이트

@Shaggy 및 @ETHproductions 덕분에 -2 바이트

A³òL² f_=ì)x ¥9«Z×

A³òL² f_=ì)x ¥9«Z×  Full program
A³òL²               Range [1000, 10000]
      f_            Filter by : 
        =ì)         Convert to array 
           x ¥9     Sum equal to 9?
               «    And 
                Z×  Product not 0

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

자바 (8) 128 117 115 바이트

v->{int i=109,r[]=new int[i],n=i;for(;i>0;n++)if((n+"").chars().sum()==201&(n+"").contains("0"))r[--i]=n;return r;}

@nwellnhof 덕분에 -11 바이트 .

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

설명:

v->{                              // Method with empty unused parameter & int-array return
  int i=109,                      //  Index-integer, starting at 109
      r[]=new int[i],             //  Result-array of size 109
      n=i;                        //  Number integer, starting at 109
   for(;i>0;                      //  Loop as long as `i` is not 0 yet:
       n++)                       //    After every iteration, increase `n` by 1
     if((n+"").chars().sum()==201 //   If the sum of the unicode values of `n` is 201,
                                  //   this means there are four digits, with digit-sum = 9
        &(n+"").contains("0"))    //   and `n` contains a 0:
       r[--i                      //    Decrease `i` by 1 first
            ]=n;                  //    And put `n` in the array at index `i`
  return r;}                      //  Return the array as result

R , 85 바이트

(R 대괄호를 가장 잘 사용하기 위해 경쟁 ... : P)

`[`=`for`;i[a<-0:9,j[a,k[a,w[a,if(sum(s<-c(i,j,k,w))==9&any(!s)&i)write(s,1,s='')]]]]

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

05AB1E , 15 13 12 10 바이트

₄4°ŸεW°ö9Q

-2 덕분에 바이트 @Emigna
-3 덕분 바이트 @Grimy을

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

설명:

₄4°Ÿ        # Create a list in the range [1000,10000]
    ʒ       # Filter this list by:
     W      #  Get the smallest digit in the number (without popping the number itself)
      °     #  Take 10 to the power this digit
       ö    #  Convert the number from this base to an integer (in base-10)
        9Q  #  Check if it's equal to 9

• $d=0$$1$$10^d$°ö 숫자의 합과 같습니다.
• $d=1$$10$$10^d$° ). 그리고 밑이 10 인 숫자는 밑이 10 인 정수로 변환 된 숫자 ö는 물론 그대로 유지됩니다.
• $d=2$$100$$10^d$°ö02345 가된다 2030405).
• $d=3$$1000$$10^d$°ö0034563004005006
• $d=[4,9]$$d=2$$d=3$$d-1$0 하며 '결합'에 있습니다.

$>0$$[1000,10000]$°ö$[1111,9000000009000000009000000009]$$9$$9$9Q$d=0$°ö$9$

핍 , 18 바이트

{0Na&$+a=9}FIm,t*m

-p읽을 수있는 출력을 얻는 등의 출력 형식 플래그를 사용하십시오 . 온라인으로 사용해보십시오!

{0Na&$+a=9}FIm,t*m
             m,t*m  Range from 1000 to 10*1000
{         }FI       Filter on this function:
 0Na                 There is at least one 0 in the argument
    &                and
     $+a             The sum of the argument
        =9           equals 9

Wolfram Language (Mathematica) , 56 55 바이트

Select[9!!~Range~9999,Tr@#==Times@@#+9&@*IntegerDigits]

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

우리는 9에서 범위를 테스트합니다! 945에서 999 사이의 결과가 없기 때문에 = 945에서 9999 사이입니다. 9000에서 10007 사이의 숫자를 쓰는 더 짧은 방법이있을 수도 있습니다.

Tr@#==Times@@#+9&는 Anno Condition과 동일한 {a,b,c,d}결과 인 경우 테스트에 적용됩니다 a+b+c+d == a*b*c*d+9.

루비 , 46 42 41 바이트

?9.upto(?9*4){|x|x.sum==201&&x[?0]&&p(x)}

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

작동 방식 :

• '9'에서 '9999'까지의 문자열에서 반복
• ASCII 값의 합이 201인지 확인하십시오.
• 문자열에 0이 포함되어 있는지 확인하십시오 (정규식이 없으면 정규식이 1 바이트 더 깁니다)

(-2 바이트에 대한 Laikoni 감사합니다)

옥타브 , 49 바이트

J.Doe가 제안한대로보다 편리한 출력 형식을 사용하여 6 바이트를 절약 했습니다 .

정정을위한 @Laikoni 에게 감사합니다 .

y=dec2base(x=1e3:9999,10)'-48;x(sum(y)==9>all(y))

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

다트 ,  103100  96 바이트

f()=>List.generate(9001,(i)=>'$i').where((i)=>i.contains('0')&&i.runes.fold(0,(p,e)=>p+e)==201);

꽤 자명하다. 셀 인덱스를 값으로하여 9001 (0-9000) 셀 목록을 생성하고 0을 포함하는 셀과 201의 ASCII 합을 갖는 셀을 필터링합니다 (모든 ASCII 문자의 합이 9 인 경우 결과). 이러한 조건에는 ASCII 숫자 2 (및 0)를 사용하여 201에 도달 할 수 없기 때문에 연도가 4 자리 길이 인 것이 포함됩니다.

다트 패드에서 사용해보십시오!

배쉬 ( seq, grep), 39 바이트

seq 0 9 1e4|egrep '([0-4].*){3}'|grep 0

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

K (ngn / k) , 22 바이트

55_&(|/~a)&9=+/a:!4#10

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

APL (Dyalog Unicode) , 23 바이트

55↓⍸(×⌿<9=+⌿)10⊥⍣¯1⍳9e3

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

PHP, 69, 87 바이트 74 바이트

for($i=999;$i<9001;$i++){echo((array_sum(str_split($i))==9&strpos($i,"0")!=0)?$i:" ");} for($i=999;$i++<1e4;)echo!strpos($i,48)|array_sum(str_split($i))-9?" ":$i;

이렇게하면 모든 "실패한"숫자를위한 공간이 생겨 일종의 펑키 한 간격이 생깁니다. 쉼표로 구분할 수 있지만 다른 4자를 추가합니다.?$i.",":""

내가 0을 확인하지 않았기 때문에 더 커졌습니다. Derp. Titus에 의해 13 단축!

APL (Dyalog), 33 29 바이트

1e3+⍸(0∘∊∧9=+/)¨⍎¨∘⍕¨1e3+⍳9e3

@Adam 덕분에 -4 바이트

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

스칼라 ( 76 63 61 56 bytes)

for(n<-0 to 9000;t=n+""if t.sum==201&t.min<49)println(t)

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

• Laikoni에게 제안 해 주셔서 감사합니다
• Jo King의 주석을 적용한 후 2 바이트 더 흘림

Tcl , 77 바이트

time {if [incr i]>1e3&[regexp 0 $i]&9==[join [split $i ""] +] {puts $i}} 9999

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

apt, 16 바이트

숫자 형 배열을 반환합니다.

L²õì l4 k_ת9aZx

그것을 테스트

설명

L                    :100
 ²                   :Squared
  õ                  :Range [1,L²]
   ì                 :Convert each to a digit array
     l4              :Filter elements of length 4
        k_           :Remove each Z that returns truthy (not 0)
          ×          :  When reduced by multiplication
           ª         :  OR
              Zx     :  When reduced by addition
            9a       :   And subtracted from 9

APL (NARS), 45 자, 90 바이트

f←{⍵×⍳(0∊x)∧9=+/x←⍎¨⍕⍵}⋄f¨1e3..5e3⋄f¨5e3..9e3

몇 가지 형식을 테스트하십시오.

1008  1017  1026  1035  1044  1053  1062  1071  1080  1107  1170  1206  1260  
  1305  1350  1404  1440  1503  1530  1602  1620  1701  1710  1800  2007  2016  
  2025  2034  2043  2052  2061  2070  2106  2160  2205  2250  2304  2340  
  2403  2430  2502  2520  2601  2610  2700  3006  3015  3024  3033  3042  3051  
  3060  3105  3150  3204  3240  3303  3330  3402  3420  3501  3510  3600  
  4005  4014  4023  4032  4041  4050  4104  4140  4203  4230  4302  4320  4401  
  4410  4500 
5004  5013  5022  5031  5040  5103  5130  5202  5220  5301  5310  5400  6003  
  6012  6021  6030  6102  6120  6201  6210  6300  7002  7011  7020  7101  7110  
  7200  8001  8010  8100  9000 

가능한 대안

r←f;i;x
   r←⍬⋄i←1e3⋄→B
A: r←r,i
B: i+←1⋄→A×⍳(0∊x)∧9=+/x←⍎¨⍕i⋄→B×⍳i≤9e3

젤리 , 13 바이트

ȷ4µṢÄm3Ḍ)ẹ9ṫ4

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

어떻게?

ȷ4µṢÄm3Ḍ)ẹ9ṫ4 - Link: no arguments
ȷ4            - literal 10^4 = 10000
  µ     )     - for each in range (1,2,3,...,10000): e.g. 3042       or  5211
   Ṣ          -   sort (given an integer makes digits)    [0,2,3,4]      [1,1,2,5]
    Ä         -   cumulative addition                     [0,2,5,9]      [1,2,4,9]
     m3       -   modulo 3 slice (1st,4th,7th...)         [0,9]          [1,9]
       Ḍ      -   convert from decimal digits             9              19
         ẹ9   - 1-based indices equal to nine             [9,99,999,1008,1017,...,8100,9000]
           ṫ4 - tail from the 4th index                   [1008,1017,...,8100,9000]