아,이 만료일은 몇 달 동안 문자로 쓰지 않습니다! 내가 3 월 10 일 또는 10 월 3 일에 만료되는 경우 ... 말할 아니, 결코 마음을, 기다릴 수 없어 올해는 말한다 2012 년 (골목 죄송 프로처럼 휴지통에 치즈의 벽돌을 반 사용)

이 마리 나라 항아리가 만료되는 시점을 추론하기에는 너무 바쁘다고 가정 해 봅시다. Cliff Notes 버전을 원할 것입니다. 코드를 작성하자!

제조업체는 세 가지 형식 중 하나를 사용하여 날짜를 3 배의 정수 정수로 인쇄한다는 것을 알고 있습니다.

YEAR  MONTH DAY
MONTH DAY   YEAR
DAY   MONTH YEAR

그리고 일부 날짜는 하나 또는 두 가지 방식으로 만 해석 될 수 있으며 세 가지 모두는 해석 할 수 없습니다. 55 인치 55-11-5는 1 년이어야합니다. 즉,이 특정 Twinkies 상자는 1955 년 11 월 5 일에 만료되었습니다. 두 가지가 아니라 일부 옵션을 배제 할 수 있습니다. 그러나 두 자리 숫자 인 경우 50..99는 1950..1999를 의미하고 0..49는 2000..2049를 의미합니다.

귀하의 임무는 위의 해석 중 하나 이상에서 유효한 날짜 인 정수 배열을 가져 와서 여전히 좋은 기회를 출력하는 프로그램 또는 함수를 작성하는 것입니다. 퍼센트 확률은 단순히 오늘 날짜 이후 의 날짜에 대한 유효한 해석의 백분율입니다 .

정수 배열은 [Int]함수에 대한 인수 인 경우 언어의 길이가 3 인 언어 유형이며 STDIN에서 전체 프로그램. *

"오늘 날짜"는 날짜 함수를 통해 얻은 오늘의 실제 날짜이거나 STDIN의 함수 또는 추가 매개 변수에 대한 추가 인수에 지정된 날짜입니다. 그것은 유닉스 시대, 위의 세 가지 방법 중 하나에 입력 된 또 다른 년-월-일 트리플 또는 다른 편리한 방식 일 수 있습니다.

몇 가지 예를 들어 봅시다! 만료 날짜 입력은 대시로 구분 된 스타일이며 아래 예에서는 오늘 날짜가 2006 년 7 월 5 일이라고 가정합니다.

• 14-12-14-2014 년 12 월 14 일, 이에 대한 두 가지 유효한 해석 (DMY 및 YMD)은 동일합니다. 이 제품은 여전히 ​​우수하기 때문에 출력은 100 입니다.
• 8-2-2006-마지막 숫자는 1 년입니다. 4 자리 숫자이기 때문입니다. 2 월 8 일 (만료) 또는 8 월 2 일 (여전히 양호) 일 수 있습니다. 출력은 50 입니다.
• 6-7-5-뭐든지 될 수있어! "2006 년 7 월 5 일"해석은 여전히 ​​훌륭하지만 (하루 만), 나머지 2 개는 2005 년에 있으며 가능한 한 빨리 던져 져야합니다. 출력은 33 입니다.
• 6-5-7-여기서 3 가지 해석 중 2 가지가 안전합니다. 소수점을 반올림 또는 내림 할 수 있으므로 66 또는 67 이 모두 가능합니다.
• 12-31-99-이것은 세기의 전환기에 분명합니다 (50-99 년은 19XX이며 31은 한 달이 될 수 없습니다). 큰 지방 0 과 냉장고를 더 자주 청소해야합니다.

위의 표준을 충족하지 않는 입력은 위의 출력 규칙에 특권이 없다고 안전하게 가정 할 수 있습니다.

웹 요청이나 표준 허점이 없습니다. 날짜 처리 라이브러리가 허용됩니다. 이것은 코드 골프입니다. 가장 짧은 프로그램이 이길 수 있습니다.

* ^{brainfuck 또는 이와 유사한 데이터 형식을 사용하는 언어를 사용하는 경우 입력시 처음 세 문자의 ASCII 값이 날짜의 정수라고 가정 할 수 있습니다. 이것은 네 자리 연도 논리를 배제하지만, Brainfuck에서 이것에 대한 해결책을 보면 약간 놀랄 것입니다.}

