Die Lösung CodingBat Herstellung von Ziegeln puzzle in Python

Ich bin Abschluss diese CodingBat problem:

Wollen wir eine Reihe von Ziegeln, die Ziel-Zoll lang. Wir haben ein paar kleine Steine (1 Zoll) und große Steine (5 Zoll jeder). Gibt True zurück, wenn es möglich ist, um das Ziel, indem Sie aus den gegebenen Bausteinen. Dies ist ein wenig schwieriger, als es aussieht und geht auch ohne Schleifen.
make_bricks(3, 1, 8) → True
make_bricks(3, 1, 9) → False
make_bricks(3, 2, 10) → True

Schrieb ich:

if small + big * 5 >= goal: return True
else: return False

Meine Fehler sind: make_bricks(3, 2, 9) → False (ich wahr, denn (2*5)+3=13, die größer ist als 9.

make_bricks(2, 1000000, 100003) → False
make_bricks(1, 4, 12) → False

Fand ich diese Antwort nicht bestandenen tests:

if goal > small + big * 5:
  return False
else:
  return goal % 5 <= small

Ich weiss nicht wirklich warum, kann mir bitte jemand erklären?

InformationsquelleAutor Benjamin Bakhshi | 2013-01-05

python

8

Hier ist eine kürzere Lösung.
```
def make_bricks(small, big, goal):
    return (goal%5)<=small and (goal-(big*5))<=small
```
- wenn möglich, könnten Sie bitte erläutern Sie Ihre Antwort ?
InformationsquelleAutor Hassan Raza

def make_bricks(small, big, goal):
    if (goal//5 <= big) and ((goal - 5*(goal//5))<= small): return True
    elif (goal//5 >= big) and ((goal - 5*(big)) <= small): return True
    return False

Ich habe das mit 2 Bedingungen Aussagen überprüfen, wenn die Anzahl os die kleinen Blöcke, die weniger als 5 ist und wenn es größer als 5 ist.

InformationsquelleAutor Alexandre Amaral

1

Sind Sie nicht berücksichtigen, dass Sie möglicherweise nicht brauchen alle von der 5 der. Zum Beispiel, wird Ihr code nicht auf:
```
def make_bricks(3, 2, 9)
```
Kann man wirklich nur ein großes backstein hier. Dies lässt Sie mit 4 und nur zwei kleine Steine, um den Unterschied auszugleichen.

Dass ist der Grund, warum das Beispiel funktioniert. Es berücksichtigt, dass alle 5 s kann nicht verwendet werden.

Die nette Sache über codingbat ist, dass Sie sagen, was Sie erwarteten und was Sie bekamen, während der Prüfungen. Sie können zu Fuß durch den code mit der fehlerhaften Werte, um zu sehen, warum es scheitert. Papier-und-Bleistift ist dein Freund.

InformationsquelleAutor Jamie Duby

def make_bricks(small, big, goal):
  if (goal%5)<=small and (goal-(big*5))<=small:
    return True
  else:
    return False

ausprobiert und getestet

InformationsquelleAutor huehue

1
```
def make_bricks(small,big,goal):
    # for checking how much small bricks we needed we use (goal%5)
    if small<(goal%5) or (small+big*5)<goal:
       return False
    else:
       return True
```
- Während der code nur Antworten könnten, bieten eine Lösung für das Problem, kann es schwierig sein, für andere zu Folgen. Bitte beachten, verlängern Sie Ihre Antwort und beschreiben Sie, was Ihr code tut und warum Sie wählten diese Lösung.
InformationsquelleAutor Pramod kumar Kushwaha

#Did it with recursion:

def make_bricks(small, big, goal):
    if (small + big * 5 )< goal:
        return False
    if (small + big * 5) == goal:
        return True
    return make_bricks(small-1, big, goal) or make_bricks(small, big-1, goal)

InformationsquelleAutor blondie9x

0

Unter python-code funktioniert bei mir in Codingbat Seite.

HTML:
```
def make_bricks(small, big, goal):
  small = small * 1
  big = big * 5
  while big > 0:
    if small == goal or big == goal:
      return True
    if small + big == goal:
      return True
    if small > goal:
      return True
    if big < goal and (small + big) > goal:
      return True
    big = big - 5
  if small > goal:
    return True
  return False
```
Ein-und Ausgänge:
Erwartet Wird Ausgeführt

make_bricks(3, 1, 8) → True True OK

make_bricks(3, 1, 9) → False False OK

make_bricks(3, 2, 10) → True True OK

make_bricks(3, 2, 8) → True True OK

make_bricks(3, 2, 9) → False False OK

make_bricks(6, 1, 11) → True True OK

make_bricks(6, 0, 11) → False False OK

make_bricks(1, 4, 11) → True True OK

make_bricks(0, 3, 10) → True True OK

make_bricks(1, 4, 12) → False False OK

make_bricks(3, 1, 7) → True True OK

make_bricks(1, 1, 7) → False False OK

make_bricks(2, 1, 7) → True True OK

make_bricks(7, 1, 11) → True True OK

make_bricks(7, 1, 8) → True True OK

make_bricks(7, 1, 13) → False False OK

make_bricks(43, 1, 46) → True True OK

make_bricks(40, 1, 46) → False False OK

make_bricks(40, 2, 47) → True True OK

make_bricks(40, 2, 50) → True True OK

make_bricks(40, 2, 52) → False False OK

make_bricks(22, 2, 33) → False False OK

make_bricks(0, 2, 10) → True True OK

make_bricks(1000000, 1000, 1000100) → True True OK

make_bricks(2, 1000000, 100003) → False False OK

make_bricks(20, 0, 19) → True True OK

make_bricks(20, 0, 21) → False False OK

make_bricks(20, 4, 51) → False False OK

make_bricks(20, 4, 39) → True True OK

andere tests
OK
- Das sieht einfacher Ansatz ist verständlich, dass eine neue Schülerin in python - warum sind Sie mit 5, was ist die Logik hinter der Verwendung von 5?
InformationsquelleAutor RajKumar Rampelli
0

verwenden Sie diesen code:

if(((klein*1)+(groß*5))< Ziel):
```
 return False
```
elif((5*(Ziel//5))+kleine
```
 return False
```
anderes:
```
 return True
```
InformationsquelleAutor user3922012

Können Sie Folgendes versuchen:

if(((small*1)+(big*5)) < goal):
    return False
elif((5*(goal//5))+small<goal):
    return False
else:
    return True

InformationsquelleAutor user3922012

Voll funktionierende Lösung in 3 Zeilen code:

def make_bricks(small, big, goal):
  #find max number of big bricks required
  bigBrickNeeded = goal / 5;
  #check if you have enough big bricks, if not use all big bricks avaible
  bigBrickNeeded = min(big, bigBrickNeeded);
  #fill the gap with small bricks
  return small >= (goal - bigBrickNeeded*5);

Getestet, es geht al-tests

InformationsquelleAutor Maurizio Ricci

0

Dies ist, was ich kam mit:
```
def make_bricks(small, big, goal):
   bigs = big * 5
   if (bigs >= goal) and (goal % 5 <= small):
     return True   
   if (goal - small <= bigs) and (bigs < goal):    
     return True  
   else:
     return False
```
Nicht einmal so dicht wie elegant, wie Haasan Razas Antwort:
```
def make_bricks(small, big, goal):
    return (goal%5)<=small and (goal-(big*5))<=small
```
** in Antwort auf "wenn möglich, könnten Sie bitte erläutern Sie Ihre Antwort ? – N997 Mar-23-3:53"
Alle Möglichkeiten abgedeckt sind, in dieser einen Zeile code. Der code wird False zurückgegeben, wenn beide Fall 1 UND Fall 2 sind nicht Erfüllt:
Fall 1: der Rest des Ziel durch 5 geteilt werden muss weniger als oder gleich zu kleinen Ziegeln. Auf diese Weise haben wir genug kleine Steine, um eventuelle Entfernung von weniger als 5 cm nach Links über nach großen Steine sind gelegt.
Fall 2: Das Ziel minus all der großen Steine ist weniger als oder gleich zu kleinen Ziegeln. In diesem Fall umfaßt das Szenario nicht genug, große und kleine, um das Ziel zu erfüllen, bit auch der Fall, wenn das Ziel erfüllt werden kann, indem nur kleine Steine

InformationsquelleAutor Craig Swann

def make_bricks(small, big, goal):
   if (goal//5) <= big: 
       if (goal%5) <= small: 
         return True
       else: 
         return False
   if (goal//5) >= big:
       if (goal - (big*5)) <= small:
         return True
       else:
         return False

InformationsquelleAutor jay.manalastas

0

Obwohl diese Frage schon beantwortet zu Tode, ich wollte nach meinem one-liner. Die Logik, die wir verwendet wurde, war 1) finden Sie heraus, wie viele große Steine verwendet werden (bis zu der Anzahl zur Verfügung), dann siehe 2), wenn es genug kleine Steine, um den Unterschied auszugleichen.

Den Beispiel-code können Sie code in Steine von unterschiedlicher Länge:
```
def make_bricks(small, big, goal):
  smallLen = 1
  bigLen = 5

  bigs = goal // bigLen
  smallGoal = goal - (min(bigs, big) * bigLen)

  return smallGoal <= (small * smallLen)
```
Könnte man diese umschreiben von smashing Sie zusammen aber dann ist es weniger lesbar (wenn zufriedenstellend klein)
```
def make_bricks(small, big, goal):
  return goal - (min(goal // 5, big) * 5) <= small
```
Es ist interessant, dass all unsere Ansätze finden Sie die Lösung, mit der maximalen Anzahl großer Steine, und das tut erfüllen Sie die Frage, aber es könnte auch andere Kombinationen von großen und kleinen Steinen, die eine richtige Antwort geben. Das problem ist nicht, dass Sie verwenden sollten, alle die großen Steine. Ich nehme an, Sie würde in einer Schleife durch den Bereich der großen Steine, und bestimmen, für welche, wenn eine beliebige Anzahl < big große Steine das Ergebnis ist auch richtig.

InformationsquelleAutor Puddles

def make_bricks(kleine, große, Ziel):

b=big*5

s=small*1

`if b==Ziel oder s==Ziel:

 return True

if b==0: #0

if s>=goal:

 return True

falls s==0:

return b>=goal

if b<goal:

if (b+s)>=goal:
  return True
else:
  return False

dann, wenn b>Ziel:

 if ((b+s)-goal)%5==0:
   return True

anderes:

return False

InformationsquelleAutor Mandeep singh

-1
```
def make_bricks(small, big, goal):
    for i in range(0, big + 1):
        for j in range(0, small + 1):
            if j  + i * 5 == goal:
                return True
    return False
```
- Bitte erklären Sie auch Ihren code
- Herzlich willkommen auf Stack Overflow! Während diese Antwort ist wohl richtig und nützlich ist, ist es bevorzugt, wenn Sie einige Erläuterung zusammen mit es um zu erklären, wie es hilft, das problem zu lösen. Dies wird besonders nützlich sein in der Zukunft, wenn es zu einer änderung (möglicherweise nicht), die bewirkt, dass es aufhören zu arbeiten und die Leser müssen verstehen, wie es einst arbeitete.
InformationsquelleAutor Sunil Kamat
-1

Ich glaube, das sollte funktionieren. Aber aus irgendeinem Grund, es funktioniert hier nicht.

http://codingbat.com/prob/p118406
```
def make_bricks(small, big, goal):

  for i in range(0, big + 1):
   for j in range(0, small + 1):
    if j  + i * 5 == goal:
     return True
  return False
```
- Ist dieser im Versuch, die Frage zu beantworten? Wo hat es nicht funktioniert?
InformationsquelleAutor Sunil Kamat
-1

Ich weiß nicht, python noch nicht, aber ich löste es für java.
Ich bin Entsendung der java-code so, dass Sie verstehen, die Logik, die Sie dann verwenden können, zu schreiben, das python-Programm.
Wir haben zu berücksichtigen, alle Kombinationen von 'klein' und 'groß' - Steine, die im Ergebnis das Ziel.
Wir brauchen also zwei geschachtelte for-Schleifen innerhalb einer anderen.

Siehe code:
```
  public boolean makeBricks(int small, int big, int goal) {
        for(int i = 0; i<=(big*5) ;i=i+5){
            for(int j=0; j<=small;j++){
                 if(i+j==goal){
                     return true;
                 }
            }
         }
   return false;
 }
```
Edit 1:
Lassen Sie uns einen Blick auf die Lösung die du gepostet hast.
```
          If goal > small + big*5
              return false
```
Diese Anweisung stellt sicher, dass, wenn alle Steine genommen werden-sammeln Sie sich kurz, um das 'Ziel', d.h. die Funktion kehrt sofort zurück, als falsch.

Nun der 'else' - Teil:
```
         else:
             return goal % 5 <= small 
```
In diesem wird geprüft, dass, wenn der Rest des Ausdrucks (Ziel % 5) ist weniger als oder gleich der Anzahl der "kleine" Bausteine .
Dies ist, weil die 'kleine' Steine sind 1 Zoll lang. Wenn jeder kleine Stein ist 2 cm lang ist, dann wäre die Bedingung sein
```
         return (goal%5)/2 <= small.
```
Wenn die kleinen bricks 'n' Zentimeter lang ist dann die Bedingung wäre
```
         return  (goal%5)/n <=small.
```
Einem sehr einfachen mathematischen Regel, die wir in der Schule lernen, wird hier benutzt, geschickt.

Anzahl = (Es ist divisor * division) + Rest

InformationsquelleAutor Deepeshkumar
-1

Das problem besagt, dass es gelöst werden kann, ohne zu Schleifen. Diese Lösung funktioniert für mich, aber vielleicht nicht die effizienteste:
```
def make_bricks(small, big, goal):
  if (big*5) + small == goal:
    return True
  elif (goal//5) >= goal:
    return True
  elif small >= goal:
    return True
  else:
    bn = goal//5
    sn = goal - (bn*5)

    if big>= bn and sn<=small:
      return True
    elif big < bn and goal<= (big*5) + small:
      return True
    else:
      return False
```
- Herzlich willkommen auf Stack Overflow! Diese Frage ist auf der Suche nach einem Erklärung, nicht einfach für den funktionierenden code. Ihre Antwort bietet keinen Einblick, für den Fragesteller, und kann gelöscht werden. Bitte Bearbeiten, um zu erklären, welche Ursachen die beobachteten Symptome.
InformationsquelleAutor Teasy
-1

def make_bricks(kleine, große, Ziel):

b=big*5

s=small*1

`if b==Ziel oder s==Ziel:
```
 return True
```
if b==0: #0
```
if s>=goal:

 return True
```
falls s==0:
```
return b>=goal
```
if b<goal:
```
if (b+s)>=goal:
  return True
else:
  return False
```
dann, wenn b>Ziel:
```
 if ((b+s)-goal)%5==0:
   return True
```
anderes:
```
return False  
```
- Willkommen ALSO! Wenn du postest eine Antwort, versuchen Sie, um zu überprüfen, dass Sie Antworten auf die user-Frage. In diesem Fall wird der Benutzer gefragt I don't really get why, can someone please explain?. Glauben Sie, dass Ihre Antwort ist zu beantworten? Und postest du es 2 mal... In diesem Fall gibt es 16 Antworten mehr, so setzen die Profis oy dein P. O. V.
InformationsquelleAutor Mandeep singh

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.