_{Un seguito a questa domanda .}

Compito

Data una matrice di numeri interi positivi, trova l' elemento k più grande per il quale:

Esiste una distanza intera positiva n , in modo che l'elemento nell'array situato n  posto a sinistra o a destra da k sia uguale a n .

Si garantisce che l'array contenga almeno un elemento che soddisfi questa condizione.

Vince il codice più breve (in byte). Puoi scegliere il formato I / O che preferisci.

Esempio

Dato l'input

[4, 6, 7, 9, 3, 6, 5, 7, 2]

I valori ammissibili sono:

• Il 4, in quanto vi è un 7situato a 7 posizioni alla sua destra
• Il primo 6, in quanto vi sono 33 posizioni posizionate alla sua destra
• Il 3, in quanto vi è un 4posizionato 4 posizioni alla sua sinistra
• Il 5, in quanto vi è un 2posizionato 2 posizioni alla sua destra
• Il secondo 7, in quanto vi sono 33 posizioni posizionate alla sua sinistra.

Di questi valori, il più grande è 7.

Casi test

[1, 13] → 13
[2, 9, 8, 3, 72, 2] → 8
[5, 28, 14, 5, 6, 3, 4, 7] → 14
[1, 3, 5, 15, 4, 1, 2, 6, 7, 7] → 7
[5, 1, 3, 5, 2, 5, 5, 8, 5, 1, 5, 1, 2, 3] → 5
[5, 12, 2, 5, 4, 7, 3, 3, 6, 2, 10, 5, 5, 5, 4, 1, 8, 5] → 10

Gelatina , 9 byte

Jạþ`=ḅa¹Ṁ

Provalo online! o verifica tutti i casi di test .

Come funziona

Jạþ`=ḅa¹Ṁ  Main link. Argument: A (array)

