En iyi 2 arkadaşınla birlikte yaşayan genç bir programlama inekisin. Her hafta, biriniz evin tüm işlerini yapmak zorundasınız ve bir sopa seçerek kimin sırası olduğuna karar veriyorsunuz. En kısa çubuğu seçen kişi kaybeder ve tüm işleri yapar.

Hepiniz programcı ve bulmaca oluşturmayı sevdiğiniz için, "En kısa çubuğu seç" i bir bilgisayar bulmacasına dönüştürdünüz.

İşte bulmacanın kuralları.

1. Size, her sütunun bir çubuğu temsil ettiği bir 2D matris verilecektir.
2. Her sütunda, 1 çubuğun bir bölümünü temsil eder ve 0 boş bir boşluktur
3. Her sütunda yukarıdan aşağıya doğru giderken, başlangıçta 0'sunuz ve 1a'ya basar basmaz, çubuk başladı ve sütunun geri kalanı 1sadece
4. Bir sütun seçmek için programınızı yazabilirsiniz. Bu sütundaki çubuğun boyutu kazananı / kaybedeni belirler. Çubuk boyutu == bu sütundaki 1'lerin sayısı.
5. Ancak, bu program yalnızca doğrusal bir en kötü durum zaman karmaşıklığına sahip olabilir.

Hepiniz programcı olduğunuzdan, bir başkasının programının zaman karmaşıklığı sınırını aşıp atmadığını bileceksiniz.

İşiniz:

• Girişi 2B biçiminde veya dize dizisinde kabul eden bir program veya işlev yazın.
• Giriş STDIN / komut istemi / konsoldan veya bir işlev bağımsız değişkeninden alınabilir.
• Eğer girişi STDIN / isteminden okuyorsanız, giriş okumasının ve bir diziye dönüştürülmesinin 0 zaman aldığını varsayabilirsiniz (bunu yapmak için kod cevabınızda olmalı)
• İçinde en uzun çubuk olan sütunu belirleyin.
• Çıktı, işlevin dönüş değeri veya STDOUT / console / alert için olabilir.
• Program / fonksiyon kötü durum zaman karmaşıklığı, doğrusal olmalıdır satır sayısı ve bir sütun sayısı.O(m+n)mn

Giriş, aşağıdaki biçimlerden biri olabilir:

2D dizi:

[ [0, 0, 0, 0],
  [1, 0, 0, 0],
  [1, 1, 0, 1],
  [1, 1, 1, 1] ]

Dizi Dizisi:

[ "0000", "1000", "1101", "1111" ]

Girdi aşağıdaki özelliklere sahip olacaktır:

• Dizinin boyutu bilinmiyor, herhangi bir boyutta bir dikdörtgen olduğunu varsayalım
• Herhangi bir sütunda, yukarıdan aşağıya gelir, 1 görürseniz, aşağıdaki her şey bir olacaktır
• Boş-sütunlar (örneğin 0-uzunluk) çubukları vardır izin verdi.

Bu bir kod golf çok kısa kod kazanır ! *

Lütfen kodunuzu açıklayın veya ungolfed sürümünü (zaman karmaşıklığını doğrulamak için) beklediğiniz iki giriş biçiminden hangisiyle birlikte verin.

GÜNCELLEME Buradaki doğrusal zaman karmaşıklığı, n'nin sütun boyutu ve m, satır boyutu olduğu O (n + m) anlamına gelir. (Belirsiz olanlar için)

GÜNCELLEME 2 Bu kesinlikle olabilir doğrusal zamanda yapılabilir. Ve eğer bir cevap gönderiyorsanız, mantık / algoritmayı adil bir mücadele için birkaç gün göndermeyi geciktirmekten çekinmeyin :)

GÜNCELLEME Zaman karmaşıklığını ve programı doğrulamak için birkaç saat içinde tüm cevapları gözden geçireceğim :)

GolfScript, 45 karakter

