Nuovo ordine n. 4: Mondo

17

Introduzione (potrebbe essere ignorata)

Mettere tutti i numeri positivi nel suo ordine regolare (1, 2, 3, ...) è un po 'noioso, no? Quindi ecco una serie di sfide intorno alle permutazioni (rimpasto) di tutti i numeri positivi. Questa è la quarta sfida di questa serie (collegamenti alla prima , seconda e terza sfida).

In questa sfida, esploreremo non una permutazione dei numeri naturali, ma un intero mondo di permutazioni!

Nel 2000, Clark Kimberling ha posto un problema nel 26 ° numero di Crux Mathematicorum , una rivista scientifica di matematica pubblicata dalla Canadian Mathematical Society. Il problema era:

Sequence a={a1=1an=⌊an−12⌋ if ⌊an−12⌋∉{0,a1,...,an−1}an=3an-1 altrimenti

Ogni numero intero positivo si verifica esattamente una volta in questa sequenza?

Nel 2004, Mateusz Kwasnicki ha fornito prove positive sulla stessa rivista e nel 2008 ha pubblicato una prova più formale e (rispetto alla domanda originale) una prova più generale. Ha formulato la sequenza con parametri e :pq

{a1=1an=⌊an−1q⌋ if ⌊an−1q⌋∉{0,a1,...,an−1}an=pan−1 altrimenti

Ha dimostrato che per ogni p,q>1 tale che logp(q) è irrazionale, la sequenza è una permutazione dei numeri naturali. Poiché esiste un numero infinito di valori p e q per i quali ciò è vero, questo è veramente un intero mondo di permutazioni dei numeri naturali. Rimarremo con l'originale (p,q)=(3,2) e per questi parametri, la sequenza può essere trovata come A050000nell'OEIS. I suoi primi 20 elementi sono:

1, 3, 9, 4, 2, 6, 18, 54, 27, 13, 39, 19, 57, 28, 14, 7, 21, 10, 5, 15

Poiché si tratta di una sfida "sequenza pura", il compito è quello di produrre un'(n) per un dato n come input, dove un'(n) è A050000 .

Compito

Dato un input intero n , output un'(n) in formato intero, dove:

{un'(1)=1un'(n)=⌊un'(n-1)2⌋ Se ⌊un'(n-1)2⌋∉{0,un'1,...,un'(n-1)}un'(n)=3un'(n-1) altrimenti

Nota: qui si assume l'indicizzazione basata su 1; puoi utilizzare l'indicizzazione basata su 0, quindi un'(0)=1;un'(1)=3 , ecc. Indicare questo nella risposta se si sceglie di utilizzarlo.

Casi test

Input | Output
---------------
1     |  1
5     |  2
20    |  15
50    |  165
78    |  207
123   |  94
1234  |  3537
3000  |  2245
9999  |  4065
29890 |  149853

Regole

  • Input e output sono numeri interi (il tuo programma dovrebbe almeno supportare input e output nell'intervallo da 1 a 32767)
  • Input non validi (0, float, stringhe, valori negativi, ecc.) Possono causare output non previsti, errori o comportamenti (non) definiti.
  • Si applicano le regole I / O predefinite .
  • Sono vietate le scappatoie predefinite .
  • Questo è code-golf , quindi vince la risposta più breve in byte
code-golf  sequence 
— agtoever
fonte
Risponderei usando TI-BASIC, ma l'input sarebbe limitato a poiché le liste sono limitate a 999 elementi. Grande sfida comunque! 0<N<1000
— Tau,
@Tau: anche se fuori specifica (e questa non competitiva), sarei interessato alla tua soluzione. Ne hai uno che puoi pubblicare?
— agtoever,
1
Ho eliminato il programma, ma dovrei essere in grado di ricrearlo. Lo posterò come non competitivo una volta che lo avrò rifatto.
— Tau,
@agtoever, "non concorrenti" non copre soluzioni non valide; era per soluzioni che utilizzano le lingue o le funzionalità linguistiche create dopo la pubblicazione di una sfida.
— Shaggy,
Meta meta PP&CG è davvero molto chiaro su questo. Non sono stato premiato con un'interpretazione così rigorosa di "non concorrenza" ... @Tau: sembra che non puoi pubblicare la tua soluzione TI-BASIC secondo queste regole. Scusa.
— agtoever,

Risposte:

3

Japt , 15 14 byte

1-indicizzati.

@[X*3Xz]kZ Ì}g

Provalo

@[X*3Xz]kZ Ì}g     :Implicit input of integer U
             g     :Starting with the array [0,1] do the following U times, pushing the result to the array each time
@                  :  Pass the last element X in the array Z through the following function
 [                 :    Build an array containing
  X*3              :      X multiplied by 3
     Xz            :      X floor divided by 2
       ]           :    Close array
        kZ         :    Remove all elements contained in Z
           Ì       :    Get the last element
            }      :  End function
                   :Implicit output of the last element in the array
— ispido
fonte
7

JavaScript (ES6),  55 51  50 byte

Salvato 1 byte grazie a @EmbodimentofIgnorance
Salvato 1 byte grazie a @tsh

n=>eval("for(o=[p=2];n--;)o[p=o[q=p>>1]?3*p:q]=p")

Provalo online!

— Arnauld
fonte
— Incarnazione dell'ignoranza il
@EmbodimentofIgnorance Di solito evito quel trucco, poiché il codice valutato è molto più lento. Ma la differenza è appena percettibile per quello, quindi immagino che vada bene.
— Arnauld,
2
Ma questo è code-golf, non ci interessa la velocità, purché porti a termine il lavoro
— Incarnazione dell'ignoranza
n=>eval("for(o=[p=2];n--;)o[p=o[q=p>>1]?3*p:q]=p")
— TSH
5

Gelatina , 15 byte

µ×3żHḞḢḟȯ1Ṫ;µ¡Ḣ

Un programma completo che accetta l'intero, n(basato su 1), da STDIN che stampa il risultato.

Provalo online!

Come?

µ×3żHḞḢḟȯ1Ṫ;µ¡Ḣ - Main Link: no arguments (implicit left argument = 0)
µ           µ¡  - repeat this monadic chain STDIN times (starting with x=0)
                -                   e.g. x = ...  0      [1,0]            [9,3,1,0]
 ×3             -   multiply by 3                 0      [3,0]            [27,9,3,0]
    H           -   halve                         0      [1.5,0]          [4.5,1.5,0.5,0]
   ż            -   zip together                  [0,0]  [[3,1.5],[0,0]]  [[27,4.5],[9,1.5],[3,0.5],[0,0]]
     Ḟ          -   floor                         [0,0]  [[3,1],[0,0]]    [[27,4],[9,1],[3,0],[0,0]]
      Ḣ         -   head                          0      [3,1]            [27,4]
       ḟ        -   filter discard if in x        []     [3]              [27,4]
        ȯ1      -   logical OR with 1             1      [3]              [27,4]
          Ṫ     -   tail                          1      3                4
           ;    -   concatenate with x            [1,0]  [3,1,0]          [4,9,3,1,0]
              Ḣ - head                            1      3                4
                - implicit print
— Jonathan Allan
fonte
4

05AB1E , 16 15 byte

Salvato 1 byte grazie a Kevin Cruijssen .
0-indicizzati.

¾ˆ$FDˆx3*‚;ï¯Kн

Provalo online!

Spiegazione

Usando n=1come esempio

¾ˆ                 # initialize global array as [0]
  $                # initialize stack with 1, input
   F               # input times do:
    Dˆ             # duplicate current item (initially 1) and add one copy to global array
                   # STACK: 1, GLOBAL_ARRAY: [0, 1]
      x            # push Top_of_stack*2
                   # STACK: 1, 2, GLOBAL_ARRAY: [0, 1]
       3*          # multiply by 3
                   # STACK: 1, 6, GLOBAL_ARRAY: [0, 1]
         ‚;ï       # pair and integer divide both by 2
                   # STACK: [0, 3], GLOBAL_ARRAY: [0, 1]
            ¯K     # remove any numbers already in the global array
                   # STACK: [3], GLOBAL_ARRAY: [0, 1]
              н    # and take the head
                   # STACK: 3
— Emigna
fonte
— Kevin Cruijssen
@KevinCruijssen: grazie! Ho pensato di usare l'array globale, ma ho pensato che avrebbe avuto la stessa lunghezza di un elenco nello stack e non l'ho mai provato: /
— Emigna
4

Perl 6 , 49 byte

-2 byte grazie a nwellnof

{(1,3,{(3*@_[*-1]Xdiv 6,1).max(*∉@_)}...*)[$_]}

Provalo online!

Restituisce l'elemento indicizzato 0 nella sequenza. Puoi cambiarlo in 1 indicizzato cambiando gli elementi iniziali in 0,1invece di1,3

Spiegazione:

{                                             }  # Anonymous code block
 (                                   ...*)[$_]   # Index into the infinite sequence
  1,3                                            # That starts with 1,3
     ,{                             }            # And each element is
       (                 ).max(    )             # The first of
          @_[*-1]X                               # The previous element
        3*        div 6                          # Halved and floored
        3*        div  ,1                        # Or tripled
                               *∉@_             # That hasn't appeared in the sequence yet
— Jo King
fonte
3

J , 47 40 byte

[:{:0 1(],<.@-:@{:@](e.{[,3*{:@])])^:[~]

Provalo online!

ungolfed

[: {: 0 1 (] , <.@-:@{:@] (e. { [ , 3 * {:@]) ])^:[~ ]

Traduzione diretta della definizione in J. Costruisce dal basso verso l'alto usando ^:per iterare dal valore iniziale il numero di volte richiesto.

— Giona
fonte
3

Java 10, 120 99 byte

n->{var L=" 1 0 ";int r=1,t;for(;n-->0;L+=r+" ")if(L.contains(" "+(r=(t=r)/2)+" "))r=t*3;return r;}

Provalo online.

Spiegazione:

n->{                              // Method with integer as both parameter and return-type
  var L=" 1 0 ";                  //  Create a String that acts as 'List', starting at [1,0]
  int r=1,                        //  Result-integer, starting at 1
      t;                          //  Temp-integer, uninitialized
  for(;n-->0;                     //  Loop the input amount of times:
      L+=r+" "))                  //    After every iteration: add the result to the 'List'
                          t=r     //   Create a copy of the result in `t`
                       r=(...)/2  //   Then integer-divide the result by 2
    if(L.contains(" "+(...)+" ")) //   If the 'List' contains this result//2:
      r=t*3;                      //    Set the result to `t` multiplied by 3 instead
  return r;}                      //  Return the result
— Kevin Cruijssen
fonte
3

Haskell , 67 65 byte

(h[1,0]!!)
h l@(a:o)|elem(div a 2)o=a:h(3*a:l)|1>0=a:h(div a 2:l)

Provalo online!

Utilizza l'indicizzazione basata su 0.

EDIT: salvato 2 byte usando eleminvece di notEleme cambiando le condizioni

— user1472751
fonte
2

C ++ (gcc) , 189 180 byte

-9 byte per il piccolo golf

#import<vector>
#import<algorithm>
int a(int n){std::vector<int>s={1};for(int i=0;i<n;++i)s.push_back(i&&std::find(s.begin(),s.end(),s[i]/2)==s.end()?s[i]/2:3*s[i]);return s[n-1];}

Provalo online!

Calcola la sequenza fino a n, quindi restituisce l'elemento desiderato. Lento per indici più grandi.

— Neil A.
fonte
@ceilingcat Sfortunatamente ciò influisce sulla precedenza dell'operatore e modifica l'output della funzione.
— Neil A.
2

Python 2 , 66 byte

l=lambda n,p=1,s=[0]:p*(n<len(s))or l(n,3*p*(p/2in s)or p/2,[p]+s)

Provalo online!

Utilizza l'indicizzazione in base zero. La lambda fa poco più che costruire ricorsivamente la sequenza e tornare non appena viene raggiunto l'indice richiesto.

— Arbo
fonte
1

Python 3 , 105 103 100 95 83 byte

-2 byte grazie a agtoever
-12 byte grazie ad ArBo

def f(n):
 s=0,1
 while len(s)<=n:t=s[-1]//2;s+=(t in s)*3*s[-1]or t,
 return s[-1]

Provalo online!

— Noodle9
fonte
È possibile sostituire il ciclo for con while len(s)<=ne sostituire i con -1. Questo dovrebbe radere via uno dei due personaggi.
— agtoever
@agtoever è così intelligente - grazie! :)
— Noodle9
83 byte lavorando con una tupla anziché con un elenco e rimuovendo il ifdal whileciclo per consentire un ciclo di quel ciclo
— ArBo
@ArBo Eeeek !!! assolutamente geniale - grazie :)
— Noodle9
1

Gaia , 22 20 byte

2…@⟨:):3פḥ⌋,;D)+⟩ₓ)

Provalo online!

Indice basato su 0.

Ringraziamo Shaggy per l'approccio

2…			| push [0 1]
  @⟨		 ⟩ₓ	| do the following n times:
    :):			| dup the list L, take the last element e, and dup that
       3פḥ⌋,		| push [3*e floor(e/2)]
	     ;D		| take the asymmetric set difference [3*e floor(e/2)] - L
	       )+	| take the last element of the difference and add it to the end of L (end of loop)
		   )	| finally, take the last element and output it

;D

— Giuseppe
fonte
0

Lua , 78 byte

x,y=1,3 u={}for _=2,...do
u[x]=0
x,y=y,y//2
if u[y]then y=3*x end
end
print(x)

Provalo online!

— Wastl
fonte
68 byte rimuovendo alcuni spazi bianchi, rimuovendo la zvariabile e cambiando l'istruzione if in ternary
— Jo King
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.