Bölünme ve kalanlar


36

Bu zorluk, muhtemelen çoğu "standart" dilde önemsiz olsa da, bu sitede çok nadir görülen, çok ezoterik, düşük seviyeli ve / veya kullanımı zor olan dillere yöneliktir. Çözmesi gereken ilginç bir problem ortaya çıkarmalı, bu yüzden okuduğunuz tuhaf dili denemeniz için bir fırsat!

Görev

İki doğal sayı alın ave bgirdi olarak ve diğer iki sayıyı alın: tam sayı bölümünün sonucu a/bve bu bölümün geri kalanı ( a%b).

Bu : en kısa cevap (bayt cinsinden), her dil için kazanıyor!

Giriş çıkış

  • 0 <= a<= 255, 1 <= b<= 255. Girişlerin her biri (ve çıkışlar da) tek bir bayta sığacaktır.
  • İki sayı açıkça ayırt edilebildiği sürece, hem giriş hem de çıkış için istediğiniz formatı seçebilirsiniz (örn. İki sonucu sınırlayıcı olmadan birlikte yazdırma)

Örnekler

a,b->division,remainder
5,7->0,5
5,1->5,0
18,4->4,2
255,25->10,5

Not: Hem bölümün sonucunu hem de geri kalanı döndüren yerleşikler yasaktır . En azından bize, dilinizin aynı argümanlara iki işlevi uygulama ile nasıl ilgilendiğini gösterin.

Not 2: Her zaman olduğu gibi, kodunuzun nasıl çalıştığının bir açıklaması çok açıktır, size okunabilir gibi görünse bile başkası için böyle olmayabilir!


Liderler Sıralaması

Kazananların dile göre genel bir bakışını oluşturmak için bir Stack Snippet'i burada bulabilirsiniz.

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

# Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

Başlığınıza birden fazla sayı eklemek istiyorsanız (örneğin, puanınız iki dosyanın toplamı olduğundan veya tercüman bayrağı cezalarını ayrı ayrı listelemek istediğiniz için), gerçek puanın başlıktaki son sayı olduğundan emin olun :

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

Dil adını, daha sonra büyük afiş snippet'inde görünecek bir bağlantı da yapabilirsiniz:

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


Argümanları tersine çevirebilir miyim, yani yerine a bsağlamak b ayerine?
Outgolfer Erik,

@EriktheOutgolfer:You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishable
Emigna

@Emigna Evet, tersine çevirmenin onları ayırt edilemez kılmadığından emin değildim.
Outgolfer Erik

@EriktheOutgolfer, tersine çevrilmeleri gerektiğini biliyorsanız, onları ayırt etmekte hiçbir problem yaşamayacaksınız :)
Leo

Ne yazık ki, bölen ise BF algoritması çalışmıyor 1.
mbomb007

Yanıtlar:


23

BitCycle , 146 79 64 bayt

Orjinal kodumun bir bölümünün gereksiz olduğunu farkettim. Büyük azalma!

v  <>!
A\B^^=
? D^>^<
 >\v^~ D@
 >/ C/
  > C ^
A/B v
^   <
?  D^

Program ilk önce bölenle birlikte komut satırından unary girdi alır. Bölüm ve kalanı, a ile ayrılmış olarak, tek tek çıktılar 0. Örneğin, burada a=11, b=4, a/b=2, a%b=3:

C:\>python bitcycle.py divmod.btc 1111 11111111111
110111

Ungolfed, eylemde

İşte benim açılmamış versiyon bilgisayarım a=3, b=5animasyonu açık (aksaklık için üzgünüm):

Divmod running in BitCycle

Bir açıklama girişimi

Bu açıklama asılsız versiyon için geçerlidir. Başa çıkmadan önce , dilin nasıl çalıştığına dair bir fikir edinmek için Esolangs sayfasını okumanızı tavsiye ederim .

Algoritma şöyle gider:

  • Program sonlandırılıncaya kadar bir dış döngü çalıştırın.
    • Bölenin bitleri üzerinde bir iç döngü geçirin, bunları temettü bitleriyle eşleştirin.
      • Bölenin tüm bitleri temettü temettü bitlerine sahipse, tek bir bit çıktılayın.
      • Bölenin bütün bitleri aynı temettü bitlerine sahip değilse, ayırıcıyı, 0ardından hangi temettü bitlerinin olduğunu izleyin, ardından sonlandırın.

