¿En cuántas piezas puedes cortar esta cuerda?


45

Considere un trozo de cuerda (como en "cuerda", no como en "un montón de caracteres"), que se pliega de un lado a otro en la línea real. Podemos describir la forma de la cadena con una lista de puntos por los que pasa (en orden). Por simplicidad, asumiremos que todos esos puntos son enteros.

Tomemos como ejemplo [-1, 3, 1, -2, 5, 2, 3, 4](tenga en cuenta que no cada entrada implica un pliegue):

ingrese la descripción de la imagen aquí

La cadena que se extiende a lo largo de la dirección vertical es solo para fines de visualización. Imagina que la cuerda se aplana en la línea real.

Ahora aquí está la pregunta: ¿cuál es el mayor número de piezas en las que se puede cortar esta cadena con un solo corte (que tendría que ser vertical en la imagen de arriba)? En este caso, la respuesta es 6 con un corte entre 2y 3:

ingrese la descripción de la imagen aquí

Para ambigüedades EVITAR, el corte tiene que ser realizado en una posición no entero.

El reto

Dada una lista de posiciones enteras por las que se pliega una cadena, debe determinar el mayor número de piezas en las que se puede cortar la cadena con un solo corte en una posición no entera.

Puede escribir un programa completo o una función. Puede recibir información a través de STDIN, argumento de línea de comando, indicador o parámetro de función. Puede escribir la salida en STDOUT, mostrarla en un cuadro de diálogo o devolverla desde la función.

Puede suponer que la lista está en cualquier lista conveniente o formato de cadena.

La lista contendrá al menos 2 y no más de 100 entradas. Las entradas serán números enteros, cada uno en el rango -2 31 ≤ p i <2 31 . Puede suponer que no hay dos entradas consecutivas idénticas.

Su código debe procesar dicha entrada (incluidos los casos de prueba a continuación) en menos de 10 segundos en una PC de escritorio razonable.

Casos de prueba

Todos los casos de prueba son simplemente de entrada seguidos de salida.

