다섯 줄을 포함하는 함수를 작성하십시오.

함수를있는 그대로 실행하면 0을 반환해야합니다.

다섯 줄 중 하나를 제거하고 함수를 실행하면 어떤 줄이 제거되었는지 알려야합니다 (예 : 마지막 줄을 제거하면 5를 반환해야 함).

간결함, 참신함 및 우아함 모두 고려할 가치가 있습니다. (적당한 시간이 지난 후) 가장 높은 평가를받은 솔루션이 승리합니다.

루비

코드 골프가 아니기 때문에 마법의 숫자를 피하십시오.

def f
  r=2^3^4^5
  defined?(r) ? r^=2 : r=1^3^4^5
  r^=3
  r^=4
  r^=5
end

각 줄은에서 고유 번호를 제거 1^2^3^4^5합니다. 루비이므로 마지막 줄은 반환 값을 정의합니다.

자바 스크립트 ( 134   77   69   65   60 자)

→ 라이브 데모 ←

function(n){
a=n-=1
n-=2
+3
+4;if(this.a)return 5
return n;var a
}

이 함수를 n = 10으로 호출하십시오.

• 누락 된 행이 없으면 5 행은 n == 0을 반환합니다.
• 1 행이 없으면 5 행은 n == 1을 반환합니다.
• 2 행이 없으면 5 행은 n == 2를 반환합니다.
• 3 행이 없으면 5 행은 n == 3을 반환합니다.
• 4 행이 없으면 5 행은 n == 4를 반환합니다.
• 라인 5가 없으면 var "a"가 전역이되고 라인 4는 "5"를 반환하는 것을 감지합니다.
• 5 행이 있으면 JS 엔진은 "가변 호이 스팅"을 수행하고 "a"는 로컬 변수가되고 4 행은 "5"를 반환하지 않습니다.

이전 버전:

65 자

function(n){
a=n-=1
n-=2
+3
+4;if(this.a)return 5
n-=5;return n;var a
}

(n = 15로 호출해야 함)

69 자

function(n){
n-=1
n-=2
n-=3
a=n-=4;if(this.a)return 5
n-=5;return n;var a
}

(n = 15로 호출해야 함)

77 자

function(){
a=
b=
c=
d=1;if(this.a)return 5
1;var a,b,c,d;return d?c?b?a?0:1:2:3:4
}

134 자

function w(){
a=1;e=1;if(this.e)return 5
b=1;if(!a)return 1
c=1;if(!b)return 2
d=1;if(!c)return 3
var a,b,c,d,e;return d?0:4
}

골퍼가 아닌

  function whichlineisremoved(){
    /* 1 */ var a = 1; e = 1; if(window.e) return 5;
    /* 2 */ var b = 1, a; if(!a) return 1;
    /* 3 */ var c = 1, b; if(!b) return 2;
    /* 4 */ var d = 1, c; if(!c) return 3;
    /* 5 */ var e = 1, d; if(!d) return 4; return 0;
  }

파이썬

매개 변수가 허용되면 다음과 같이 작동합니다.

def f(n=10):
    n -= 1
    n -= 2
    n -= 3
    if n == 4: return 0 if f(7) else 5
    return n - 4 or 4

아르 자형

f <- function() {
  T <- FALSE
  F <- TRUE
  month.abb <- TRUE
  (pi <- 5)
  T + (!F) * 2 + (!isTRUE(month.abb)) * 3 + (pi != 5) * 4
}

이 함수는 내장 "상수"를 사용하고 각각에 다른 값을 할당합니다. 이러한 변수가 모두 새 값과 같으면 함수는 0을 반환합니다. 수학 연산자로 인해 논리 값이 숫자로 변환됩니다. 네 번째 줄 주위의 괄호를 사용하면 결과를 시각적으로 반환 할 수 있습니다 (마지막 명령 인 경우).

루아 5.2+

개행을 제외한 함수 본문에 55 자 나는 더 나은 것을 생각해 낼 수 없었습니다.

function f()
return 7--[[
return 1--[=[]]-2
--[[
-2--[=[]]
-5--]=]--]]-1
end

댓글 남용에 대한 추가 포인트를 원합니다 : P