Kodun kalbi koleksiyonerler arasındaki ilişkidir (büyük harfler). Her harfi ile birden fazla ayrı toplayıcıları olduğundan, en onlara bakın izin A1, A2, B1, B2, vb yukarıdan aşağıya doğru numaralandırma.

  • A1ve A2ana döngünün başında sırasıyla böleni ve temettü tutun.
  • İç döngü, bölücü ve temettüden bir seferde bir bit sıyrılıyor.
    • Bölenin geri kalanı, eğer varsa, her zaman içine gider B1.
    • Hem bölen hem de temettü boşsa, bir bit girer, C1diğeri girer C3. Temettü geri kalanı içine gider B2.
    • Eğer sadece bölen boş değilse, temettü sonuna ulaştık ve kalanı basma zamanı geldi. Bölenden gelen bit içine gider C2.
    • Eğer sadece temettü boş değilse, bölenin sonuna ulaştık; bitlerin çıktının içine C3veya C2çıktısına işlenmesinin zamanı geldi . Temettü geri kalanı içine gider C4.
  • BKolektörlerde herhangi bir bit varsa , içeriğini Akollektörlere geri döndürür ve iç döngüde devam eder.
  • Bir kez Ave Btoplayıcıları hepsi boş, Ckoleksiyoncular açıp biz işleme aşamasına geçin:
    • C1ve C4içeriklerini (sırasıyla bölen ve kalan temettü) D1ve D3.
    • Eğer C2boş, hala katsayısı baskı ediyoruz.
      • İçeriği C3sağ üst =düğmeye kadar gider . İlk 1bit doğrudan üzerinden geçer !ve çıktıdır.
      • Zaman 1biraz geçer, bu kurulu kapalı sonraki tüm bit gönderir noktası sağa, anahtarı devreye sokar.
    • Eğer C2boş değil, biz kalan baskı ediyoruz.
      • İlk biti C2a ile engellenir 0ve anahtardan geçer. Devam 0eder !ve çıktıdır.
      • Zaman 0biraz geçer, bu nokta sola doğru anahtarı devreye sokar. Artık tüm bitler C3anahtardan sola doğru gider ve !geri kalan kısmın tamamına çıkarak yeniden yönlendirilir .
      • Ayrıca ilk bitin bir kopyası C2da gönderilir D2.
  • Şimdi Dkoleksiyonerler açılıyor.
    • İçinde bir şey varsa D2, bu sadece kalanı yazdırdığımız anlamına gelir. Üzerindeki bit , programı sonlandıran yere D2vurur @.
    • Aksi takdirde, içerikleri D1ve D3içine döngü geri A1ve A2sırasıyla ve ana döngü yeniden başlar.

Bu harika
Evan Carslake,

"Program unary komut satırından giriş alır": Bu bana ikili gibi görünüyor?
therealfarfetchd

Whoops. Çıktı ikili gibi göründüğü için, girdi de olmalıydı. Sonra metni okudum. Boşver. : P
therealfarfetchd

15

brainfuck , 43 41 bayt

,<,[>->+<[>]>>>>+<<<[<+>-]<<[<]>-]>>.>>>.

Bu , Esolangs'taki yıkıcı modül algoritmamın değiştirilmiş bir versiyonunu kullanıyor .

Program, STDIN'den iki sıra - d ve n okur - STDIN'den iki sıra yazdırır - n% d ve n / d , bu sırayla STDOUT'a. TIO'da olduğu gibi, iki kat sonsuz veya dairesel bir bant içeren bir beyinsel tercüman gerektirir.

Çevrimiçi deneyin!

Nasıl çalışır

