Il s'agit d'une question d'entrevue Google, voir ici pour un lien youtube.

La tâche:

Trouvez 2 entiers dans une liste non ordonnée qui totalisent un entier donné.

1. Étant donné une liste non ordonnée d'entiers, recherchez 2 entiers qui totalisent une valeur donnée, imprimez ces 2 entiers et indiquez le succès (sortie 0). Ils n'ont pas besoin d'être des nombres particuliers (c'est-à-dire les 2 premiers entiers additionnant au bon nombre), n'importe quelle paire qui additionne la valeur fonctionnera.
2. un entier est positif et supérieur à zéro.
3. une liste d'entiers peut être dans n'importe quelle structure de données, y compris un fichier d'entiers - un entier par ligne.
4. si aucun entier ne peut être trouvé, indiquer un échec (sortie 1).
5. deux entiers à des positions différentes dans la liste doivent être retournés. (c'est-à-dire que vous ne pouvez pas renvoyer deux fois le même numéro à partir de la même position)

(Remarque: dans la vidéo, ce ne sont pas exactement les exigences. L'enquêteur a changé ses multiples fois.)

par exemple.

sum2 8 <<EOF
1
7
4
6
5
3
8
2
EOF

Imprime 3et 5et le statut de sortie est 0. Notez que cela 1,7et 2,6serait également autorisé des résultats.

sum2 8 <<EOF
1
2
3
4

Renvoie l'état de sortie 1 car aucun combo possible. 4,4n'est pas autorisé, selon la règle 5.

Bash, 84 octets

Mon implémentation de la solution (grossièrement) de l'ingénieur de Google mais en utilisant bash et un flux d'entrée - pas ma solution, donc cela ne compte pas.

while read V;do((V<$1))&&{ ((T=R[V]))&&echo $T $V&&exit;((R[$1-V]=V));};done;exit 1

Méthode

alors que nous pouvons lire l'entier V du flux d'entrée s'il est inférieur à la cible $ 1, alors s'il est déjà vu $ 1-V, puis imprimer $ 1-V et V et quitter 0 (sinon) enregistrer le candidat pour l'entrée $ 1-V quitter 1

Brachylog , 9 octets

h⊇Ċ.+~t?∧

Essayez-le en ligne!

En supposant que j'ai bien compris le défi…

Explication

h⊇Ċ          Ċ ('couple') has two elements, and is a subset of the head of the input
  Ċ.         Output = Ċ
   .+~t?     The sum of the elements of the Output is the tail of the Input
        ∧    (disable implicit unification)

Perl 6 , 59 octets

$_=get;put lines().combinations(2).first(*.sum==$_)//exit 1

Essayez-le
Essayez sans résultat possible

Étendu:

$_ = get;            # get one line (the value to sum to)

put                  # print with trailing newline
    lines()          # get the rest of the lines of input
    .combinations(2) # get the possible combinations
    .first(          # find the first one
      *.sum == $_    # that sums to the input
    )
  //                 # if there is no value (｢Nil｣)
    exit 1           # exit with a non-zero value (｢put｣ is not executed)

JavaScript ES6, 58 70 68 64 octets

a=>b=>{for(i in a)if(a.includes(b-a[i],i+1))return[a[i],b-a[i]]}

Renvoie une paire de nombres sous la forme d'un tableau s'il est trouvé, sinon renvoie undefinedune valeur falsifiée.

f=a=>b=>{for(i in a)if(a.includes(b-a[i],i+1))return[a[i],b-a[i]]}

console.log(f([1,7,4,6,5,3,8,2])(8));
console.log(f([1,2,3,4,5,6,7,8])(8));
console.log(f([1,2,3,4])(8));
console.log(f([2,2])(4));

JavaScript (ES6), 61 57 56 octets

Prend le tableau d'entiers aet la somme attendue sdans la syntaxe de curry (a)(s). Renvoie une paire d'entiers correspondants sous forme de tableau, ou undefinedsi aucune paire de ce type n'existe.

a=>s=>(r=a.find((b,i)=>a.some(c=>i--&&b+c==s)))&&[r,s-r]

Formaté et commenté

a =>                      // given an array of integers (a)
  s => (                  // and an expected sum (s)
    r = a.find((b, i) =>  // look for b at position i in a such that:
      a.some(c =>         //   there exists another c in a:
        i-- &&            //     - at a different position
        b + c == s        //     - satisfying b + c == s
      )                   //   end of some()
    )                     // end of find(): assign the result to r
  ) &&                    // if it's not falsy:
  [r, s - r]              // return the pair of integers

Tester

let f =

a=>s=>(r=a.find((b,i)=>a.some(c=>i--&&b+c==s)))&&[r,s-r]

console.log(f([1,7,4,6,5,3,8,2])(8))
console.log(f([1,2,3,4])(8))

Gelée , 14 octets

ŒcS=⁹$$ÐfḢṄo⁶H

Essayez-le en ligne!

Il s'agit d'une fonction (pas d'un programme complet) qui produit une sortie standard. (Le lien TIO a un wrapper qui exécute une fonction et ignore sa valeur de retour.)

Ce programme pourrait être de 4 octets plus court si ce n'est pour l'exigence de code de sortie; renvoyer un code de sortie de 1 dans Jelly est assez difficile. (Il est possible qu'il y ait un moyen terser de faire cela que j'ai manqué.)

Explication

ŒcS=⁹$$ÐfḢṄo⁶H
Œc                All pairs of values from {the first argument}
       Ðf         Take only those which
  S=⁹               sum to {the second argument}
     $$           Parse the preceding three builtins as a group
         Ḣ        Take the first result (0 if there are no results)

          Ṅ       Output this result (plus a newline) on standard output
           o⁶     If this value is falsey, replace it with a space character
             H    Halve every element of the value

Nous pouvons très bien diviser par deux chaque entier d'une paire, donc le o⁶Hne fera rien si nous trouvons un résultat, autre que le retour d'une valeur de retour inutile qui n'est pas pertinente de toute façon (le Ṅsert de méthode pratique à un octet pour déterminer le retour de la fonction valeur anticipée, selon les règles PPCG). Cependant, si nous ne trouvons pas de résultat, nous finissons par essayer de diviser par deux un espace, une opération si vide de sens qu'elle fait planter l'interpréteur Jelly. Heureusement, ce plantage produit un code de sortie de 1.

Perl 5 , 51 octets

46 octets de code + pour 5 octets pour les -plidrapeaux.

$\="$_ $v"if$h{$v=$^I-$_};$h{$_}=1}{$\||exit 1

Essayez-le en ligne!

L'idée est d'itérer sur la liste d'entrée: sur un nombre x( $_), si nous avons vu précédemment n-x( $^I-$_) alors nous avons trouvé ce que nous cherchions, et mis $\à ces deux valeurs ( "$_ $v"). À la fin, s'il $\n'est pas défini, alors nous exit 1, sinon il sera implicitement imprimé.

Röda , 60 56 octets

f s,a{seq 1,s|{|x|[[x,s-x]]if[x in a,s-x in a-x]}_|pull}

Essayez-le en ligne!

Ce code renvoie une erreur s'il n'y a pas de réponse. Il génère toutes les paires possibles qui peuvent former la somme s, c'est-à-dire. 1, s-1, 2, s-2, 3, s-3, ... Ensuite , il vérifie si les deux chiffres sont dans le tableau aet le cas échéant, les pousse au courant.pulllit une valeur du flux et la renvoie. S'il n'y a pas de valeurs dans le flux, il renvoie une erreur. a-xrenvoie le tableau aavec xsupprimé.

Python 2, 60 octets

Ce court, jusqu'à ce que les règles de sortie avec le code 1 soient clarifiées. Quitte maintenant avec erreur si rien n'est trouvé.

-5 octets grâce à @Peilonrayz

-4 octets grâce à @Rod

Essayez-le en ligne

a,s=input()
while a:
 x=a.pop()
 if s-x in a:r=s-x,x
print r

C ++ 133 octets (compilé avec clang 4 et gcc 5.3 -std = c ++ 14)

#include <set>
auto f=[](auto s,int v,int&a,int&b){std::set<int>p;for(auto i:s)if(p.find(i)==end(p))p.insert(v-i);else{a=v-i;b=i;}};

C 108 octets

void f(int*s,int*e,int v,int*a,int*b){do{int*n=s+1;do if(v-*s==*n){*a=*s;*b=*n;}while(++n<e);}while(++s<e);}

Haskell , 34 octets

(n:v)#s|elem(s-n)v=(n,s-n)|1<2=v#s

Essayez-le en ligne!

Pour chaque élément de la liste, cette fonction vérifie si (sum-element) se trouve dans la partie suivante de la liste. Renvoie le premier couple qu'il trouve. Si la fonction atteint la fin de la liste, elle génère une erreur "modèles non exhaustifs" et se termine avec le code 1.

PowerShell, 109 97 octets

param($i,$a)($c=0..($a.count-1))|%{$c-ne($f=$_)|%{if($a[$f]+$a[$_]-eq$i){$a[$f,$_];exit}}};exit 1

A pris un accord de 12 octets qu'AdmBorkBork a offert

Explication

# Get the parameter passed where $i is the addition target from the array of numbers in $a
param($i,$a)

($c=0..($a.count-1))|%{
    # We are going to have two loops to process the array elements.
    # The first loop element will be held by $f
    $f=$_
    # Create a second loop that will be the same as the first except for the position of $f to
    # prevent counting the same number twice. 
    $c|?{$_-ne$f}|%{
        # Check if the number at the current array indexes add to the target value. If so print and exit.
        if($a[$f]+$a[$_]-eq$i){$a[$f],$a[$_];exit}        
    }

}
# If nothing was found in the loop then we just exit with error.
exit 1

Les règles actuelles recherchent le code de sortie, ce qui est le cas. Ceux-ci pourraient être supprimés et vérifier simplement les numéros retournés et une fausse.

Exemple d'utilisation

Si le code ci-dessus a été enregistré en tant que fonction s

s 8 @(1,2,3,4)
s 8 @(1,7,4,6,5,3,8,2) 

R, 49 octets

function(x,y){r=combn(x,2);r[,colSums(r)==y][,1]}

Ceci trouve toutes les 2 combinaisons de xet retourne une matrice. Ensuite, somme par colonne et trouve toutes les sommes égales à y(donc sans la [,1]partie à la fin, il imprimera toutes les combinaisons auxquelles leurs sommes sont égales y)

Japt , 9 octets

Beaucoup d'octets enregistrés grâce à @ETHproductions

à2 æ_x ¥V

Essayez-le en ligne!

Explication

à2 æ_x ¥V
à2         // Creates all combinations of the input, length 2
   æ       // Returns the first item where:
    _x     //     The sum of the two items in each set
       ¥V  //     == Second input   

Exemple

Input:        [1,2,3], 4
à2         // [[1,2],[1,3],[2,3]]
   æ_x     // [3,    4,    5    ]
       ¥V  //  3!=4, 4==4 ✓
Output:    //  1,3

Javascript, 114 96 86 84 octets

a=>b=>{c=b.length;for(x=0;x<c;x++)for( y=x;++y<c;)if(b[x]+b[y]==a)return[b[x],b[y]]}

1 octet enregistré grâce à @Cyoce et 8 octets supplémentaires grâce à @ETHProductions

Cela renvoie un tuple avec la première combinaison d'éléments de liste qui résument à l'entrée donnée, ou rien pour aucune correspondance. J'ai supprimé les vars dans la fonction; REPL.it se bloque sans eux, mais la console de développement Chrome gère cela très bien ...

Essayez-le en ligne!

Clojure, 77 octets

#(first(mapcat(fn[i a](for[b(drop(inc i)%):when(=(+ a b)%2)][a b]))(range)%))

Renvoie la première paire ou nil.

Haskell, 62 octets

r=return;s#[]=r 1;s#(a:b)|elem(s-a)b=print(a,s-a)>>r 0|1<2=s#b

Je ne sais toujours pas ce qui est permis par le défi et ce qui ne l'est pas. Je vais pour une fonction qui imprime une paire de nombres et renvoie 0 s'il y a une solution et n'imprime rien et renvoie 1 s'il n'y a pas de solution. Comme l'impression est une E / S, je dois relever les valeurs de retour dans l'IO-Monad (via return) et le type réel de la fonction est Num a => IO a.

Exemple d'utilisation (avec valeur de retour imprimée par le repl):

*Main> 4 # [2,2]
(2,2)
0

Essayez-le en ligne! .

Si l'augmentation des exceptions est autorisée, vous failéconomiserez quelques octets (total 51):

s#[]=fail"";s#(a:b)|elem(s-a)b=print(a,s-a)|1<2=s#b

Gelée , 9 octets

ŒcS=¥ÐfḢZ

Jelly n'a aucun moyen de définir le code de sortie sur des valeurs arbitraires, donc cela produit une TypeError pour l'entrée sans une solution valide qui provoquera la sortie de l'interpréteur parent avec le code de sortie 1 .

Essayez-le en ligne!

Comment ça fonctionne

ŒcS=¥ÐfḢZ  Main link. Argument: A (array of integers), n (integer)

Œc         Yield all 2-combinations of different elements of A.
     Ðf    Filter by the link to the left.
    ¥        Combine the two links to the left into a dyadic chain.
  S            Take the sum of the pair.
   =           Compare the result with n.
       Ḣ   Head; extract the first pair of the resulting array.
           This yields 0 if the array is empty.
        Z  Zip/transpose the result.
           This doesn't (visibly) alter pairs, but it raise a TypeError for 0.

Nova , 101 octets

q(Int[] a,Int x)=>a{if(Int y=a.firstWhere({a.contains(x-a.remove(0))}))return [y,x-y];System.exit(1)}

Une bonne chose à propos du code golf est qu'il m'aide à trouver des bugs dans ma langue. par exemple l'espace requis entre returnet [y,x-y].

Une fois que j'ajoute des fonctions push / pop à Array.nova et corrige le retour, ce serait 96 octets:

q(Int[] a,Int x)=>a{if(Int y=a.firstWhere({a.contains(x-a.pop())}))return[y,x-y];System.exit(1)}

Usage:

class Test {
    static q(Int[] a,Int x)=>a{if(Int y=a.firstWhere({a.contains(x-a.remove(0))}))return [y,x-y];System.exit(1)}

    public static main(String[] args) {
        Console.log(q([1, 2, 3, 4, 5], 8)) // [5, 3]
        Console.log(q([1, 2, 3, 4, 5], 5)) // [1, 4]
        Console.log(q([1, 2, 3, 4], 8)) // exit code 1
    }
}

Edit: Il y a aussi cette façon à 73 octets (69 en utilisant pop), aussi:

q(Int[] a,Int x)=>[Int y=a.firstOrThrow({a.contains(x-a.remove(0))}),x-y]

firstOrThrow lèvera une exception, qui ne sera pas interceptée et donc finira par quitter le programme avec le code de sortie 1.;)

Cette manière semble également plus lisible.

Pyth, 12 octets

hfqsThQ.ceQ2

Explication

       .ceQ2   Get all pairs from the second input
 fqsThQ        Find the ones whose sum is the first input
h              Take the first (exits with error code 1 if there aren't any)

PHP, 88 octets

for($i=1;$a=$argv[$k=++$i];)for(;$b=$argv[++$k];)if($a+$b==$argv[1])die("$a $b");die(1);

prend l'entrée des arguments de ligne de commande, somme d'abord. Courez avec -nr.

Heureusement, die/ se exittermine 0lorsque vous lui donnez une chaîne en paramètre.

_{J'ai essayé de fusionner les boucles en une seule; mais cela nécessite une initialisation plus longue et un test cette fois.}

Mathematica, 76 octets

f::e="1";If[(l=Cases[#~Subsets~{2},x_/;Tr@x==#2])=={},Message@f::e,First@l]&

Assez simple: #~Subsets~{2}obtient tous les sous-ensembles à 2 éléments de la liste, puis Cases[...,x_/;Tr@x==#2]ne sélectionne que ceux dont la somme est le nombre souhaité. S'il n'y en a pas, If[l=={}, Message@f::e,First@l]imprime le message d'erreur f::e : 1que nous avons défini précédemment (puisque je n'ai aucune idée de ce que pourrait signifier "exit status 1" pour Mathematica); sinon, elle renvoie la première entrée de la liste des paires qui correspondent à la bonne chose.

Si nous sommes autorisés à renvoyer une valeur falsey au lieu de faire cette chose de statut de sortie étrange, le code suivant a 58 octets:

If[(l=Cases[#~Subsets~{2},x_/;Tr@x==#2])=={},1<0,First@l]&

Scala, 55 41 octets

(l,n)=>l combinations 2 find(_.sum==n)get

Renvoie une liste des deux nombres s'ils existent et renvoie une erreur dans le cas contraire. Non détectée, cette erreur entraînera un état de sortie de 1.

Rubis, 53 48 octets

->a,s{p(a.combination(2).find{|x,y|x+y==s})?0:1}

Entrée: a est la liste, s est la somme attendue.

Si les 2 nombres sont trouvés, imprimez-les et retournez 0, sinon retournez 1, comme dans la spécification.

TI-Basic, 59 octets

Prompt L1
Prompt X
While 1
L1(1→B
seq(L1(C),C,2,dim(L1→L1
If sum(not(X-L1-B
Then
Disp B,X-B
Return
End
End

Explication:

Prompt L1               # 4 bytes, input array like "{1, 2, 3}"
Prompt X                # 3 bytes, Input target sum
While 1                 # 3 bytes, until the list is empty
L1(1→B                  # 7 bytes, try the first element (now B)
seq(L1(C),C,2,dim(L1→L1  # 18 bytes, remove first element from list
If sum(not(X-L1-B       # 10 bytes, if any element in the list plus B is the target
Then                    # 2 bytes, then...
Disp B,X-B              # 7 bytes, print it and it's "complement"
Return                  # 2 bytes, and exit gracefully
End                     # 2 bytes
End                     # 1 byte

Si le programme ne s'est pas terminé correctement, il provoquera une erreur lorsqu'il n'y aura pas suffisamment d'éléments dans la liste pour qu'il puisse continuer.

CJam, 23 octets

l~_,1>{e!2f<::+#)}{;;}?

L'entrée est sum numbers. Par exemple:6 [3 2 3] . Laisse un nombre positif pour true et une chaîne vide ou 0 pour falsey.

Explication:

l~    e# Read input and evaluate:  | 7 [3 2 3]
_     e# Duplicate:                | 7 [3 2 3] [3 2 3]
,     e# Take the length:          | 7 [3 2 3] 3
1>{   e# If more than 1:           | 7 [3 2 3]
  e!  e#   Unique permutations:    | 7 [[2 3 3] [3 2 3] [3 3 2]]
  2f< e#   Slice each to length 2: | 7 [[2 3] [3 2] [3 3]]
  ::+ e#   Some each:              | 7 [5 5 6]
  #   e#   Index:                  | -1
  )   e#   Increment:              | 0
}{    e# Else:                     | 7 [3 2 3]
  ;   e#   Pop                     | 7
  ;   e#   pop                     |
}?    e# Endif
e# Implicit output: 0