:^,:y;0:x{^y(=x=2%y*{y(:y;x\}{x):x}if^0=,<}do

Girdiyi dizeler dizisi olarak alır, en uzun sütunun (0 tabanlı) dizinini döndürür. O ( satırlar + sütunlar ) yinelemelerinde çalışır ve her yinelemenin temelde sabit zaman alması gerekir (en azından sabit zamanlı aritmetik varsayılarak). Döngü içinde yapılan tek dizi / dize işlemleri, öğe aramaları ( =) ve ,GolfScript'te sabit zaman alan bir dizenin ( ) uzunluğunu almaktır.

Çevrimiçi deneyin.

Açıklama:

Buradaki çözümlerin çoğu gibi, bu kod da matrisin sol alt köşesinden başlayarak, matrisin geçerli öğesinin 1 veya 0 olup olmamasına bağlı olarak yukarı veya sağa yürüterek ve en son taşındığı sütunun kaydını tutarak çalışır .

Programın başında, girdi dizisini değişkene ^, uzunluğuna (yani satır sayısı) yve 0'a atarım x. 0 değeri de yığın üzerinde kalır; sonraki döngü sırasında, yerini en uzun sütunun dizini alacaktır.

Ana döngü içinde, -d satırının -th karakterini ^y(=x=ayıklar . Bu aslında karakterin ASCII kodunu döndürür, bu nedenle son bit dışında tümünü bırakmak gerekir. Özel bir durum olarak, 0'a eşitse (şimdiye kadar bulunan en uzun sütun en üst satıra kadar ulaşırsa gerçekleşebilir), aranan bit aslında matristeki son satırdan (dizin -1) gelir, ancak aşağıdakiler sıfıra zorlar, böylece matrisin üstünde sanal bir sıfırlar satırı oluşturur.xy-1^2%yy*

Ardından if, aranan bit sıfırdan farklı (doğru) veya sıfır (yanlış) olmasına bağlı olarak, bundan önceki iki kod bloğundan birini yürütür. Sıfırdan farklıysa, bir ydeğer azaltılır ve geçerli değer x, yığındaki en uzun sütun dizininin yerini alır (eski değer geçici olarak üstünde bırakılır). Sıfır ise x, bir artırılır (ve geçici olarak yığın üzerinde, en uzun sütun dizininin üstünde).

Son olarak, ^0=matrisin ilk satırını ayıklar, ,uzunluğunu döndürür ve <geçici olarak yığın üzerinde bırakılan sütun dizini ile karşılaştırır ( xeğer artmışsa eşit olur) Dizin satır uzunluğundan daha azsa, döngü tekrarlar.

Ps. Testlerime dayanarak ,<, döngünün sonunda dize uzunluğu testini değiştirerek, dizeyi >verilen dizinde kesen ve bitiş bölümünü (boş olacak ve böylece yanlış, döngü sonunda). Ancak, GolfScript'te sabit zamanlı bir işlem olarak (veya daha doğrusu GolfScript'in üzerinde çalıştığı Ruby'de) uygulanmış gibi görünen bir dizeyi keserken , bunu söyleyen herhangi bir resmi belge bulamadım. Sadece güvenli olmak için, yukarıdaki biraz daha uzun, ama kesinlikle O (1) versiyonunu seçtim.

Yakut, 83 75 68 66 63 bayt

f=->m{m[b=c=i=0].map{(c=i;b-=1)while(r=m[b-2])&&r[i]>0;i+=1};c}

f2B dizi formunu girdi olarak alan bir işlevi tanımlar .

Sol alttan başlıyorum, maksimum çubuk uzunluğunu (aslında eksi) ve ilgili sütunu takip ediyorum. Her sütunda, 1önceki maksimum çubuk uzunluğunun üzerinde hala s varsa , çubuğu sonuna kadar yürüyorum ve yeni maksimum uzunluğu ve sütunu hatırlıyorum. Bu, sütunlar boyunca bir kez ve satırlar boyunca en fazla bir kez yinelediğim anlamına gelir (özellikle maksimum çubuk uzunluğuna kadar yineliyorum) O(m+n).

Python 2-71, 69, 73, 75 81

j=i=-1
M=input()
for m in M[0]:
 j+=1
 while-i<len(M)and M[i][j]:i-=1;J=j
print J

C, 64 bayt

Düzenleme: Sorunun uzunluğunu değil, en uzun sütunun yerini istediğini öğrendim.

İlk satır golf kodudur ve geri kalanı örnek çağırmadır.

g(int m,int n,int**a,int*r){for(*r=n;n*m;a[m][n]?m--,*r=n:--n);}

/* usage:
    m = number of rows
    n = number of columns
    a = 1-based 2D array such that a[i][j] gives the value at the ith row and jth column
    r = address of return value 
    Returns (to r) the 1-indexed location of a column with the longest length, or 0 if n=0
    */

int main()
{
    int flat[4*4] = {1, 0, 0, 0,
                     1, 0, 0, 1,
                     1, 1, 0, 1,
                     1, 1, 1, 1};
    int*twoD[4] = {flat-1,flat+3,flat+7,flat+11};
    int ret;
    g(4,4,twoD-1,&ret);
    printf("%d", ret);
    return 0;
}

// old function which determines longest length (65 bytes)
f(int m,int n,int**a,int*r){for(*r=m;n*m;a[m][n]?m--:--n);*r-=m;}

C #: 236 Karakter

int p(int[,] a){int y=0,s=0,i=0,x;for(;++y<=a.GetUpperBound(0);)for(x=i;x<=a.GetUpperBound(1);){if(a[y,x++]==0)break;s=y;i++;}return s;}

ungolfed:

int p(int[,] a)
{
    int selectedRow=0;
    int maxLength=0;
    for(var y = 0; y<=a.GetUpperBound(0); y++)
        for(var x=maxLength; x<=a.GetUpperBound(1); x++)
        {
            if(a[y,x++]==0)
                break;
            selectedRow=y;
            maxLength++;
        }
    return selectedRow;
}

PHP 5.4 - 108 bayt

(Dahil ederseniz 113 <?php)

Girdi biçimi: Dizi JSON dizesi olarak okunur.

php longest_stick.php "[[0, 0, 0, 0],[1, 0, 0, 0],[1, 1, 0, 1],[1, 1, 1, 1]]"

Okunabilirlik için boşluk eklendi - tüm yeni satırlar ve önde gelen alanlar kaldırılabilir.

<?php
$t=count($s=json_decode($argv[1]))-1;
foreach($s[0] as $k=>$_)
    while($s[$t][$k]) {
        $t--;
        $l = $k;
    }
echo $l?:0;

Küçültülmüş sürüm:

<?php $t=count($s=json_decode($argv[1]))-1;foreach($s[0] as $k=>$_)while($s[$t][$k]){$t--;$l=$k;}echo $l?:0;

Algoritmayı burada Martin'den çalmak gibi, ama burada sık görülmeyen dillerle oynamak güzel XD

Kobra - 98

def f(a)
    s,x,y=0,0,a.count-1
    while y+1and x<a[0].count
        while a[y][x],y,s=y-1,x
        x+=1
    print s

C ++ :: 78

Diğer C çözümünün aksine, tüm program budur. (invokasyona gerek yok, fonksiyona dizinin boyutunu söylemeye gerek yok). Ne yazık ki bu, maintek bir karakter işlev adı yerine kullanılması gerektiği gibi daha uzun olduğu anlamına gelir , ben girdiyi yorumlamak ve daha sonra diğer çözüm "başka yerde" işliyor cevap, çıktısını almak zorunda. Ayrıca benim ilk kod golf.
ile derlenmiş g++ file.cpp -include iostream, ./a 000 010 110 111(örneğin) == dizeleri dizisi ile çalıştırın (bu soru spec izin verilir inanıyorum)

int c;main(int r,char**v){for(r--;r*v[r][c];v[r][c]-48?std::cout<<c,r--:++c);}

Yukarıdaki sürüm, her yinelemede şimdiye kadar bulunan en iyi akımı verir. Son çıkış basamağı cevaptır. Sağ alt yerine alt soldan işleme ve 0dizine ekleme, bu çözümü 10 (!) Karakter azalttı.
c ++ 'a geçiş, gönderimi daha std::cout<<kısa olduğu gibi bir karakter daha bırakır putchar(-48)ve ayrıca uygun çıktıya sahip 9'dan fazla çubuğu açıkça desteklemelidir (her bir çıktıyı ayırt
etmek zorlaşabilir ) Yanıt alanını kaldırmak ve doğrudan çıkış yapmak 6 karakteri daha keser. Şimdi sadece en iyi çıkışını keser ve bu da en azından bazı çıkışları keser.
Tüm dosya şimdi sadece 78 bayt boyutundadır - diğer fonksiyonlarınCgönderme kullanır. (bahsedilen işlevi desteklemek için çok sayıda ekstra kod ile).

Aşağıdaki açıklama güncel değil:

cküresel olduğundan 0
rgiriş sayısı (satır) +1 ile başlar (program adı) geçersiz
volan dizeler dizisidir v[0](program adı)
0 dizinli rolduğu için sınırların dışındadır, bu nedenle azaltın.
İken r!=0(geçerli dize işaret) ve karakter cdizesi null sonlandırıcı değil '\0'
karakter değildir '0' ise
bir satır (yukarı çıkmak r) ve çıkış sütunu ( c)
sonraki sütuna başka go ( c)

yapılır

Bunu daha da golf edebilir miyim?

Kodlanmamış kod (ekstra çıkışlı):

#include <stdio.h>
#include <string.h>

int main(int argc, char* argv[])
{
  int rows = argc-1;
  int cols = strlen(argv[1]);
  int ans;

  printf("rows: %d, cols: %d\n",rows, cols);

  while((rows)&&cols)
  {
    if (argv[rows][cols-1]-'0')
    {
      printf("stick @%d,%d\n",cols,rows);
      ans = cols;
      rows--;
    }
    else
    {
      printf("no stick @%d,%d\n",cols,rows);
      cols--;
    }
  }
  printf("%d",ans);
}

Sütun sayısını bulmak için dizelerin uzunluğunu, satır sayısını bulmak için argc'yi kullanır. Sağ alt köşeden başlayarak şu basit kuralları izler: Hücre bir çubuksa, yukarı taşı, geçerli sütuna cevabı ayarla. Hücre bir çubuk değilse, sola gidin. O (n + m): yalnızca yukarı ve sola hareket ettiğinden, yalnızca maksimum n + m okuma alabilir. Dizinin üstünden veya solundan düşerse erken çıkar.

OCaml - 144 karakter

let s a=Array.(let rec f i j m=if i=0then m else if a.(i).(j)=0then if j=length a.(i)-1then m else f i(j+1)m else f(i-1)j j in f(length a-1)0 0)

A int array arraygirişini alır ve sol veya alttan başlar, a 1veya a görürse yukarı veya sağa hareket eder 0. Sütun sayısı başlar 0.

kullanım

 s [| [| 0; 0; 0; 0 |]; [| 0; 0; 1; 0|]; [| 1; 0; 1; 0 |]; [| 1; 1; 1; 0 |]; [| 1; 1; 1; 1 |] |];;
 - : int = 2

Ungolfed

let s a = Array.(
  let rec f i j m = (* m is the longest stick seen so far *)
    if i=0 then m (* A column is full: this is the longest possible stick and j=m anyway *)
    else if a.(i).(j)=0 then (* current column is shorter than a previously seen stick *)
      if j=length a.(i)-1 then m (* we have examined all columns, just return m *)
      else f i(j+1) m (* start examining next column *)
    else f (i-1) j j (* current column is longer than all the ones previously seen. Check how long the stick is *)
  in
  f (length a-1) 0 0)

T-SQL - 71 64

Tablo A'yı girdi olarak alır

SELECT IDENTITY(INT, 1, 1) R, A INTO A
FROM (VALUES
 ('0000')
,('1000')
,('1101')
,('1111')
) AS A(A)

Ve sorgu

SELECT TOP(1)CHARINDEX('1',A)FROM A WHERE A LIKE'%1%' ORDER BY R

SQLFiddle

Bu, a satırında 1 olduğu r tarafından sıralanan tablodan ilk satırı döndürür.

TOP(1) sonucu döndürülen ilk satıra kısıtlar.

CHARINDEX('1',A) dizedeki ilk 1 konumunu veya bulunmazsa sıfır değerini döndürür.

WHERE A LIKE'%1%' A'nın içerdiği satırlara filtreler 1

ORDER BY R tablonun yukarıdan aşağıya okunmasını sağlar

Delphi 122 karakter

Ah ... bu çok hacimli bir dildir.

Güncelleme: dönüş tipini I'den tamsayıya değiştirme işlevinde 6 karakter eklemek zorunda kaldı. Test programı "tip I = tamsayı;" ifadesi programın önceki bir sürümünden kaldırılmıştır.

function S(A:array of string):integer;var n,c:integer;begin n:=0; repeat c:=Pos('1',A[n]);inc(n) until c>0; result:=c;end;

şeması - 236 karakter

Delphi versiyonundan bile daha uzun ... muhtemelen bunu şema ile çok daha verimli bir şekilde yapmanın bir yolu var. Ve daha da kötüsü - sadece sipariş m * n olduğunu fark ettim.

(define (s l) (cond ((eq? (cdr l) '()) (car l)) (else (map + (car l) (s (cdr l)))))) (define (u l) (define (t n p q l) (cond ((eq? l '()) p) ((< n (car l)) (t (car l) q (+ 1 q) (cdr l))) (else (t n p (+ 1 q) (cdr l))))) (t 0 0 1 (s l)))

l '((0 0 0 0) (1 0 0 0) (1 1 0 1) (1 1 1 1)) biçiminin bir listesidir. Bence bu, düzen için bir 2D dizi girdisinin adil bir temsili.

(sl), nuimbers listelerinin bir alt listesinin her birinin ninci öğelerini toplar, böylece (s '((0 0 0 0) (1 0 0 0) (1 1 0 1) (1 1 1 1))) geri dönecektir (3 2 1 2).

(ul) bir sayı listesinin en büyük girişinin 'indeksini' döndürür (yardımcı işlev t'i kullanarak), böylece (u '(3 2 1 2)) 1 değerini döndürür (listedeki' en büyük eleman olarak '3' (3 2 1 2) 1) konumundadır.

Raket 70

golfed:

(define(h m)(for/last([r m]#:final(memv 1 r))(length(takef r even?))))

Girdinin, Raket'te bir liste listesi olacağı iki boyutlu bir dizi olduğunu varsayar:

(define m 
  '((0 0 0 0)
    (1 0 0 0)
    (1 1 0 1)
    (1 1 1 1)))

Ungolfed:

(define (h m)
  ;; step through rows, stopping at the first that contains a 1
  (for/last ([r m] #:final (memv 1 r)) 
    (length (takef r even?)))) ; pop off the leading zeroes to get the column index

En uzun çubukla sütun dizinini döndürür.

JavaScript, ES6, 76 karakter

W=a=>(j=>{for(k=i=a.length-1;~i&~j;)a[i][j]?(k=j,i--):j--})(a[0].length-1)|k

Dizi girişi dizisini alır.

JavaScript ES6, 65 bayt

Her iki giriş biçimini de alır

f=(a,t)=>a.reduceRight((p,c)=>t+1?t:(x=c.indexOf(1,p))+1?x:t=p,0)

Açıklaması:

Aşağıdan yukarıya doğru yinelenir. Her değerdeki girişe göre String.prototype.indexOf()veya kullanır Array.prototype.indexOf(). Önceki satırdan 1 ile her satırın ilk dizinini bulur, hiçbiri bulamazsa, tdeğişkeni son ofsete ayarlar ve artık indexOfarama yapmaz .