Program başlamadan önce, tüm hücreler 0 değerini tutar . Okuduktan sonra d (STDIN'den ,kalan bir adım hareket eden,) ( <) ve okuma n STDIN'den ( ,), aşağıdaki gibi bant görünüyor.

       v
A      B      C      D      E      F      G      H      J
0      n      d      0      0      0      0      0      0

Daha sonra, n> 0 olduğu varsayıldığında , while döngüsüne giriyoruz.

[>->+<[>]>>>>+<<<[<+>-]<<[<]>-]

Bu, bandı aşağıdaki gibi dönüştürür.

İlk olarak, C>->+< hücresine ilerler ve onu azaltır, sonra D hücresine ilerler ve arttırır ve son olarak C hücresine geri döner . Sonra ne olacağı, C hücresinin değerinin sıfır olup olmamasına bağlıdır .

  • C hücresi pozitif bir değer tutuyorsa, [>](hücre sıfır değilken sağa gidin) E hücresine ilerler .

    >>>>+<<<J hücresine ilerletmek için ilerler , sonra F hücresine geri döner .

    F hücresi her zaman 0 tutacağından , while döngüsü [<+>-]tamamen atlanır ve D<< hücresine geri döner .

    Eksikliğine rağmen son olarak, D ya sahip 0 , [<]hücre için geri vermek olacaktır (hücre dışı sıfır ise sol gidin) A .

  • C hücresi 0 tutarsa , döngü [>]tamamen atlanır; arttırmak için G>>>>+<<< hücresine ilerler , sonra D hücresine geri döner .

    Bu noktada, D düzenleyecek d (aslında, değerlerin toplamı C ve D her zaman olacaktır d , böylece) [<+>-](iken D pozitif artış olduğunu Eksiltme D koyacaktır) C için d ve D için , 0 .

    Son olarak, <<hücre için retrocedes B , [<]daha fazla hücre sol (hücre dışı sıfır ise sol gidin) A .

Her iki durumda da, B>- hücresine ilerler ve onu azaltır, bu sıfırlamadığı sürece döngü başlar.

Sonra k tekrarlamalar, kaset olarak aşağıda görünüyor.

       v
A      B      C      D      E      F      G      H      J
0      n-k    d-k%d  k%d    0      0      k/d    0      k-k/d

Sonra n tekrarlamalar B sıfırlanmasını ve biz döngünün patlak. İstenen değerler ( n% d ve n / d ), D ve G hücrelerinde saklanır , bu nedenle >>.>>>.bunları yazdırır.


12

Funciton , 224 108 bayt

Bayt sayısı, BOM ile UTF-16 kodlaması yaptığını varsayar.

 ┌──┬───┐
┌┴╖╓┴╖ ┌┴╖
│%╟║f╟┐│÷╟┘
╘╤╝╙─╜│╘╤╝
 └────┴─┘

Çevrimiçi deneyin!

Yukarıdaki, fiki tam sayı alan ve hem bölümlerini hem de ürünlerini döndüren bir işlevi tanımlar (Funciton'daki işlevler, girdilerin ve çıktıların toplamı 4'ü geçmediği sürece birden fazla çıktı alabilir).

İki giriş değerini birden fazla amaç için kullanmak aslında oldukça önemsizdir: konektörü bölüştürmeniz yeterlidir. Değerdeki bir T-kavşağı ile bölünmüş ve her iki dal boyunca çoğaltılacaktır, böylelikle bölme ve modulo için yerleşik olarak ayrı besleyebileceğiz.

Sonuç olarak, kullanıcıya sonucu nasıl göstereceğimi bulmak sadece çözümü uygulamaktan iki kat daha uzun sürdü.

Ayrıca, Funciton yerleşik bir divmod ÷%ve eğlenceli bir şekilde yerleşiktir.÷ ve %benim çözümümün kullandığı uygulamalar açısından ÷% . Bununla birlikte, fyukarıdaki işlevim tamamen aynı değil ÷%: Girdilerin sırasını değiştirmek zorunda kaldım ve bunu değiştirmek kolay gibi görünse de, şimdiye kadar bayt sayısını artırmadan bunu başaramadım .


10

JavaScript (ES6), 17 bayt

Bir baytta golf oynamak için @Arnauld'a teşekkürler

x=>y=>[x/y|0,x%y]

Girişi (x) (y) biçiminde alır

Bit yönünde gerçekleştirerek x / y tabanını alır veya
x% y ile kalanı döndürür
Her iki değeri de her ikisinin de döndürülebilmesi için bir diziye koyar

Çevrimiçi deneyin!


10

APL (Dyalog) , 5 bayt

@Ngn sayesinde -2 bayt

⌊÷,|⍨

Bu, tepenin sağ dişinin türetilmiş bir işlev (bir işleve uygulanan bir operatörün sonucu) olduğu bir çatalın (2 tren) üstündedir (3 tren):

       result 
         ↑┌──────────┐
         ││    ┌────┐│┌──────┐ (derived function)
         │↓        ↓│↓      │╱
       ┌───┐ ┌───┐ ┌───┐ ╔═══╤═══╗
           ÷   ,   |    
       └───┘ └───┘ └───┘ ╚═══╧═══╝
                              
left argument ┴─────────────────┘  (operator)
                └─────────┴ right argument

 katında

÷ bölünme

, katlanmak

| kalan bölüm
 değiş tokuş edilmiş argümanlarla (APL modülü "geriye")

Çevrimiçi deneyin!


Bu harika diyagramı nasıl yaptın?
emiflake

2
@ WolfgangTS Özenle. Dyalog APL, temel fonksiyonların temel ağaç şemalarını yapma kabiliyetine sahiptir. Çevrimiçi deneyin! Bununla başladım ...
Adám

Ah, çok zor görünüyor. Korkarım bunun için sabrım yok, haha
emiflake 27:17

kısa:⌊÷,|⍨
ngn

@ ngn Ouch, beni yakaladınız. Hala burada olduğunu gördüğüme sevindim.
Adám

7

Brachylog , 6 bayt

{÷|%}ᶠ

Çevrimiçi deneyin!

açıklama

ᶠ findallİki bağımsız değişkeni iki bağımsız değişkenin Giriş listesine uygulamak için meta belirtiyi kötüye kullanıyoruz :

{   }ᶠ         Findall for the Input [A,B] :
 ÷               Integer division
  |              Or…
   %             Modulo

7

MATL , 12 10 bayt

Qt:ie=&fhq

Giriş a, o zaman b. Çıktı kalan, sonra bölüm.

Çevrimiçi deneyin!

açıklama

Bu, hem modulo hem de bölünmeyi önler. Bunun yerine yeniden biçimlendirme dizi kullanır :

  1. a+1Sıfır olmayan bir öğeler dizisi oluşturun .
  2. 2B bsatır dizisi olarak yeniden şekillendirin. Bu, gerektiğinde otomatik olarak sıfırlarla doludur.
  3. Sıfır olmayan son girişin satır ve sütun endeksleri eksi 1, sırasıyla kalan ve bölümlerdir.

Örneğin düşünün a=7, b=3.

Q    % Input a implicitly. Push a+1
     % STACK: 8
t:   % Duplicate. Range from 1 to that
     % STACK: 8, [1 2 3 4 5 6 7 8]
ie   % Input b. Reshape as a matrix with b rows (in column major order)
     % STACK: 8, [1 4 7;
                  2 5 8]
                  3 6 0]