k4 (90) (88) (87) (82)

{100*(+/~d<x)%3-+/^d:{"D"$"."/:$|z,y,x+(x<100)*100*19+x<50}.'y@/:3 3#.:'$21020101}

로 호출 x의 .z.D오늘과 비교, 또는 다른 선택의 리터럴 날짜 (A 내장) :

  f:{100*(+/~d<x)%3-+/^d:{"D"$"."/:$|z,y,x+(x<100)*100*19+x<50}.'y@/:3 3#.:'$21020101}
  .z.D f'(14 12 14;8 2 2006;6 7 5;6 5 7;12 31 99)
100 0 0 0 0f
  2006.07.05 f'(14 12 14;8 2 2006;6 7 5;6 5 7;12 31 99)
100 50 33.33333 66.66667 0

이것은 기본적으로 @ Alex-l의 Python 솔루션 포트이며 몇 가지 기타 골프 트릭이 추가되었습니다.

• 재 배열 명령어는 문자열로 인코딩되어 두 문자를 저장합니다.
• 조건부 논리 (ab)는 정수로 진리를 사용하지만 (파이썬 솔루션과는 다른 방식으로)
• 유효성 테스트는 약간 다릅니다. k4 / q는 모든 문자열을 모든 데이터 유형으로 행복하게 구문 분석합니다. 이해할 수 없으면 단순히 null을 반환합니다. 따라서 내부 함수에서 날짜 목록을 반환합니다.이 목록은 null이거나 null이 아닐 수 있습니다.
• 최종 결과는 몇 개의 가능한 날짜 해석이 널 (null)인지 비교하고 비교 날짜보다 적은 수를 확인하는 것입니다. 여기서 null 날짜는 다른 날짜보다 적은 것으로 간주됩니다.

루비, 115 자

f=->a,t{[a,a.rotate(~s=r=0),a.reverse].map{|x,*y|(t>Time.gm(x<100?x+2e3-100*x/=50:x,*y)||r+=100
s+=1)rescue p}
r/s}

f입력을 포함하는 배열과 "오늘"날짜의 두 가지 인수를 취하는 함수 를 정의 합니다.

예 :

f[[14,12,14], Time.new]
100
f[[8,2,2006], Time.new]
0
f[[8,2,2006], Time.new(2006, 7, 5)]
50
f[[6,7,5], Time.new(2006, 7, 5)]
33

파이썬 2.7-172

날짜 및 시간 비교를 위해 datetime 모듈을 사용합니다. 경우 date입력에서 유효한 날짜를 만들 수 없습니다, 그것은 발생합니다 ValueError. 이 방법 s은 만료되지 않은 날짜 t의 합계이며 유효한 총 날짜 수입니다. True == 1파이썬에서 추가 및 인덱싱을 목적으로 한다는 사실을 이용 하고 있습니다. 또한 (1900,2000) 대신 25 * (76,80)을 사용하여 문자를 저장합니다.

두 번째 들여 쓰기 수준의 줄은 공백이 아닌 탭 문자를 사용합니다.

def f(e,c,s=0,t=3):
 for Y,M,D in(0,1,2),(2,0,1),(2,1,0):
  y=e[Y]
  try:s+=date(y+25*[[76,80][y<50],0][y>99],e[M],e[D])>=c
  except:t-=1
 return 100*s/t

이것을 테스트 끝에 추가하십시오 :

examples = [[14,12,14],[8,2,2006],[6,7,5],[6,5,7],[12,31,99]]
for e in examples:
 print f(e, date(2006,7,5))

PowerShell, 183 173 168

[int](100*(($d=@(($a,$b,$c=$args[0]),($c,$a,$b),($c,$b,$a)|%{$_[0]+=1900*($_[0]-le99)+100*($_[0]-le49)
.{date($_-join'-')}2>$x}|sort -u))-ge(date)+'-1').Count/$d.Count)

