Encontre um ponto fixo


24

Dado um número inteiro e alguma função de caixa preta, encontre um ponto fixo de na sequência definida por .x1 f: ℤ → ℤfxk+1 := f(xk)

Detalhes

  • Um valor xé considerado um ponto fixo de fse x = f(x).

    Por exemplo, se f(x) := round(x/pi)e temos um ponto de partida , obtemos , então , então e finalmente, o que significa que a submissão deve retornar .x1 = 10x2 = f(x1) = f(10) = 3x3 = f(x2) = f(3) = 1x4 = f(x3) = f(1) = 0x5 = f(x4) = f(0) = 00

  • Você pode assumir que a sequência gerada realmente contém um ponto fixo.
  • Você pode usar o tipo nativo para números inteiros no lugar de .
  • Você pode usar qualquer idioma para o qual há padrões para as funções de caixa preta inseridas na meta post de E / S padrão . Se não houver esse padrão para o seu idioma, adicione um no sentido da definição de funções da caixa preta e certifique-se de vincular suas propostas nessa definição. Também não se esqueça de votar neles.

Exemplos

f(x) = floor(sqrt(abs(x)))
0 -> 0,  all other numbers -> 1

f(x) = c(c(c(x))) where c(x) = x/2 if x is even; 3*x+1 otherwise
all positive numbers should result in 1,2 or 4 (Collatz conjecture)

f(x) = -42
all numbers -> -42

f(x) = 2 - x
1 -> 1

Observe que, embora esteja implícito nos detalhes que a função de caixa preta convergirá no ponto fixo, o último exemplo diz o contrário
phflack

11
@phflack A caixa preta só precisa convergir para a entrada especificada.
flawr

Oh, originalmente eu pensei que a submissão não é dada x_0, o que me causou alguma confusão. Eu pensei que uma solução deveria ser (Jelly) ~Nƭ⁻Ç$¿, que é algo como, (pseudo código) for x in [0, -1, 1, -2, 2, -3, 3, -4, 4, ...]: if (x == f(x)): break; print(x); . Isso pode valer outro desafio.
user202729

11
Nota para futuros visitantes: encontrar um ponto fixo não funciona, você deve encontrar um ponto fixo acessível a partir de x_0. É garantido que existe um.
User202729

E se não existir um ponto fixo, para uma função f, e um valor inicial x0 ... Qual deve ser o valor que ela deve retornar? E se x0 = 0 ef = int (9 / (x-1)) com for x1 = x0 + 1 f (x1) = f (1) já é um erro ... O que deve retornar o operador para esse f, x0?
RosLuP

Respostas:


16

Na verdade , 1 byte

Y

Experimente online!

Yé a função de ponto fixo em Na verdade. No exemplo do TIO, a função é mostrada como uma sequência e £é usada para transformá-la em uma função na pilha. Também é possível simplesmente empurrar a função para a pilha dessa maneira . Estas são as únicas duas maneiras de obter uma entrada de função no Actually.


7
Você sabia que algum dia esse desafio seria lançado, não é? : P
Erik the Outgolfer

2
@EriktheOutgolfer Na verdade, eu usei Ypara vários desafios. Eu sou aparentemente extremamente precognitivo : P
Mego 08/12

11

APL (Dyalog) , 2 bytes

⍣=

Experimente online!

NB: Eu defino O←⍣=na seção de entrada devido a um erro em que os operadores monádicos derivados não podem ser definidos da maneira que o TIO gosta de definir.

É um operador que pode ser usado como (function⍣condition) ⍵

Aplica-se a function, fpara até (f ⍵) condition ⍵retornos verdade.

⍣=é um operador monádico derivado que assume uma função monádica f, como argumento à esquerda e a aplica ao argumento à direita , atéf ⍵ = ⍵


Talvez observe que ⍣=é um operador monádico derivado que assume uma função como operando esquerdo e encontra o ponto de correção no valor inicial fornecido. Gostaria de usar uma letra diferente para ⍣=que f, uma vez que é um o perator, não uma f unção.
Adám

Sim. Eu gostaria. É confuso que você chame a função "input" fem sua descrição, mas no TIO fé seu operador de solução. Você também pode mover a O←⍣=seta para cima no campo Código para permitir que seja contada e apontar que essa é a solução real e que o restante (Entrada) está apenas testando-a.
Adám

