Número em Número ao quadrado

13

Considere uma sequência de números naturais para a qual N aparece como uma substring em N ^ 2. A018834

Saída do n th th elemento desta sequência.

Regras

O programa recebe apenas ncomo entrada e gera apenas um número -N .

A sequência pode ser indexada em 0 ou 1.

Sequence: 1 5 6 10 25 50 60 76 100 250 376 500 600 625 760 ...
Squares:  1 25 36 100 625 2500 3600 5776 10000 62500 141376 250000 360000 390625 577600 ...

Isso é código-golfe, então o código mais curto vence.

code-golf  sequence 
— Vedant Kandoi
fonte
1
Muitas implementações terão problemas (para mim, devido à impossibilidade de criar matrizes com mais de 2 ^ 32 valores), o que tornará a maioria das soluções vinculadas a um tamanho máximo por padrão. Essas soluções devem ser desqualificadas?
— Max28 /
1
@ maxb Eu acho que teoricamente foi concebido como não necessariamente prático .
— Arnauld
1
@Ourous Eu sei que é muito baixo, é por isso que não gosto da minha solução. Eu poderia adicionar um byte e tê-lo trabalhar para entradas muito maiores, por isso vou acrescentar que, como alternativa
— maxb
1
"N aparece em N ^ 2" seria melhor redigido como algo como "os dígitos decimais de N são uma substring [contígua] dos dígitos decimais de N ao quadrado" (11 não "aparece em" 121). [Strictly "contíguo" é redundante, mas acrescentando que é clara.]
— Jonathan Allan
1
@ JonathanAllan Sugestão de reformulação alternativa: "N está lexicograficamente presente em N ^ 2"
— Οurous 28/11/18

Respostas:

4

05AB1E , 6 bytes

Indexado 1

µNNnNå

Experimente online!

Explicação

µ         # loop over increasing N until counter equals input
 N        # push N (for the output)
  Nn      # push N^2
    N     # push N
     å    # push N in N^2
          # if true, increase counter
— Emigna
fonte
Esse µcomando é apenas ... eu gostaria de ter isso.
— maxb
@maxb: é bastante prático para desafios em que você precisa encontrar o Nthnúmero que atende a uma condição específica.
— Emigna
" se for verdade , aumente o contador"?
— Jonathan Allan
@ JonathanAllan: Como em "Se N estiver contido em N ^ 2, aumente o valor do contador em 1". Eu provavelmente deveria ter escrito "contador de incremento".
— Emigna
Na verdade, eu não entendi a explicação; parece que se åproduz true, então temos a corrente Nno topo da pilha (contador e incremento de incremento N), mas se não continuarmos (incremento N). Talvez use algo diferente de " N", pois esse é o resultado final no corpo da pergunta: p
— Jonathan Allan
4

Perl 6 , 33 31 bytes

-2 bytes graças a nwellnhof

{(grep {$^a²~~/$a/},1..*)[$_]}

Experimente online!

Explicação:

{                            }  # Anonymous code block that returns
 (                      )[$_]   # The nth index of
  grep {          },1..*        # Filtering from the natural numbers
        $^a²                    # If the square of the number
            ~~/$a/              # Contains the number
— Brincadeira
fonte
3

MathGolf , 8 bytes (funciona para qualquer entrada na teoria, mas apenas n<10na prática)

úrgɲï╧§

Experimente online!

Alternativa (trabalha n<49na prática e na teoria)

►rgɲï╧§

A única diferença é que, em vez de criar uma lista com 10^(input) valores, eu crio uma lista com10^6 itens. Isso demora um pouco para ser executado, para que você possa trocar o primeiro byte por qualquer outro literal de 1 byte para testá-lo.

Explicação

ú          pop(a), push(10**a)
 r         range(0, n)
  g        filter array by...
   É       start block of length 3
    ²      pop a : push(a*a)
     ï     index of current loop
      ╧    pop a, b, a.contains(b)
           Block ends here
       §   get from array