=    % Compare for equality
     % STACK: [0 0 0;
               0 0 1;
               0 0 0]
&f   % Row and column indices (1-based) of nonzero element
     % STACK: 2, 3
hq   % Concatenate. Subtract 1. Implicitly display
     % STACK: [1 2]

2
Bu, lateral düşüncenin güzel bir örneği, iyi iş!
Leo

6

Mathematica, 20 18 bayt

⌊#/#2⌋@Mod@##&

Esnek çıktı kurallarının küçük suiistimali: sonuç div[mod]değerlendirilmez olarak kalır. Bireysel sayılar result[[0]]ve ile elde edilebilir result[[1]].

Ve hey, gülünç olarak adlandırılan yerleşikten daha uzun bir bayt QuotientRemainder .

Mathematica, aslında aynı girdiye birden fazla işlevi uygulamak için düzgün bir yol kullanır, ancak üç bayt daha uzundur:

Through@*{Quotient,Mod}

1
Dilin basitçe yerleşikleri birleştiren yerleşikler oluşturması kötü bir şey ...
Fatalize, 27.07

1
@Fatalize öyle mi? Divmod yerleşiklerini oldukça faydalı buluyorum ve Mathematica, sahip olan tek dil değil.
Martin Ender

8
@Fatalize, kalanları hesaplamak için gerekli olan bölümleri hesaplamak için aynı işin çoğuna ihtiyaç duyulur. Her iki sonucun da kullanılması gerekiyorsa, uygun şekilde quotRemyapılandırılmış bir yerleşik çağrı yapmaktan quotve remayrı olarak önemli ölçüde zaman kazandırabilir .
Julian Wolf

6

05AB1E , 5 bayt

÷²¹%‚

Çevrimiçi deneyin!

05AB1E'de bir hata var, bu nedenle örtük girdi çalışmıyor :( Emigna , girdilerin genellikle tersten itildiğini belirtti.


5 bayt için ÷ ²¹%) yapabilirsiniz .
Emigna

@Emigna Yine de geçerliyse bilmiyorum. Bekle, bu nasıl çalıştı?
Outgolfer Erik,

1
Neden geçerli olmadığını anlamıyorum. İşe yarıyor, çünkü örtük girdiler bu gibi durumlarda varsaydıklarınızın tersi sırayla yığına itiliyor.
Emigna

@Emigna OP'ye argümanları tersine çevirip çeviremeyeceğimi sordum.
Outgolfer Erik,

2
Attığım You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishableEğer girişler alınır karar verebilir demek divisor, dividend. divisor, dividend
Cevapta

6

Denizanası , 14 bayt

p
m
,|S
% i
Ei

Çevrimiçi deneyin!

açıklama

