L'intervista: The Front Nine


18

L'intervista: The Front Nine

Questa è la prima di una serie di sfide ispirate dalla programmazione di domande di colloquio di lavoro.

Entra nell'ufficio dove si trova il tuo potenziale capo futuro. "Vieni e siediti", dice. Ti siedi nervosamente, assicurandoti che il tuo abbigliamento scattante ma professionale sia privo di rughe. Ti pone molte domande sulla tua istruzione, esperienze lavorative precedenti e così via. Gli rispondi per lo più onestamente, aggiungendo un po 'di abbellimento qua e là per farti sembrare migliore. Si sporge in avanti e ricomincia a parlare.

"Hai mai sentito parlare del golf del codice?" Perché sì, ti piace il codice golf e lo fai spesso nel tempo libero. "Fantastico. L'ultima parte del colloquio è un esame tecnico. Ti verrà assegnato il compito di scrivere codice per risolvere una serie di problemi ..." Ti consegna un foglio di carta. Lo guardi rapidamente. Vai tranquillo. Ora, perché ha chiesto del golf a codice?

"Sarai valutato in base alla dimensione totale delle tue soluzioni a questi problemi. Se riesci a ottenere un punteggio inferiore rispetto a tutti gli altri candidati, il lavoro è tuo." Oh. "Come il golf, ci sono 18 problemi, suddivisi in due serie da 9. Sentiti libero di usare qualsiasi lingua che ti piace per risolverli; abbiamo compilatori e interpreti per ogni lingua di cui hai sentito parlare, e sicuramente alcuni che non hai buona fortuna! "

I compiti

Attività 1: tabella di moltiplicazione

Dato un numero ncome input, genera una tabella di moltiplicazione per numeri interi positivi nell'intervallo [1, n]. nsarà nella gamma [1, 12]. Tutti i numeri devono essere allineati a sinistra nella tabella. Usa il personaggio xper l'angolo in alto a sinistra.

Esempi:

n=4
x   1   2   3   4
1   1   2   3   4
2   2   4   6   8
3   3   6   9   12
4   4   8   12  16

n=10
x   1   2   3   4   5   6   7   8   9   10
1   1   2   3   4   5   6   7   8   9   10
2   2   4   6   8   10  12  14  16  18  20
3   3   6   9   12  15  18  21  24  27  30
4   4   8   12  16  20  24  28  32  36  40
5   5   10  15  20  25  30  35  40  45  50
6   6   12  18  24  30  36  42  48  54  60
7   7   14  21  28  35  42  49  56  63  70
8   8   16  24  32  40  48  56  64  72  80
9   9   18  27  36  45  54  63  72  81  90
10  10  20  30  40  50  60  70  80  90  100

Compito 2: RMS ordinario

Data una stringa di caratteri ASCII, genera la media quadrata medio -radice delle ordinali ASCII. La stringa non conterrà mai un byte NULL (0 ordinale).

Esempi:

Input: The Interview: The Front Nine
Output: 95.08290393488019