Parece um bug para mim. Amanhã falarei com um colega relevante.
Adám

@ Adám Updated. Deixe-me saber se o bug fica fixo
H.PWiz

10

Haskell, 17 bytes

until=<<((==)=<<)

Experimente online!


3
Caso alguém esteja interessado: aqui está uma explicação do porquê de until=<<((==)=<<) encontrar um ponto de correção para uma determinada função.
Laikoni

9

MATLAB , 41 bytes

function x=g(f,x);while f(x)-x;x=f(x);end

Há também essa beleza que não precisa de arquivos de função. Infelizmente, é um pouco mais longo:

i=@(p,c)c{2-p}();g=@(g,f,x)i(f(x)==x,{@()x,@()g(g,f,f(x))});q=@(f,x)g(g,f,x)

Experimente online!


7
Esta resposta foi usada como exemplo e não impede que alguém responda.
flawr

Obviamente, se você chamou isso de oitava, poderá remover dois ;s. Experimente online! .
Sanchises

E na sua função anônima, você pode remover o @()antes xpor 50 bytes. Parabéns também pela forma como você agrupa sua função auxiliar (com a g(g)no final), eu só consegui fazer 51 bytes @(g,x)(f=@(r,z){@()r(r,m),z}{(m=g(z)==z)+1}())(f,x). Gostaria de saber se existe alguma combinação das duas abordagens mais curta ainda.
Sanchises

6

ML padrão (MLton) , 30 bytes

fun& $g=if$ =g$then$else&(g$)g

Experimente online! Use como & n blackbox.

As funções da caixa preta são definidas da seguinte maneira:

fun blackbox1 x = floor(Math.sqrt(Real.fromInt(abs x)))

fun blackbox2 x = c(c(c(x))) 
and c x = if x mod 2 = 0 then x div 2 else 3*x+1

fun blackbox3 _ = ~42

fun blackbox4 x = 2-x

Versão não destruída:

fun fixpoint n g = if n = g n then n else fixpoint (g n) g

11
É bom ver o SML em estado selvagem! Nós o usamos para nossa aula de programação funcional em nossa universidade.
vijrox



4

Python 2 , 39 37 33 bytes

graças a @ Mr.Xcoder por -2 bytes

s=lambda k:s(f(k))if k-f(k)else k

Experimente online!

assume que a função de caixa preta seja nomeada f


A função não precisa ser passada como parâmetro? Não acho que variáveis ​​predefinidas sejam um método de entrada aceito.
mbomb007