[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 suponer que desea que el corte esté en un lugar que garantice el máximo número de piezas?
DavidC

2
Probablemente diría, "determina el mayor número de piezas" en lugar de "determina cuántas piezas".
DavidC

1
¿No es a reasonable desktop PCbastante ambiguo?
globby

3
@globby Es una frase bastante común que usamos cuando el tiempo de ejecución no es parte del criterio ganador (pero solo se usa para garantizar que las soluciones no usen la fuerza bruta). Principalmente significa que el límite no es 100% estricto. Si tarda 15 segundos en su máquina (y no está usando una supercomputadora), es probable que alguien por aquí tenga una PC de escritorio donde se complete en 10 segundos. Pero si tarda un minuto en su máquina, es menos probable, por lo que tendría que pensar en un enfoque diferente. Además, el límite se elige de modo que un algoritmo eficiente se complete fácilmente en menos de 10 segundos.
Martin Ender

2
@ZainR no .
Martin Ender

Respuestas:


16

APL, 16 14 bytes

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

Gracias a @ngn por guardar 2 bytes.

El es en realidad un carácter de cuadro, no un error de fuente faltante. Puede probar el programa en tryapl.org , pero como no es totalmente compatible allí, debe reemplazarlo por el valor de entrada:

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

Explicación

El programa se explica mejor con la entrada de ejemplo s = ¯1 3 1 ¯2 5 2 3 4, que es tomada de STDIN por . Primero, calculamos el producto externo de ssí mismo usando ∘.≤⍨. Esto da como resultado una matriz booleana cuya ifila th indica qué elementos sson menores o iguales que 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

Las ocurrencias de 0 1y 1 0en la fila imarcan los lugares donde la cadena pasa sobre el punto s[i] + 0.5. Coincidimos con estos en cada fila usando 2≠/"reducir 2 sublistas por ":

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

Lo que queda es tomar las sumas de las filas con +/

2 5 3 0 2 3 5 3

y uno más el máximo de estos con 1+⌈/:

6

El resultado se imprime automáticamente en STDOUT en la mayoría de las implementaciones de APL.


@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ Mi mal resultado esperado es el número de piezas, no la ubicación para producirlo.
J ...

Técnicamente son 16 caracteres, 28 bytes. Unicode te hará eso = P
KChaloux

1
@KChaloux solo si cuenta en utf8 bytes, lo que no haría para APL. Hay una página de códigos de un solo byte que contiene todo el conjunto de caracteres utilizado por APL, por lo que es justo usarlo para contar.
Martin Ender

@ MartinBüttner Un enlace fuente confiable sería genial. De lo contrario, alguien podría crear una página web arbitraria con solo el conjunto de caracteres utilizados para cualquier idioma para reducir el recuento de bytes.
agweber

1
@GuillaumeLethuillier APL es realmente fácil de aprender, al menos hasta el punto en que puedes escribir respuestas simples de golf como esta. Hay unas pocas docenas de funciones con nombres fáciles de recordar, como ×multiplicación, y reglas de sintaxis muy simples. Google "dominando Dyalog APL" para una buena guía.
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

Solo una simple lambda


Solo para mostrar otro enfoque:

Pyth, 28 27 bytes

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

Este es 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 a la lista de entrada de STDIN. Pruébelo en el intérprete en línea .


Incluso puede almacenar la función en la misma cantidad 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

44
@ChristianSonne Su función no devuelve nada.
Jakube

Dispara, tienes razón @Jakube
Christian Sonne

No estoy completamente seguro de cómo funciona esto, pero creo que puede eliminar los +.5s para guardar algunos caracteres. Me di cuenta de que no tenían sentido en el mío.
KSFT

@KSFT Divide la cadena en intervalos, itera sobre cada uno a = point + .5y cuenta el número de intervalos que contiene estrictamente a. Sin el .5tendrás problemas con casos como el [1, 0, -1]ejemplo.
Sp3000

16

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

heSmsm&<hSkdgeSkdC,tQQQ

Pruébalo aquí: Pyth Compiler / Executor

Espera una lista de enteros como entrada [-1, 3, 1, -2, 5, 2, 3, 4]

Es una traducción directa de mi programa Python:

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

Antigua solución: Pyth 28 char

Solo por razones de archivo.

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

Un código de Python correspondiente sería:

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

,QtQ[QtQ)
Estoy

ino es la línea de intersección, i - 0.5es. Y por lo tanto 1 (en realidad 1 - 0.5 = 0.5) está adentro (-1, 1). min(a)<i<=max(a)es equivalente a min(a) < i - 0.5 < max(a), que se resuelve en Pyth con min(a) < i < max(a)+1(aviso el hen heSk).
Jakube

Creo que estás aquí O al menos no puedo encontrar ningún caso en el que esta lógica falle ...
Optimizer

Puede guardar un personaje usando g, que es >=, si lo reemplaza <dheSkcon geSkd.
isaacg

2
Gracias @isaacg. Pero, ¿por qué siempre vienes y destruyes mi solución, cuando estoy realmente feliz y segura de ello? ;-)
Jakube

10

CJam, 36 34 33 30 bytes

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

Creo que hay un mejor algoritmo en la naturaleza. Aún así, esto funciona por debajo del límite requerido para todos los casos de prueba (incluso en el compilador en línea)

La entrada es 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]

La salida (para el caso anterior) es

2

Cómo 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";

Ahora suponga que la matriz de entrada es [-1 3 1 -2 5 2 3 4], los pasos de compresión se ven así:

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

La segunda matriz en la última línea son los pliegues de la cadena.

Ahora iteramos [-1 3 1 -2 5 2 3 4]y calculamos el número de conjuntos en los que se encuentra cada uno de ellos. Obtenga el máximo de ese número, increméntelo y tenemos nuestra respuesta.

Pruébalo en línea aquí


10

Matlab (123) (97) (85)

Sí, finalmente un uso para XNOR =) Estoy seguro de que se puede jugar mucho más.

Pero, sinceramente, estoy un poco avergonzado de que MatLab se esté convirtiendo en el idioma que mejor conozco = /