Input: `1234567890-=qwertyuiop[]\asdfghjkl;'zxcvbnm,./
Output: 91.38101204135423

Task 3: Motion proiettile

Data la velocità iniziale e l'angolo con l'orizzonte di un proiettile sparato dal livello del suolo, genera la distanza orizzontale che percorrerà prima dell'atterraggio. La velocità iniziale sarà data in metri al secondo, l'angolo sarà dato in gradi e la distanza sarà in metri. Assumi la gravità terrestre ( g=9.81 m/s/s) e ignora gli effetti relativistici. Per motivi di questo problema, potresti supporre che la Terra sia piatta (non dovrai considerare la curvatura della Terra quando esegui i tuoi calcoli). L'angolo dato sarà compreso nell'intervallo [0, 90]. La risposta deve essere accurata con almeno due cifre decimali (è consentito l'arrotondamento).

Esempi:

velocity=50, angle=45
Result: 254.84 (rounded)

velocity=10, angle=60
Result: 8.82798576742547

Compito 4: etaoin shrdlu

Data una stringa di caratteri ASCII stampabili non nulli (ordinali nell'intervallo [32,127]), genera la stringa, con i suoi caratteri ordinati in base alla loro frequenza in ordine decrescente. In caso di pareggio, ordina per ASCII ordinale, in ordine crescente.

Esempi:

Input: "Hello, World!"
Output: "llloo !,HWder"

Input: "Programming Puzzles and Code Golf"
Output: "    oooPPaaddeeggllmmnnrrzzCGfisu"

Compito 5: indice di Fibonacci

Dato un numero, determina se è un numero di Fibonacci e, se lo è, genera il suo indice (a partire da 1) nella sequenza. Se non è un numero di Fibonacci, emettere 0. Nel caso di 1, che è nella sequenza due volte, emettere il primo evento (indice 1).

Esempi:

Input: 1
Output: 1

Input: 144
Output: 12

Input: 4
Output: 0

Compito 6: Anagrammi

Dato tre stringhe di lettere inglesi minuscole ( [a-z]), genera una stringa che utilizza tutte le lettere nella prima stringa, inizia con la seconda stringa e termina con la terza stringa. Se tale stringa non può essere costruita, emettere una stringa vuota. Le stringhe di input saranno sempre lunghe almeno una lettera. Il "mezzo" della stringa di output (tra la stringa di prefisso e postfisso) può essere vuoto, se le stringhe di prefisso e postfisso insieme usano tutte le lettere nella stringa di origine.

Esempi:

Input: geobits bi es
Possible output: bigtoes

Input: mariatidaltug digital trauma
Output: digitaltrauma

Input: mego go lf
Output: (empty string)

Attività 7: Riempimento degli spazi vuoti

Dato un elenco di stringhe e un carattere di riempimento, emette il risultato del riempimento di tutte le stringhe alla lunghezza della stringa più lunga con il carattere di riempimento, ordinati in ordine crescente in base alle lunghezze originali delle stringhe, preservando l'ordine originale nel caso di una cravatta. Dovresti essere in grado di gestire elenchi di qualsiasi lunghezza finita, contenenti stringhe di qualsiasi lunghezza finita, delimitate solo da vincoli di memoria.

Esempi:

Input: ["hello","world","this","is","a","test"], 'x'
Output: ["axxxx","isxxx","thisx","testx","hello","world"]

Input: ["I'm","a","lumberjack","and","I'm","okay"], '!'
Output: ["a!!!!!!!!!","I'm!!!!!!!","and!!!!!!!","I'm!!!!!!!","okay!!!!!!","lumberjack"]

Attività 8: apportare modifiche

Dato un numero nell'intervallo [0.01,0.99], genera il numero di ciascuna delle 4 monete statunitensi standard che dovrebbero essere utilizzate per rappresentare questo valore in modo tale da ridurre al minimo il numero totale di monete. L'input avrà sempre esattamente 2 posizioni dietro il decimale.

Riferimento valore moneta:

Penny: 0.01, Nickel: 0.05, Dime: 0.10, Quarter: 0.25

Esempi:

Input: 0.75
Output: [0,0,0,3]

Input: 0.23
Output: 3 pennies, 0 nickels, 2 dimes, 0 quarters

Attività 9: unione di intervalli

Dato un elenco finito di 2 tuple contenente numeri interi che rappresentano intervalli, produce il risultato della fusione di tutti gli intervalli sovrapposti o adiacenti. Tutti gli intervalli avranno almeno la lunghezza 1 e il valore iniziale sarà sempre inferiore al valore finale. L'ordine dell'output non ha importanza.

Esempi:

Input: (2,3), (4,5), (6,9), (0,7)
Output: (0,9)

Input: (-3,4), (2,5), (-10,-4)
Output (-10,-4), (-3,5)

Input: (2,3), (5,6), (6,8)
Output: (5,8), (2,3)

Regole

  • Questo è , quindi vince la risposta più breve (in byte).
  • Il tuo punteggio sarà la somma dei conteggi dei byte per tutte le tue soluzioni.
  • Sono vietate le scappatoie standard.
  • L'input e l'output possono essere eseguiti in qualunque modo sia considerato standard nella vostra lingua.
  • Puoi scrivere programmi o funzioni completi per ogni sfida e puoi scambiare tra le due sfide.
  • Devi usare la stessa lingua per tutte le sfide. Se le differenze di versione sono abbastanza significative per essere generalmente considerate voci separate nelle sfide, è necessario utilizzare la stessa versione per tutto. Ad esempio, se si utilizza Python, è necessario utilizzare Python 2 o Python 3 per tutte le sfide.
  • Devi risolvere tutte le sfide. Le risposte che risolvono solo alcune delle sfide saranno considerate non competitive.
  • È possibile utilizzare i built-in di lingua o le librerie standard.

Classifica

Lo snippet di stack nella parte inferiore di questo post genera la classifica dalle risposte a) come un elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

## Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


Siamo autorizzati a produrre numeri in notazione scientifica nell'attività 1?
FUZxxl,

1
anche se mi piacerebbe avere un'intervista del genere, dubito che classifichi bene le persone. eh, qualunque cosa. ancora divertente
orgoglioso haskeller il

Dobbiamo stampare i risultati o possiamo restituirli dalle funzioni? Se quest'ultimo è consentito, per l'attività 1 possiamo restituire una matrice o simile?
Alex A.

L'attività 8 sembra avere 2 formati di output, possiamo usare solo il primo?
aditsu,

1
@pppery, questa domanda è più vecchia del link che hai fornito, quindi non credo che si applichi a questa domanda.
Night2

Risposte:


8

Pyth, 155 153 149 142 141 131 130 byte

4 byte grazie a @FryAmTheEggman

1, 5 e 4 byte grazie a @Jakube

  1. 24 byte :J+1SQp\xtjmsm.[`*dk\ 4JJ

