Em quantas peças você pode cortar esse barbante?


45

Considere um pedaço de corda (como em "corda", não como em "um monte de caracteres"), que é dobrado para frente e para trás na linha real. Podemos descrever o formato da string com uma lista de pontos pelos quais ela passa (em ordem). Para simplificar, assumiremos que todos esses pontos são inteiros.

Tome como exemplo [-1, 3, 1, -2, 5, 2, 3, 4](observe que nem cada entrada implica em uma dobra):

insira a descrição da imagem aqui

A corda que se estende ao longo da direção vertical é apenas para fins de visualização. Imagine a corda toda achatada na linha real.

Agora, aqui está a pergunta: qual é o maior número de peças em que essa corda pode ser cortada com um único corte (que teria que ser vertical na figura acima). Nesse caso, a resposta é 6 com um corte em qualquer lugar entre 2e 3:

insira a descrição da imagem aqui

Para evitar ambiguidades, o corte deve ser realizado em uma posição não inteira.

O desafio

Dada uma lista de posições inteiras pelas quais uma string é dobrada, você deve determinar o maior número de partes em que a string pode ser cortada com um único corte em uma posição não inteira.

Você pode escrever um programa completo ou uma função. Você pode receber entradas via STDIN, argumento de linha de comando, prompt ou parâmetro de função. Você pode gravar a saída em STDOUT, exibi-la em uma caixa de diálogo ou retorná-la da função.

Você pode supor que a lista esteja em qualquer formato conveniente de lista ou string.

A lista conterá pelo menos 2 e não mais de 100 entradas. As entradas serão inteiras, cada uma no intervalo -2 31 ≤ p i <2 31 . Você pode assumir que não há duas entradas consecutivas iguais.

Seu código deve processar qualquer entrada (incluindo os casos de teste abaixo) em menos de 10 segundos em um PC de mesa razoável.

Casos de teste

Todos os casos de teste são simplesmente de entrada, seguidos de saída.

[0, 1]
2

[2147483647, -2147483648]
2

[0, 1, -1]
3

[1, 0, -1]
2

[-1, 3, 1, -2, 5, 2, 3, 4]
6

[-1122432493, -1297520062, 1893305528, 1165360246, -1888929223, 385040723, -80352673, 1372936505, 2115121074, -1856246962, 1501350808, -183583125, 2134014610, 720827868,  -1915801069, -829434432, 444418495, -207928085, -764106377, -180766255, 429579526,  -1887092002, -1139248992, -1967220622, -541417291, -1617463896, 517511661, -1781260846,  -804604982, 834431625, 1800360467, 603678316, 557395424, -763031007, -1336769888,  -1871888929, 1594598244, 1789292665, 962604079, -1185224024, 199953143, -1078097556, 1286821852, -1441858782, -1050367058, 956106641, -1792710927, -417329507, 1298074488,  -2081642949, -1142130252, 2069006433, -889029611, 2083629927, 1621142867, -1340561463,  676558478, 78265900, -1317128172, 1763225513, 1783160195, 483383997, -1548533202,  2122113423, -1197641704, 319428736, -116274800, -888049925, -798148170, 1768740405,  473572890, -1931167061, -298056529, 1602950715, -412370479, -2044658831, -1165885212,  -865307089, -969908936, 203868919, 278855174, -729662598, -1950547957, 679003141,  1423171080, 1870799802, 1978532600, 107162612, -1482878754, -1512232885, 1595639326,  1848766908, -321446009, -1491438272, 1619109855, 351277170, 1034981600, 421097157,  1072577364, -538901064]
53