A razão pela qual essa solução não lida com entradas grandes é que notei que a sequência cresce menos que exponencialmente, mas mais que qualquer polinômio. É por isso que usei o 10**noperador (eu queria usar, 2**nmas falhou na entrada 1). Isso significa que eu crio uma matriz extremamente grande, mesmo para pequenas entradas, apenas para filtrar a grande maioria dela e depois pegar um dos primeiros elementos. É extremamente inútil, mas não consegui encontrar outra maneira de fazer isso sem aumentar a contagem de bytes.

— maxb
fonte
3

Lisp comum, 95 bytes

(lambda(n)(do((i 0))((= n 0)i)(if(search(format()"~d"(incf i))(format()"~d"(* i i)))(decf n))))

Experimente online!

— Renzo
fonte
2

Limpo , 83 bytes

import StdEnv,Text


(!!)[i\\i<-[1..]|indexOf(""<+i)(""<+i^2)>=0]

Experimente online!

(!!)                               // index into the list of
 [ i                               // i for every
  \\ i <- [1..]                    // i from 1 upwards
  | indexOf (""<+i) (""<+i^2) >= 0 // where i is in the square of i
 ]
— Furioso
fonte
2

Gelatina , 6 bytes

1ẇ²$#Ṫ

1 indexado.

Experimente online!

Quão?

Localiza o primeiro nda sequência como uma lista e depois produz a cauda N,.

1ẇ²$#Ṫ - Link: integer, n (>0)
1      - initialise x to 1
    #  - collect the first n matches, incrementing x, where:
   $   -   last two links as a monad:
  ²    -     square x
 ẇ     -     is (x) a substring of (x²)?
       -     (implicitly gets digits for both left & right arguments when integers)
     Ṫ - tail

Se 0fosse considerado um número Natural, poderíamos usar o programa completo indexado em 1 ẇ²$#Ṫpara 5.

— Jonathan Allan
fonte
2

Java 8, 66 65 63 bytes

n->{int r=0;for(;!(++r*r+"").contains(r+"")||--n>0;);return r;}

-1 byte graças a @Shaggy .
-2 bytes graças a @Arnauld .

1 indexado.

Experimente online.

Explicação:

n->{                // Method with integer as both parameter and return-type
  int r=0;          //  Result-integer, starting at 0
  for(;             //  Loop as long as:
       !(++r*r+"")  //    (increase result `r` by 1 first with `++r`)
                    //    If the square of the result `r` (as String) 
        .contains(  //    does not contain
          r+"")||   //    the result `r` itself (as String):
       --n>0;);     //     (decrease input `n` by 1 first with `--n`)
                    //     And continue looping if input `n` is not 0 yet
  return r;}        //  Return the result `r`
— Kevin Cruijssen
fonte
1
— Salsicha
1
@ Shagy Ah, é claro. Obrigado!
— Kevin Cruijssen
1
@ Arnauld Ah, maneira inteligente de combinar o loop e se! Obrigado.
— 21718 Kevin Kelijsen em
2

Clojure , 81 bytes

