To jest pytanie do wywiadu Google, patrz link do youtube tutaj.

Zadanie:

Znajdź 2 liczby całkowite z nieuporządkowanej listy, które sumują się do danej liczby całkowitej.

1. Biorąc pod uwagę nieuporządkowaną listę liczb całkowitych, znajdź 2 liczby całkowite, które sumują się do danej wartości, wydrukuj te 2 liczby całkowite i wskaż sukces (wyjście 0). Nie muszą to być żadne konkretne liczby (tj. Pierwsze 2 liczby całkowite sumujące się do właściwej liczby), każda para sumująca się do wartości będzie działać.
2. liczba całkowita jest dodatnia i większa od zera.
3. lista liczb całkowitych może mieć dowolną strukturę danych, w tym plik liczb całkowitych - jedna liczba całkowita na linię.
4. jeśli nie można znaleźć liczb całkowitych, wskazać awarię (wyjście 1).
5. dwie liczby całkowite na różnych pozycjach na liście muszą zostać zwrócone. (tzn. nie możesz zwrócić tej samej liczby dwa razy z tej samej pozycji)

(Uwaga: w filmie nie są to dokładnie wymagania. „Ankieter” wielokrotnie się zmieniał).

na przykład.

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

Stan wydruków 3i 5wyjścia wynosi 0. Zauważ, że w tym 1,7i 2,6również będą dozwolone wyniki.

sum2 8 <<EOF
1
2
3
4

Zwraca status wyjścia 1, ponieważ nie ma możliwej kombinacji. 4,4nie jest dozwolone, zgodnie z regułą 5.

Bash, 84 bajtów

Moja implementacja (z grubsza) rozwiązania inżynierskiego Google, ale używając bash i strumienia wejściowego - nie moje rozwiązanie, więc to się nie liczy.

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

metoda

podczas gdy możemy odczytać liczbę całkowitą V ze strumienia wejściowego, jeśli jest mniejsza niż docelowy 1 $, to jeśli już widzieliśmy 1-V $, to wypisz 1-V i V i wyjdź 0 (w przeciwnym razie) zapisz kandydata na wejście 1-V wyjście 1

Brachylog , 9 bajtów

h⊇Ċ.+~t?∧

Wypróbuj online!

Zakładając, że poprawnie zrozumiałem wyzwanie…

Wyjaśnienie

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 bajtów

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

Wypróbuj
Wypróbuj bez możliwych rezultatów

Rozszerzony:

$_ = 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 bajtów

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

Zwraca parę liczb w postaci tablicy, jeśli zostanie znaleziona, w przeciwnym razie zwraca undefinedwartość fałszowania.

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 bajtów

Pobiera tablicę liczb całkowitych ai oczekiwaną sumę sw składni curry (a)(s). Zwraca parę pasujących liczb całkowitych jako tablicę lub undefinedjeśli taka para nie istnieje.

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

Sformatowane i skomentowane

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

Test

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))

Galaretka , 14 bajtów

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

Wypróbuj online!

Jest to funkcja (nie pełny program), która przekazuje dane na standardowe wyjście. (Łącze TIO ma opakowanie, które uruchamia funkcję i ignoruje jej wartość zwracaną.)

Ten program mógłby być o 4 bajty krótszy, gdyby nie wymaganie kodu wyjścia; zwrócenie kodu wyjścia 1 w Jelly jest dość trudne. (Możliwe, że jest jeszcze szybszy sposób na zrobienie tego, za czym tęskniłem.)

Wyjaśnienie

Œ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

Możemy całkowicie zmniejszyć o połowę każdą liczbę całkowitą w parze, więc o⁶Hnic nie zrobi, jeśli znajdziemy wynik, poza zwrotem bezużytecznej wartości zwrotnej, która i tak nie jest istotna ( Ṅsłuży jako wygodna metoda jednobajtowa do określenia zwrotu funkcji wartość wcześnie, zgodnie z zasadami PPCG). Jeśli jednak nie znaleźliśmy wyniku, próbujemy zmniejszyć o połowę znak spacji, operacja tak bezsensowna, że ​​powoduje awarię interpretera Jelly. Na szczęście ta awaria generuje kod wyjścia 1.

Perl 5 , 51 bajtów

46 bajtów kodu + na 5 bajtów dla -pliflag.

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

Wypróbuj online!

Chodzi o iterację na liście danych wejściowych: na liczbie x( $_), jeśli wcześniej widzieliśmy n-x( $^I-$_), to znaleźliśmy to, czego szukaliśmy, i ustawiliśmy $\te dwie wartości ( "$_ $v"). Na koniec, jeśli $\nie jest ustawiony, to my exit 1, w przeciwnym razie zostanie to domyślnie wydrukowane.

Röda , 60 56 bajtów

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

Wypróbuj online!

Ten kod zgłasza błąd, jeśli nie ma odpowiedzi. Generuje wszystkie możliwe pary, które mogą tworzyć sumę s, tj. 1, s-1, 2, s-2, 3, s-3, ... Następnie sprawdza, czy oba numery są w tablicy a, a jeśli tak, to popycha je do strumienia. pullodczytuje jedną wartość ze strumienia i zwraca ją. Jeśli w strumieniu nie ma żadnych wartości, generuje błąd. a-xzwraca tablicę apo xusunięciu.

Python 2, 60 bajtów

To krótkie, dopóki zasady z wyjściem z kodem 1 nie zostaną wyjaśnione. Teraz kończy się z błędem, jeśli nic nie zostanie znalezione.

-5 bajtów dzięki @Peilonrayz

-4 bajty dzięki @Rod

Wypróbuj online

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