• int[]매개 변수 를 통한 입력 ( 예 :

  PS> ./milk.ps1 5,6,7
  

• stderr의 출력 허용 여부를 모르는 한 try/ 를 통해 오류 메시지가 catch표시되지 않습니다.
• 현재 날짜를 하루로 이동하는 +"-1"것으로 해석되는 날짜를 사용하면 .AddDays(-1)어제와 비교할 수 있습니다 (오늘 대신). 이렇게하면 시간이 0:00 인 날짜를 얻을 수 있지만 오늘의 시간이있는 날짜와 비교해야하는 문제가 해결됩니다.
• 지금까지 많이 인라인
• 약간 더 짧은 오류 침묵을위한 새로운 트릭 사용

R, 269

나는 이것이 R에서 쉬울 것으로 기대했지만 한 자리 연도는 꽤 큰 곡선이었습니다. 나는 이것보다 훨씬 나을 수 있다고 생각합니다.

lubridateCRAN의 패키지이므로와 함께 설치해야합니다 install.packages("lubridate").

require(lubridate)
f = function(d){
d=sapply(d,function(l)if(nchar(l)==1)sprintf("%02d",l)else l)
d=paste0(d,collapse="-")
t=ymd(Sys.Date())
s=na.omit(c(ymd(d),mdy(d),dmy(d)))
s=lapply(s,function(d){
if(year(d)>2049){year(d)=year(d)-100;d}
else d})
sum(s>t)/length(s)}

사용법 : f(c(d1,d2,d3))어디 c(d1,d2,d3)정수의 벡터입니다.

예를 들어을 f(c(6,10,14))반환합니다 0.3333333.

lubridate패키지는 다른 순서의 날짜를 구문 분석에 대한 래퍼 일련의 기능을 가지고있다. 이 형식을 사용하여 유효한 날짜를 생성하는 형식을 확인하고 유효하지 않은 형식을 삭제 한 다음 아직 발생하지 않은 형식을 확인합니다.

매쓰, 163 (153) 164 바이트

( 편집 : 1950-2049 범위를 벗어난 고정 날짜)

f=100.Count[#,x_/;x<1]/Length@#&[DateDifference[#,Date[]]&/@Cases[{If[#<100,Mod[#+50,100]+1950,#],##2}&@@@{{##},{#3,#2,#},{#3,#,#2}}&@@#,d_/;DateList@d~Take~3==d]]&

이것은 당신이 호출 할 수있는 기능을 정의합니다

f[{6,7,5}]

현재 비율은 반올림되지 않습니다 (OP가 명확해질 때까지).

여기에 어떤 티카 지식 없이도 이해할 수 있어야한다 약간 긴 설명 (참고 인 &매개 변수 익명 함수라고 부릅니다 그것의 왼쪽에 모든 것을 만드는 #, #2, #3...)은 :

{{##},{#3,#2,#},{#3,#,#2}}&

이것은 3 개의 파라미터 a,b,c를 3 개의리스트로 바꾸는 함수를 정의 합니다 {{a,b,c},{c,b,a},{c,a,b}. 그주의 ##모든 매개 변수의 단지 순서입니다.

{{##},{#3,#2,#},{#3,#,#2}}&@@#

만료 날짜에 적용되면 {y,m,d}가능한 세 가지 순열 각각에 대한 목록이 제공 됩니다.

{If[#<100,Mod[#+50,100]+1950,#],##2}&

이 세 가지 매개 변수를 익명 함수 a,b,c첫 번째는 주어진 규칙에 따라 연간 변환 된 세 가지의 목록을 반환합니다 : 사이의 숫자 50와 99(모듈은 100) 사이에하는 20 세기 년에 번호를 설정되어 0및 49( 모듈로 100)는 21 세기로 바뀌고 다른 모든 것은 그대로 남아 있습니다. 다음 ##2은 두 번째 매개 변수로 시작하는 일련의 매개 변수 b,c입니다.

{If[#<100,Mod[#+50,100]+1950,#],##2}&@@@{{##},{#3,#2,#},{#3,#,#2}}&@@#

이전의 세 가지 결과 각각에 적용되는이 형식은 연도 형식 만 정규화합니다. 이것을 호출 canonicalDates하여 다음 표현을 줄이십시오.

Cases[canonicalDates,d_/;DateList@d~Take~3==d]

이것은 유효하지 않은 해석을 걸러냅니다. 다양한 날짜 형식을 DateList@d완벽하게 {y,m,d,h,m,s}표현합니다. 이 같은 순서로 목록을 해석하지만, 캐치는 것입니다 수 처럼 것들을 통과 {8,2,2006}가 계산되는 경우 8 years + 2 months + 2006 days. 따라서 반환 된 목록의 처음 세 요소가 입력과 동일한 지 확인합니다 (입력 범위가 월과 일인 경우에만 발생할 수 있음).

다음 줄을 줄이려면 validDates지금부터 해당 표현식의 결과를 참조하겠습니다 .

DateDifference[#,Date[]]&

날짜를 가져와 오늘의 차이를 오늘까지 반환하는 또 다른 익명 함수입니다 (에서 획득 함 Date[]).

DateDifference[#,Date[]]&/@validDates

유효한 날짜 해석에이를 맵핑하십시오.

100.Count[#,x_/;x<1]/Length@#&

리스트 ( #)가 주어진 다른 익명 함수 는 그리스트에서 양수가 아닌 숫자의 백분율을 반환합니다. (가) .결과로 유리수를 피하기 위해 곱셈 있었으나 결국 진수 아니다 (당신은 같은 것들을 얻을 것 100/3대신에 33.333- 그 문제의 경우 실제로 모른다).

100.Count[#,x_/;x<1]/Length@#&[DateDifference[#,Date[]]&/@validDates]

날짜 차이 목록에 적용하면 아직 만료되지 않은 일부 해석이 제공됩니다.

자바 스크립트 (E6) (159) 164 172

편집 덕분에 힌트에 대해 다시 생각하는 나를 밀어 위해 nderscore합니다. 매개 변수를 피하고 일부 문자를 자르는 D를 재구성했습니다.

편집 2 nderscore에 의한 또 다른 속임수, 2 개의 함수가 1로 병합되었습니다. 그런 다음 두 개의 괄호는 쉼표로 구분 된 표현식을 하나로 병합하지 않았습니다. 0 근처에서 가독성. 참고 : 반올림하지 않으면 다른 두 문자 (| 0)를 절약 할 수 있습니다.

F=(a,t)=>t?100*(3-((i=F([y,m,d]=a))<t)-((j=F([m,d,y]=a))<t)-((k=F([d,m]=a))<t))/(3-!i-!j-!k)|0:(q=new Date(y<50?y+2e3:y,--m,d)).getMonth()==m&q.getDate()==d&&q

FireFox 콘솔에서 테스트

;[[14,12,14],[8,2,2006],[6,7,5],[6,5,7],[12,31,99]]
.map(x=>x + ' ' + F(x, new Date(2006,6,5)))

산출:

["14,12,14 100", "8,2,2006 50", "6,7,5 33", "6,5,7 66", "12,31,99 0"]

언 골프

NB D 함수는 주어진 연도, 월, 일로 날짜를 작성하려고 시도하지만 작성된 날짜가 의도 한 날짜가 아닌 경우 (! = 일 또는 월) false를 리턴합니다.

F=(d,t)=>
(
  D=(y,m,d)=>(
    q=new Date(y<50?y+2000:y, --m, d), // decr m as javascript (like java) counts months starting at 0
    q.getMonth() == m & q.getDate() == d && q
  ),
  [a,b,c] = d, 
  x=D(...d), // three ways of express the date ...
  y=D(c,a,b),
  z=D(c,b,a),
  100 * (3-(x<t)-(y<t)-(z<t)) / (3-!x-!y-!z) | 0  
)   

LINQPad에서 C 번호 - 446 408 272 바이트

세 번째 편집 : DateTime.Now가 아니라 DateTime.Today가 정확하다는 점을 지적한 Le Canard fou에게 감사드립니다. 두 번째 편집 : 이 영리한 솔루션에 감사합니다 VisualMelon!

void g(int[]d){var p=".";int a=d[2],b=d[1],e=d[0],y=a+(a<100?a>49?1900:2000:0),q=0,s=0;DateTime c;Action<string>z=x=>{if(DateTime.TryParse(x,out c)){s++;if(c>=DateTime.Today)q+=100;}};z(e+p+b+p+y);z(b+p+e+p+y);z(a+p+b+p+(e<100?‌​e>49?1900+e:2000+e:e));(q/(s>0?s:1)).Dump();}

편집 : 코드를 단축시키는 데 도움을 준 podiluska와 edc65에게 감사드립니다! 또한 연도 입력 길이가 4 바이트 인 경우 솔루션이 올바르지 않은 것으로 나타 났으므로 해당 문제에 대한 수정 사항이 포함되었습니다. 이 솔루션의 점수는 408 바이트입니다.

이전 답변을 꺾지 않아도 C # 솔루션을 공유하고 싶었습니다. 도움이나 제안을 부탁드립니다! ;)

void g(int[]d){var q=new List<DateTime>();var p=".";int s=0,a=d[2],b=d[1],e=d[0],y=0;var c=new DateTime();y=(a<100)?(a>49)?1900+a:2000+a:a;if(DateTime.TryParse(e+p+b+p+y,out c)){q.Add(c);s++;}if(DateTime.TryParse(b+p+e+p+y,out c)){q.Add(c);s++;}y=(e<100)?(e>49)?1900+e:2000+e:e;if(DateTime.TryParse(a+p+b+p+y,out c)){q.Add(c);s++;}q=q.Where(i=>i>=DateTime.Now).ToList();if(s==0){s=1;}(q.Count*100/s).Dump();}

포맷 및 언 골프 버전 :

void g(int[] d)
    {
        var q = new List<DateTime>();
        var p = ".";
        int s = 0, a = d[2],b = d[1],e = d[0], y=0;
        var c = new DateTime();
        y = (a < 100) ?((a > 49) ? 1900 + a : 2000 + a) : a;

        if (DateTime.TryParse(e + p + b + p + y, out c))
        {
            q.Add(c);
            s++;
        }
        if (DateTime.TryParse(b + p + e + p + y, out c))
        {
            q.Add(c);
            s++;
        }
        y = (e < 100) ? ((e > 49) ? 1900 + e : 2000 + e) : e;

        if (DateTime.TryParse(a + p + b + p + y, out c))
        {
            q.Add(c);
            s++;
        }
        q = q.Where(i => i >= DateTime.Now).ToList();
        if (s == 0)
        {
            s = 1;
        }
        (q.Count*100/s).Dump();
    }

이 솔루션 에서처럼 "DateTime.TryParse"-Part가 반복되지 않는 솔루션을 만들려고했지만 21 바이트 더 길었습니다.

"DateTime.TryParse"를 반복하지 않는 솔루션 : 467 바이트

void g(int[]d){var q=new List<DateTime>();int s=0;int a=d[2];int b=d[1];int e=d[0];int y=0;if(a<100){if(a>49){y=1900+a;}else{y=2000+a;}}if(z(e,b,y,q)){s++;}if(z(b,e,y,q)){s++;}if(e<100){if(e>49){y=1900+e;}else{y=2000+e;}}if(z(a,b,y,q)){s++;}q=q.Where(i=>i>=DateTime.Now).ToList();if(s==0){s=1;}(q.Count*100/s).Dump();}bool z(int a,int b,int d,List<DateTime> q){var c=new DateTime();var p=".";if(DateTime.TryParse(a+p+b+p+d,out c)){q.Add(c);return true;}return false;}

언 골프 버전 :

private void g(int[] d)
    {
        var q = new List<DateTime>();
        int s = 0;
        int a = d[2];
        int b = d[1];
        int e = d[0];
        int y = 0;
        if (a < 100)
        {
            if (a > 49)
            {
                y = 1900 + a;
            }
            else
            {
                y = 2000 + a;
            }
        }
        if (z(e, b, y, q))
        {
            s++;
        }
        if (z(b, e, y, q))
        {
            s++;
        }
        if (e < 100)
        {
            if (e > 49)
            {
                y = 1900 + e;
            }
            else
            {
                y = 2000 + e;
            }
        }
        if (z(a, b, y, q))
        {
            s++;
        }
        q = q.Where(i => i >= DateTime.Now).ToList();
        if (s == 0)
        {
            s = 1;
        }
        (q.Count*100/s).Dump();
    }

    private bool z(int a, int b, int d, List<DateTime> q)
    {
        var c = new DateTime();
        string p = ".";
        if (DateTime.TryParse(a + p + b + p + d, out c))
        {
            q.Add(c);
            return true;
        }
        return false;
    }

하스켈, 171165 자

l=length
r y|y<100=(y+50)`mod`100+1950|y>0=y
q d m y z|d<32&&m<13&&d*m>0=(r y,m,d):z|1<3=z
v(a,b,c)=q c b a$q b a c$q a b c[]
t%d=(l$filter(>t)(v d))*100`div`l(v d)

함수의 이름은 %입니다. 실제 연도를 기준으로 정식 (y, m, d) 순서로 튜플로 테스트 날짜를 사용하고 세 숫자의 튜플로 카톤 스탬프를 실행하십시오.

λ: (2006,6,5)%(14,12,14)
100

λ: (2006,6,5)%(8,2,2006)
50

λ: (2006,6,5)%(6,7,5)
33

λ: (2006,6,5)%(6,5,7)
66

λ: (2006,6,5)%(12,31,99)
0

λ: (2006,6,5)%(0,1,7)
0

에를 랑, 146

f([A,B,C]=U,N)->F=[T||T<-[{(Y+50)rem 100+1950,M,D}||[Y,M,D]<-[U,[C,A,B],[C,B,A]]],calendar:valid_date(T)],100*length([1||T<-F,T>=N])div length(F).

테스트 기능은 다음과 같습니다.

t() ->
    0 = f([12,31,99],{2006,6,5}),
    66 = f([6,5,7],{2006,6,5}),
    33 = f([6,7,5],{2006,6,5}),
    100 = f([14,12,14],{2006,6,5}),
    50 = f([8,2,2006],{2006,6,5}),
    100 = f([29,2,2],{2006,6,5}).

언 골프

f([A,B,C]=U,Today)->
    Perms = [U,[C,A,B],[C,B,A]],
    WithYears = [{(Y+50) rem 100+1950,M,D} || [Y,M,D] <- Perms],
    ValidDates = [T || T <- WithYears, calendar:valid_date(T)],
    100*length([1 || T <- ValidDates, T >= Today]) div length(ValidDates).

이 솔루션은 목록 이해에 의존합니다. 그것은 Haskell 솔루션에서 일년 동안 모듈로 트릭을 빌립니다. 또한 calendar:valid_date/1주어진 월의 일 수 때문에 불가능한 날짜를 처리하는 데 사용 됩니다 (예 : "29-2-2"는 YMD 형식 일 수 있음). 또한 Today는 Erlang date()형식 (YMD 튜플)입니다.

APL (85)

이것은 Dyalog APL 14의 새로운 기능 중 일부를 사용하지만 외부 라이브러리는 사용하지 않습니다. 변경 사항은 TryAPL에서 작동합니다 .

{100×(+/÷⍴)⍺≤{(3/100)⊥⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵}¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵}

이 함수는 3 요소 배열을 오른쪽 ( ⍵) 인수로 사용하고 왼쪽 ( ⍺) 인수 로 검사 할 날짜를 YYYYMMDD형식 의 정수로 사용하는 함수 입니다. 즉, 날짜 2014-07-09는 숫자로 표시됩니다 20140709.

테스트:

      20060705 {100×(+/÷⍴)⍺≤{(3/100)⊥⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵}¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵} 14 12 14
100
      20060705 {100×(+/÷⍴)⍺≤{(3/100)⊥⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵}¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵} 8 2 2006
50
      20060705 {100×(+/÷⍴)⍺≤{(3/100)⊥⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵}¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵} 6 7 5
33.3333
      20060705 {100×(+/÷⍴)⍺≤{(3/100)⊥⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵}¨Z/⍨{∧/12 31≥1↓⍵}¨Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵} 12 31 99
0

설명:

• Z←(⊂⌽⍵),(⊂2⌽⍵),⊂⍵: 뒤집기 (⊂⌽⍵), 왼쪽으로 2 회전 (⊂2⌽⍵), 아무것도하지 않음 으로써 주어진 날짜를 YMD 형식으로 바꿉니다 ⊂⍵. 이 중 적어도 하나는 이제 YMD 형식의 올바른 날짜이며 날짜가 모호한 경우 둘 이상일 수 있습니다.
• {∧/12 31≥1↓⍵}¨Z: 각 날짜가 유효한지 테스트합니다. 연도 (첫 번째 요소)가 삭제 된 다음 달이 12보다 크지 않아야하고 일이 31보다 크지 않아야합니다.
• Z/⍨:에서 유효한 날짜를 필터링합니다 Z.
• {... }¨: 유효한 각 날짜에 대해 :
  • ⍵+(99≥⊃⍵)×3↑1900+100×50>⊃⍵: 연도가 99보다 높지 않으면 1900을 추가하고 연도가 50보다 작 으면 100을 추가하십시오.
  • (3/100)⊥: 기본 100 자리 숫자 인 것처럼 디코딩합니다. (연도는 100보다 높지만 첫 번째 요소이므로 중요하지 않습니다.) 이것은 왼쪽 인수와 동일한 형식으로 각 유효한 날짜에 숫자를 제공합니다.
• ⍺≤: 각 날짜에 대해보다 작지 않은지 확인하십시오 ⍺. 이것은 1을 의미 OK하고 0을 의미 하는 이진 벡터를 제공합니다 spoiled.
• 100×(+/÷⍴): 이진 벡터의 합을 길이로 나누고 100을 곱합니다.

Java : 349 자 (공백없이 3 자)

int e(int[]n,Date t){int a=n[0],b=n[1],c=n[2];Date[]d=new Date[3];if(b<13&&c<32)d[0]=new Date((a<50?100:(a>100?-1900:0))+a,b-1,c);if(b<13&&a<32)d[1]=new Date((c<50?100:(c>100?-1900:0))+c,b-1,a);if(a<13&&b<32)d[2]=new Date((c<50?100:(c>100?-1900:0))+c,a-1,b);int v=0,g=0;for(int i=0;i<3;i++)if(d[i]!=null){if(!d[i].before(t))g++;v++;}return 100*g/v;}

다음은 (약간) degolfed 메소드 버전을 포함하여 테스트에 사용할 수있는 포함 클래스입니다.

import java.util.*;
class i{

   int e(int[]n,Date t){
      int a=n[0],b=n[1],c=n[2];
      Date[]d=new Date[3];
      if(b<13&&c<32)d[0]=new Date((a<50?100:(a>100?-1900:0))+a,b-1,c);
      if(b<13&&a<32)d[1]=new Date((c<50?100:(c>100?-1900:0))+c,b-1,a);
      if(a<13&&b<32)d[2]=new Date((c<50?100:(c>100?-1900:0))+c,a-1,b);
      int v=0,g=0;
      for(int i=0;i<3;i++)
         if(d[i]!=null){
            if(!d[i].before(t))
               g++;
            v++;
         }
      return 100*g/v;}

   public static void main(String[] args){
      int[]i=new int[3];
      for(int k=0;k<3;k++)
         i[k] = Integer.parseInt(args[k]);
      int j = new i().e(i,new Date());
      System.out.println(j+"%");
   }   
}

이것은 나의 첫 번째 코드 골프이며, 나는 보통 많은 Java 골퍼를 보지 못하는 이유를 알아 낸 것 같습니다.

C # 287 바이트

namespace System{class E{static float a,o,l;void M(int[]i){int d=i[0],m=i[1],y=i[2],t;if(l<3)try{if(l==1){t=y;y=d;d=t;}if(l++==0){t=d;d=m;m=t;}if(y<100&&(y+=1900)<1950)y+=100;o+=new DateTime(y,m,d)>=DateTime.Today?1:0;a++;if(l<3)i[9]=9;}catch{M(i);throw;}Console.Write(o/a);}}}

처음 골프를 타면서 조언을 구합니다. 특히 네임 스페이스로 인해 바이트를 제거합니다.

실제 프로그램이 아니라 기능 만 필요하다는 사실을 남용합니다. 또한이 함수는 항상 포착되지 않은 예외를 발생시킵니다.

언 골프

namespace System {
    class E {
        static float a, o, l;
        void M(int[] i) {
            int d = i[0], m = i[1], y = i[2], t;
            if (l < 3)
                try {
                    if (l == 1) { 
                        t = y; y = d; d = t; 
                    } 
                    if (l++ == 0) { 
                        t = d; d = m; m = t; 
                    } 
                    if (y < 100 && (y += 1900) < 1950)
                        y += 100; 
                    o += new DateTime(y, m, d) >= DateTime.Today ? 1 : 0; // # not expired
                    a++; // # valid dates
                    if (l < 3)
                        i[9] = 9; // throw new Exception()
                } 
                catch { 
                    M(i);
                    throw; // fail after the first Console.Write()
                } 
            Console.Write(o / a); 
        } 
    } 
}

수학 , 118

m.buettner의 코드를 시작점으로 사용하여 몇 가지 개선 사항이 있습니다.

⌊100Mean@UnitStep@Cases[DateDifference@{If[#<100,Mod[#+50,100]+1950,#],##2}&@@@{#,RotateRight@#,Reverse@#},_Integer]⌋&