[-2142140080, -2066313811, -2015945568, -2013211927, -1988504811, -1884073403, -1860777718,  -1852780618, -1829202121, -1754543670, -1589422902, -1557970039, -1507704627, -1410033893,  -1313864752, -1191655050, -1183729403, -1155076106, -1150685547, -1148162179, -1143013543,  -1012615847, -914543424, -898063429, -831941836, -808337369, -807593292, -775755312, -682786953, -679343381, -657346098, -616936747, -545017823, -522339238, -501194053,  -473081322, -376141541, -350526016, -344380659, -341195356, -303406389, -285611307, -282860017, -156809093, -127312384, -24161190, -420036, 50190256, 74000721, 84358785,  102958758, 124538981, 131053395, 280688418, 281444103, 303002802, 309255004, 360083648,  400920491, 429956579, 478710051, 500159683, 518335017, 559645553, 560041153, 638459051,  640161676, 643850364, 671996492, 733068514, 743285502, 1027514169, 1142193844, 1145750868,  1187862077, 1219366484, 1347996225, 1357239296, 1384342636, 1387532909, 1408330157,  1490584236, 1496234950, 1515355210, 1567464831, 1790076258, 1829519996, 1889752281,  1903484827, 1904323014, 1912488777, 1939200260, 2061174784, 2074677533, 2080731335, 2111876929, 2115658011, 2118089950, 2127342676, 2145430585]
2

Podemos supor que você deseja que o corte esteja em um local que garanta o número máximo de peças?
DavidC

2
Eu provavelmente diria: "determine o maior número de peças" em vez de "determine quantas peças".
21915 DavidC

1
Não é a reasonable desktop PCambíguo?
globby

3
@globby É uma frase bastante comum que usamos quando o tempo de execução não faz parte do critério vencedor (mas usado apenas para garantir que as soluções não estejam usando força bruta). Significa principalmente que o limite não é 100% estrito. Se levar 15 segundos na sua máquina (e você não estiver usando um supercomputador), é provável que alguém por aqui tenha um PC de mesa onde ele será concluído em 10 segundos. Mas se for menos provável que demore um minuto na sua máquina, é necessário pensar em uma abordagem diferente. Além disso, o limite é escolhido de forma que um algoritmo eficiente seja concluído facilmente em menos de 10 segundos.
Martin Ender

Respostas:


16

APL, 16 14 bytes

1+⌈/+/2≠/∘.≤⍨⎕

Obrigado a @ngn por salvar 2 bytes.

Na verdade, é um caractere de caixa, não um erro de fonte ausente. Você pode experimentar o programa em tryapl.org , mas como não é totalmente suportado por lá, substitua-o pelo valor de entrada:

    1+⌈/+/2≠/∘.≤⍨ ¯1 3 1 ¯2 5 2 3 4
6

Explicação

O programa é melhor explicado com o exemplo de entrada s = ¯1 3 1 ¯2 5 2 3 4, retirado do STDIN por . Primeiro, calculamos o produto -outer susando ele mesmo ∘.≤⍨. Isso resulta em uma matriz booleana cuja ilinha th indica quais elementos ssão menores ou iguais a s[i]:

1 1 1 0 1 1 1 1
0 1 0 0 1 0 1 1
0 1 1 0 1 1 1 1
1 1 1 1 1 1 1 1
0 0 0 0 1 0 0 0
0 1 0 0 1 1 1 1
0 1 0 0 1 0 1 1
0 0 0 0 1 0 0 1

As ocorrências de 0 1e 1 0na linha imarcam os locais onde a sequência passa sobre o ponto s[i] + 0.5. Combinamos isso em todas as linhas usando 2≠/"reduzir 2 sublistas em ":

0 0 1 1 0 0 0
1 1 0 1 1 1 0
1 0 1 1 0 0 0
0 0 0 0 0 0 0
0 0 0 1 1 0 0
1 1 0 1 0 0 0
1 1 0 1 1 1 0
0 0 0 1 1 0 1

O que resta é pegar as somas das linhas com +/

2 5 3 0 2 3 5 3

e um mais o máximo destes com 1+⌈/:

6

O resultado é impresso automaticamente em STDOUT na maioria das implementações de APL.


@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ Meu resultado ruim esperado é o número de peças, não o local para produzi-lo.
J ...

Tecnicamente, são 16 caracteres e 28 bytes. O Unicode vai fazer isso com você = P
KChaloux

1
@KChaloux apenas se você contar em utf8 bytes, o que não seria para o APL. Há uma página de código de byte único que contém todo o conjunto de caracteres usado pelo APL, portanto, é justo usá-lo para a contagem.
Martin Ender

