Escreva uma função que informe quais linhas foram removidas


28

Escreva uma função que contenha cinco linhas.

Se você executar a função como ela é, ela deve retornar 0.

Se você remover qualquer uma das cinco linhas e executar a função, deverá informar qual das linhas foi removida (por exemplo, se você remover a linha final, ela retornará 5).

Brevidade, novidade e elegância merecem consideração. A solução mais votada (após um período de tempo razoável) vence.


4
A função pode assumir um parâmetro?
Jeremy

6
A declaração da função conta como uma das linhas se queremos usar esse tipo de linguagem ou apenas o corpo é contado?
meiamsome 28/12/13

1
Além disso, nossas linhas precisam ser numeradas 1, 2, 3, 4, 5 ou é permitido algum esquema de numeração?
meiamsome 28/12/13

@ Jeremy, sim, tudo bem.
jawns317

@meiamsome, apenas o corpo conta e as linhas devem ser numeradas 1, 2, 3, 4, 5 para fins de valores de retorno.
jawns317

Respostas:


18

Rubi

Evitando números mágicos, pois não é um código de golfe.

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

Cada linha retira seu próprio número 1^2^3^4^5. É Ruby, então a última linha define o valor de retorno.


13

JavaScript ( 134   77   69   65   60 caracteres)

→ demonstração ao vivo ←

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

chame esta função com n = 10.

  • Se nenhuma linha estiver faltando, a linha 5 retornará n == 0.
  • Se a linha 1 estiver ausente, a linha 5 retornará n == 1.
  • Se a linha 2 estiver ausente, a linha 5 retornará n == 2.
  • Se a linha 3 estiver ausente, a linha 5 retornará n == 3.
  • Se a linha 4 estiver ausente, a linha 5 retornará n == 4.
  • Se a linha 5 estiver ausente, o var "a" se tornará global e a linha 4 detectará que retornará "5".
  • Se a linha 5 estiver presente, o mecanismo JS executará "içamento variável", "a" se tornará uma var local e a linha 4 não retornará "5".



Versões prévias:

65 caracteres

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

(deve ser chamado com n = 15)

69 caracteres

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

(deve ser chamado com n = 15)

77 caracteres

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 caracteres

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
}

sem golfe

  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;
  }

O que exatamente o var adepois do returnfazer? Em teoria, não deve ser alcançado.
Braden Best

@B1KMusic, in fact it is "reached" due to something called JavaScript variable hoisting. When JS is "compiled", all the "var" declarations are virtually placed at the beginning of the functions in which they are.
xem

Hmm, isso é estranho. Existe um uso prático para isso no idioma, ou isso é apenas uma exploração / golfe? Não me lembro de ler nada sobre elevação variável na documentação do Mozilla.
Braden Best


Ah, então é mais uma façanha para o golfe.
Braden Best

6

Python

Se parâmetros forem permitidos, isso funcionará:

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

4

R

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

A função usa "constantes" internas e atribui outro valor a cada uma delas. Se todas essas variáveis ​​forem iguais ao novo valor, a função retornará 0. Os valores lógicos serão transformados em valores numéricos devido aos operadores matemáticos. Os parênteses em torno da quarta linha permitem retornar visivelmente o resultado (se for o último comando).


3

Lua 5.2+

55 caracteres no corpo da função, excluindo novas linhas. Eu não poderia pensar em nada melhor, mas isso:

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

Na esperança de obter pontos extras por abuso de comentários: P

O motivo pelo qual não funciona no 5.1 é que os aninhados [[]]foram removidos e no 5.1 ele gera um erro de compilação em vez de ignorá-lo, como o 5.2.

  • Se nenhuma das linhas for removida, o corpo da função é equivalente a return 7-2-5
  • Se a primeira linha for removida, return 1
  • Se o segundo, return 7-5
  • Se o terceiro, return 7-2-2
  • Se o quarto, return 7-2-1
  • Se o quinto, return 7-2

2

Rubi

Tentei fazê-lo com operações bit a bit e então percebi que há uma solução muito mais simples usando listas! Esse desafio é melhor atendido por uma linguagem de programação que retorna automaticamente o último valor que vê, como 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