El tiempo de ejecución aproximado es 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)

EDITAR: Nueva versión más golfizada (incluyendo pistas de @DennisJaheruddin, ¡gracias!)

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)

Versión antigua:

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: ¡Realmente disfruto de tus pequeños y agradables desafíos justo antes de irme a la cama!


10
Mi esposa no soporta XNORing
gnibbler

99
Es hora de que @xnor tome notas =)
error

Creo que puede ahorrar algo para encontrar los puntos de corte, ya que los pliegues siempre son enteros: por c=sort(a)-.5supuesto, el primer punto está fuera del rango, pero seguramente es más fácil lidiar con eso. En el peor de los casos puedes hacerlo c(1)=[];. - También puede quitar el comando disp, simplemente calculando algo lo escribirá en stdout. Finalmente, en este caso numelpuede ser reemplazado connnz
Dennis Jaheruddin

Pero estaba muy orgulloso de mi convenfoque ... = D. Siempre me olvido del nnz, muchas gracias!
flawr

¡Podría encontrar bastantes maneras de hacerlo aún más corto de esa manera! Estoy usando dispdesde que alguien una vez criticado que con el método que usted propuso, también puede obtener otros caracteres (nombre de la variable o ans) por escrito a la salida estándar ...
flawr

9

Mathematica 134 133 104

Divertido de resolver, a pesar del tamaño del código. Se puede seguir jugando al golf reemplazando la idea de IntervalMemberQ[Interval[a,b],n]con 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 6


Explicación

list1la lista de puntos dada list2es una lista abreviada que elimina los números que no estaban en pliegues; Son irrelevantes. No es necesario hacer esto, pero conduce a una solución más clara y más 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}

Los intervalos en list1y list2se muestran en las parcelas a continuación:

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

intervalos


Solo necesitamos probar una sola línea en cada intervalo determinado por los puntos de plegado. Las líneas de prueba son las líneas verticales discontinuas en el gráfico.

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

líneas de prueba


fencuentra el número de cortes o cruces de cada línea de prueba. La línea en x = 2.5 hace 5 cruces. Eso deja 5 + 1 piezas de cuerda.

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

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


8

Pyth, 21 bytes

heSmsmq1xS+dSkdC,tQQQ

Pruébalo aquí

Dar entrada como lista de estilo Python, por ejemplo [-1, 3, 1, -2, 5, 2, 3, 4]

Estrechamente basado en el programa de @jakube, pero con un algoritmo central mejorado. En lugar de hacer una >verificación y una >=verificación, hago un a .index()en los tres números combinados y me aseguro de que el índice sea 1, lo que significa que es mayor que el mínimo y menor o igual que el máximo.


7

R, 86 83

Estaba trabajando en esto y luego me di cuenta de que esencialmente había encontrado la misma solución que Optimizer y otras que sospecho.

De todos modos aquí es como una función que toma un vector

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

OK, entonces soy parcial y me gusta R. FWIW podría guardar 3 caracteres utilizando Tpara "VERDADERO"
Carl Witthoft

@CarlWitthoft Gracias por el consejo
MickyT

4

GolfScript (43 bytes)

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

En términos de eficiencia, esto es O (n ^ 2) suponiendo que las comparaciones toman O (1) tiempo. Rompe la entrada en segmentos de línea y para cada punto de inicio cuenta los segmentos de línea medio abiertos que la cruzan.

Demostración en línea


4

Python - 161

Esto probablemente se puede jugar más al golf. gnibbler ayudó mucho al golf.

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 Lo arreglé. Ahora funciona para todos los casos de prueba en menos de diez segundos.
KSFT

¿Por qué hay dos votos negativos en esto?
KSFT

3

Rubí, 63

Similar a las soluciones de Python en concepto.

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

Agregue 2 caracteres antes del código, por ejemplo, f=si desea una función con nombre. Gracias a MarkReed .


El proceso simple parece ser una respuesta aceptable sin asignarlo a una variable. Guarda dos personajes.
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))