@ MartinBüttner Um link de fonte confiável seria ótimo. Caso contrário, alguém poderia criar sua própria página da web arbitrária apenas com o conjunto de caracteres usado em qualquer idioma para reduzir a contagem de bytes.
precisa saber é

1
@GuillaumeLethuillier O APL é realmente muito fácil de aprender, pelo menos até o ponto em que você pode escrever respostas simples sobre golfe como essa. Existem algumas dezenas de funções com nomes fáceis de lembrar, como ×multiplicação e regras de sintaxe muito simples. Google "dominando Dyalog APL" para um bom guia.
Zgarb

16

Python, 88 75 73 bytes

lambda x:max(sum((a+.5-m)*(a+.5-n)<0for m,n in zip(x,x[1:]))for a in x)+1

Apenas uma lambda direta


Apenas para mostrar outra abordagem:

Pitão, 28 27 bytes

heSmsmq@S+k(d)1dC,QtQm+b.5Q

Este é aproximadamente equivalente a

lambda x:max(sum(a+.5==sorted(n+(a+.5,))[1]for n in zip(x,x[1:]))for a in x)+1

aplicado à lista de entrada do STDIN. Experimente no intérprete online .


Você pode até armazenar a função na mesma quantidade de caracteres:def f(x):max(sum((a+.5-m)*(a+.5-n)<0for m,n in zip(x,x[1:]))for a in x)+1
Christian Sonne

4
@ChristianSonne Sua função não retorna nada.
Jakube 14/01

Atire, você está certo @Jakube
Christian Sonne

Não sei ao certo como isso funciona, mas acho que você pode remover os +.5s para salvar alguns caracteres. Eu percebi que eles eram inúteis nos meus.
KSFT

@KSFT Ele divide a string em intervalos, itera sobre todos a = point + .5e conta o número de intervalos que contêm estritamente a. Sem o, .5você terá problemas com casos como o [1, 0, -1]exemplo.
Sp3000

16

Pyth : caractere 31 30 29 28 24 23 (caracteres Python 68)

heSmsm&<hSkdgeSkdC,tQQQ

Experimente aqui: Pyth Compiler / Executor

Ele espera uma lista de números inteiros como entrada [-1, 3, 1, -2, 5, 2, 3, 4]

É uma tradução direta do meu programa Python:

lambda s:1+max(sum(min(a)<i<=max(a)for a in zip(s,s[1:]))for i in s)

Solução antiga: Pyth 28 char

Apenas por razões de arquivamento.

heSmsm<*-dhk-dek0C,tQQm+b.5Q

Um código Python correspondente seria:

f=lambda x:1+max(sum((i-a)*(i-b)<0for a,b in zip(x,x[1:]))for i in [j+.5 for j in x])

Tenho certeza que você pode usar em ,QtQvez de[QtQ)
FryAmTheEggman

inão é a linha de interseção, i - 0.5é. E, portanto 1 (na verdade 1 - 0.5 = 0.5) está dentro (-1, 1). min(a)<i<=max(a)é equivalente a min(a) < i - 0.5 < max(a), resolvido em Pyth com min(a) < i < max(a)+1(observe o hin heSk).
Jakube

Eu acho que você está bem aqui. Ou pelo menos não consigo encontrar nenhum caso em que essa lógica falhe ...
Optimizer

Você pode salvar um personagem usando g, ou seja >=, se você substituir <dheSkpor geSkd.
Isaacg

2
Obrigado @isaacg. Mas por que você sempre aparece e destrói minha solução, quando estou realmente feliz e confiante? ;-)
Jakube 15/01

10

CJam, 36 34 33 30 bytes