Denizanası, aynı girişe birden fazla fonksiyon uygulamak söz konusu olduğunda güzel bir dildir. Dil 2B'dir ve tüm ikili fonksiyonlar bir giriş için güney, diğeri doğuya bakar. Yani batıdan ve kuzeyden bir değere yaklaşarak, kodu kopyalamak zorunda kalmadan iki işleve besleyebiliriz.

Programdaki iki isaniye, program başladığında iki giriş değeriyle değiştirilir. Şimdi %bölünmedir. Doğrudan bir doğudan bir girdi alır ve güneye doğru ilerlerken, Eo da doğuyu aramayı yönlendiren yere çarpar . Böylece her iki giriş %de argüman olarak beslenir .

| temelde aynı şeyi yapan modulo için yerleşiktir, ancak her ikisi için de sonuca bakar.

İki sonucu da bir çift halinde birleştirdik ,. Öyleyse m, kat işlevi (ihtiyaç duyduğumuz %için kayan nokta bölünmesidir) ve sonuç olarak da sonucu yazdırıyoruz p.


6

Cubix , 12 13 bayt

;W@o,I|\S%;O

Aşağıdaki küp üzerinde hangi haritalar

    ; W
    @ o
, I | \ S % ; O
. . . . . . . .
    . .
    . .

Burada dene

Yürütülen adımlarla açıklama
,I|I,- çok katlı bir tamsayı bölmesiyle başlar, girdiden ilk tamsayıyı alır, geri yansıtır ve bir sonraki tamsayıyı girdiden alır, sonra tekrar böler
O;- Tamsayı bölmesinin sonucunu çıkar ve çıkar
%- modunu değiştir. Bu daha sonra yapılabilir, ancak burada sona erdi
S\o- Yığına boşluk karakteri ekle, yeniden yönlendir ve alanı çıkar
W;- Sola kaydır ve yığını yığından çıkar
O|@- Daha önce hesaplanan modu çıkar, yatay yansıtıcıdan geç ve dur.


Beni iki dakika geç. Güzel cevap!
Luke,

@Luke Teşekkürler, başka bir tane çıkarabileceğimi düşündüm, ama zorlayıcı
olduğumu

6

Brain-Flak , 56 54 bayt