C ++ 133 bajty (skompilowane z clang 4 i 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 bajtów

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 bajty

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

Wypróbuj online!

Dla każdego elementu listy ta funkcja sprawdza, czy (element sum) znajduje się w następnej części listy. Zwraca pierwszą znalezioną parę. Jeśli funkcja osiągnie koniec listy, zgłasza błąd „niewyczerpujące wzorce” i kończy działanie z kodem 1.

PowerShell, 109 97 bajtów

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

Podjęto 12-bajtową ofertę, którą zaoferował AdmBorkBork

Wyjaśnienie

# 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

Obecne reguły szukają kodu wyjścia, który to robi. Można je usunąć i po prostu sprawdzić, czy zwracane są liczby i fałsz.

Przykładowe użycie

Jeśli powyższy kod został zapisany jako funkcja s

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

R, 49 bajtów

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

Znajduje wszystkie 2 kombinacje xi zwraca macierz. Następnie sumuje według kolumny i znajduje wszystkie sumy równe y(więc bez [,1]części na końcu wypisze wszystkie kombinacje, których sumy są równe y)

Japt , 9 bajtów

Zaoszczędzono wiele bajtów dzięki produktom @ETH

à2 æ_x ¥V

Wypróbuj online!

Wyjaśnienie

à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   

Przykład

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 bajtów

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]]}

Zapisano 1 bajt dzięki @Cyoce i kolejne 8 bajtów dzięki @ETHProductions

Zwraca krotkę z pierwszą kombinacją elementów listy, które sumują się do podanych danych wejściowych lub nic w przypadku braku dopasowania. Usunąłem vars w funkcji; REPL.it ulega awarii bez nich, ale konsola Chrome Dev radzi sobie z tym dobrze ...

Wypróbuj online!

Clojure, 77 bajtów

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

Zwraca pierwszą taką parę lub nil.

Haskell, 62 bajty

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

Nadal nie wiem, na co pozwala wyzwanie, a co nie. Idę na funkcję, która wypisuje parę liczb i zwraca 0, jeśli istnieje rozwiązanie, i nie drukuje nic i zwraca 1, jeśli nie ma rozwiązania. Ponieważ druk jest we / wy, muszę podnieść zwracane wartości do IO-Monad (via return), a faktyczny typ funkcji to Num a => IO a.

Przykład użycia (z wartością zwrotną wydrukowaną przez replikę):

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

Wypróbuj online! .

Jeśli dozwolone jest zgłaszanie wyjątków, failzapisze niektóre bajty (łącznie 51):

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

Galaretka , 9 bajtów

ŒcS=¥ÐfḢZ

Jelly nie ma możliwości ustawienia kodu wyjścia na dowolne wartości, więc powoduje to błąd TypeError dla danych wejściowych bez prawidłowego rozwiązania, które spowoduje, że interpreter nadrzędny zakończy działanie z kodem wyjścia 1 .

Wypróbuj online!

Jak to działa

Œ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 bajtów

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

Jedną fajną rzeczą w Code Golf jest to, że pomaga mi znaleźć błędy w moim języku. np. wymagana przestrzeń między returni [y,x-y].

Gdy dodam funkcje push / pop do Array.nova i naprawię return, będzie to 96 bajtów:

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

Stosowanie:

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
    }
}

Edycja: Jest też ten sposób na 73 bajtach (69 przy użyciu pop):

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

firstOrThrow zgłosi wyjątek, który nie zostanie przechwycony, a tym samym ostatecznie wyjdzie z programu z kodem wyjścia 1.;)

Ten sposób również wydaje się bardziej czytelny.

Pyth, 12 bajtów

hfqsThQ.ceQ2

Wyjaśnienie

       .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 bajtów

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

pobiera dane wejściowe z argumentów wiersza poleceń, najpierw sumuj. Uruchom z -nr.

Na szczęście die/ exitkończy działanie, 0gdy podasz mu ciąg jako parametr.

_{Próbowałem połączyć pętle w jedną; ale tym razem wymaga dłuższej inicjalizacji i przetestowania.}

Mathematica, 76 bajtów

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

Całkiem proste: #~Subsets~{2}pobiera wszystkie 2-elementowe podzbiory listy, a następnie Cases[...,x_/;Tr@x==#2]wybiera tylko te, których suma jest liczbą, której chcemy. Jeśli nie ma żadnego z nich, If[l=={}, Message@f::e,First@l]wyświetla komunikat o błędzie f::e : 1, który zdefiniowaliśmy wcześniej (ponieważ nie mam pojęcia, co jeszcze może oznaczać „status wyjścia 1” dla Mathematica); w przeciwnym razie zwraca pierwszy wpis na liście par, które sumują się do poprawnej rzeczy.

Jeśli wolno nam zwrócić wartość falsey zamiast robić ten dziwny status wyjścia, poniższy kod ma 58 bajtów:

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

Scala, 55 41 bajtów

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

Zwraca listę dwóch liczb, jeśli istnieją, i w przeciwnym razie zgłasza błąd. Nieprzechwycony, ten błąd spowoduje status wyjścia 1.

Rubin, 53 48 bajtów

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

Dane wejściowe: a to lista, s to oczekiwana suma.

Jeśli 2 liczby zostaną znalezione, wydrukuj je i zwróć 0, w przeciwnym razie zwróć 1, jak w specyfikacji.

TI-Basic, 59 bajtów

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

Wyjaśnienie:

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

Jeśli program nie zamknął się płynnie, spowoduje błąd, gdy na liście nie będzie wystarczającej liczby elementów, aby kontynuować.

CJam, 23 bajty

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

Dane wejściowe to sum numbers. Na przykład: 6 [3 2 3]. Pozostawia liczbę dodatnią dla prawdy i pusty ciąg znaków lub 0 dla falsey.

Wyjaśnienie:

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