5.1에서 작동하지 않는 이유는 중첩 [[]]이 제거되었으므로 5.1에서는 5.2처럼 무시하지 않고 컴파일 오류가 발생하기 때문입니다.

• 라인이 제거되지 않으면 함수 본문은 return 7-2-5
• 첫 번째 줄이 제거되면 return 1
• 두 번째 경우 return 7-5
• 세 번째 경우 return 7-2-2
• 네 번째라면 return 7-2-1
• 다섯 번째라면 return 7-2

루비

비트 단위 작업으로 시도한 다음 목록을 사용하는 훨씬 간단한 솔루션이 있음을 깨달았습니다! 이 과제는 Ruby와 같이 마지막으로 표시되는 값을 자동으로 반환하는 프로그래밍 언어를 사용하는 것이 가장 좋습니다.

def tellMe(x=[1,2,3,4,5])
    x.delete(1)
    x.delete(2)
    x.delete(3)
    x.delete(4);x[0]
    x.delete(5);x==[]?0:x[0]
end

Befunge에는 명시적인 함수가 없지만 다음은 Befunge에서 함수라고 부르는 것입니다.

v^    <
>v
1>v
 2>v
##3>5v
$0v4 >
>>>>>>^

첫 줄과 마지막 줄은 기능 시작과 기능 끝입니다. 가장 "반환"하는 것, 즉 올바른 값을 스택에 푸시합니다.

새로운 답변

다른 해결책을 찾았습니다. 너무 나쁘다, 나는 수학을 너무 좋아했다. 이 솔루션은 재귀와 전역 변수 (yuck!)를 사용하여 모든 줄이 실행되었는지 여부를 알려줍니다. 다른 솔루션과 다른 것을 원했기 때문에 이것은 우아하지 않지만 제대로 작동합니다. :)

PHP

function LOL($a) {
    if (!$a) { LOL(true); if (!$GLOBALS['b']) return 2; if (!$GLOBALS['c']) return 3; if (!$GLOBALS['d']) return 4; if (!$GLOBALS['e']) return 5; return 0; } 
    if ($a) $GLOBALS['b'] = true; else return 1;
    $GLOBALS['c'] = true;
    $GLOBALS['d'] = true;
    $GLOBALS['e'] = true;
}

나는이 도전을 정말로 즐겼습니다. 감사합니다! :)

기존 답변

나는 수학을 사용하여 그것을 해결했다. 각 변수를 알 수없는 것으로 보았고 한 줄에 하나씩 선언하면 5 개의 알 수없는 코드와 5 개의 코드 줄이 있습니다. 이렇게하면 다음 5x5 시스템으로 연결됩니다.

b+c+d+e = 1;
a+c+d+e = 2;
a+b+d+e = 3;
a+b+c+e = 4;
a+b+c+d = 5;
//Solutions are displayed in the code below.

일단 값을 찾으면 하드 코딩하고 몇 가지 기본 사항을 추가했습니다.

PHP

function LOL(){
    $a = 2.75;
    $b = 1.75;
    $c = 0.75;
    $d = -0.25; if ($a+$b+$c+$d == 5) return $a+$b+$c+$d;
    $e = -1.25; return $a+$b+$c+$d+$e;
}

참고 : 기존 답변은 그대로두면 작동하지 않습니다.

밀랍 , 86 바이트

내가 처음 발명 한 esolang을 시험해보기. 초기 혼란 후 솔루션이 너무 간단하다는 것을 알았습니다.