J          Indices; yield [1, ..., len(A)].
   `       Use the previous return value as left and right argument:
 ạþ        Absolute difference table; take the absolute value of the difference
           of each pair of indices, yielding a 2D array.
    =      Compare each absolute difference with the corresponding item of A.
     ḅ     Base; convert each Boolean list from base i to integer, where i is the
           corresponding item of A. The value of i is not important; we only care
           if the list contains a 1, which will result in a non-zero integer.
       ¹   Identity; yield A.
      a    Logical AND; replace non-zero values with the corresponding items of A.
        Ṁ  Take the maximum.

05AB1E , 21 byte

vyN+Ny-})¹gL<Ãv¹yè})Z

Spiegazione

v      }               # for each num in input
 yN+                   # push index + num
    Ny-                # push index - num
        )              # wrap stack in a list
         ¹gL<Ã         # remove indices outside the range of input
              v¹yè})   # get list of elements in input at the remaining indices
                    Z  # get max

Provalo online!

Haskell, 61 57 55 byte

f x=maximum[a|(n,a)<-x,(i,b)<-x,b==abs(n-i)]
f.zip[0..]

Esempio di utilizzo: (f.zip[0..]) [5,28,14,5,6,3,4,7]-> 14.

(Più o meno) un'implementazione diretta della definizione: per ogni indice ndell'elenco di input xmantenere a := x!!nse c'è un indice idove è b := x!!iuguale abs(n-i). Trova il massimo.

Modifica: @xnor ha salvato due byte. Grazie!

Gelatina , 10 byte

,N+JFfJị¹Ṁ

Provalo online! o verifica tutti i casi di test .

Come funziona

,N+JFfJị¹Ṁ  Main link. Argument: A (array)

,N          Pair A with -A (element-wise negative).
   J        Yield the indices of A [1, ..., len(A)].
  +         Add the elements of A (and their negatives) with the corr. indices.
    F       Flatten the resulting 2D array.
     fJ     Filter indices; remove invalid indices (not in [1, ..., len(A)]) from
            the generated array. The result is the list of all indices of eligible
            elements of A.
       ị¹   Retrieve the corresponding elements of A.
         Ṁ  Take the maximum.

Python 3, 85 80 72 byte

lambda l,e=enumerate:max(i for p,i in e(l)for s,j in e(l)if j==abs(s-p))

Modifica: -8 byte grazie a @Dennis

EXCEL: 32 30 byte

=MAX(IF(A:A-ROW(A:A)<0,A:A,0))

Non riesco ancora a credere di aver capito che è così corto ...

Come usare:
incollalo in QUALSIASI cella SALVO le celle della colonna A. Dopo aver incollato, mentre stai ancora modificando, premi control+ shift+ enterper inserirlo correttamente.
inserisci i tuoi valori nella colonna A, 1 valore per cella (secondo la voce CSV).

Se vuoi scoprire come funziona, ho pubblicato un suggerimento aggiuntivo nella mia domanda Suggerimenti per giocare a golf in Excel .

JavaScript (ES6), 61 byte

a=>Math.max(...a.filter((_,i)=>a.some((e,j)=>e==i-j|e==j-i)))

Perl, 45 byte

Include +2 per -ap

Indica i numeri su una riga su STDIN:

largest.pl <<< "5 12 2 5 4 7 3 3 6 2 10 5 5 5 4 1 8 5"

largest.pl:

#!/usr/bin/perl -ap
($_)=sort{$b-$a}map@F[$^P=$n-$_,$n+++$_],@F

È possibile ottenere un ulteriore byte sostituendolo ^Pcon il carattere di controllo letterale, ma ciò porta a un avviso su STDERR su perls recenti.

assume largest number + array length < 2^32

Pyth, 19 17 byte

Grazie a @ Pietu1998 per -2 byte

eS@LQ@UQs.e,-kb+b

Un programma che accetta l'inserimento di un elenco su STDIN e stampa il risultato.

Provalo online

Come funziona

eS@LQ@UQs.e,-kb+b  Program. Input: Q
         .e        Map over Q (implicit input fill) with elements as b and indices as k:
            -kb     k-b
               +b   k+b (Implicit fill with k)
           ,        2-element list of those (possible indices)
        s          Flatten that
      UQ           Yield [0, 1, 2, 3..., len(Q)-1]
     @             Filter the flattened list by presence in the above, removing invalid
                   indices
  @LQ              Index into Q at those indices
 S                 Sort that
e                  Yield the last element of that, giving the maximum
                   Implicitly print

MATL, 13 byte

ttn:tYTq=a)X>

L'input deve essere un vettore di colonna. Vale a dire, l'input è separato da punto e virgola come [1; 2; 3] o virgola separata con un segno di spunta alla fine come [1,2,3] '.

Provalo online!

Tutti i casi di test: (A) , (B) , (C) , (D) , (E) , (F)

Grazie a Suever per i suggerimenti nella chat room MATL per salvare 2 personaggi.

Spiegazione:

La strategia generale è la stessa della mia risposta Octave / MATLAB, in cui viene spiegato il concetto di base: https://codegolf.stackexchange.com/a/94161/42247

Il codice specifico in questa risposta MATL è costruito come segue:

Il nucleo del metodo è la costruzione della matrice di Toeplitz la cui ij'th entry è abs (ij). Costruiamo prima la matrice di Toeplitz con le voci abs (i-1) +1 con il comando toeplitz di MATL YT come segue:

n:tYT % Equivalent to @(v)toeplitz(1:length(v))

Per vedere come funziona, chiamiamo il vettore di input a questo frammento di codice 'v'. La 'n' trova la lunghezza di v, quindi ':' costruisce il vettore 1: lunghezza (v). Successivamente la 't' crea un'altra copia di 1: lunghezza (v) nella pila; questa copia aggiuntiva è necessaria a causa di un noto bug nella funzione YT in MATL (l'equivalente MATL di toeplitz ()), in cui si aspetta due copie dell'input invece di 1. Quindi YT prende le due copie di questo vettore 1 : lunghezza (v) dalla pila e rende gli addominali (ij) +1 Toeplitz matrice da loro.

Ora dobbiamo sottrarre 1 da questa matrice per ottenere la matrice di Toeplitz con le voci abs (ij) e trovare le posizioni ij in cui questa matrice di abs (ij) Toeplitz è uguale alla matrice di tutti i vettori di colonna che contengono copie di colonne dell'input vettore v. Questo viene fatto come segue:

t n:tYT q=
% t [code] q= is equivalent to @(v) [code](v)-1 == v

La prima "t" crea una copia aggiuntiva dell'input e la memorizza nello stack. 'N: tYT' crea la matrice toeplitz come descritto in precedenza e la emette nello stack. Quindi 'q' sottrae 1 dalla matrice di Toeplitz e '=' fa il confronto di uguaglianza elementalmente tra la matrice abs (ij) e il vettore le cui colonne sono copie dell'input. Si noti che confrontando un vettore di colonna con una matrice, stiamo sfruttando implicitamente le regole di trasmissione dell'operatore MATLAB / MATL (il vettore di colonna nel confronto viene copiato per creare una matrice senza emettere alcun comando).

Infine, dobbiamo trovare gli indici di riga i in cui è presente una colonna j tale che la ij'th entry nella differenza di matrice costruita sopra sia uguale a 1, quindi ottenere il valore del vettore di input corrispondente a questi indici, quindi prendere il massimo. Questo nei tre passaggi seguenti:

1) Trova gli indici per ogni riga che contiene un valore diverso da zero:

tn:tYTq= a
% [code] a is equivalent to @(v) any([code](v))

2) Estrarre gli elementi del vettore di input corrispondenti a quegli indici:

t tn:tYTq= a ) X>
% t [code] ) is equivalent to @(v) v([code](v)]

3) Trova e restituisci l'elemento massimo:

t tn:tYTq= a ) X>
% [code] X> is equivalent to @(v) max(v).

Rubino, 66 byte

->a{i=-1;a.map{|e|i+=1;[a[j=i+e]||0,a[0>(k=i-e)?j:k]||0].max}.max}

Octave / MATLAB, 40 byte

@(v)max(v(any(toeplitz(1:nnz(v))-v==1)))

L'input deve essere un vettore di colonna.

Grazie a Luis Mendo per suggerimenti su come salvare 3 byte (vedi commento)

Grazie a Suever per i suggerimenti che salvano altri 4 byte (sostituendo ~~ (sum ()) con any ())

Spiegazione:

Dato un vettore di input v, questo problema equivale a trovare tutte le soluzioni i, j della seguente equazione discreta,

abs(i-j) = v(i),   i,j both in 1..k,

dove abs () è la funzione di valore assoluto. Ogni v (i) per cui viene risolta questa equazione è una delle soluzioni candidate su cui possiamo massimizzare.

Come funzione discreta di iej, tutte le possibilità per il lato sinistro possono essere disposte nella matrice toeplitz che assomiglia a questo:

[0, 1, 2, 3, 4]
[1, 0, 1, 2, 3]
[2, 1, 0, 1, 2]    <--- abs(i-j)
[3, 2, 1, 0, 1]
[4, 3, 2, 1, 0]

E poiché il lato destro non dipende da i, tutte le possibilità possono essere disposte in una matrice in cui le colonne sono tutte copie dell'input,

[v(1), v(1), v(1), v(1), v(1)]
[v(2), v(2), v(2), v(2), v(2)]
[v(3), v(3), v(3), v(3), v(3)]   <--- v(i)
[v(4), v(4), v(4), v(4), v(4)]
[v(5), v(5), v(5), v(5), v(5)]

Per trovare tutte le soluzioni all'equazione, sottraggiamo queste due matrici e troviamo le posizioni in cui è presente uno zero. Le righe dove c'è uno zero corrispondono agli indici desiderati i dove c'è aj tale che abs (ij) = v (i).

Altri trucchi:

• Sono necessari meno caratteri per costruire la funzione del valore assoluto più uno, abs (ij) +1, quindi verificare le posizioni in cui la differenza è 1, anziché costruire la funzione del valore assoluto (non spostato) vero.
• Utilizza la trasmissione automatica da parte dell'operatore per fare implicitamente copie di colonne di v
• Ottiene la lunghezza dell'input tramite nnz () invece di length (), che funziona poiché si dice che gli input sono positivi nell'istruzione problematica.

Mathematica, 69 byte

Max@MapIndexed[{If[#2[[1]]>#,a[[#2-#]],{}],a[[#2+#]]~Check~{}}&,a=#]&

Funzione anonima. Prende un elenco di numeri interi come input e restituisce un numero intero come output. Ignora tutti i messaggi generati.

Scala, 94 byte

a=>a.zipWithIndex.filter(p=>a.zipWithIndex.exists(x=>x._1==Math.abs(p._2-x._2))).unzip._1.max

PHP, 128 byte

<?foreach(($i=$_GET[i])as$k=>$v){$k-$v<0?:!($i[$k-$v]>$m)?:$m=$i[$k-$v];if($k+$v<count($i))if($i[$k+$v]>$m)$m=$i[$k+$v];}echo$m;

Java 7, 125 123 byte

int c(int[]a){int r=0,i=0,l=a.length,x;for(;i<l;r=l>(x=i+a[i])?a[x]>r?a[x]:r:r,r=(x=i-a[i++])>0?a[x]>r?a[x]:r:r);return r;}

2 byte salvati grazie a @mrco .

Ungolfed (sorta di) e codice di prova:

Provalo qui.

class M{
  static int c(int[] a){
    int r = 0,
        i = 0,
        l = a.length,
        x;
    for(; i < l; r = l > (x = i + a[i])
                      ? a[x] > r
                         ? a[x]
                         : r
                      : r,
                 r = (x = i - a[i++]) > 0
                      ? a[x] > r
                         ? a[x]
                         : r
                      : r);
    return r;
  }

  public static void main(String[] a){
    System.out.println(c(new int[]{ 1, 13 }));
    System.out.println(c(new int[]{ 2, 9, 8, 3, 72, 2 }));
    System.out.println(c(new int[]{ 5, 28, 14, 5, 6, 3, 4, 7 }));
    System.out.println(c(new int[]{ 1, 3, 5, 15, 4, 1, 2, 6, 7, 7 }));
    System.out.println(c(new int[]{ 5, 1, 3, 5, 2, 5, 5, 8, 5, 1, 5, 1, 2, 3 }));
    System.out.println(c(new int[]{ 5, 12, 2, 5, 4, 7, 3, 3, 6, 2, 10, 5, 5, 5, 4, 1, 8, 5 }));
  }
}

Produzione:

13
8
14
7
5
10

Java, 118 byte

int f(int[]a){int t=0,i,j,z=0,l=a.length;while(t<l*l){i=t/l;j=t++%l;z=a[i]>z&&((i<j?j-i:i-j)==a[j])?a[i]:z;}return z;}

Python, 58 byte

Sulla base di risposta di Tony S. Rubino . Questa risposta funziona in Python 2 e 3. Suggerimenti di golf benvenuti.

lambda n:max([n[i+v]for i,v in enumerate(n)if i+v<len(n)])

Ungolfing

def f(array):
    result = []
    for index, value in enumerate(array):
        if index + value < len(array):
            result.append(array[index + value])
    return max(result)

Ruby 56 byte

La mia più piccola soluzione di rubini.

->n{x=[];i=0;n.map{|v|x<<n[v+i]&&v+i<n.size;i+=1};x.max}

Abbastanza facile da testare nella console delle rotaie

a = ->n{x=[];i=0;n.map{|v|x<<n[v+i]&&v+i<n.size;i+=1};x.max}
a[[1, 13]
=> 13
a[[2, 9, 8, 3, 72, 2]]
=> 8
a[[5, 12, 2, 5, 4, 7, 3, 3, 6, 2, 10, 5, 5, 5, 4, 1, 8, 5]]
=> 10

Questo è iniziato a 63 byte, grazie per i suggerimenti per aiutarti a ridurlo!

In realtà , 17 byte

Questa risposta è in realtà una porta della mia risposta Python . Suggerimenti di golf benvenuti. Provalo online!

;╗ñ♂Σ⌠╜l>⌡░⌠╜E⌡MM

Ungolfing

         Implicit input L.
;╗       Duplicate L and save a copy of L to register 0.
ñ        enumerate() the other copy of L.
♂Σ       sum() all the pairs of [index, value of n]. Call this list Z.
⌠...⌡░   Push values of Z where the following function returns a truthy value. Variable v_i.
  ╜        Push L from register 0.
  l        Push len(L).
  >        Check if len(L) > v_i.
⌠...⌡M   Map the following function over Z_filtered. Variable i.
  ╜        Push L from register 0.
  E        Take the ith index of L.
M        max() the result of the map.
         Implicit return.

T-SQL (sqlserver 2016), 132 byte

golfed:

;WITH C as(SELECT value*1v,row_number()over(order by 1/0)n FROM STRING_SPLIT(@,','))SELECT max(c.v)FROM C,C D WHERE abs(D.n-C.n)=D.v

Ungolfed:

DECLARE @ varchar(max)='2, 9, 8, 3, 72, 2'

;WITH C as
(
  SELECT
    value*1v,
    row_number()over(order by 1/0)n
  FROM
    STRING_SPLIT(@,',')
)
SELECT
  max(c.v)
FROM
  C,C D
WHERE
  abs(D.n-C.n)=D.v

Violino

JavaScript (ES6), 56 54 byte

let f =
    
l=>l.map((n,i)=>m=Math.max(m,l[i+n]|0,l[i-n]|0),m=0)|m

console.log(f([1, 13])); // → 13
console.log(f([2, 9, 8, 3, 72, 2])); // → 8
console.log(f([5, 28, 14, 5, 6, 3, 4, 7])); // → 14
console.log(f([1, 3, 5, 15, 4, 1, 2, 6, 7, 7])); // → 7
console.log(f([5, 1, 3, 5, 2, 5, 5, 8, 5, 1, 5, 1, 2, 3])); // → 5
console.log(f([5, 12, 2, 5, 4, 7, 3, 3, 6, 2, 10, 5, 5, 5, 4, 1, 8, 5])); // → 10

Clojure, 68 byte

#(apply max(map(fn[i](get % i 0))(flatten(map-indexed(juxt - +)%))))

Ad esempio (map-indexed (juxt - +) [3 4 1 2])è ([-3 3] [-3 5] [1 3] [1 5])(indicizza il +/-suo valore), questi sono usati per cercare i valori dal vettore originale (fuori range predefinito di default 0) e viene trovato il valore massimo. Mi sento ancora un po 'prolisso ma almeno devo usare juxt:)