2

O Befunge não possui funções explícitas, mas aqui está o que eu chamaria de função no Befunge:

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

A primeira e a última linha são o início e o término da função. Faz a coisa mais próxima de "retornar", ou seja, coloca o valor correto na pilha.


1

Nova resposta

Encontrei outra solução. Isso é tão ruim, eu gostei muito da matemática. Essa solução usa variáveis ​​globais e de recursão (eca!) Para saber se todas as linhas foram executadas ou não. Eu queria fazer algo diferente das outras soluções, então isso não é muito elegante, mas funciona corretamente :)

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;
}

Eu realmente gostei deste desafio, obrigado! :)


Resposta antiga

Eu resolvi isso usando matemática. Se cada variável é vista como desconhecida e fazemos uma declaração por linha, há cinco desconhecidas e cinco linhas de código: isso nos leva ao seguinte sistema 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.

Depois de encontrar os valores, codifiquei-os e adicionei algumas coisas básicas.

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;
}

Nota: A resposta antiga não funcionará se for deixada como está.


Eu gosto da idéia do sistema de equações lineares.
ML

1

cera de abelha , 86 bytes

Experimentando meu primeiro esolang inventado. Após confusão inicial, descobri que a solução é muito simples.

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

Explicação:

programas de cera de abelha trabalham em uma grade hexagonal 2D. Os programas são armazenados em um formato retangular.

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

é armazenado como

abcd
efgh
ijkl

As instruções para se mover em determinadas direções são:

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

Breve explicação

_1 p Crie um IP, adicione 1 e redirecione o IP para a linha 2

_^v>~2+p Crie outro IP, caso a linha 1 esteja ausente, diminua a velocidade do IP para garantir que o IP da linha um esteja à frente, adicione 2 e redirecione para a linha 3

> >~3+p Adicione 3 e redirecione para a linha 4

> >~4+X@7~8+~@$^^{; Adicione 4, defina o 2º valor do lstack como 15 e, em seguida, o XOR lstack top e o 2º, reduza a velocidade do IP (para garantir que o IP na linha 5 esteja à frente, se a linha 5 existir) e emita o resultado e encerre o programa.

> >~5+@7~8+~@${; Adicione 5 e faça o mesmo que na linha 4, exceto a desaceleração.

Basicamente, o programa apenas calcula uma soma xor 15

  • Programa intacto: (1 + 2 + 3 + 4 + 5) xor 15 = 0
  • Linha 1 ausente: (2 + 3 + 4 + 5) xor 15 = 1
  • Linha 2 ausente: (1 + 3 + 4 + 5) xor 15 = 2
  • Linha 3 ausente: (1 + 2 + 4 + 5) xor 15 = 3
  • Linha 4 ausente: (1 + 2 + 3 + 5) xor 15 = 4
  • Linha 5 ausente: (1 + 2 + 3 + 4) xor 15 = 5

O adicional >nas linhas 3 a 5 apenas garante que, se uma das linhas 2 a 4 estiver ausente, o IP ainda será redirecionado corretamente e não sairá do programa.

Você pode clonar meu intérprete de cera de abelha, escrito em Julia, no meu repositório GitHub

O leia-me no GitHub é mais atualizado e melhor estruturado que a página esolangs.



0

LISP comum:

(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))
)

NB: Ter parênteses finais em sua própria linha é considerado um estilo ruim, mas como outros idiomas têm ende }eu presumo que seja permitido.


0

Bash, 131 caracteres

#!/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 $?

Tudo é direto até a linha 5. Em seguida, ele precisa detectar se a linha final se foi. Isso tira proveito dos parâmetros de função permitidos, chamando a si próprio recursivamente, uma vez, para testar seu próprio valor de sucesso quando é instruído a falhar na linha 5 e, se a linha 5 for removida, a linha 4 retornará 5.

(Nota: o limite é de no mínimo 131 caracteres, se você retirar tudo, menos a função, deixar espaço em branco e alterar / bin / bash para / bin / sh)


0

Javascript

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)+"*");
};
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.