Costruisci la tabella di moltiplicazione dall'elenco [1, 1, 2, 3, ...], che è +1SQ, quindi stampa a xe rimuovi il suo primo carattere.

  1. 10 byte :@.Om^Cd2z2

Semplice.

  1. 18 byte :c*.t.tyvw7Z*QQ9.81

Usa la formula sin(2 theta) * v^2/a, dove thetaè l'angolo, vè la velocità iniziale ed aè9.81

  1. 7 byte :o_/zNSz

Semplice.

  1. 15 byte :hxeM.u,eNsNQU2Q

Genera coppie di fibonacci, trova in esse l'indice dell'input, aggiungine uno.

  1. 14 byte :IqSzSJj.-zsQQJ

Usa la sottrazione bagwise per rimuovere il prefisso e il suffisso dalla parola, quindi metti il ​​resto della parola nel mezzo. Se il risultato non è una permutazione dell'input, non stamparlo.

  1. 8 byte :C.tolNQz

Ordina per lunghezza. Trasposizione riempita. Trasporre di nuovo.

  1. 18 byte :Jsttz/L~%Jd[25T5 1

I conteggi delle monete in uscita sono nell'ordine [quarters, dimes, nickels, pennies].

Rimuovi i primi 2 caratteri dell'input e esegui il cast su int per ottenere centesimi. Salva in J. Per ogni numero dnell'elenco [25, 10, 5, 1], post-assegnare J%da J, quindi generare il valore /Jdcon il valore originale di J. Stampa.

  1. 16 byte :C-M.p,JS{srMQhMJ

Trasforma le tuple in intervalli, combinali in un elenco, deduplica e ordina. Salva questo in J. Modulo J, hMJe hMJ, J, dove hMJè Jcon ogni elemento aumentato di 1. Eseguire sottrazione in entrambi i casi. Il primo è l'estremità inferiore delle gamme, il secondo è l'estremità superiore. Trasponili in coppie e stampali.



6

CJam, 223 byte

Attività 1, 35 byte

ri_)_,0Xt2m*::*0'xt:s@s,2+f{Se]}/N*

Provalo online.

Attività 2, 12 byte

q_:i:mh\,mq/

Provalo online.

Attività 3, 27 byte

rd180/P*_mc\ms]rdf*~4.905/*

Provalo online.

Attività 4, 12 byte

q$e`{0=~}$e~

Provalo online.

Attività 5, 17 byte

XXri:R{_2$+}*]R#)

Provalo online.

Attività 6, 25 byte

re!_rf#:!.*r:S;{N+SN+#)}=

Provalo online.

Attività 7, 19 byte

{:C;{,}$_W=,f{Ce]}}

Provalo online.

Attività 8, 33 byte

A4m*{:+}$r2>i:R;{[X5A25].*:+R=}=p

Provalo online.

Attività 9, 43 byte

{{~1$-,f+}%:|$__,(%a\2ew{:-W<},+e_$2/2,f.+}

Provalo online.


4

Haskell, 650 byte

Attività 1, 88 byte:

f n="x   "++unlines(map(take 4.(++"   ").show=<<)$[1..n]:map(\a->a:map(a*)[1..n])[1..n])

Attività 2, 76 byte:

g s=sqrt(sum(map(fromIntegral.(^2).fromEnum)s)/sum(s>>[1]))

Attività 3, 28 byte

v?a=v*v/9.81*sin(2*a*pi/180)

Attività 4, 60 byte:

import Data.List
i x=concat$sortOn((0-).length)$group$sort x

Attività 5, 64 byte

j=(%zip[0..]z);x%((i,h):t)|x<h=0|x==h=i|1<2=x%t;z=scanl(+)0(1:z)

Attività 6, 93 byte

import Data.List
k a b c|q b a&&q c a=b++((a\\b)\\c)++c|1<2="";q=(.sort).isSubsequenceOf.sort

Attività 7, 81 byte

import Data.List
s!f=map(take(maximum$map r s).(++cycle[f]))(sortOn r s);r=length

Attività 8, 73 byte

m x=floor(x*100)#[25,10,5,1];x#[]=[];x#(h:t)|(d,m)<-divMod x h=(m#t)++[d]

Attività 9, 87 byte (una copia spudorata della risposta di @ MtnViewMark da una sfida simile)

n i=foldr(&)[]i;p@(a,b)&(q@(c,d):r)|b<c=p:q&r|a>d=q:p&r|1<3=(min a c,max b d)&r;p&_=[p]

2

Mathematica 10.3, 465 byte

Tutte queste sono funzioni anonime. Inoltre, grazie a Martin per l'aiuto nel golf, dal momento che sono un noob a Mathematica.

Attività 1, 69 byte

Grid@Join[{Join[{"x"},r=Range@#]},Flatten/@({r,Outer[1##&,r,r]}\[Transpose])]&

\[Transpose] è il simbolo di "trasposizione" a 3 byte.

Attività 2, 13 byte

Mean[#^2]^.5&

o

√Mean[#^2]&

(√ è 3 byte). Il RootMeanSquarebuilt-in non è abbastanza corto ...

Attività 3, 18 byte

Sin[2#2°]#/9.81#&

Attività 4, 57 byte

""<>SortBy[c=Characters@#,{-c~Count~#&,ToCharacterCode}]&

Attività 5, 33 byte

Tr@Position[Fibonacci@Range@#,#]&

o

Tr[Fibonacci@Range@#~Position~#]&

o

Tr[Fibonacci~Array~#~Position~#]&

Attività 6, 178 byte (attualmente ha un bug)

({s,a,b}=Characters@{##};q=If[#2~SubsetQ~#,List@@(Plus@@#-Plus@@#2),{}]&;i=If[#!={},##]&;x=i[q[s,a],{}];y=If[x!={},i[q[x,b],{},Null],Null];Echo[If[y!=Null,""<>Join@{a,y,b},""]])&

Meno golf:

({s,a,b}=Characters@{##};
q=If[#2~SubsetQ~#,List@@(Plus@@#-Plus@@#2),{}]&;
i=If[#!={},##]&;
x=i[q[s,a],{}];
y=If[x!={},i[q[x,b],{},Null],Null];
Echo[If[y!=Null,""<>Join@{a,y,b},""]])&

La manipolazione delle stringhe è orribile ...

Attività 7, 39 byte

#~SortBy~StringLength~StringPadRight~#1

Attività 8, 46 byte

FrobeniusSolve[{1,5,10,25},100#]~MinimalBy~Tr&

o

{.1,.5,.10,.25}~FrobeniusSolve~#~MinimalBy~Tr&

Attività 9, 12 byte

Interval@##&

Gli intervalli passati al costruttore vengono automaticamente uniti. Battilo.

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.