({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

Çevrimiçi deneyin!

Buğday Sihirbazı sayesinde -2 bayt

açıklama

Brain-Flak'taki mevcut en iyi bilinen tamsayı bölümü ve modulo çok benzer (aslında şu anda kullanılan tamsayı bölümü sadece feersum üzerinde yaptığım bir değişiklik modulo ).

Modulo ve tamsayılı bölünme karşılaştırması:
Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

Uygun şekilde, tamsayı bölme programı veri depolamak için sadece üçüncü yığını kullanırken, modulo programı veri depolamak için sadece normal iki yığını kullanır. Böylece her ikisini de aynı anda çalıştırarak birbirleriyle çarpışmazlar.

Modulo ve tamsayı bölme kombinasyonu:
Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

Combined: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><([{}()]{})>)

Son olarak, bu kombinasyonda kullanılan hem tamsayı bölümü hem de modulo programları yığın temiz olacak şekilde tasarlandı (yığınları çöp bırakmaz / girdilerin dışındaki değerlerin (var olmayan) varlığına bağlıdır) ama bu gerekli değildir bu problem için. Böylece, başlangıçta sıfıra basmadan ziyade sıfırı açmamak için iki bayttan tasarruf edebiliriz, bunun yerine başlangıçta sıfıra basmayarak, yerine yığınların altındaki sıfır dolgusuna güvenerek başka bir iki bayt alabiliriz.

Bu bize son programı verir:
({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

Tamsayılı bölünme programın açıklaması için feersum'un cevabına bakınız.

Integer Division Açıklama Çok Yakında ...


5

Java 8, 18 Bayt

(a,b)->a/b+","+a%b

Bu, türün bir lambda ifadesidir BiFunction<Integer, Integer, String>.

Şaşırdım ... bu aslında Java için oldukça özlü bir çözüm. Go lambda ifadeleri!


5

Brain-Flak , 168 148 110 bayt

Ben kontrol ettim sanırım Wiki ilk

(({})(<({}(<(({})<>)>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<>)

Biçim:

Input:    Output:
A (18)    remainder (2)
B (4)     division  (4)

Çevrimiçi deneyin!

(({})(<           # Copy A
({}(<             # Pick up A
(({})<>)          # Copy B to the other stack
>))               # Put A on top of a 0 on the second stack
                  # At this point the stacks look like this:   A
                                                               0
                                                             B B
                                                               ^

<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>) # Positive division from the wiki
>))                                          # Put down A on top of a 0
                                             # The stack now: A
                                                              0
                                                            Div B
                                                              ^

<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<>)     # Modulo from the wiki


5

sed, 36 bayt

35 baytlık kod, -rbayrak için +1 .

:a;s/^(1+)( 1*)\1/\1\2x/;ta;s/.* //

Girdiyi küçük, ilk önce daha küçük sayıyla boşlukla ayrılmış olarak alır. Birim olarak çıktı, bölüm ilk önce 1s, geri kalan saniye ise xs. (Bu kabul edilebilir değilse, bana bildirin ve 1girdi gibi boşlukla ayrılmış olarak değiştireceğim .)

açıklama

:a;                                  Define label a
   s/            /     /;            Perform this substitution:
     ^(1+)                           Match the first unary number...
          ( 1*)                      ... followed by a space and 0 or more 1s...
               \1                    ... followed by the the first group again
                  \1\2x              Keep the first two parts unchanged; replace the third
                                     with an x
                         ta;         If the substitution succeeded, goto a
                            s/.* //  After the loop is over, remove the first number

5

Excel 2013, 31 30 26 bayt

=INT(A1/B1)&","&MOD(A1;B1)

açıklama

Giriş hücrede A1ve B1. Bu, sadece ve bölmenin döşenmesi ve geri kalanlar için olan FLOORve MODfonksiyonunun dönüş değerlerini döndürür . Bu değerler virgül ile ayrılmıştır.


Sana ortalama hücre A1 ve B1 değil A1 ve A2 düşünüyorum
fənɛtɪk

Evet teşekkürler. Şimdi düzeltildi
Luke,

FLOOR(A1/B1;1)Bunun yerine 1 bayttan QUOTIENT(A1;B1)
Engineer Toast

Girdi her zaman bir Doğal sayı olduğundan, FLOOR(A1/B1;1)4 bayttan daha fazla tasarruf etmek için `INT (A1 / B1) ile değiştirebileceğinizi düşünüyorum
Wernisch



4

OIL , 134 106 103 102 bayt

Girdiyi stdin'den alır, iki sayı bir yeni satırla ayrılmış. Tamsayı bölmesinin, ardından bir yeni satırın ve sonra kalanın sonucunu verir.

Bu, bugüne kadar yazdığım en karmaşık OIL programlarından biridir; çünkü OIL, bölme, geri kalanlar, toplama, çıkarma vb. İçin yerleşik yapılara sahip değildir. Tekrarlanan iç içe azaltma: Bölünme yapmanın ilkel yöntemiyle çalışır.

Kodu, açıklamalı bir biçimde, betik dilleri tarzında yorumlarla sunuyorum. Yürütmeden önce, yorumlar kaldırılmalıdır.

5  # read input into lines 0 and 2

5
2
0  # the zero to compare to (nops)
1  # make a backup of the second input at line 3
2
3
10 # check if the second input is 0. %
4
2
24 # if so, jump to 24 (marked with §)
13 # else, go on
10 # check if the first input is zero &
4

31 # if so, jump to 31 (marked with $)
18 # else, go on
9  # decrement both numbers

9
2
6  # jump to line 8 (marked with %)
8
8  # increment the value in line 1 (initially a zero) §
1
1  # "restore the backup"
3
2
6  # jump to line 13 (marked with &)
13
10 # is the second number zero? $
4
2
42 # if so, jump to 42 (marked with +)
36 # else go on
9  # decrement both the second number and the backup
2
9
3
6  # jump to 31 (marked with $)
31
4  # print the division +
1
11 # a newline
4
3  # and the remainder (from the backup)

düzenleme: Bir "sabit" tek basamaklı bir konuma (referans için daha az bayt) taşıyarak 3 bayt daha kapalı ve daha sonra 2 sıfır konumlarını (bunun yerine boş bir satır kullanarak) uygulayarak. önce).

düzenleme: Ve başka bir bayt ilk sıfır örtülü yaparak. Gerçekten sadece tek bir değişmez sıfıra ihtiyacımız var.


Harika iş! Bu, tam olarak bu zorluğun alacağını umduğum cevap türüdür :) Sadece bir not: bölenin her zaman kesinlikle olumlu olacağı garantilidir, bu nedenle 0'a kadar bir bölünme olup olmadığını kontrol etmeniz gerekmez;)
Leo

@Leo Bölenin başlangıçta her zaman kesinlikle olumlu olacağına garanti ederim . Bölmeyi sıfır kısım çıkarırsam işe yaramaz, bu durum "gerçek" bölünme normal olsa bile olabilir. Doğru hatırlıyorsam, geri kalan sıfır olduğunda bu durum ortaya çıkar.
L3viathan

4. satırdaki kontrolden bahsediyorum, 12. satırdakilerden değil ... Programın başında sadece bir kez çalıştırılmıyor mu?
Leo

@Leo Tamam, neredeyse 30 karakter daha az, teşekkürler!
L3viathan

4

Retina , 14 bayt

Giriş / çıkış formatlarını kötüye kullanalım!

(.*)¶(\1)*
$#2

Girdiyi b\na, unary basamağı için herhangi bir rakam olmayan, yeni satır olmayan karakterlerden herhangi birini kullanarak alır. Giriş bölümünü, ondalık sayı olarak çıkarır, ardından geri kalanı giriş olarak aynı karakteri kullanarak unary içinde izler.

Çevrimiçi deneyin!

(.*) ¶(\1)*ilk sayı ile eşleşir, daha sonra yeni bir satır (¶, Retina \ n için kısa yoldur), ardından ilk sayı mümkün olduğunca tekrarlanır. İkinci grubun eşleşme sayısı bölünmenin sonucu olacaktır ve eşleşmeyen kısım kalan kısım olacaktır.

İle $#2önceki satırda eşleşen her şeyi ikinci grubun yakalama sayısıyla değiştiririz ve sonucumuzu alırız.


Haha, oldukça doğru, açıkça akşamları geç saatlerde programlar yazmamalıyım.
FryAmTheEggman

4

ArnoldC , 286 283 bayt

HEY CHRISTMAS TREE c
YOU SET US UP 0
HEY CHRISTMAS TREE d
YOU SET US UP 0 
GET TO THE CHOPPER c
HERE IS MY INVITATION a
HE HAD TO SPLIT b
ENOUGH TALK
GET TO THE CHOPPER d
HERE IS MY INVITATION a
I LET HIM GO b
ENOUGH TALK
TALK TO THE HAND c
TALK TO THE HAND d
YOU HAVE BEEN TERMINATED

Çevrimiçi deneyin!

Nasıl çalışır

HEY CHRISTMAS TREE c      //DECLARE VARIABLE c = 0
YOU SET US UP 0
HEY CHRISTMAS TREE d      //DECLARE VARIABLE d = 0
YOU SET US UP 0

GET TO THE CHOPPER c      /*
HERE IS MY INVITATION a      SET c = a/b
HE HAD TO SPLIT b         
ENOUGH TALK                */

GET TO THE CHOPPER d      /*
HERE IS MY INVITATION a      SET d = a mod b
I LET HIM GO b
ENOUGH TALK                */

TALK TO THE HAND c        // PRINT c
TALK TO THE HAND d        // PRINT d
YOU HAVE BEEN TERMINATED  //END

Çıkış biçimi

a/b
a mod b

3

Labirent , 11 bayt

?:?:}/!\{%!

Çevrimiçi deneyin!

açıklama

?:   Read a and duplicate.
?:   Read b and duplicate.
}    Move a copy of b over to the auxiliary stage.
/    Compute a/b.
!    Print it.
\    Print a linefeed.
{    Get back the other copy of b.
%    Compute a%b.
!    Print it.

IP daha sonra bir çıkmaza %girer , geri döner ve program tekrar denendiğinde bölünme girişimi nedeniyle sona erer .



3

> <> , 27 26 16 + 1 = 17 bayt

:r:{%:n','o-$,n;

Not

  • -vBayrağı kullanarak giriş yapın , örneğin TIO'ya bakın.
  • Bu, önce kalanı, sonra virgül ve son olarak da tamsayı bölmesini verir.

Çevrimiçi deneyin!

açıklama

Not yığını olarak başlar A, Bburada, Ave Bnedeniyle, birinci ve ikinci giriş temsil -vbayrak kullanılır.

:r:{%:n','o-$,n; # Explanation
:r:{             # Do some stack modifications to prepare it for
                 #    next part
                 #    (Stack: B, A, A, B)
    %            # Take the modulo of the top two items
                 #    (Stack: B, A, A%B)
     :           # Duplicate it
                 #    (Stack: B, A, A%B, A%B)
      n          # Pop once and output as number
                 #    (Stack: B, A, A%B)
       ','o      # Print separator
                 #    (Stack: B, A, A%B)
           -     # Subtract the modulo from the first input
                 #    (Stack: B, A-A%B)
            $,   # Swap the two inputs so they are back in order
                 #     and divide, so we get an integer
                 #    (Stack: floor(A/B))
              n; # Output that as a number and finish.

255'e kadar giriş değerlerini nasıl sağlayabilirsiniz?
Leo,

Sadece daha yüksek ASCII / Unicode değerleri kullanın. Bu şekilde, į255 olur.
Luke

Tamam, güzel :) Bu arada, girdi numaralarını komut satırından doğrudan -v bayrağıyla almak daha kısa olmaz mıydı?
Leo,

Olurdu, ama bunu TIO üzerinde çalışmak için alamadım, bu yüzden bu çözüme karar verdim. 8 bayt - 1 tasarruf eder ( -vbayrak için).
Luke,


3

C, 21 bayt

#define f(a,b)a/b,a%b

F (a, b) 'yi virgülle ayrılmış 2 terim ile değiştiren bir makro. Her ne kadar onu bir işleve geçirsen iyi edersin, yoksa başka birini seçmenin bir yolu yok.

Çevrimiçi Deneyin


3

Haskell , 21 bayt

a#b=(div a b,mod a b)

Çevrimiçi deneyin! Örnek kullanım: 13#2döndürür (6,1). Evet, bu oldukça sıkıcı, ancak biraz daha ilginçdivMod aynı şekilde çalışan .

Biz bunu iken, orada da quot, remve quotRemhangi gibi doğal sayılar aynı davranırlar div, modve divMod. Bununla birlikte, negatif girdiler için sonuç modbölen ile aynı işarete sahipken, sonucunun remtemettü ile aynı işarete sahip olması gerekir. Veya, Prelüd belgelerinde belirtildiği gibi quot, tamsayı bölümü sıfıra doğru kesilir ve divtamsayı bölümü negatif sonsuzluğa doğru kesilir.


Nasıl hayır hakkında divveyamod inşalar?

Eklenti yok, 36 32 31 bayt

a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b

Çevrimiçi deneyin! Örnek kullanım: 13#2döner (1,6), modsonuç birinci, divsonuç ikinci olur. Eğer aküçüktür b, daha sonra a mod bise ave a div bolduğu 0, bu nedenle (a,0)döndürülür. Aksi takdirde yinelemeli hesaplamak modve divbir a-bve b, eklenti1 bölünme sonucu ve kalan tutar.

Bölünme sonucuna 1 eklenmesi <$>, yaygın olarak kullanılan, kullanılarak elde edilir.map listelerde işlevlerin haritalandırılması , ancak perdelerde de çalışan, ancak işlev yalnızca ikinci tutamaç elemanına uygulanan, kullanılarak elde edilir.

Düzenleme: xnor sayesinde bir bayt kurtarıldı!


2
Sizin ikinci çözüm kullanarak bir bayt tıraş <$>ikinci elemana hareket etmeye tupleda: a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b.
xnor

3

SWI Prolog, 109 bayt

p(A):-print(A).
d(F,S,0,F):-S>F.
d(F,S,D,R):-G is F-S,d(G,S,E,R),D is E+1.
d(F,S):-d(F,S,D,R),p(D),p(-),p(R).

Çıktı:

?- d(255,25).
10-5
true .
?- d(5,7).
0-5
true .

Açıklama:

Yerleşik bölümleme veya modulo olmadan basit özyinelemeli algoritma. Basitçe "İkinci sayıya birinciye kaç kez uyar?" ve sonucu (D ile birleştirilir) geri kalan (R) ile birlikte rapor eder.

// edit: gereksiz boşluk kaldırıldı


PPCG'ye Hoşgeldiniz! Prolog'u daha önce hiç kullanmamıştım, ancak :-son satırda diğerlerinde boşluk olduğunu gördüm . Orada bazı nedenlerden dolayı gerekli mi? Aynı şey, boşluk gerektirmediğini E + 1söylerken de geçerlidir F-S.
Laikoni

Laikoni: Kesinlikle haklısın! Az önce boşlukları kaldırdım ve son bayt sayısını güncelledim.
Jan,


2

MATL, 5 bayt

/k&G\

MATL Online'da deneyin !

açıklama

        % Implicitly grab the two inputs as numbers
/       % Divide them
k       % Round down the result
&G      % Grab the two inputs again
\       % Compute the remainder

2

Ouroboros , 15 bayt

r.r.@/Inao\%n1(

Sayıları ters sırada alır (örn. 10 42).Burada dene.

açıklama

r.r.             Read a number, duplicate, read a number, duplicate
    @            Rotate a copy of the first number to the top of the stack
     /I          Divide and truncate to integer
       n         Output as number
        ao       Push 10 and output as character (newline)
          \%     Swap the remaining two values and take the mod
            n    Output as number
             1(  Push 1 and swallow that many characters from the end of the program,
                 halting execution
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.