Défi:

Prenez un vecteur / une liste d’entiers comme entrée et indiquez le plus grand nombre adjacent à un zéro.

Caractéristiques:

• Comme toujours, formats d'entrée et de sortie optionnels
• Vous pouvez supposer qu'il y aura au moins un zéro et au moins un élément différent de zéro.

Cas de test:

1 4 3 6 0 3 7 0
7

9 4 9 0 9 0 9 15 -2
9

-4 -6 -2 0 -9
-2

-11 0 0 0 0 0 -12 10
0

0 20 
20

Bonne chance et bon golf!

Gelée , 8 octets

ṡ2ẠÐḟS€Ṁ

Essayez-le en ligne!

ṡ2            Overlapping pairs
  ẠÐḟ         Remove pairs without zeroes
     S€       Sum of each pair
       Ṁ      Maximum

MATL , 10 octets

t~5BZ+g)X>

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Prenons l'entrée [-4 -6 -2 0 -9]comme exemple.

t     % Input array. Duplicate
      %   STACK: [-4 -6 -2 0 -9],  [-4 -6 -2 0 -9]
~     % Logical negate. Replaces zeros by logical 1, and nonzeros by logical 0
      %   STACK: [-4 -6 -2 0 -9],  [0 0 0 1 0]
5B    % Push logical array [1 0 1] (5 in binary)
      %   STACK: [-4 -6 -2 0 -9], [0 0 0 1 0], [1 0 1]
Z+    % Convolution, maintaining size. Gives nonzero (1 or 2) for neighbours of
      % zeros in the original array, and zero for the rest
      %   STACK: [-4 -6 -2 0 -9], [0 0 1 0 1]
g     % Convert to logical
      %   STACK: [-4 -6 -2 0 -9], [0 0 1 0 1]
)     % Use as index into original array
      %   STACK: [-2 -9]
X>    % Maximum of array.
      %   STACK: -2
      % Implicitly display

05AB1E , 9 octets

ü‚D€P_ÏOZ

Explication

ü‚         # pair up elements
  D        # duplicate
   €P      # product of each pair (0 if the pair contains a 0)
     _     # logical negate, turns 0 into 1 and everything else to 0
      Ï    # keep only the pairs containing at least 1 zero
       O   # sum the pairs
        Z  # take max

Ne fonctionne pas dans l'interprète en ligne, mais fonctionne hors ligne.

Haskell, 63 43 octets

f x=maximum[a+b|(a,b)<-tail>>=zip$x,a*b==0]

Merci à @MartinEnder pour 4 octets!

Pyth, 12 11 10 octets

eSsM/#0,Vt

Les paires de formulaires, filtrées par un membre zéro, triées par la somme, retournent le plus grand nombre.

JavaScript (ES6), 59 57 56 octets

let f =
    
l=>l.map((n,i)=>m=l[i-1]==0|l[i+1]==0&&n>m?n:m,m=-1/0)|m

console.log(f([1, 4, 3, 6, 0, 3, 7, 0]));       // 7
console.log(f([9, 4, 9, 0, 9, 0, 9, 15, -2]));  // 9
console.log(f([-4, -6, -2, 0, -9]));            // -2
console.log(f([-11, 0, 0, 0, 0, 0, -12, 10]));  // 0
console.log(f([3, 0, 5]));                      // 5
console.log(f([28, 0, 14, 0]));                 // 28

Edit: sauvegardé 2 octets grâce à Huntro
Edit: sauvegardé 1 octet grâce aux ETHproductions

JavaScript (ES6), 53 octets

a=>(m=-1/0,a.reduce((l,r)=>(m=l*r||l+r<m?m:l+r,r)),m)

Parce que j'aime utiliser reduce. Solution alternative, également 53 octets:

a=>Math.max(...a.map((e,i)=>e*a[++i]==0?e+a[i]:-1/0))

Python, 49 octets

lambda a:max(sum(x)for x in zip(a,a[1:])if 0in x)

Les tests sont à l' idéone

Zip à travers les paires, somme celles contenant zéro, renvoie le maximum.

Ruby, 51 octets

->a{a.each_cons(2).map{|a,b|a*b!=0?-1.0/0:a+b}.max}

usage

f=->a{a.each_cons(2).map{|a,b|a*b!=0?-1.0/0:a+b}.max}
p f[gets.split.map(&:to_i)]

PHP, 77 68 71 octets

-3 octets d'anonymes, -4 et -2 de MartinEnder

preg_match_all("#(?<=\b0 )\S+|\S+(?= 0)#",$argv[1],$m);echo max($m[0]);