_1 p
_^v>~2+p
   >   >~3+p
       >   >~4+X@7~8+~@$^^{;
           >    >~5+@7~8+~@${;

설명:

밀랍 프로그램은 2D 육각형 격자에서 작동합니다. 프로그램은 직사각형 형식으로 저장됩니다.

    a — b — c — d
   / \ / \ / \ /
  e — f — g — h
 / \ / \ / \ /
i — j — k — l

로 저장

abcd
efgh
ijkl

특정 방향으로 이동하기위한 지침은 다음과 같습니다.

    b — d 
   / \ / \                                  bd
  < —IP — >    or in compact form (β=IP):   <β>
   \ / \ /                                   pq
    p — q

간단한 설명

_1 p IP를 작성하고 1을 추가 한 다음 IP를 2 행으로 경로 재 지정

_^v>~2+p 1 행이 누락 된 경우를 대비하여 다른 IP를 작성하고 IP를 느리게하여 1 행의 IP가 앞서 있는지 확인한 다음 2를 추가 한 후 3 행으로 경로 재 지정하십시오.

> >~3+p 3을 추가 한 다음 4 행으로 리디렉션

> >~4+X@7~8+~@$^^{; 4를 추가 한 다음 2nd lstack 값을 15로 설정 한 다음 XOR lstack top 및 2nd 값을 설정하고 IP를 느리게하여 (라인 5가 존재하는 경우 5 행의 IP가 앞서 있는지 확인) 결과를 출력 한 다음 프로그램을 종료하십시오.

> >~5+@7~8+~@${; 5를 더한 다음 속도 저하를 제외하고 4 행에서와 동일하게 수행하십시오.

기본적으로 프로그램은 합계 xor 15를 계산합니다.

• 그대로 프로그램 : (1 + 2 + 3 + 4 + 5) xor 15 = 0
• 1 행 누락 : (2 + 3 + 4 + 5) xor 15 = 1
• 2 행 누락 : (1 + 3 + 4 + 5) xor 15 = 2
• 3 행 누락 : (1 + 2 + 4 + 5) xor 15 = 3
• 4 행 누락 : (1 + 2 + 3 + 5) xor 15 = 4
• 5 행 누락 : (1 + 2 + 3 + 4) xor 15 = 5

>3 행에서 5 행 의 추가 는 2 행에서 4 행 중 하나가 누락 된 경우에도 IP가 여전히 올바르게 재 지정되고 프로그램을 떠나지 않는다는 것을 보증합니다.

내 GitHub 저장소 에서 Julia로 작성된 밀랍 통역사를 복제 할 수 있습니다

GitHub의 readme는 esolangs 페이지보다 최신 상태이며 더 잘 구성되어 있습니다.

MuPAD, 57 자

subs(()->
-d(1)
-d(2)
-d(3)
-d(4)
-d(5)
,d=Dom::IntegerMod(15))

일반적인 LISP :

(defun which-line-is-removed (&aux (x 30)) 
  (decf x 2)
  (decf x 4)
  (decf x 8)
  (decf x 16) 5
  (if (zerop x) 0 (log x 2))
)

주의 : 그 자체가 줄에 괄호를 종료하는 것은 나쁜 스타일로 간주하지만, 다른 언어 때문에이 갖는 end그리고 }나는 그것이 허용되는 가정합니다.

배쉬, 131 자

#!/bin/bash

# the function:
function f(){
  a=1;
  b=2;
  c=3;
  d=4;[ ! $1 ]&&f 1&&return 5||true
  [ $1 ]&&return 6;e=5;s=$((a+b+c+d+e));return $((15-$s))
}

# call it:
f
# report the result:
echo Removed line $?

모두 5 행까지 간단합니다. 그런 다음 마지막 행이 사라 졌는지 감지해야합니다. 이것은 5 번째 줄에서 실패하라는 지시를받을 때 자체 성공 값을 테스트하기 위해 한 번만 재귀 적으로 호출함으로써 허용 된 함수 매개 변수를 이용하며, 5 번째 줄이 제거되면 4 번째 줄이 5대신 반환 됩니다.

(참고 : 기능 이외의 모든 것을 제거하고 공백을 버리고 / bin / bash를 / bin / sh로 변경하면 최소 131 자입니다)

자바 스크립트

function(){
/*aa*/if(arguments.callee.toString().indexOf("*"+"a".repeat(6)+"*")==-1)return 5;
/*aaa*/if(arguments.callee.toString().indexOf("*"+"a".repeat(5)+"*")==-1)return 4;
/*aaaa*/if(arguments.callee.toString().indexOf("*"+"a".repeat(3)+"*")==-1)return 2;
/*aaaaa*/if(arguments.callee.toString().indexOf("*"+"a".repeat(4)+"*")==-1)return 3;
/*aaaaaa*/return +!~arguments.callee.toString().indexOf("*"+"a".repeat(2)+"*");
};