Não tenho certeza de que você possa assumir que a função é f, não é que uma forma de assumir que a entrada está em uma variável? (edit: ninja'd por mbomb)
FlipTack



4

Gelatina , 3 bytes

vÐL

Experimente online!

Aceita o argumento esquerdo como uma string que representa um link Jelly ( 2_por exemplo) e o argumento direito como um número inteiro

Como funciona

 ÐL - While the output is unique...
v   -   Evaluate the function with the argument given

4

Flak cerebral , 24 bytes

(()){{}(({})<>[({})])}{}

Experimente online!

(para a função caixa preta x -> 2-xno exemplo abaixo)

A função de caixa preta fornecida deve ser um programa que, fornecido xna parte superior da pilha, pop xe push f(x)-in, ou seja, deve avaliar a função fno valor na parte superior da pilha.

Mini-Flak equivalente é de 26 bytes (graças ao Assistente de Trigo por salvar 2 bytes):

(()){{}(({})( )[{}({})])}{}
             ^ put the function f here

(sem contar os comentários e os espaços)

Pegue a função (dentro da <>) e um número da entrada. (observe que Brain-Flak é uma linguagem esotérica e não pode receber argumentos funcionais como entrada)x0


Exemplo de funções de caixa preta:

x -> 2-x: Experimente online!


Explicação:


(()){{}(({})<f>[({})])}{}   Main program.
                            Implicit input from stdin to stack.
(  )                        Push
 ()                         literal number 1.
                            Now the content of the stack: [1, x0]
    {                 }     While stack top ≠ 0:
                            current stack content: [something ≠ 0, x]
     {}                       Pop stack top (something). stack = [x]
       (             )        Push
        ({})                    Stack top = x. Current stack = [x]
             f                  Evaluate f. Current stack = [f(x)]
            < >                   (suppress the value of f(x), avoid adding it)
               [    ]           plus the negative of
                ({})            the top of the stack ( = -f(x) )
                              In conclusion, this change (x) on the stack to
                              (f(x)), and then push (x + -f(x))
                            If it's 0, break loop, else continue.
                       {}   Pop the redundant 0 on the top.
                            Implicit output stack value to stdout.


3

Rápido , 47 42 bytes

func h(_ n:Int){f(n)==n ?print(n):h(f(n))}

Abordagem ingênua, assume que a função caixa preta é denominada f


Estou em dúvida sobre sua segunda tentativa, porque é um fechamento complexo e seu tipo é ambíguo, a menos que você o faça explicitamente {...}as(<parameter types>)-><return type>. Se você não especificar seu tipo de retorno, ele lançará erros no tempo de compilação, então não acho que seja válido a partir de agora (observe que a conversão deve ser incluída na contagem de bytes). Sua primeira submissão é boa, no entanto.
Mr. Xcoder

2

C (gcc) , 40 bytes

f(n,b)int(*b)(_);{n=n^b(n)?f(b(n),b):n;}

Experimente online!Observe que os sinalizadores não são necessários, eles estão lá para ajudar no teste da função de ponto de correção definida acima.

Esta é uma função que recebe um int ne um ponteiro de função b : int → int. Abusar do fato de que gravar no primeiro argumento da variável define o eaxregistro, o que equivale a retornar . Caso contrário, isso é bastante padrão no que diz respeito ao golfe C. n^b(n)verifica a desigualdade ne a caixa preta aplicada a n. Quando desigual, chama a função de ponto fixo fnovamente recursivamente com o aplicativo e a caixa preta como argumentos. Caso contrário, ele retornará o ponto de correção.

† Citação necessária, lembro-me vagamente de ler isso em algum lugar e o Google parece confirmar minhas suspeitas

Ele declara a entrada com a digitação de parâmetros no estilo K & R:

f(n, b)
int(*b)(_);
{
    n=n^b(n)?f(b(n),b):n;
}

O bit arcano na segunda linha acima declara bser um ponteiro de função que aceita um parâmetro inteiro - o tipo padrão de _é assumido como um número inteiro. Da mesma forma, né considerado um número inteiro e fé retornado um número inteiro. Viva a digitação implícita?


2

Limpo , 46 bytes

import StdEnv
p x=hd[n\\n<-iterate f x|f n==n]

Assume que a função está definida como f :: !Int -> Int

Leva a cabeça da lista infinita de aplicativos f f f ... xfiltrados para os elementos em que f el == el.

Experimente online!

Se você deseja alterar a função no TIO, a sintaxe lambda do Clean é:

\argument = expression

(na verdade, é muito mais complicado, mas felizmente precisamos apenas de funções unárias)


2

APL (Dyalog Unicode) , 14 bytes

{⍵=⍺⍺⍵:⍵⋄∇⍺⍺⍵}

Experimente online!

A função no cabeçalho é equivalente a f(x) = floor(sqrt(abs(x)))

Obrigado @ Adám por apontar que a resposta original não era válida de acordo com o consenso do PPCG.

Como funciona:

{⍵=⍺⍺⍵:⍵⋄∇⍺⍺⍵}  Main 'function' (this is actually an operator)
      :          if
 ⍵=⍺⍺⍵           the right argument (⍵) = the left function (⍺⍺, which is f) of 
                return 
                else
         ∇⍺⍺⍵    return this function (∇) with argument f(⍵)

{⍵ = f⍵: ⍵⋄∇ (f⍵)} seria ok para função anônima separado do seu nome (n)
RosLuP

2
Isso assume que fé pré-atribuído, o que eu acho que é proibido pelo consenso do PPCG. {⍵=⍺⍺⍵:⍵⋄∇⍺⍺⍵}seria uma solução de operador válida.
Adám



1

Adiante (gforth), 36 bytes

Esta versão assume apenas que fé predefinida. Não é tão legal quanto a solução abaixo dela. Ambos os programas são encerrados com um estouro de pilha, se não encontrado, ou um estouro de pilha, se encontrado (após a impressão do resultado).

Experimente online

: g dup f over = IF . THEN recurse ;

Quarto (gforth), 52 bytes

Isso permite que o token de execução de uma função seja transmitido como parâmetro e é definitivamente a solução mais legal.

: g 2dup execute rot over = IF . THEN swap recurse ;

Experimente online

Explicação:

: g             \ x1 f          Define g. Params on the stack. f is on top
2dup execute    \ x1 f x2       duplicate both params, execute f(x1)
rot over        \ f x2 x1 x2    move x1 to top and copy x2 to top
= IF . THEN                     compare, if equal, print
swap recurse ;                  otherwise, recurse


1

repl do tinylisp , 28 bytes

(d P(q((x)(i(e(f x)x)x(P(f x

Assume que a função f é predefinida.

Experimente online! (A função de exemplo é f(x) = (x*2) mod 10.)

Ungolfed

(load library)
(def P
 (lambda (x)
  (if (equal? (f x) x)
   x
   (P (f x)))))

Se for f(x)igual x, então xé um ponto fixo; devolver. Caso contrário, procure recursivamente um ponto fixo iniciando em f(x)vez de x.


1

APL NARS 65 caracteres

r←(f v)n;c
   c←0⋄→B
E: r←∞⋄→0
A: n←r
B: r←f n⋄c+←1⋄→E×⍳c>1e3⋄→A×⍳r≠n

v O operador retornaria ∞ (ou possivelmente -oo ou Nan) por erro, senão um valor x com x = f (x). No teste f = piso (sqrt (abs (x))), f1 = 2-x, f2 = c (c (c (x))) com c = x% 2 == 0? X / 2: 3 * x +1

  f←⌊∘√∘|
  f v 0
0
  f v 9
1
  f1←{2-⍵}
  f1 v 1
1
  f1 v ¯10
∞
  f1 v 2
∞
  c1←{0=2∣⍵:⍵÷2⋄1+3×⍵}
  f2←c1∘c1∘c1
  f2 v 1
1
  f2 v 2
2
  f2 v 7
2
  f2 v 82
4

1

Clojure, 45 43 bytes

Bem, este é o mais curto e mais feio:

#(loop[a + b %2](if(= a b)a(recur b(% b))))

+ existe em vez de um número para que não seja igual a qualquer valor de x0 .

55 bytes e funcional:

#(reduce(fn[a b](if(= a b)(reduced a)b))(iterate % %2))

Exemplo:

(def f #(...))
(defn collaz [x] (if (even? x) (-> x (/ 2)) (-> x (* 3) (+ 1))))
(f (->> collaz (repeat 3) (apply comp)) 125)
; 1

1

x86 opcode, 8 bytes

fun:
        call    edx          ; 2B
        cmpxchg eax,    ecx  ; 3B, on 8086 use xchg and cmp instead
        jnz     fun          ; 2B
        ret                  ; 1B

Receber entrada: ecx(valor ), (endereço da função, receber entrada , gravar resultado sem modificar o valor de e )x0edxecxeaxecxedx

8086 opcode, 7 bytes (mas lento)

    xor     cx,     cx
    call    dx
    loop    $-2
    ret

Se existe um ponto fixo, o loop 65536 vezes sempre o leva até lá.
Receber entrada: ax(valor inicial ), (endereço da função, receber entrada , gravar saída sem modificar o valor de e ). Emita o ponto fixo no registro .x0dxaxaxcxdx
ax


Certamente ajudaria se você tornasse a resposta mais legível.
user202729

mais editar para corrigi-lo
l4m2


0

Java 8, 42 bytes

Isso pega um Function<Integer, Integer>ou IntFunction<Integer>e um intou Integer(com curry) e retorna o ponto fixo.

f->i->{while(i!=(i=f.apply(i)));return i;}

Experimente Online

Aproveita o fato de o Java avaliar subexpressões da esquerda para a direita (para que o antigo iseja comparado ao novo), uma propriedade que eu desconhecia ao escrever isso!

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.