courir avec php -r '<code>' '<space separated values>'

Java 7, 118 105 106 octets

int d(int[]a){int i=0,m=1<<31,c;for(;++i<a.length;m=a[i]*a[i-1]==0&(c=a[i]+a[i-‌​1])>m?c:m);return m;}

13 octets sauvegardés grâce à @cliffroot en utilisant une approche arithmétique. 1 octet supplémentaire à @mrco après avoir découvert un bogue (le cas de test ajouté 2, 1, 0reviendrait 2au lieu de 1).

Ungolfed & code de test:

Essayez ici.

class M{
  static int c(int[] a){
    int i,
        m = a[i=0],
        c;
    for(; ++i < a.length; m = a[i] * a[i-1] == 0 & (c = a[i] + a[i - 1]) > m)
                           ? c
                           : m);
    return m;
  }

  public static void main(String[] a){
    System.out.println(c(new int[]{ 1, 4, 3, 6, 0, 3, 7, 0 }));
    System.out.println(c(new int[]{ 9, 4, 9, 0, 9, 0, 9, 15, -2 }));
    System.out.println(c(new int[]{ -4, -6, -2, 0, -9 }));
    System.out.println(c(new int[]{ -11, 0, 0, 0, 0, 0, -12, 10 }));
    System.out.println(c(new int[]{ 0, 20 }));
    System.out.println(c(new int[]{ 2, 1, 0 }));
  }
}

Sortie:

7
9
-2
0
20
1

CJam , 16 octets

q~2ew{0&},::+:e>

Essayez-le en ligne!(En tant que suite de tests.)

Explication

q~    e# Read and eval input.
2ew   e# Get all (overlapping) pairs of adjacent values.
{0&}, e# Keep only those that contain a 0.
::+   e# Sum each pair to get the other (usually non-zero) value.
:e>   e# Find the maximum.

MATLAB avec boîte à outils de traitement d'images, 32 octets

@(x)max(x(imdilate(~x,[1 0 1])))

C'est une fonction anonyme. Exemple d'utilisation pour les cas de test:

>> f = @(x)max(x(imdilate(~x,[1 0 1])))
f =
  function_handle with value:
    @(x)max(x(imdilate(~x,[1,0,1])))

>> f([1 4 3 6 0 3 7 0])
ans =
     7

>> f([9 4 9 0 9 0 9 15 -2])
ans =
     9

>> f([-4 -6 -2 0 -9])
ans =
    -2

>> f([-11 0 0 0 0 0 -12 10])
ans =
     0

>> f([0 20])
ans =
    20

Dyalog APL , 14 octets

⌈/∊2(+↑⍨0∊,)/⎕

⌈/ le plus grand des