(fn[n](nth(filter #(clojure.string/includes?(str(* % %))(str %))(range))n))

Experimente online!(Infelizmente, o TIO parece não suportar a biblioteca de cordas padrão do Clojure)

Se o Clojure tivesse uma sintaxe de importação mais curta ou um includes?método na biblioteca principal, isso poderia ser realmente um pouco competitivo. clojure.string/includes?sozinho é mais do que algumas respostas aqui:

(defn nth-sq-subs [n]
  (-> ; Filter from an infinite range of numbers the ones where the square of
      ;  the number contains the number itself
    (filter #(clojure.string/includes? (str (* % %)) (str %))
            (range))

    ; Then grab the "nth" result. Inc(rementing) n so 0 is skipped, since apparently
    ;  that isn't in the sequence
    (nth (inc n))))

Como o link do TIO está quebrado, aqui está um teste. O número à esquerda é o índice ( n) e o resultado ( N) está à direita:

(mapv #(vector % (nth-sq-subs %)) (range 100))
=>
[[0 1]
 [1 5]
 [2 6]
 [3 10]
 [4 25]
 [5 50]
 [6 60]
 [7 76]
 [8 100]
 [9 250]
 [10 376]
 [11 500]
 [12 600]
 [13 625]
 [14 760]
 [15 1000]
 [16 2500]
 [17 3760]
 [18 3792]
 [19 5000]
 [20 6000]
 [21 6250]
 [22 7600]
 [23 9376]
 [24 10000]
 [25 14651]
 [26 25000]
 [27 37600]
 [28 50000]
 [29 60000]
 [30 62500]
 [31 76000]
 [32 90625]
 [33 93760]
 [34 100000]
 [35 109376]
 [36 250000]
 [37 376000]
 [38 495475]
 [39 500000]
 [40 505025]
 [41 600000]
 [42 625000]
 [43 760000]
 [44 890625]
 [45 906250]
 [46 937600]
 [47 971582]
 [48 1000000]
 [49 1093760]
 [50 1713526]
 [51 2500000]
 [52 2890625]
 [53 3760000]
 [54 4115964]
 [55 5000000]
 [56 5050250]
 [57 5133355]
 [58 6000000]
 [59 6250000]
 [60 6933808]
 [61 7109376]
 [62 7600000]
 [63 8906250]
 [64 9062500]
 [65 9376000]
 [66 10000000]
 [67 10050125]
 [68 10937600]
 [69 12890625]
 [70 25000000]
 [71 28906250]
 [72 37600000]
 [73 48588526]
 [74 50000000]
 [75 50050025]
 [76 60000000]
 [77 62500000]
 [78 66952741]
 [79 71093760]
 [80 76000000]
 [81 87109376]
 [82 88027284]
 [83 88819024]
 [84 89062500]
 [85 90625000]
 [86 93760000]
 [87 100000000]
 [88 105124922]
 [89 109376000]
 [90 128906250]
 [91 146509717]
 [92 177656344]
 [93 200500625]
 [94 212890625]
 [95 250000000]
 [96 250050005]
 [97 289062500]
 [98 370156212]
 [99 376000000]]

Isso deve ser capaz de suportar qualquer valor de n; desde que você esteja disposto a aguardar o término (encontrar os 50º a 100º números inteiros na sequência levou 15 minutos). O Clojure suporta aritmética inteira arbitrariamente grande; portanto, quando os números começam a ficar grandes, ele começa a usar BigInts.

— Carcinigenicado
fonte
1

Carvão , 25 bytes

Ｎθ≔¹ηＷθ«≦⊕η¿№Ｉ×ηηＩη≦⊖θ»Ｉη

Experimente online!Link é a versão detalhada do código. Indexado a 0. Explicação:

Ｎθ

Entrada n .

≔¹η

Comece Nem 1. (Ou, isso pode começar a contar em0 que tornaria a entrada indexada em 1).

Ｗθ«

Repita até encontrarmos n números na sequência.

≦⊕η

Incremento N .

¿№Ｉ×ηηＩη

Se N*NcontémN , então ...

≦⊖θ»

... decrementar n .

Ｉη

Imprimir N.

Minhas tentativas de jogar golfe foram frustradas por Charcoal a) não ter uma if..thenexceção no final de um bloco (que custa 2 bytes) b) não ter um Containsoperador (convertendo a saída de Findou Countem um booleano que eu poderia subtrair dos ncustos novamente) 2 bytes).

— Neil
fonte
1

Editar (resposta aos comentários): Python 2, 76 bytes

Queria tentar um método não recursivo. (Novo no golfe, todas as dicas seriam ótimas!)

def f(c,n=0):
    while 1:
        if`n`in`n*n`:
            if c<2:return n
            c-=1
        n+=1

Obrigado BMO e Vedant Kandoi!

— Henry T
fonte
2
Você não precisa contar print(f(13))no código. Além disso while 1:, if c==1:return n,c==1 can be c<2
— Vedant Kandoi
Ah, eu não vi que você queria uma versão não recursiva, nvm. Enfim, atualmente conto 76 bytes e não 79.
— ბიმო
E você pode economizar um pouco mais: os espaços antes e depois `são redundantes e o outro depoisc<2: também; em seguida, você pode misturar guias e espaços para indentação (como mostrado aqui ): 69 bytes Btw. não há necessidade de manter sua versão antiga (está no histórico de edições para quem está interessado) e por que não vincular ao TIO (ou similar) / usar o modelo a partir daí?
— ბიმო
1

Haskell, 60 bytes

([n^2|n<-[1..],elem(show n)$words=<<mapM(:" ")(show$n^2)]!!)

Experimente online!

      n<-[1..]              -- loop n through all numbers starting with 1
 [n^2|        ,    ]        -- collect the n^2 in a list where
     elem(show n)           -- the string representation of 'n' is in the list
       words ... (show$n^2) -- which is constructed as follows:

            show$n^2        -- turn n^2 into a string, i.e. a list of characters
          (:" ")            -- a point free functions that appends a space
                            -- to a character, e.g.  (:" ") '1' -> "1 "
        mapM                -- replace each char 'c' in the string (n^2) with
                            -- each char from (:" ") c and make a list of all
                            -- combinations thereof.
                            -- e.g. mapM (:" ") "123" -> ["123","12 ","1 3","1  "," 23"," 2 ","  3","   "]
      words=<<              -- split each element into words and flatten to a single list
                            -- example above -> ["123","12","1","3","1","23","2","3"]

(                      !!)  -- pick the element at the given index
— nimi
fonte
1

Python 2 , 47 43 bytes

-4 bytes graças a Dennis (adicionando 1 à chamada recursiva em vez de retornar n-1)

f=lambda c,n=1:c and-~f(c-(`n`in`n*n`),n+1)

Experimente online!

Explantion / Ungolfed

Função recursiva usando dois argumentos c,n; n é contado 1,2,3... e sempre n dentro n2 diminui c. A recursão termina assim quec=0 0:

# Enumerating elements of A018834 in reverse starting with 1
def f(counter, number=1):
    # Stop counting
    if counter == 0:
        return 0
    # Number is in A018834 -> count 1, decrement counter & continue
    elif `number` in `number ** 2`:
        return f(counter-1, number+1) + 1
    # Number is not in A018834 -> count 1, continue
    else:
        return f(counter, number+1) + 1
— ბიმო
fonte
1

Lua , 137 123 79 bytes

-obrigado @Jo King por 44 bytes

n=io.read()i=0j=0while(i-n<0)do j=j+1i=i+(n.find(j*j,j)and 1or 0)end
print(j*j)

Experimente online!

— ouflak
fonte
79 bytes . Algumas dicas genéricas; false/truepode ser 0>1/ 0<1, colchetes não são necessários para ifs e whiles, você pode remover a maioria dos espaços em branco após os números (até as novas linhas).
— Jo rei
1

Tcl , 82 bytes

proc S n {while 1 {if {[regexp [incr i] [expr $i**2]]&&[incr j]==$n} {return $i}}}

Experimente online!

— sergiol
fonte
Eu acho que você pode misturar o tempo e o if com:proc S n {while {[incr j [regexp [incr i] [expr $i**2]]]-$n} {};return $i}
— david
0

Arrumado , 24 bytes

{x:str(x)in'~.x^2}from N

Experimente online!

Retorna uma lista lenta que, quando chamada como uma função, retorna o nelemento th da série.

Explicação

{x:str(x)in'~.x^2}from N
{x:              }from N       select all natural numbers `x` such that
   str(x)                      the string representation of `x`
         in                    is contained in
           '~.x^2              "~" + str(x^2)
— Conor O'Brien
fonte
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.