q~[__(+]zW<f{f{1$+$#1=}1b}$W=)

Eu acredito que existe um algoritmo melhor por aí na natureza. Ainda assim, isso funciona abaixo do limite exigido para todos os casos de teste (mesmo no compilador online)

Entrada é como

[-2142140080 -2066313811 -2015945568 -2013211927 -1988504811 -1884073403 -1860777718  -1852780618 -1829202121 -1754543670 -1589422902 -1557970039 -1507704627 -1410033893  -1313864752 -1191655050 -1183729403 -1155076106 -1150685547 -1148162179 -1143013543  -1012615847 -914543424 -898063429 -831941836 -808337369 -807593292 -775755312 -682786953 -679343381 -657346098 -616936747 -545017823 -522339238 -501194053  -473081322 -376141541 -350526016 -344380659 -341195356 -303406389 -285611307 -282860017 -156809093 -127312384 -24161190 -420036 50190256 74000721 84358785  102958758 124538981 131053395 280688418 281444103 303002802 309255004 360083648  400920491 429956579 478710051 500159683 518335017 559645553 560041153 638459051  640161676 643850364 671996492 733068514 743285502 1027514169 1142193844 1145750868  1187862077 1219366484 1347996225 1357239296 1384342636 1387532909 1408330157  1490584236 1496234950 1515355210 1567464831 1790076258 1829519996 1889752281  1903484827 1904323014 1912488777 1939200260 2061174784 2074677533 2080731335 2111876929 2115658011 2118089950 2127342676 2145430585]

A saída (para o caso acima) é

2

Como funciona

q~[__(+]zW<f{f{1$+$#1=}1b}$W=)
q~                                "Evaluate input string as array";
  [__                             "Put two copies of it in an array";
     (+]                          "Shift first element of second copy to its end";
        z                         "Zip together the two arrays. This creates";
                                  "pair of adjacent elements of the input.";
         W<                       "Remove the last pair";
           f{            }        "For each element of input array, take the zipped";
                                  "array and run the code block";
             f{       }           "For each element of the zipped array along with";
                                  "the current element from input array, run this block";
               1$+                "Copy the current number and add it to the pair";
                  $#              "Sort the pair and find index of current number";;
                    1=            "check if index == 1 for a < I <= b check";
                       1b         "Get how many pairs have this number inside of them";
                          $W=)    "Get the maximum parts the rope can be cut into";

Agora, suponha que a matriz de entrada seja [-1 3 1 -2 5 2 3 4], as etapas de zipagem se parecem com:

[-1 3 1 -2 5 2 3 4] [[-1 3 1 -2 5 2 3 4] [-1 3 1 -2 5 2 3 4]
[-1 3 1 -2 5 2 3 4] [[-1 3 1 -2 5 2 3 4] [3 1 -2 5 2 3 4 -1]
[-1 3 1 -2 5 2 3 4] [[-1 3] [3 1] [1 -2] [-2 5] [5 2] [2 3] [3 4]]]

A segunda matriz na última linha são as dobras da string.

Agora, iteramos [-1 3 1 -2 5 2 3 4]e calculamos o número de conjuntos em que cada um deles se encontra. Tire o máximo proveito desse número, aumente e tenha nossa resposta.

Experimente online aqui


10

Matlab (123) (97) (85)

Finalmente, um uso para o XNOR =) Tenho certeza de que ele pode ser jogado muito mais.

Mas, honestamente, estou um pouco envergonhado por o MatLab estar se tornando o idioma que eu conheço melhor = /

O tempo de execução aproximado é O(n^2).

EDIT2:

a=input();v=2:nnz(a);disp(max(arrayfun(@(e)sum(~xor(a(v-1)<e,e<a(v))),sort(a)-.5))+1)

EDIT: Nova versão mais golfe (incluindo dicas de @DennisJaheruddin, obrigado!)

a=input();c=sort(a)-.5;n=0;v=2:nnz(c);for e=c;n=[n,sum(~xor(a(v-1)<e,e<a(v)))];end;disp(max(n)+1)

Versão antiga:

a=input();
c=conv(sort(a),[.5,.5],'valid');' %find all cutting positions by taking the mean of two successive points
k=numel(c);
for e=1:k %iterate over all 'cuts'
    n(e)=sum(~xor(a(1:k)<c(e),c(e)<a(2:k+1)));%find the number of threads the cut cuts
end
disp(max(n)+1) %output the max

@ MartinBüttner: Gosto muito dos seus pequenos e agradáveis ​​desafios antes de ir para a cama!


10
Minha esposa não pode ficar XNORing
gnibbler

9
Hora de o @xnor fazer anotações =)
flawr

Acho que você pode economizar um pouco para encontrar os pontos de corte, pois as dobras são sempre inteiras: c=sort(a)-.5é claro que o primeiro ponto está fora do intervalo, mas certamente é mais fácil lidar com isso. No pior dos casos, você pode fazer c(1)=[];. - Além disso, você pode remover o comando disp, apenas o cálculo de algo o escreverá em stdout. - Finalmente, neste caso, numelpode ser substituído pornnz
Dennis Jaheruddin

Mas eu estava tão orgulhosa da minha convabordagem ... = D. Eu sempre esquecer o nnz, muito obrigado!
precisa saber é

Eu poderia encontrar algumas maneiras de torná-lo ainda mais curto dessa maneira! Eu estou usando dispdesde que alguém uma vez criticado que, com o método proposto, você também terá outros personagens (nome do var ou ans) escrito em stdout ...
flawr

9

Mathematica 134 133 104

Divertido de resolver, apesar do tamanho do código. Ainda mais golfe pode ser alcançado, substituindo a idéia de IntervalMemberQ[Interval[a,b],n]com a<n<b.

n_~f~i_:=Count[IntervalMemberQ[#,n]&/@i,1>0];
g@l_:=Max[f[#,Interval/@Partition[l,2,1]]&/@(Union@l+.5)]+1

g[{-1, 3, 1, -2, 5, 2, 3, 4}]

6


Explicação

list1é que a lista de pontos fornecida list2é uma lista abreviada que remove números que não estavam nas dobras; eles são irrelevantes. Não é necessário fazer isso, mas leva a uma solução mais clara e eficiente.

list1 = {-1, 3, 1, -2, 5, 2, 3, 4};
list2 = {-1, 3, 1, -2, 5,2, 3, 4} //. {beg___, a_, b_, c_, end___} /; (a <= b <= c) 
 \[Or] (a >= b >= c) :> {beg, a, c, end}

Os intervalos list1e list2são mostrados nos gráficos abaixo:

NumberLinePlot[Interval /@ Partition[list1, 2, 1]]
NumberLinePlot[intervalsArrangedVertically = Interval /@ Partition[list2, 2, 1]]

intervalos


Só precisamos testar uma única linha em cada intervalo determinado pelos pontos de dobra. As linhas de teste são as linhas verticais tracejadas no gráfico.

delimitersLeftToRight = Union[list2]
testLines = delimitersLeftToRight + .5
NumberLinePlot[
 intervalsArrangedVertically = Interval /@ Partition[list2, 2, 1], 
 GridLines -> {testLines, {}}, 
 GridLinesStyle -> Directive[Gray, Dashed]]

linhas de teste


flocaliza o número de cortes ou cruzamentos de cada linha de teste. A linha em x = 2,5 faz 5 cruzamentos. Isso deixa 5 + 1 pedaços de barbante.

f[num_, ints_] := Count[IntervalMemberQ[#, num] & /@ ints, True]
f[#, intervalsArrangedVertically] & /@ testLines
Max[%] + 1

{2, 3, 5, 3, 2, 0}
6


8

Pitão, 21 bytes

heSmsmq1xS+dSkdC,tQQQ

Experimente aqui.

Dê entrada como lista no estilo Python, por exemplo [-1, 3, 1, -2, 5, 2, 3, 4]

Basicamente baseado no programa do @ jakube, mas com um algoritmo central aprimorado. Em vez de fazer uma >verificação e uma >=verificação, eu faço uma .index()nos três números combinados e certifico-me de que o índice seja 1, o que significa que é maior que o mínimo e menor ou igual ao máximo.


7

R, 86 83

Estava trabalhando nisso e percebi que eu tinha essencialmente encontrado a mesma solução que o Optimizer e outras que eu suspeito.

Enfim, aqui é como uma função que leva um vetor

f=function(l)max(colSums(mapply(function(n)c(l[-1],NA,l)<=n&c(l,l[-1],NA)>=n,l),T))

OK, então eu sou tendencioso e assim R. FWIW, você pode salvar 3 caracteres usando T"TRUE"
Carl Witthoft 15/15/15

@CarlWitthoft Obrigado pela dica
MickyT 15/01

4

GolfScript (43 bytes)

~[.(;]zip);{$}%:x{0=:y;x{{y>}%2,=},,}%$-1=)

Em termos de eficiência, é O (n ^ 2) assumindo que as comparações levam tempo O (1). Ele divide a entrada em segmentos de linha e, para cada ponto inicial, conta os segmentos de linha semi-abertos que a atravessam.

Demonstração online


4

Python - 161

Provavelmente isso pode ser jogado mais. gnibbler ajudou muito a jogar golfe.

l=input()
d={}
for i in zip(l,l[1:]):d[sum(i)/2.]=0
for i,k in zip(l,l[1:]):
 for j in[m for m in d.keys()if min(i,k)<m<max(i,k)]:d[j]+=1
print max(d.values())+1

1
@ MartinBüttner / Jakube Eu consertei. Agora ele funciona para todos os casos de teste em menos de dez segundos.
KSFT

Por que existem dois votos negativos sobre isso?
KSFT

3

Ruby, 63

Semelhante às soluções Python em conceito.

->a{a.map{|x|a.each_cons(2).count{|v|v.min<x&&x<=v.max}}.max+1}

Adicione 2 caracteres antes do código, por exemplo, f=se você deseja uma função nomeada. Thx para MarkReed .


O processo simples parece ser uma resposta aceitável sem atribuí-lo a uma variável. Salva dois caracteres.
Mark Reed

3

C #, 73 65 bytes

N=>1+N.Max(i=>N.Zip(N.Skip(1),(f,s)=>f<i+.5==i+.5<s).Count(b=>b))

Lendo as regras, pensei que um lambda C # deveria se sair muito bem.

Edit: recém encontrado Counttem uma sobrecarga útil para filtrar!

Você pode testar isso definindo o delegatetipo apropriado :

delegate int solver(int[] l);

E depois

var l = new int[] { -1, 3, 1, -2, 5, 2, 3, 4 };
solver s = N=>1+N.Max(i=>N.Zip(N.Skip(1),(f,s)=>f<i+.5==i+.5<s).Count(b=>b));

Console.WriteLine(s(l));

3

Matlab ( 63 43)

A entrada é fornecida como um vetor de linha passado para a função f. Então, por exemplo, f([-1, 3, 1, -2, 5, 2, 3, 4])retorna 6.

f=@(x)max(sum(diff(bsxfun(@le,2*x',x(1:end-1)+x(2:end)))~=0))+1

Versão mais curta:

f=@(x)max(sum(diff(bsxfun(@lt,x',x))~=0))+1

Oitava (31)

No Octave bsxfunpode ser removido graças à transmissão automática:

f=@(x)max(sum(diff(x'<x)~=0))+1

2

JavaScript (ES6) 80 82

Ver comentários - a contagem de bytes não inclui a atribuição a F (ainda é necessário testar)

F=l=>Math.max(...l.map(v=>l.map(t=>(n+=t>u?v<t&v>=u:v>=t&v<u,u=t),n=1,u=l[0])&&n))

Teste no console do FireFox / FireBug

;[
 F([0, 1])
,F([2147483647, -2147483648])
,F([0, 1, -1])
,F([1, 0, -1])
,F([-1, 3, 1, -2, 5, 2, 3, 4])  
,F([-1122432493, -1297520062, 1893305528, 1165360246, -1888929223, 385040723, -80352673, 1372936505, 2115121074, -1856246962, 1501350808, -183583125, 2134014610, 720827868, -1915801069, -829434432, 444418495, -207928085, -764106377, -180766255, 429579526, -1887092002, -1139248992, -1967220622, -541417291, -1617463896, 517511661, -1781260846, -804604982, 834431625, 1800360467, 603678316, 557395424, -763031007, -1336769888, -1871888929, 1594598244, 1789292665, 962604079, -1185224024, 199953143, -1078097556, 1286821852, -1441858782, -1050367058, 956106641, -1792710927, -417329507, 1298074488, -2081642949, -1142130252, 2069006433, -889029611, 2083629927, 1621142867, -1340561463, 676558478, 78265900, -1317128172, 1763225513, 1783160195, 483383997, -1548533202, 2122113423, -1197641704, 319428736, -116274800, -888049925, -798148170, 1768740405,  473572890, -1931167061, -298056529, 1602950715, -412370479, -2044658831, -1165885212, -865307089, -969908936, 203868919, 278855174, -729662598, -1950547957, 679003141,  1423171080, 1870799802, 1978532600, 107162612, -1482878754, -1512232885, 1595639326, 1848766908, -321446009, -1491438272, 1619109855, 351277170, 1034981600, 421097157, 1072577364, -538901064])
,F([-2142140080, -2066313811, -2015945568, -2013211927, -1988504811, -1884073403, -1860777718, -1852780618, -1829202121, -1754543670, -1589422902, -1557970039, -1507704627, -1410033893,  -1313864752, -1191655050, -1183729403, -1155076106, -1150685547, -1148162179, -1143013543,  -1012615847, -914543424, -898063429, -831941836, -808337369, -807593292, -775755312, -682786953, -679343381, -657346098, -616936747, -545017823, -522339238, -501194053,  -473081322, -376141541, -350526016, -344380659, -341195356, -303406389, -285611307, -282860017, -156809093, -127312384, -24161190, -420036, 50190256, 74000721, 84358785,  102958758, 124538981, 131053395, 280688418, 281444103, 303002802, 309255004, 360083648,  400920491, 429956579, 478710051, 500159683, 518335017, 559645553, 560041153, 638459051,  640161676, 643850364, 671996492, 733068514, 743285502, 1027514169, 1142193844, 1145750868,  1187862077, 1219366484, 1347996225, 1357239296, 1384342636, 1387532909, 1408330157,  1490584236, 1496234950, 1515355210, 1567464831, 1790076258, 1829519996, 1889752281,  1903484827, 1904323014, 1912488777, 1939200260, 2061174784, 2074677533, 2080731335, 2111876929, 2115658011, 2118089950, 2127342676, 2145430585])
]

Resultado

[2, 2, 3, 2, 6, 53, 2]


2
Com base nas lambdasoluções Python , você não precisa atribuir o valor da função a uma variável real, para poder digitar dois caracteres.
Mark Reed

1
Sim. Salvo indicação em contrário no desafio, as funções não nomeadas são perfeitas.
Martin Ender

1

Gelatina , 10 bytes

>þ`^ƝS$€Ṁ‘

Experimente online!

Como funciona

>þ`^ƝS$€Ṁ‘ - Main link. 1 argument        e.g.   [1, 0, -1]
>þ`        - Greater than outer product          [[0, 0, 0], [1, 0, 0], [1, 1, 0]]
      $€   - Over each sublist:           e.g.   [1, 1, 0]
    Ɲ      -   Over each overlapping pair e.g.   [1, 0]
   ^       -     Perform XOR                     1
     S     -   Take the sums                     [0, 1, 1]
        Ṁ  - Take the maximum                    1
         ‘ - Increment                           2

1

05AB1E , 6 bytes

ε@Ôg}à

Experimente online!

Explicação:

ε   }    # for each element of the input
 @       # is each element >= this one? (returns list of booleans)
  Ô      # connected uniquified
   g     # length
     à   # maximum


0

Adicionar ++ , 27 bytes

D,w,@@,VbUG€<ÑBxs
L~,A€wM1+

Experimente online!

Abordagem graças a Zgarb por sua resposta APL

A parte principal desse desafio é implementar um comando externo do produto. Infelizmente, o Add ++ não possui um built-in para isso, não possui nenhuma maneira de definir funções que usam outras funções como argumentos. No entanto, ainda podemos fazer com que um produto externo generalizado funcione. Como a única maneira de acessar uma função dentro de outra função é através da referência a uma função existente, definida pelo usuário ou embutida, precisamos criar um 'embutido' que faça referência a essa função.

Uma função "tabela" generalizada ficaria assim:

D,func,@@,+

D,iter,@@*, VbUG €{func}
D,table,@@, $ bRbU @ €{iter} B]

Experimente online!

onde funcé uma função diádica que contém nosso operando. Você pode ver pequenas semelhanças dessa estrutura na submissão original, no início da função w , mas aqui queremos, principalmente, uma função de produto externo monádico - uma função de produto externo que adota o mesmo argumento dos dois lados.

A função geral da tabela tira proveito de como o ach quick aborda as funções diádicas. Se a pilha parecer

 [a b c d e]

quando €{func}é encontrado, o pop aparece e, vincula esse argumento à esquerda à díade e mapeia essa função parcial a, b, c, d. No entanto, os mapas rápidos sobre toda a pilha, em vez de sobre as listas. Portanto, precisamos achatar as matrizes passadas como argumentos primeiro.

A função de tabela funciona de maneira geral assim

D,func,@@,+

D,iter,		; Define our helper function iter
		;   This takes an array as its left argument
		;   And a single integer as its right argument
	@@	; Dyadic arguments - take two arguments and push to the stack
	*,	; After execution, return the entire stack, rather then just the top element
		;
		; Example arguments:	[5 6 7 8] 1
		; 
	VbUG	; Unpack the array;	[5 6 7 8 1]
		;
	€{func}	; Map func over the stack
		; As func is dyadic, this pops the right argument
		;   and binds that to a monadic func
		; This then maps the remaining elements, [5 6 7 8]
		;   over the monadic call of func, yielding [6 7 8 9]
		; Now, as the * flag was defined, we return the entire array
		;   rather than just the last element.
		; We'd achieve the same behaviour by removing the flag and appending B]

D,table,	; Define the main table function
		;   This takes two arrays as arguments
		;   Returns a single 2D array representing their outer product with func
	@@,	; Take the two arrays and push to the stack
		; 
		; Example arguments:	[[1 2 3 4] [5 6 7 8]]
		;
	$	; Swap;		STACK = [[5 6 7 8] [1 2 3 4]]
	bR	; Reverse last;	STACK = [[5 6 7 8] [4 3 2 1]]
	bU	; Unpack;	STACK = [[5 6 7 8] 4 3 2 1]
	@	; Reverse;	STACK = [1 2 3 4 [5 6 7 8]]
		; 
		; This allows us to place the stack so that each element of
		;   the first array is iterated over with the second array
		;
	€{iter}	; Map iter;	STACK = [[6 7 8 9] [7 8 9 10] [8 9 10 11] [9 10 11 12]]
		;
	B]	; Return the whole stack;

$table>?>?
O

No entanto, podemos reduzi-lo bastante devido ao fato de que precisamos que nossa tabela externa seja monádica e que apenas seja aplicável ao argumento passado. O Acomando envia cada argumento para a pilha individualmente, portanto, não precisamos mexer com nenhuma manipulação de pilha. Em resumo, se nosso argumento é a matriz [a b c d], precisamos transformar a pilha em

[a b c d [a b c d]]

O valor superior é, obviamente, o argumento. Você pode ter notado no exemplo geral que bUé o comando unpack, ou seja, ele divide a matriz superior na pilha. Então, para fazer a configuração acima, podemos usar o código

L,bUA

Experimente online!

No entanto, isso pode ser reduzido por um byte. Como um alias para L,bU, podemos usar a ~flag, para dividir os argumentos na pilha de antemão, transformando nosso exemplo de configuração em

L~,A

Experimente online!

que é o início da segunda linha do programa. Agora que implementamos o produto externo monádico, precisamos apenas implementar o restante do algoritmo. Depois de recuperar o resultado da tabela com <(menor que) e conte o número de [0 1]e [1 0]pares em cada linha. Finalmente, pegamos o máximo dessas contagens e incrementamos.

O passo completo para o passo a passo é

D,w,		; Define a function w
		;   This takes an array and an integer as arguments
		;   First, it produces the outer product with less than
		;   Then reduce overlapping pairs by XOR
		;   Finally, sum the rows
	@@,	; Take two arguments
		;
		; Example arguments:		[[0 1 2 3] 0]
		;
	VbUG€<	; Map < over the array;	STACK = [0 1 1 1]
	ÑBx	; Equals [1 0];		STACK = [1 0 0]
	s	; Sum;			STACK = [1]

L		; Define a lambda function
		;   This takes one argument, an array
	~,	;   Splat the array to the stack before doing anything
		;
		; Example argument:		[0 1 2 3]
		;
	A€w	; Map with w;		STACK = [1 1 1 0]
	M	; Maximum;		STACK = [1]
	1+	; Increment;		STACK = [2]
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.