∊le aplati (" e nlisted"

2(... )/par paire

 + somme (zéro plus quelque chose est quelque chose)

 ↑⍨ pris si

 0 zéro

 ∊ est membre de

 , la paire (lit. la concaténation du numéro de gauche et du numéro de droite)

TryAPL en ligne!

R, 48 47 octets

EDIT: Correction d'une erreur grâce à @Vlo et l'a modifiée pour lire les entrées de stdins, sauvegardé d'un octet en assignant wet en sautant des parenthèses.

function(v)sort(v[c(w<-which(v==0)-1,w+1)],T)[1]

v=scan();w=which(v==0);sort(v[c(w-1,w+1)],T)[1]

Explication non imbriquée

1. Recherchez les indices pour lesquels le vecteur vprend les valeurs 0:w <- which(v == 0)
2. Créer un nouveau vecteur contenant les index +-1: w-1etw+1
3. Extraire les éléments qui correspondent aux index w-1etw+1
4. Trier par ordre décroissant et extraire le premier élément

Notez que si le dernier ou le premier élément vest un zéro, w+-1un index situé en dehors de la longueur du vecteur sera effectivement récupéré, ce qui implique que le résultat est v[length(v)+1]retourné NA. Ce n’est généralement pas un problème, mais les max()fonctions renvoient inopportunément NAs’il existe des occurrences dans le vecteur, à moins que l’on spécifie l’option na.rm=T. Ainsi, il est plus court de 2 octets pour trier et extraire que pour utiliser max(), par exemple:

max(x,na.rm=T)
sort(x,T)[1]

Mathematica, 46 43 octets

^{3 octets enregistrés en raison de @MartinEnder .}

Max[Tr/@Partition[#,2,1]~Select~MemberQ@0]&

Fonction anonyme. Prend une liste d'entiers en entrée et retourne un entier en sortie. Basé sur la solution Ruby.

Perl, 42 octets

Comprend +1 pour -p

Donnez les numéros en ligne sur STDIN

largest0.pl <<< "8 4 0 0 5 1 2 6 9 0 6"

largest0.pl:

#!/usr/bin/perl -p
($_)=sort{$b-$a}/(?<=\b0 )\S+|\S+(?= 0)/g

Julia, 56 55 octets

f(l)=max(map(sum,filter(t->0 in t,zip(l,l[2:end])))...)

Créez des tuples pour les valeurs voisines, prenez les tuples contenant 0, additionnez les valeurs de tuple et trouvez le maximum

Python 2, 74 octets

def f(x):x=[9]+x;print max(x[i]for i in range(len(x)) if 0in x[i-1:i+2:2])

Parcourez chaque élément, s'il y en a un 0à gauche ou à droite de l'élément actuel, incluez-le dans le générateur, puis exécutez-le max. Nous devons compléter la liste avec des non- 0numéros. Ça ne sera jamais inclus parce que la tranche[-1:2:2] n'inclura rien.

T-SQL, 182 octets

Golfé:

DECLARE @x varchar(max)='1 5 4 3 6 1 3 17 1 -8 0 -7'

DECLARE @a INT, @b INT, @ INT WHILE @x>''SELECT @a=@b,@b=LEFT(@x,z),@x=STUFF(@x,1,z,''),@=IIF(@a=0,IIF(@b<@,@,@b),IIF(@b<>0 or @>@a,@,@a))FROM(SELECT charindex(' ',@x+' ')z)z PRINT @

Ungolfed:

DECLARE @x varchar(max)='1 5 4 3 6 1 3 17 1 -8 0 -7'

DECLARE @a INT, @b INT, @ INT
WHILE @x>''
  SELECT 
   @a=@b,
   @b=LEFT(@x,z),
   @x=STUFF(@x,1,z,''),
   @=IIF(@a=0,IIF(@b<@,@,@b),IIF(@b<>0 or @>@a,@,@a))
  FROM(SELECT charindex(' ',@x+' ')z)z 
PRINT @

Violon

PowerShell v3 +, 62 octets

param($n)($n[(0..$n.count|?{0-in$n[$_-1],$n[$_+1]})]|sort)[-1]

Un peu plus long que les autres réponses, mais une approche astucieuse.

Prend les entrées $n. Ensuite, parcourt les index 0..$n.count, utilise la méthode Where-Object( |?{...}) pour extraire les index où se trouve l’élément précédent ou suivant du tableau 0et les renvoie dans la tranche de tableau $n[...]. Nous avons ensuite |sortces éléments, et prenons le plus grand[-1] .

Exemples

PS C:\Tools\Scripts\golfing> @(1,4,3,6,0,3,7,0),@(9,4,9,0,9,0,9,15,-2),@(-4,-6,-2,0,-9),@(-11,0,0,0,0,0,-12,10)|%{""+$_+" --> "+(.\largest-number-beside-a-zero.ps1 $_)}
1 4 3 6 0 3 7 0 --> 7
9 4 9 0 9 0 9 15 -2 --> 9
-4 -6 -2 0 -9 --> -2
-11 0 0 0 0 0 -12 10 --> 0

PS C:\Tools\Scripts\golfing> @(0,20),@(20,0),@(0,7,20),@(7,0,20),@(7,0,6,20),@(20,0,6)|%{""+$_+" --> "+(.\largest-number-beside-a-zero.ps1 $_)}
0 20 --> 20
20 0 --> 20
0 7 20 --> 7
7 0 20 --> 20
7 0 6 20 --> 7
20 0 6 --> 20

q, 38 octets

{max x where 0 in'x,'(next x),'prev x}

J, 18 octets

[:>./2(0&e.\#+/\)]

Explication

[:>./2(0&e.\#+/\)]  Input: array A
                 ]  Identity. Get A
     2              The constant 2
      (         )   Operate on 2 (LHS) and A (RHS)
               \    Get each subarray of size 2 from A and
             +/       Reduce it using addition
           \        Get each subarray of size 2 from A and
       0&e.           Test if 0 is a member of it
            #       Filter for the sums where 0 is contained
[:>./               Reduce using max and return

Perl 6 , 53 octets

{max map ->$/ {$1 if !$0|!$2},(1,|@_,1).rotor(3=>-2)}

Étendu:

# bare block lambda with implicit signature of (*@_)
{
  max

    map

      -> $/ {           # pointy lambda with parameter ｢$/｣
                        # ( ｢$0｣ is the same as ｢$/[0]｣ )
        $1 if !$0 | !$2 # return the middle value if either of the others is false
      },

      ( 1, |@_, 1 )     # list of inputs, with added non-zero terminals
      .rotor( 3 => -2 ) # grab 3, back-up 2, repeat until less than 3 remain
}

PHP, 66 octets

foreach($a=$argv as$k=>$v)$v||$m=max($m,$a[$k-1],$a[$k+1]);echo$m;

Assez simple. Itère sur l'entrée et lorsqu'un nombre est 0, il définit $mle nombre le plus élevé des 2 nombres adjacents et toute valeur précédente de$m .

Courez comme ceci ( -dajouté pour l'esthétique seulement):

php -d error_reporting=30709 -r 'foreach($a=$argv as$k=>$v)$v||$m=max($m,$a[$k-1],$a[$k+1]);echo$m;' -- -4 -6 -2 0 -9;echo

C # 76 74 octets

using System.Linq;i=>i.Zip(i.Skip(1),(a,b)=>a*b==0?1<<31:a+b).Max(‌​);

Explication:

Utilisez zip pour joindre le tableau à lui-même, en ignorant la première valeur de la deuxième référence afin que l'élément zéro soit joint au premier élément. Multipliez a fois b, si le résultat est zéro, l’un d’eux doit être zéro et produire a + b. Sinon, indiquez le nombre minimum possible dans la langue. En supposant que nous aurons toujours un zéro et un non-zéro, cette valeur minimale ne sera jamais sortie en tant que max.

Usage:

[TestMethod]
public void LargestFriend()
{
    Assert.AreEqual(7, F(new int[] { 1, 4, 3, 6, 0, 3, 7, 0 }));
    Assert.AreEqual(9, F(new int[] { 9, 4, 9, 0, 9, 0, 9, 15, -2 }));
    Assert.AreEqual(-2, F(new int[] { -4, -6, -2, 0, -9 }));
    Assert.AreEqual(0, F(new int[] { -11, 0, 0, 0, 0, 0, -12, 10 }));
    Assert.AreEqual(20, F(new int[] { 0, 20 }));
}

R, 48 54 octets

s=scan()

w=which;max(s[c(w(s==0)+1,w(s==0)-1)],na.rm=T)

Lit le vecteur à partir de l'entrée de la console, puis prend le maximum sur toutes les valeurs adjacentes à 0.

Edit: Captures produites à la limite, merci rturnbull!

Raquette 183 octets

(λ(k)(let*((lr(λ(l i)(list-ref l i)))(l(append(list 1)k(list 1)))(m(for/list((i(range 1(sub1(length l))))
#:when(or(= 0(lr l(sub1 i)))(= 0(lr l(add1 i)))))(lr l i))))(apply max m)))

Version détaillée:

(define f
 (λ(k)
    (let* ((lr (λ(l i)(list-ref l i)))
           (l (append (list 1) k (list 1)))
           (m (for/list ((i (range 1 (sub1(length l))))
                         #:when (or (= 0 (lr l (sub1 i)))
                                    (= 0 (lr l (add1 i))) ))
                (lr l i) )))
      (apply max m) )))

Essai:

(f (list 1 4 3 6 0 3 7 0))
(f (list 9 4 9 0 9 0 9 15 -2))
(f (list -4 -6 -2 0 -9))
(f (list -11 0 0 0 0 0 -12 10))
(f (list 0 20 ))

Sortie:

7
9
-2
0
20

C 132 octets

Sorties utilisant le code de retour de main:

int main(int a,char**_){int i,m=0;_[0]=_[a]="1";for(i=1;i<a;++i){m=(*_[i-1]-48||*_[i+1]-48?m>atoi(_[i])?m:atoi(_[i]):m);}return m;}

J'ai le sentiment que je devrais pouvoir économiser quelques octets en enregistrant l'un des appels atoi, mais je ne trouvais pas de moyen efficace. ( ,tplus t=plus ,plus tdeux fois c'est trop long). De plus, cela utilise techniquement un comportement indéfini (définir _ [a] sur "1"), mais chaque compilateur que je connais le permet par défaut.

Stratégie: complétez le début et la fin du tableau par 1, puis passez en boucle sur la section interne en vérifiant chaque voisin.

PHP 69 64 octets

Quelques octets de Jörg Hülsermann et Titus. =(-5)

Nécessite register_globals activé. Usage:http://localhost/notnull.php?i[]=9&i[]=-5i[]=...

$x=$_GET['i'];
$y=0;
foreach($x as $j){
if($y<abs($j)){
$y=$j;
}
}
echo $y;

Golfé:

$x=$_GET['i'];$y=0;foreach($x as $j)if($y<abs($j))$y=$j;echo $y;