Leyendo las reglas, pensé que una lambda C # debería funcionar bastante bien.

Editar: ¡recién encontrado Counttiene una sobrecarga útil para filtrar!

Puede probar esto definiendo el delegatetipo apropiado :

delegate int solver(int[] l);

Y entonces

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)

La entrada se da como un vector de fila pasado a la función f. Entonces, por ejemplo, f([-1, 3, 1, -2, 5, 2, 3, 4])vuelve 6.

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

Versión más corta:

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

Octava (31)

En Octave bsxfunse puede eliminar gracias a la transmisión automática:

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

2

JavaScript (ES6) 80 82

Ver comentarios: el recuento de bytes no incluye la asignación a F (que todavía se necesita para probar)

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

Prueba en la consola 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])
]

Salida

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


2
Basado en las lambdasoluciones de Python , no necesita asignar el valor de la función a una variable real, por lo que puede eliminar dos caracteres.
Mark Reed

1
Sí. A menos que se indique lo contrario en el desafío, las funciones sin nombre están perfectamente bien.
Martin Ender

1

Jalea , 10 bytes

>þ`^ƝS$€Ṁ‘

Pruébalo en línea!

Cómo 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}à

Pruébalo en línea!

Explicación:

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


0

Agregar ++ , 27 bytes

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

Pruébalo en línea!

Enfoque gracias a Zgarb por su respuesta APL

La parte clave de este desafío es implementar un comando externo del producto. Desafortunadamente, Add ++ no tiene una función integrada para hacerlo, tampoco tiene ninguna forma de definir funciones que tomen otras funciones como argumentos. Sin embargo, aún podemos hacer que un producto externo general funcione de todos modos. Como la única forma de acceder a una función dentro de otra función es haciendo referencia a una función existente, definida por el usuario o incorporada, tenemos que crear un 'incorporado' que haga referencia a dicha función.

Una función de "tabla" generalizada se vería así:

D,func,@@,+

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

Pruébalo en línea!

donde funces una función diádica que contiene nuestro operando. Puede ver ligeras similitudes de esta estructura en la presentación original, al comienzo de la función w , pero aquí queremos, principalmente, una función de producto externo monádico , una función de producto externo que tome el mismo argumento en ambos lados.

La función de tabla general aprovecha la forma en que ach quick se acerca a las funciones diádicas. Si la pila se ve así

 [a b c d e]

cuando €{func}se encuentra, los estallidos e, lo vinculan como argumento izquierdo a la díada, y mapean esa función parcial a, b, c, d. Sin embargo, los mapas rápidos sobre toda la pila, en lugar de sobre listas. Por lo tanto, primero debemos aplanar las matrices pasadas como argumentos.

La función de tabla funciona en general de esta manera

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

Sin embargo, podemos acortar esto bastante debido al hecho de que necesitamos que nuestra tabla externa sea monádica , y solo necesitamos aplicarla al argumento pasado. El Acomando empuja cada argumento a la pila de forma individual, por lo que no necesitamos perder el tiempo con ninguna manipulación de la pila. En resumen, si nuestro argumento es la matriz [a b c d], necesitamos convertir la pila en

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

El valor superior es, por supuesto, el argumento. Puede haber notado en el ejemplo general que bUes el comando desempaquetar, es decir, salpica la matriz superior a la pila. Entonces, para hacer la configuración anterior, podemos usar el código

L,bUA

Pruébalo en línea!

Sin embargo, esto puede acortarse en un byte. Como un alias para L,bU, podemos usar la ~bandera, para salpicar los argumentos a la pila de antemano, convirtiendo nuestro ejemplo de configuración en

L~,A

Pruébalo en línea!

que es el comienzo de la segunda línea en el programa. Ahora que hemos implementado un producto externo monádico, solo necesitamos implementar el resto del algoritmo. Una vez recuperar el resultado de mesa con <(menor que), y contar el número de [0 1]y [1 0]pares en cada fila. Finalmente, tomamos el máximo de estos recuentos y lo incrementamos.

El paso completo para caminar paso a paso es

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]
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.